【AI学习从零至壹】Numpy基础知识

Numpy基础

NumPy（Numerical Python）是 Python 语言中用于科学计算的一个重要基础库，它提供了高性能的多维数组对象，以及用于处理这些数组的各种工具和函数。

NumPy 基本数据类型

• bool_ 布尔型数据类型（True 或者 False）
• int_ 默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
• int8 字节（-128 to 127）
• int16 整数（-32768 to 32767）
• int32 整数（-2147483648 to 2147483647）
• int64 整数（-9223372036854775808 to 9223372036854775807）
• uint8 无符号整数（0 to 255）
• uint16 无符号整数（0 to 65535）
• uint32 无符号整数（0 to 4294967295）
• uint64 无符号整数（0 to 18446744073709551615）
• float_ float64 类型的简写
• float16 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
• float32 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
• float64 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
• complex_ complex128 类型的简写，即 128 位复数
• complex64 复数，表示双 32 位浮点数（实数部分和虚数部分）
• complex128 复数，表示双 64 位浮点数（实数部分和虚数部分）
  numpy 的数值类型实际上是 dtype 对象的实例，并对应唯一的字符，包括
  np.bool_np.int32，np.float32，等等。

Numpy数组

• NumPy 数组是一个多维数组对象。称为 Ndarray，由数组实际数据与描述这些
  数据的元数据组成.
• ⼀般来说，⼤部分操作仅针对于元数据，⽽不改变底层实际的数据。
  元数据：元数据就是描述数据的数据，比如说数组的形状、数据类型等等实际的数据说的是存储在内存中的实际数据内容，numpy里面的一些操作，比如说切片，他是创建一个新的视图，不是修改原始数据的存储位置
• 需要注意的是，NumPy 数组的下标起始位 0，同⼀个 NumPy 数组中的所有元素
  类型必须相同，NumPy 数组的创建访问中 () 与 [] 功能没有什么区别。

NumPy 基础数组创建

Numpy数组有很多中创建方式，一般常⽤的⽅式是将 list 转换为 np.array：

import numpy as np
a = [1,2,3]
b = np.array(a)
c = np.array([1,2,3])
print("b:",b)
print("c:",c)

# 输出：
b: [1 2 3]
c: [1 2 3]

两种方式输出的内容都是一样的

• 创建多维数组

a1 = np.array([(1,2,3),(4,5,6),(7,8,9)])
a1
# 跟C语言多维数组一个理解方式
# 输出
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

Numpy特殊数组创建

NumPy 提供了⼀些使⽤占位符创建数组的函数，这些数组在机器学习中是⽐较常⻅的。在创建过程中我们同样可以使⽤ dtype = int 指定元素类型：

• 创建一个全是0的数组

a2 = np.zeros((5,3),dtype=int) #创建一个五行三列的数组，元素类型是int
a2
#输出
array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]])

• 创建一个全是1的数组

a3 = np.ones((3,3),dtype=float)#创建一个三行三列，元素类型为float的数组
a3
#输出
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

• 创建等差数列

a4 = np.arange(1,11,2)#创建一个从1开始，11结束，差值为2的等差数列
a4
array([1, 3, 5, 7, 9])

• 创建单位矩阵（矩阵的乘法中，有⼀种矩阵起着特殊的作⽤，如同数的乘法中的 1，这种矩阵被称为单位矩阵。它是个⽅阵，从左上⻆到右下⻆的对⻆线（称为主对⻆线）上的元素均为 1）

a = np.eye(4) #创建一个四行四列的单位矩阵
a
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

• [0,1)之间的随机数组

a5 = np.random.random(5)#生成指定长度，在[0,1)之间平均分布的随机数组
a5
#输出
array([0.53019882, 0.70241453, 0.08357814, 0.69802226, 0.85959921])

• 生成指定长度，符合正态分布的随机数组

a6 = np.random.normal(0,0.1,5)#生成其均值为0，标准差为0.1的随机数组
a6
#输出
array([-0.15249953, -0.0443617 , -0.20765963,  0.05754567,  0.05691443])

Numpy数组的访问

和 list 的访问形式基本⼀致，⽀持切⽚操作，我们可以切⽚每⼀个维度，索引每⼀个维度

a7 = np.array([(1,3,4),(5,8,7),(8,9,7)])
a7[:2]#输出array数组的前两个数组
#输出
array([[1, 3, 4],
       [5, 8, 7]])
a7[:,2]#输出每一行的第三个元素，组成一个数组
#输出
array([4, 7, 7])
a7[:,:2]#输出每一行每一列的前两个元素，组成一个数组
#输出
array([[1, 3],
       [5, 8],
       [8, 9]])

NumPy数组的遍历

一维数组的遍历我们大家都知道

a = np.array([1,2,3,4])
for i in a:
	print(i)

• 多维数组的遍历

a8 = np.array([(1,2,3),(3,4,5)])
i,h,k = a8[0]#可以使用直接赋值遍历
for i,j,k in a8:
    print(i*j*k)

Numpy数组的常用属性

比较常用的属性有：

ndarray.ndim : 数组的维度（数组轴的个数），等于秩
ndarray.shape : 数组的⼤⼩。为⼀个表⽰数组在每个维度上⼤⼩的整数元组。例如⼆维数组中，表⽰数组的ʼ ⾏数ʼ 和ʼ 列数ˮ
ndarray.size : 数组元素的总个数，等于 shape 属性中元组元素的乘积
ndarray.dtype : 表⽰数组中元素类型的对象

