Python-numpy 笔记整理

只记录自己不熟的
Referece：
https://vitu.ai/course/65598890065315648
某速查表
https://www.cnblogs.com/rrttp/p/8028421.html
https://www.jianshu.com/p/cbd0db72058e

构造多维数组（矩阵）

import numpy as np
a = np.arange(20)
a = a.reshape(4, 5)
print(a)
a = a.reshape(2, 2, 5)
print(a)

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
 
 [[[ 0  1  2  3  4]
  [ 5  6  7  8  9]]

 [[10 11 12 13 14]
  [15 16 17 18 19]]]

既然a是array，我们还可以调用array的函数进一步查看a的相关属性："ndim"查看维度；"shape"查看各维度的大小；"size"查看全部的元素个数，等于各维度大小的乘积；"dtype"可查看元素类型；"dsize"查看元素占位（bytes）大小。

a.ndim
a.shape
a.size
a.dtype

创建数组

raw = [0,1,2,3,4]
a = np.array(raw)
raw = [[0,1,2,3,4], [5,6,7,8,9]]
b = np.array(raw)

一些特殊的数组有特别定制的命令生成，如4*5的全零矩阵：

d = (4, 5)
np.zeros(d)
np.ones(d, dtype=int)

array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])
array([[1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1]])

数组操作

全部的’+’，’-’，’’，’/‘运算都是基于全部的数组元素的。
两个二维数组相加要求各维度大小相同。当然，NumPy里这些运算符也可以对标量和数组操作，结果是数组的全部元素对应这个标量进行运算，还是一个数组。
类似C++，’+=’、’-=’、’=’、’/='操作符在NumPy中同样支持：

print("a:")
print(a)
print("np.exp(a):")
print(np.exp(a))
print("np.sqrt(a):")
print(np.sqrt(a))
print("np.square(a):")
print(np.square(a))
print("np.power(a, 3):")
print(np.power(a, 3))

需要知道二维数组的最大最小值怎么办？想计算全部元素的和、按行求和、按列求和怎么办？for循环吗？不，NumPy的ndarray类已经做好函数了：

a = np.arange(20).reshape(4,5)
print("a:")
print(a)
print("sum of all elements in a: " + str(a.sum()))
print("maximum element in a: " + str(a.max()))
print("minimum element in a: " + str(a.min()))
print("maximum element in each row of a: " + str(a.max(axis=1)))
print("minimum element in each column of a: " + str(a.min(axis=0)))

a:
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
sum of all elements in a: 190
maximum element in a: 19
minimum element in a: 0
maximum element in each row of a: [ 4  9 14 19]
minimum element in each column of a: [0 1 2 3 4]

也许简单的来记就是axis=0代表往跨行（down)，而axis=1代表跨列（across)，作为方法动作的副词。换句话说:

• 使用0值表示沿着每一列或行标签\索引值向下执行方法
• 使用1值表示沿着每一行或者列标签模向执行对应的方法

科学计算中大量使用到矩阵运算，除了数组，NumPy同时提供了矩阵对象（matrix）。矩阵对象和数组的主要有两点差别：一是矩阵是二维的，而数组的可以是任意正整数维；二是矩阵的’‘操作符进行的是矩阵乘法，乘号左侧的矩阵列和乘号右侧的矩阵行要相等，而在数组中’'操作符进行的是每一元素的对应相乘，乘号两侧的数组每一维大小需要一致。数组可以通过asmatrix或者mat转换为矩阵，或者直接生成也可以：

a = np.arange(20).reshape(4, 5)
a = np.asmatrix(a)
b = np.matrix('1.0 2.0; 3.0 4.0')

使用arange生成另一个矩阵b，arange函数还可以通过arange(起始，终止，步长)的方式调用生成等差数列，注意含头不含尾：

b = np.arange(2, 45, 3).reshape(5, 3)
b = np.mat(b)
#生成一维（start，stop，num）起始、终止、个数
np.linspace(0, 2, 9)

数组元素访问

可以通过下标访问来修改数组元素的值

a = np.array([[3.2, 1.5], [2.5, 4]])
b = a
a[0][1] = 2.0
print("a:")
print(a)
print("b:")
print(b)

现在问题来了，明明改的是a[0][1]，怎么连b[0][1]也跟着变了？这个陷阱在Python编程中很容易碰上，其原因在于Python不是真正将a复制一份给b，而是将b指到了a对应数据的内存地址上。想要真正的复制一份a给b，可以使用copy：

a = np.array([[3.2, 1.5], [2.5, 4]])
b = a.copy()#深度拷贝
#创建数组的副本
#np.copy(a)
a[0][1] = 2.0
print("a:")
print(a)
print("b:")
print(b)

区分“=”号和copy的区别，新手踩点。

