Python中列表(list)，虽然可以当作数组使用，但是由于列表中的元素可以是任意对象，因此列表中所保存的是对象的指针，一个元素拥有一个指针和一个对象。对于数值运算来说，这种结构比较浪费。
此外，Python的array模块，虽然可以直接保存数值，但是不支持多维，也没有各种函数。
而NumPy库提供了两种基本对象，弥补了这一不足：
- ndarray：存储单一数据类型的多维数组
- ufunc：能够对数组进行处理的函数
目录
数组的创建
- 使用array将列表或元组转换成ndarray数组
import numpy as np
a1 = np.array([1, 2, 3, 4])
print('a1=', a1) # 输出：a1= [1 2 3 4]
print(a1.dtype) # 输出：int32
a2 = a1.astype(float) # astype用于数组的数据类型转换。
print('a2=', a2) # 输出：a2= [1. 2. 3. 4.]
print(a2.dtype) # 输出：float64
a3 = np.array([1, 2, 3, 4], dtype=float)
print('a3=', a3) # 输出：a3= [1. 2. 3. 4.]
print(a3.dtype) # 输出：float64
b = np.array([[1, 2, 3], [4, 5, 6]])
print('b=', b)
'''
输出：
b= [[1 2 3]
[4 5 6]]
'''- 使用arange在给定区间内创建等差数组，语法：arange(strat,stip,step,dtpye)，生成区间[start, stop)上步长为step的等差数组，dtype表示数据类型
import numpy as np
c = np.arange(1, 5)
print('c=', c) # 输出：c= [1 2 3 4]
h = np.arange(20, 50, 2)
print('h=', h) # 输出：h= [20 22 24 26 28 30 32 34 36 38 40 42 44 46 48]- 使用linspace在给定区间内创建间隔相等的数组，语法：linspace(start,stop,num,endpoint )， 生成区间[start, stop]上间隔相等的num个元素的等差数组，num的默认值为50，endpoint默认为True
import numpy as np
d = np.linspace(2, 8, 4)
print('d=', d) # 输出：d= [2. 4. 6. 8.]
- 使用logspace在给定区间上生成等比数组，语法：logspace(start,stop,num,endpoint,base), 生成区间[base^start, base^stop]上的num个元素的等比数组，base默认值为10，endpoint默认为True
import numpy as np
e = np.logspace(1, 3, 3, base=2)
print('e=', e) # 输出：e= [2. 4. 8.]- 使用ones、zeros、empty和ones_like等函数，ones默认float型
import numpy as np
a0 = np.ones(4)
print('a0=', a0) # 输出：a0= [1. 1. 1. 1.]
a = np.ones(4, dtype=int)
print('a=', a) # 输出：a= [1 1 1 1]
b = np.ones((4,), dtype=int) # 同a
print('b=', b) # 输出：b= [1 1 1 1]
c = np.ones((4, 1)) # 生成4行1列的数组
print('c=', c)
'''
输出：
c= [[1.]
[1.]
[1.]
[1.]]
'''
print(c.dtype) # 输出：float64
d = np.zeros(4)
print('d=', d) # 输出：d= [0. 0. 0. 0.]
e = np.empty(3)
print('e=', e) # 输出：e= [0. 0.5 1. ]
f = np.eye(3) # 生成3阶单位阵
print('f=', f)
'''
输出：
f= [[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
'''
g = np.eye(3, k=1) # 生成第k对角线的元素为1，其他元素为0的3阶方阵
print('g=', g)
'''
输出：
g= [[0. 1. 0.]
[0. 0. 1.]
[0. 0. 0.]]
'''
h = np.zeros_like(a) # 生成与a同维数的全0数组
print('h=', h) # 输出：h= [0 0 0 0]数组元素的索引
一维数组
数组名[start:end:step]，前闭后开
二维数组
数组名[行号][列号]或者数组名[行号,列号]
import numpy as np
print(list(np.arange(16)))
# 输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
a = np.arange(16).reshape(4, 4) # 生成4行4列的数组
print(a)
'''
输出：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
'''
b = a[1][2]
print(b)
# 输出：6
c = a[1, 2] # 同b
print(c)
# 输出：6布尔索引和花式索引
import numpy as np
a = np.arange(16).reshape(4, 4) # 生成4行4列的数组
print(a)
'''
输出：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
'''
d = a[1:2, 2:3] # 输出[[6]],行选第2行，列选第3列
print(d)
# 输出：[[6]]
x = np.array([0, 1, 2, 1])
print(a[x == 1]) # 布尔索引 输出a的第2、4行元素
'''
[[ 4 5 6 7]
[12 13 14 15]]
'''矩阵合并
上下合并vstack([A,B])
左右合并hstack([A,B])
import numpy as np
a = np.arange(16).reshape(4, 4) # 生成4行4列的数组
print('a=', a)
'''
输出：
a= [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
'''
b = np.floor(5 * np.random.random((2, 4))) # floor向下取整3.14取为3
print('b=', b)
'''
输出：
b= [[0. 1. 0. 0.]
[0. 0. 0. 1.]]
'''
c = np.ceil(6 * np.random.random((4, 2))) # ceil向上取整3.14取为4
print('c=', c)
'''
输出：
c= [[1. 4.]
[2. 4.]
[3. 3.]
[4. 3.]]
'''
d = np.vstack([a, b]) # 上下合并矩阵
print('d=', d)
'''
输出：
d= [[ 0. 1. 2. 3.]
[ 4. 5. 6. 7.]
[ 8. 9. 10. 11.]
[12. 13. 14. 15.]
[ 4. 4. 1. 3.]
[ 2. 4. 2. 1.]]
'''
e = np.hstack([a, c]) # 左右合并矩阵
print('e=', e)
'''
输出：
e= [[ 0. 1. 2. 3. 5. 2.]
[ 4. 5. 6. 7. 6. 3.]
[ 8. 9. 10. 11. 5. 1.]
[12. 13. 14. 15. 5. 3.]]
'''
矩阵分割
按行分割vsplit(a,m)
按列分割hsplit(a,n)
import numpy as np
a = np.arange(16).reshape(4, 4) # 生成4行4列的数组
print('a=', a)
'''
输出：
a= [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
'''
b = np.vsplit(a, 2) # 行分割，把a平均分成2个行数组
print('b=把a按行分割:\n', b[0], '\n', b[1])
'''
输出：
b=把a按行分割:
[[0 1 2 3]
[4 5 6 7]]
[[ 8 9 10 11]
[12 13 14 15]]
'''
c = np.hsplit(a, 4) # 列分割，把a平均分成4个列数组
print('c=把a按列分割:\n', c[0], '\n', c[1], '\n', c[2], '\n', c[3])
'''
输出：
c=把a按列分割:
[[ 0]
[ 4]
[ 8]
[12]]
[[ 1]
[ 5]
[ 9]
[13]]
[[ 2]
[ 6]
[10]
[14]]
[[ 3]
[ 7]
[11]
[15]]
'''矩阵的简单运算
矩阵求和
import numpy as np
a = np.array([[0, 3, 4], [1, 6, 4]])
print('a= ', a)
'''
输出：
a= [[0 3 4]
[1 6 4]]
'''
b = a.sum() # 使用方法，求矩阵所有元素的和
print('b= ', b) # 输出：b= 18
c1 = sum(a) # 使用内置函数，求矩阵逐列元素的和
print('c1= ', c1) # 输出：c1= [1 9 8]
c2 = np.sum(a, axis=0) # 使用函数，求矩阵逐列元素的和.axis=0是逐列求和,axis=1是逐行求和
print('c2=', c2) # 输出：c2= [1 9 8]
c3 = np.sum(a, axis=0, keepdims=True) # 逐列求和.keepdims=True是保持其原来的维数
print('c3= ', c3) # 输出：c3= [[1 9 8]]
print(c2.shape, c3.shape) # 输出数组行列信息
# 输出：(3,) (1, 3)矩阵的逐个元素运算
对矩阵进行+，-，*，/，**，运算，如果两个矩阵维数不同，则广播后进行运算
import numpy as np
a = np.array([[0, 3, 4], [1, 6, 4]])
b = np.array([[1, 2, 3], [2, 1, 4]])
c = a / b # 两个矩阵对应元素相除
print('c= ', c)
'''
输出：
c= [[0. 1.5 1.33333333]
[0.5 6. 1. ]]
'''
d = np.array([2, 3, 2]) # d先广播成与a同维数的[[2,3,2],[2,3,2]]矩阵，再逐个元素相乘
e = a * d
print('d=', d) # 输出：d= [2 3 2]
print('e= ', e)
'''
输出：
e= [[ 0 9 8]
[ 2 18 8]]
'''
f = np.array([[3], [2]])
print('f= ', f)
'''
输出：
f= [[3]
[2]]
'''
g = a * f # f先广播成与a同维数的矩阵[[3, 3, 3], [2, 2, 2]]，再逐个元素相乘
print('g= ', g) # 输出：
'''
输出：
g= [[ 0 9 12]
[ 2 12 8]]
'''
h = a ** (1 / 2) # a矩阵逐个元素的1/2次幂。
print('h= ', h)
'''
输出：
h= [[0. 1.73205081 2. ]
[1. 2.44948974 2. ]]
'''矩阵乘法
import numpy as np
a = np.ones(4) # 全为1.0的行向量
print('a=', a) # 输出：a= [1. 1. 1. 1.]
b = np.arange(2, 10, 2) # 区间[2，10)上步长为2的等差数组
print('b=', b) # 输出：b= [2 4 6 8]
c = a @ b # a作为行向量, b作为列向量
print('c=', c) # 输出：c= 20.0
d = np.arange(16).reshape(4, 4) # arange(16):生成[0，16)区间上的等差数组，默认步长为1;常用reshape改变形状
print('d=', d)
'''
输出：
d= [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
'''
f = a @ d # a作为行向量,a的每一行都×d的各列
print('f=a*d=', f) # 输出：f=a*d= [24. 28. 32. 36.]
g = d @ a # a作为列向量，d的每一行都×a的各元素
print('g=d*a=', g) # 输出：g=d*a= [ 6. 22. 38. 54.]
矩阵运算与线性代数
主要使用numpy.linalg模块
求范数
norm(x,ord,axis,keepdims)
- x表示要度量的向量或矩阵
- ord表示范数的种类（1范数，2范数，无穷范数），默认情况下是求整个矩阵元素平方和再开根号
- axis=1表示按行向量处理，axis=0表示按列向量处理，求多个行或列向量的范数；axis默认等于None表示矩阵范数
- keepdims=True表示保持矩阵的二维特性，False反之
import numpy as np
a = np.array([[0, 3, 4], [1, 6, 4]])
b = np.linalg.norm(a, axis=1) # 行向量2范数=行向量的模
print(np.round(b, 4)) # 输出：[5. 7.2801]
c = np.linalg.norm(a, axis=0) # 求列向量2范数
print(np.round(c, 4)) # 输出：[1. 6.7082 5.6569]
d = np.linalg.norm(a)
print(np.round(d, 4)) # 输出：8.8318求线性方程唯一解
import numpy as np
a = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x1 = np.linalg.inv(a) @ b # 第一种解法
x2 = np.linalg.solve(a, b) # 第二种解法
print(x1)
print(x2) # 求得x=2，y=3求超定线性方程组的最小二乘解
最小二乘解:将这组解代入后函数值的平方和最小
import numpy as np
a = np.array([[3, 1], [1, 2], [1, 1]])
b = np.array([9, 8, 6])
x = np.linalg.pinv(a) @ b # linalg.pinv求伪逆，不是方阵或不可逆的情况下.
print(np.round(x, 4)) # 只能求出最小二乘解为x=2，y=3.1667求特征值和特征向量
import numpy as np
a = np.eye(4)
print('a=\n', a)
b = np.rot90(a)
print('b=\n', b)
c, d = np.linalg.eig(b) # 输出第一个量是特征值，第二个量是特征向量
print('特征值为：', c)
print('特征向量为：\n', d)
'''
输出：
a=
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]
b=
[[0. 0. 0. 1.]
[0. 0. 1. 0.]
[0. 1. 0. 0.]
[1. 0. 0. 0.]]
特征值为： [ 1. -1. 1. -1.]
特征向量为：
[[ 0.70710678 0.70710678 0. 0. ]
[ 0. 0. 0.70710678 -0.70710678]
[ 0. 0. 0.70710678 0.70710678]
[ 0.70710678 -0.70710678 0. 0. ]]
'''