李哥考研深度学习第二章 python基础

一、基本数据结构

数据结构：赋值、整型、浮点、列表、字典、字符串

 # 数据结构：赋值、整型、浮点、列表、字典、字符串
 ​
 # 赋值
 a = 3
 # a = 3.0 //浮点和整数不同
 print(a)
 ​
 b = 4
 print(a, b)
 ​
 # 支持多变量直接交换
 a, b = b, a
 print(a, b)
 ​
 name = "riannDon"
 print(name)
 # 下标从0开始
 print(name[2])
 ​
 # 列表list
 list1 = [1, 2, 3, 4, 5]
 ​
 print(list1)
 print(list1[2])
 # 在python中可以使用-1访问最后一个元素
 print(list1[-1])
 ​
 # 字典就是哈希表：key：value
 dict1 = {"name": "riann", "age": 24, 20: 80}
 print(dict1["name"])
 print(dict1["age"])
 ​
 ​
 # 列表甚至可以放不同的类型
 list2 = [1, "name", dict1]
 ​
 # 从属关系使用tab表示
 if a == 3:
     print("right")
 else:
     print("wrong")
 ​
 # 表示空
 A = None
 if A == None :
     print("A是空")
 ​
 # 循环
 # for i in 范围
 for i in list1 :
     print(i)
 # [0 , 10 )
 for i in range(10):
     print(i)
 for i in range(1,10) :
     print(i)
 for i in range(1,10,2) : # 以步长为2进行遍历
     print(i)
 # 遍历字典
 for i in dict1 :
     print(i)
     # 输出对应位置的值
     print(dict1[i])
 # while循环
 i = 0
 while i < 10:
     i += 1
     print(i)

二、列表操作

# 列表切片：在python中：代表切片或者映射
 list1 = [1, 2, 3, 4, 5]
 ​
 for each in list1:
     print(each)
 ​
 # 切片
 # 左开右闭
 print(list1[1:4])
 print(list1[0:4])
 print(list1[1:-1])
 print(list1[1:])
 print(list[:])
 # 遍历列表
 # 注意这里不是range，range是遍历值
 for i in list1[1:4]:
     print(i)
 dict1 = {"name": "riann", "age": 24, 20: 30}
 list2 = [1, "art", dict1]
 print(list2)
 for each in list2:
     print(each)
 ​
 list1 = [1, 2, 3, 4, 5, 6]
 print(list1)
 list1.remove(10)
 print(list1)
 # 删除下标为3的元素
 del list1[3]
 print(list1)
 # 插入元素到列表
 list1.append(7)
 print(list1)
 list1.extend([8, 9])
 print(list1)
 ​
 # 将某一范围的每一个值都加到列表中
 list2 = [i for i in range(10)]
 print(list2)
 # 等同于
 list3 = []
 for i in rnage(10):
     list3.append(i)
 print(list3)

三、加减乘除

# 基础操作
 a = 1
 b = 2
 print(a+b)
 print(a-b)
 print(a*b)
 print(a/b)
 # 地板除
 print(a//b)
 #求幂
 print(a**b)
 ​
 # 函数--返回a的平方
 def myfun1(A):
     c = A**2
     return c
 ​
 # 返回A的B次方
 def myfun2(A, B):
     c = A**B
     return c
 ​
 # 如果传入B，则返回A的B次方，如果没有返回A的平方
 a = 3
 def myfun3(A, B=2):
     c = A**B
     return c
 print(myfun3(a))

四、类与继承

# 深度学习  模型  东西 集成很多自己的函数和属性 ， 是这个类的实例。就可以使用类的东西
 '''
 __init__
 __init__ 方法：这是一个特殊的方法，每当你创建一个新的类实例时它都会被自动调用。self 参数代表类的一个实例（即对象），而name和age是传递给类的参数。
 方法：在类内部定义的函数称为方法。方法定义了类的行为。例如，bark方法使狗叫。
 '''
 #定义类
 class person():
     def __init__(self, name, age):
         self.name = name
         self.age = age
     def print_name(self):
         print(self.name)
     def print_age(self):
         print(self.age)
 #实例化--其实就是把它变成一个实实在在的物品
 riann = person("riann", 24)
 print(riann.print_name())
 ​
 #继承
 class superman(person):# 继承了人的属性
     #此时初始化可以删掉，同时继承了所有以前的函数，修改初始化
     def __init__(self, name, age):
         super(superman, self).__init__(name, age)
         self.fly = True
     def fly(self):
         if self.fly == True:
             print("我是超人")
 riannDon = superman("riann", 24)
 riannDon.print_name()
 print(riann.name)

五、矩阵操作

# 引入矩阵和矩阵操作
 import numpy
 import numpy as np
 import torch
 ​
 # tensor建立序列，列表形式
 list1 =[
     [1, 2, 3, 4, 5],
     [6, 7, 8, 9, 10],
     [11, 12, 12, 14, 15]
 ]
 print(list1)
 ​
 # 将list1转换为矩阵
 array = np.array(list1)
 print(array)
 ​
 # 矩阵的操作-矩阵赋值给另一个矩阵，也要套np.array
 array2 = np.array(list1)
 print(array2)
 # concatenate操作
 array3 = np.concatenate((array, array2), axis= 0)
 print(array3)
 ​
 # 矩阵切片
 array = np.array(list1)
 # 切片
 print(array[1:3])
 # 横竖轴切片，横轴切片，竖轴切片
 print(array[1:3,2:4])
 print(array[:, :])
 # 跳着切片
 idx = [1, 3]
 print(array[:, idx])

六、张量操作

6.1Numpy 张量概念

张量是机器学习和深度学习中常用的数据结构，它是矩阵向任意维度的推广。张量的维度通常称为轴（axis），轴的个数称为阶（rank）。在Numpy中，张量可以通过多维数组来表示和操作。

张量的基本概念

1. 标量（0D张量）：仅包含一个数字的张量称为标量。例如：

   ​​​​​​​import numpy as np x = np.array(12) print(x) # 输出: 12 print(x.ndim) # 输出: 0

2. 向量（1D张量）：由一组数字组成的数组称为向量。例如：

   x = np.array([12, 3, 6, 14, 7]) print(x) # 输出: [12 3 6 14 7] print(x.ndim) # 输出: 1

3. 矩阵（2D张量）：由多个向量组成的二维数组称为矩阵。例如：

   x = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8]]) print(x) # 输出: [[1 2 3 4 5] [4 5 6 7 8]] print(x.ndim) # 输出: 2