利用切片’:'可以访问到某一维的全部数据，例如取矩阵中的指定列：

a = np.arange(20).reshape(4, 5)
print("a:")
print(a)
print("the 2nd and 4th column of a:")
print(a[:,[1,3]])

可使用where函数查找特定值在数组中的位置：

loc = numpy.where(a==11)
print(loc)
print(loc[0][0],loc[1][0])
print(a[loc[0][0], loc[1][0]])

(array([2]), array([1]))
2 1
11

数组操作

矩阵转置:

在这里插入代码片a = np.random.rand(2,4)
print("a:")
print(a)
a = np.transpose(a)
print("a is an array, by using transpose(a):")
print(a)
b = np.random.rand(2,4)
b = np.mat(b)
print("b:")
print(b)
print("b is a matrix, by using b.T:")
print(b.T)

a:
[[0.44700403 0.15124915 0.98673924 0.8960694 ]
 [0.34178734 0.62996559 0.44709344 0.95187586]]
a is an array, by using transpose(a):
[[0.44700403 0.34178734]
 [0.15124915 0.62996559]
 [0.98673924 0.44709344]
 [0.8960694  0.95187586]]
b:
[[0.73047661 0.39316143 0.64073751 0.23083609]
 [0.50107713 0.89359348 0.43847597 0.85086228]]
b is a matrix, by using b.T:
[[0.73047661 0.50107713]
 [0.39316143 0.89359348]
 [0.64073751 0.43847597]
 [0.23083609 0.85086228]]

矩阵求逆

import numpy.linalg as nlg
a = np.random.rand(2,2)
a = np.mat(a)
print("a:")
print(a)
ia = nlg.inv(a)
print("inverse of a:")
print(ia)
print("a * inv(a)")
print(a * ia)

a * inv(a)基本不会等回于1

a:
[[0.09518872 0.22478887]
 [0.63148552 0.62333853]]
inverse of a:
[[-7.54499869  2.72088388]
 [ 7.64361135 -1.15218095]]
a * inv(a)
[[ 1.0000000e+00 -2.3175063e-18]
 [-1.8267241e-16  1.0000000e+00]]

求特征值和特征向量

a = np.random.rand(3,3)
eig_value, eig_vector = nlg.eig(a)
print("eigen value:")
print(eig_value)
print("eigen vector:")
print(eig_vector)

eigen value:
[ 1.09899566 -0.79780077  0.08959699]
eigen vector:
[[-0.60173274 -0.68473823 -0.15828174]
 [-0.68469162  0.66081492 -0.07746116]
 [-0.41123606 -0.30733892  0.98435088]]

按列拼接两个向量成一个矩阵

a = np.array((1,2,3))
b = np.array((2,3,4))
print(np.column_stack((a,b)))

在循环处理某些数据得到结果后，将结果拼接成一个矩阵是十分有用的，可以通过vstack和hstack完成：

a = np.random.rand(2,2)
b = np.random.rand(2,2)
print("a:")
print(a)
print("b:")
print(b)
c = np.hstack([a,b])
d = np.vstack([a,b])
print("horizontal stacking a and b:")
print(c)
print("vertical stacking a and b:")
print(d)

a:
[[0.22168551 0.82199303]
 [0.32527535 0.01246789]]
b:
[[0.82914286 0.64084578]
 [0.04604942 0.07175226]]
horizontal stacking a and b:
[[0.22168551 0.82199303 0.82914286 0.64084578]
 [0.32527535 0.01246789 0.04604942 0.07175226]]
vertical stacking a and b:
[[0.22168551 0.82199303]
 [0.32527535 0.01246789]
 [0.82914286 0.64084578]
 [0.04604942 0.07175226]]

分割数组

#纵向分割数组为3等份
np.hsplit(a,3)
#横向分割数组为2等份
np.vsplit(c,2)

缺失值

缺失值在分析中也是信息的一种，NumPy提供nan作为缺失值的记录，通过isnan判定。nan_to_num可用来将nan替换成0，但只在当前print中替换。

a = np.random.rand(2,2)
a[0, 1] = np.nan
print(np.isnan(a))
print(np.nan_to_num(a))
print(a)

[[False  True]
 [False False]]
[[0.38132598 0.        ]
 [0.72693486 0.29079685]]
[[0.38132598        nan]
 [0.72693486 0.29079685]]

文件读写

保存与载入磁盘上的文件

np.save('my_array', a)
np.savez('array.npz', a, b)
np.load('my_array.npy')

保存与载入文本文件

np.loadtxt("myfile.txt")
np.genfromtxt("my_file.csv", delimiter=',')
np.savetxt("myarray.txt", a, delimiter=" ")

末尾速查表，有中文版，自行查找