a8 = np.array([(1,2,3),(3,4,5)])
print("ndim:", a.ndim)
print("shape:", a.shape)
print("size", a.size)
print("dtype", a.dtype)

Numpy数组的基本操作

• in:检测数值是否在数组中

a9 = np.array([[0,2,3,4]])
print(5 in a9)
print(3 in a9)
#输出
False
True

• reshape:数组的重排列，例如将一个3维数组转变成1维（元素数一定要保持不变）

a8 = np.array([(1,2,3),(3,4,5)])
a8.reshape(1,6)#把两行三列的数组变成一行六列的
#输出
array([[1, 2, 3, 3, 4, 5]])

• tanspose:转置（T)

a8 = np.array([(1,2,3),(3,4,5)])
a8.transpose()
a8.T

• flatten:把多维数组转换成一维数组，注意每个元组的长度是相同的

a8.flatten()
#输出

• newaxis：增加维度

a = np.array([[1,2,3],[2,3,5]])
a.shape
a = a[np.newaxis]#在前面加一个维度
#输出
#(1, 2, 3)
a = a[:,np.newaxis,:]#在中间加一个维度
#输出
#(2, 1, 3)
a.shape

Numpy数组的数学操作

加减乘除

• *表示矩阵内各位置对应相乘，点承表示求矩阵内积，二维数组称为矩阵积

a = np.ones((2,2))
b = np.array([(1,1),(3,3,)])
print(a)
print(b)
print(a+b)
print(a-b)
print(a*b)
print(a/b)
print(a.sum())
print(a.prod())```
#输出
[[1. 1.]
 [1. 1.]]
[[1 1]
 [3 3]]
[[2. 2.]
 [4. 4.]]
[[ 0.  0.]
 [-2. -2.]]
[[1. 1.]
 [3. 3.]]
[[1.         1.        ]
 [0.33333333 0.33333333]]
4.0
1.0

• 平均数，⽅差，标准差，最⼤值，最⼩值

import numpy as np
a = np.array([5,2,1])
print("mean:",a.mean())#平均数
print("var:", a.var())#方差
print("std:", a.std())#标准差
print("max:", a.max())
print("min:", a.min())

• 最⼤与最⼩值对应的索引值：argmax,argmin。取元素值上限，下限，四舍五⼊：ceil, floor, rint

a = np.array([1.2,2.2,3.5])
print("argmax:",a.argmax())#最大的索引值
print("argmin:",a.argmin())#最小的索引值
print("ceil:",np.ceil(a))#取元素值的上限
print("floor:",np.floor(a))#取元素值的下限
print("rint:",np.rint(a))#四舍五入
#输出
a = np.array([1.2,2.2,3.5])
print("argmax:",a.argmax())#最大的索引值
print("argmin:",a.argmin())#最小的索引值
print("ceil:",np.ceil(a))#取元素值的上限
print("floor:",np.floor(a))#取元素值的下限
print("rint:",np.rint(a))#四舍五入

除了上述函数外，还有很多数据运算操作，它们的使⽤⽅式基本都类似，例如：abs, sign, sqrt, log,log10, exp, sin, cos, tan, arcsin, arccos, arctan, sinh, cosh, tanh, arcsinh, arccosh,arctanh 等等。

Numpy线性代数

矩阵 (matrix) 是 array 的分⽀，matrix 和 array 在很多时候都是通⽤的，⽤哪⼀个都⼀样。官⽅建议⼤家如果两个可以通⽤，那就选择 array，因为 array 更灵活，速度更快。
array 的优势就是不仅仅表⽰⼆维，还能表⽰ 3、4、5… 维，⽽且在⼤部分 Python 程序⾥，array 也是更常⽤的。
dot : 矩阵乘法，对于两个⼀维的数组，计算的是这两个数组对应下标元素的乘积和 (数学上称之为内积)；
对于⼆维数组，计算的是两个数组的矩阵乘积；
对于多维数组，它的通⽤计算公式如下，即结果数组中的每个元素都是：数组 a 的最后⼀维上的所有元素与数组 b 的倒数第⼆位上的所有元素的乘积和：dot(a, b)[i,j,k,m]= sum(a[i,j,:] * b[k,:,m])

m1 = np.array([[1,2],[3,4]],dtype = np.float32)
m2 = np.array([[5,6],[7,8]],dtype = np.float32)
result_dot = np.dot(m1,m2)
result_at = m1@m2
print("矩阵 1")
print(m1)
print("矩阵 2")
print(m2)
print("使⽤ np.dot 得到的矩阵乘法结果:")
print(result_dot)
#输出
矩阵 1
[[1. 2.]
 [3. 4.]]
矩阵 2
[[5. 6.]
 [7. 8.]]
使⽤ np.dot 得到的矩阵乘法结果:
[[19. 22.]
 [43. 50.]]

Numpy广播机制

⼴播 (Broadcast) 是 numpy 对不同形状 (shape) 的数组进⾏数值计算的⽅式，对数组的算术运算通常在相应的元素上进⾏。如果两个数组 a 和 b 形状相同，即满⾜ a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的⻓度相同。

a = np.array([(1,2),(4,5),(1,1)])
b = np.array([1,2])# shape(2)→→ shape(1,2) →→ shape(3,2)
a+b
#输出
array([[2, 4],
       [5, 7],
       [2, 3]])