4. 更高维度的张量：例如三维张量：

   x = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]]) print(x) # 输出: 三维数组 print(x.ndim) # 输出: 3

张量的形状与数据类型

张量的形状是一个整数元组，表示张量沿每个轴的维度大小。例如：

 x = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8]])
 print(x.shape) # 输出: (2, 5)

张量的数据类型可以是float32、uint8、float64等。

张量运算

1. 逐元素相乘：与点乘不同，逐元素相乘是对两个张量的每个对应元素进行乘法运算。例如：

   B = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) C = np.array([[1], [2], [3]]) D = B \* C print(D) # 输出: [[1 1 1] [4 4 4] [9 9 9]]

2. 点积：点积运算将输入张量的元素合并在一起。例如：

   x = np.array([1, 2, 3]) y = np.array([4, 5, 6]) z = np.dot(x, y) print(z) # 输出: 32

张量的应用

张量在处理不同数据类型时有广泛应用，例如序列数据、图像数据和视频数据。对于图像数据，通常使用三维或四维张量来表示。例如，128张256x256的灰度图像可以表示为形状为(128, 256, 256, 1)的张量。

通过Numpy库，我们可以方便地创建和操作张量，从而在机器学习和深度学习中处理各种复杂的数据结构。

张量和矩阵的区别

矩阵类似于一个动作，张量类似于向量的集合，表示一个空间。

6.2代码

import torch
 import numpy as np
 ​
 list1 = [
         [1,2,3,4,5],
         [6,7,8,9,10],
         [11,12,13,14,15]
     ]
 # 三种输出的不同:序列、矩阵、张量
 print(list1)
 array = np.array(list1)
 tensor1 = torch.tensor(list1)
 print(tensor1)
 print(array)
 #
 # 梯度下降，表示需要梯度下降
 x = torch.tensor(3.0)
 x.requires_grad_(True)
 y = x**2
 y.backward()
 #
 # 第二个梯度下降，摘下张量，不再计算梯度
 # x = x.detach()# 承接，摘下张量
 # x.grad = torch.tensor(0.0)
 # y2 = x**2
 # y2.backward()#在此处报错，因为已经删除该梯度
 # print(y2)
 # print(x.grad)  # 2x
 ​
 # 创建张量，分别初始化为1和0
 ​
 tensor1 = torch.ones((100,4))
 print(tensor1)
 tensor2 = torch.zeros((10,4))
 print(tensor2)
 #
 # 创建10行4列的矩阵
 tensor3 = torch.normal(10, 1, (3,10, 4))
 print(tensor3)
 ​
 ​
 # 求和
 tensor1 = torch.ones((10,4))
 print(tensor1)
 #
 ​
 # 用dim列求和；使用keepdim表示保持10行
 sum1 = torch.sum(tensor1, dim=1)
 print(sum1)
 sum1 = torch.sum(tensor1, dim=1, keepdim=True)
 print(sum1)
 print(tensor1.shape)# callable多打了小括号问题

七、引用

 #从tensor.py文件中引用tensor1这个序列变量，并输出
 from tensor import tensor1
 print(tensor1)