Numpy
Numpy是一个专门用来做科学计算的一个包，数据存储结构是纯数组，也就是没有索引跟列名的，所以运算速度快!
数组创建 数组属性
import numpy as np
import warnings
warnings.filterwarnings('ignore')创建一维数组 array([])
arr1 = np.array([0,1,2,3,4,5,6,7,8])
print(arr1)[0 1 2 3 4 5 6 7 8]
# 数组的维度 m*n
print('数组维度:',arr1.shape)
# 数组轴的个数
print('数组轴个数:',arr1.ndim)
# 数组元素的总个数
print('元素总个数:',arr1.size)
# 描述数组中元素类型的对象
print(arr1.dtype)数组维度: (9,)
数组轴个数: 1
元素总个数: 9
int32
创建二维数组
#二维数组
arr2 = np.arange(9).reshape(3,3)# 3行3列
print(arr2)[[0 1 2]
[3 4 5]
[6 7 8]]
# 数组的维度 m*n
print('数组维度:',arr2.shape)
# 数组轴的个数
print('数组轴个数:',arr2.ndim)
# 数组元素的总个数
print('元素总个数:',arr2.size)数组维度: (3, 3)
数组轴个数: 2
元素总个数: 9
#三维数组
arr3 = np.arange(27).reshape(3, 3, 3)
print(arr3)[[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]]
[[ 9 10 11]
[12 13 14]
[15 16 17]]
[[18 19 20]
[21 22 23]
[24 25 26]]]
# 数组的维度 m*n
print('数组维度:',arr3.shape)
# 数组轴的个数
print('数组轴个数:',arr3.ndim)
# 数组元素的总个数
print('元素总个数:',arr3.size)数组维度: (3, 3, 3)
数组轴个数: 3
元素总个数: 27
创建数值全为0或1的数组
print(np.zeros((3,3,3)))[[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]]
print(np.ones((3,3,3)))[[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]]
描述数组中元素类型 array.dtype
# 描述数组中元素类型的对象
print(arr1.dtype)int32
数组元素类型转换
# 转换数组中元素的类型
arr4 = np.array([1,2,3,4,5], dtype='float64')
arr5 = np.array([1,2,3,4,5], dtype='complex')
print(arr4)
print(arr4.dtype)
print(arr5)
print(arr5.dtype)[1. 2. 3. 4. 5.]
float64
[1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j]
complex128
数组运算 常用函数
数组运算
arr6 = np.array([20,30,40,50])
arr7 = np.arange(4)print(arr6-arr7)[20 29 38 47]
print(arr6*2)[ 40 60 80 100]
常用函数
# 返回输入数量的等比间隔，linspace(start, stop, num=50)
arr8 = np.linspace(1,4,4)arr8array([1., 2., 3., 4.])
# 求和
print(arr8.sum())10.0
# 累加
print(arr8.cumsum())[ 1. 3. 6. 10.]
# 对数
print(np.log(arr8))[0. 0.69314718 1.09861229 1.38629436]
# 指数
print(np.exp(arr8))[ 2.71828183 7.3890561 20.08553692 54.59815003]
# 开方
print(np.sqrt(arr8))[1. 1.41421356 1.73205081 2. ]
print(arr2)[[0 1 2]
[3 4 5]
[6 7 8]]
print(arr2[:,1])[1 4 7]
print(arr2[1, :])[3 4 5]
print(arr2[arr2>3])[4 5 6 7 8]
print(arr3)[[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]]
[[ 9 10 11]
[12 13 14]
[15 16 17]]
[[18 19 20]
[21 22 23]
[24 25 26]]]
print(arr3[-1][:,-1])[20 23 26]
print(arr3[0:,0:2,0:2])[[[ 0 1]
[ 3 4]]
[[ 9 10]
[12 13]]
[[18 19]
[21 22]]]
# 迭代
for row in arr3[0][0]:
print(row)0
1
2
# flat数组元素迭代器
for element in arr3.flat:
print(element)0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
创建一个10*10的数组，并且边框是1，里面是0
# 将多维数组降成一维
print(arr2.ravel())[0 1 2 3 4 5 6 7 8]
a1 = np.array([9,10,11])# 横向添加数组
a2 = np.vstack((arr2,a1))
print(a2)[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
# 不改变原有数组
print(a2.reshape(2,6))[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
a3 = a2.reshape(2,6)# 改变原有数组
a2.resize(2,6)print(a2)[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
# 转变形状
print(a2.transpose())[[ 0 6]
[ 1 7]
[ 2 8]
[ 3 9]
[ 4 10]
[ 5 11]]
print(a2)[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
# 垂直切分
print(np.hsplit(a2,3))[array([[0, 1],
[6, 7]]), array([[2, 3],
[8, 9]]), array([[ 4, 5],
[10, 11]])]
# 生成对角矩阵
print(np.eye(5))[[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]]
矩阵相乘
矩阵A和B必须是相符的矩阵，A的列要等于B的行。
A = np.array([
[1, 2],
[4, 5],
[7, 8]
])
B = np.array([
[4, 4, 2],
[2, 3, 1],
])
print(np.dot(A, B))[[ 8 10 4]
[26 31 13]
[44 52 22]]
矩阵与逆矩阵相乘为 [[1,0][0,1]]
A=np.array([[2,1,2],[1,-2,-1],[-1,-2,1]])
# 计算逆矩阵
A_=np.linalg.inv(A)
print(A)
print(A_)
print(np.dot(A,A_))[[ 2 1 2]
[ 1 -2 -1]
[-1 -2 1]]
[[ 0.25 0.3125 -0.1875]
[-0. -0.25 -0.25 ]
[ 0.25 -0.1875 0.3125]]
[[ 1.00000000e+00 -5.55111512e-17 0.00000000e+00]
[ 0.00000000e+00 1.00000000e+00 0.00000000e+00]
[ 0.00000000e+00 -2.77555756e-17 1.00000000e+00]]