Numpy
Numpy数组的属性
arr = np.array([[1, 2, 3],
[4, 5, 6]])
print(arr)
print('dim:', arr.ndim) # 查看arr数组的维度
print('shape:', arr.shape) # 查看arr数组的形状，即几行几列
print('size:', arr.size) # 查看arr数组共有多少个元素
print('type:', arr.dtype) # 查看arr数组中的元素是什么类型
print('data:', arr.data) # 查看arr数组数据开头的内存地址
print('itemsize:', arr.itemsize) # 查看arr数组中每一个元素占用的内存大小，以字节为单位
# arr.flat是数组迭代器，可以用在for循环中迭代输出数组中的每一个元素
# arr.flatten()，把多维数组降维成一维数组
---------
[[1 2 3]
[4 5 6]]
dim: 2
shape: (2, 3)
size: 6
type: int32
data: <memory at 0x000002A9DD4B0E48>
itemsize: 4
Numpy数组的几个特殊的生成方法
arr1 = np.zeros((3, 4)) # 生成3行4列的全零矩阵
arr2 = np.ones((3, 4), dtype=int) # 生成3行4列数据类型为整型的全一矩阵
arr3 = np.eye(3) # 生成对角线元素全为一的3阶矩阵
print(arr1)
print('-'*9)
print(arr2)
print('-'*9)
print(arr3)
---------
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
---------
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]
---------
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
Numpy数组的数据生成
arr1 = np.arange(12) # 生成0到11的数值，以一维数组的形式返回
arr2 = np.arange(12).reshape(3, 4) # 重塑为3行4列的矩阵
arr3 = np.arange(10, 21, 2).reshape(2, 3) # 步长为2生成10到20的数值，重塑为2行3列的矩阵
arr4 = np.linspace(1, 10, 5) # 均匀间隔生成1到10的5个数值，以一维数组的形式返回
arr5 = np.linspace(50, 100, 6).reshape(2, 3) # 重塑为2行3列的矩阵
print(arr1)
print('-'*9)
print(arr2)
print('-'*9)
print(arr3)
print('-'*9)
print(arr4)
print('-'*9)
print(arr5)
---------
[ 0 1 2 3 4 5 6 7 8 9 10 11]
---------
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
---------
[[10 12 14]
[16 18 20]]
---------
[ 1. 3.25 5.5 7.75 10. ]
---------
[[ 50. 60. 70.]
[ 80. 90. 100.]]
一维数组的基础运算
a = np.array([10, 20, 30, 40])
b = np.arange(4) # [0 1 2 3]
arr1 = a + b # 相加，对应元素相加
arr2 = a - b # 相减，对应元素相减
arr3 = a * b # 相乘，对应元素相乘
arr4 = a / b # 相除，对应元素相除
arr5 = np.dot(a, b)
arr6 = np.dot(b, a)
arr7 = b ** 2 # 平方，各元素平方
print(arr1)
print(arr2)
print(arr3)
print(arr4)
print(arr5)
print(arr6)
print(arr7)
print(b < 3) # 判断b数组中哪些元素小于3，以数组形式返回，元素类型为布尔型
---------
[10 21 32 43]
[10 19 28 37]
[ 0 20 60 120]
[ inf 20. 15. 13.33333333]
200
200
[0 1 4 9]
[ True True True False]
二维数组的基础运算
a = np.array([[10, 20, 30],
[40, 50, 60]])
b = np.array([[1, 2, 3],
[4, 5, 6]])
c = np.array([[1, 2],
[3, 4],
[5, 6]])
arr1 = a + b # 相加，对应元素相加
arr2 = a - b # 相减，对应元素相减
arr3 = a * b # 相乘，对应元素相乘
arr4 = a / b # 相除，对应元素相除
arr5 = b ** 2 # 平方，各元素平方
arr6 = np.dot(a, c) # 矩阵乘法，a乘c; 也可写成 a.dot(c)
arr7 = np.dot(c, a) # 矩阵乘法，c乘a; 也可写成 c.dot(a)
print(arr1)
print('-'*9)
print(arr2)
print('-'*9)
print(arr3)
print('-'*9)
print(arr4)
print('-'*9)
print(arr5)
print('-'*9)
print(arr6)
print('-'*9)
print(arr7)
print('-'*9)
print(b < 3) # 判断b数组中哪些元素小于3，以数组形式返回，元素类型为布尔型
---------
[[11 22 33]
[44 55 66]]
---------
[[ 9 18 27]
[36 45 54]]
---------
[[ 10 40 90]
[160 250 360]]
---------
[[10. 10. 10.]
[10. 10. 10.]]
---------
[[ 1 4 9]
[16 25 36]]
---------
[[220 280]
[490 640]]
---------
[[ 90 120 150]
[190 260 330]
[290 400 510]]
---------
[[ True True False]
[False False False]]
数组的求和、最小值、最大值、平均值、中位数…
arr = []
for i in range(12):
arr.append(np.random.randint(1, 10))
arr = np.array(arr).reshape(3, 4)
aw = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.10, 0.11, 0.12])
print(arr)
print('sum:')
print(np.sum(arr)) # 计算arr数组中所有元素的和；也可写成 arr.sum()
print(np.sum(arr, axis=0)) # 计算arr数组中每一列元素的和
print(np.sum(arr, axis=1)) # 计算arr数组中每一行元素的和
print('min:')
print(np.min(arr)) # arr数组中最小的元素值；也可写成 arr.min()
print(np.min(arr, axis=0)) # arr数组中每一列的最小元素值
print(np.min(arr, axis=1)) # arr数组中每一行的最小元素值
print('max:')
print(np.max(arr)) # arr数组中最大的元素值；也可写成 arr.max()
print(np.max(arr, axis=0)) # arr数组中每一列的最大元素值
print(np.max(arr, axis=1)) # arr数组中每一行的最大元素值
print('mean:')
print(np.mean(arr)) # 计算arr数组中所有元素的平均值；也可写成 arr.mean()
print(np.mean(arr, axis=0)) # 计算arr数组中每一列元素的平均值
print(np.mean(arr, axis=1)) # 计算arr数组中每一行元素的平均值
# np.average()可以计算加权平均
print('average:')
print(np.average(arr)) # 计算arr数组中所有元素的平均值；在不加权的情况下与np.mean()是一模一样的
print(np.average(arr, weights=aw.reshape(3, 4))) # 计算arr数组中所有元素的加权平均值
print('median:')
print(np.median(arr)) # 计算arr数组的中位数，会先排序
print(np.median(arr, axis=0)) # 计算arr数组中每一列的中位数
print(np.median(arr, axis=1)) # 计算arr数组中每一行的中位数
print('arg:')
print(np.argmin(arr)) # arr数组中最小元素值的索引；把二维数组看成是一维数组，再取索引
print(np.argmax(arr)) # arr数组中最大元素值的索引；把二维数组看成是一维数组，再取索引
print('cumsum:')
print(np.cumsum(arr)) # 计算arr数组的前缀和
print('diff:')
print(np.diff(arr)) # 沿给定轴计算离散差，在二维数组中默认axis=1
print('sort:')
print(np.sort(arr)) # 沿给定轴排序，在二维数组中默认axis=1；当axis=None时，把二维数组当作一维数组来排序
print('transpose:')
print(np.transpose(arr)) # 矩阵的转置，也可以写成 arr.T
print('clip:')
print(np.clip(arr, 3, 7)) # arr数组的形状不变，所有小于3的数值都等于3，所有大于7的数值都等于7
---------
[[2 2 4 8]
[5 2 9 6]
[7 1 7 4]]
sum:
57
[14 5 20 18]
[16 22 19]
min:
1
[2 1 4 4]
[2 2 1]
max:
9
[7 2 9 8]
[8 9 7]
mean:
4.75
[4.66666667 1.66666667 6.66666667 6. ]
[4. 5.5 4.75]
average:
4.75
5.683229813664597
median:
4.5
[5. 2. 7. 6.]
[3. 5.5 5.5]
arg:
9
6
cumsum:
[ 2 4 8 16 21 23 32 38 45 46 53 57]
diff:
[[ 0 2 4]
[-3 7 -3]
[-6 6 -3]]
sort:
[[2 2 4 8]
[2 5 6 9]
[1 4 7 7]]
transpose:
[[2 5 7]
[2 2 1]
[4 9 7]
[8 6 4]]
clip:
[[3 3 4 7]
[5 3 7 6]
[7 3 7 4]]
Numpy数组的索引
arr = np.arange(3, 15)
print(arr)
print('对一维数组索引取值:')
print(arr[2]) # 对一维数组索引取值，与列表的索引取值形式一样
arr = arr.reshape(3, 4)
print(arr)
print('对二维数组索引取值:')
print(arr[2]) # 对二维数组索引取值，取到的是一行元素
print('对二维数组取某个具体值:')
print(arr[2][1]) # 也可以写成 arr[2, 1]
print('对二维数组取某一行或某一列的所有或部分元素:')
print(arr[1, :]) # 行索引为1的所有元素值
print(arr[1, 1:3]) # 行索引为1且列索引为1-2的元素值
print(arr[:, 1]) # 列索引为1的所有元素值
print(arr[:2, 1]) # 行索引为0-1且列索引为1的元素值
print('对二维数组迭代:')
for row in arr: # 对二维数组进行迭代，每一次输出的都是一个行
print(row)
for column in arr.T: # 如果要对二维数组的列进行迭代输出，则需要对矩阵做转置或其它操作
print(column)
for element in arr.flat: # 迭代输出数组中的每一个元素，arr.flat是数组迭代器
print(element)
print('把多维数组展平成一维数组:')
print(arr.flatten())
---------
[ 3 4 5 6 7 8 9 10 11 12 13 14]
对一维数组索引取值:
5
[[ 3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]]
对二维数组索引取值:
[11 12 13 14]
对二维数组取某个具体值:
12
对二维数组取某一行或某一列的所有或部分元素:
[ 7 8 9 10]
[8 9]
[ 4 8 12]
[4 8]
对二维数组迭代:
[3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]
[ 6 10 14]
3
4
5
6
7
8
9
10
11
12
13
14
把多维数组展平成一维数组:
[ 3 4 5 6 7 8 9 10 11 12 13 14]
Numpy数组的合并
# 二维数组中只有一行元素，比如[[1, 2, 3]]，shape为(1, 3)
# 一维数组，比如[1, 2, 3]，shape为(3,)
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.array([[10, 20, 30],
[40, 50, 60]])
d = np.array([[100, 200, 300],
[400, 500, 600]])
print('对一维数组:')
print(np.vstack((a, b))) # 数组在列向上合并，即行与行合并
print(np.hstack((a, b))) # 数组在行向上合并，即列与列合并
print(np.concatenate((a, b))) # a与b的shape都是(3,)，默认axis=0
print('对二维数组:')
print(np.vstack((c, d))) # 数组在列向上合并
print(np.hstack((c, d))) # 数组在行向上合并
# np.concatenate()根据shape中的维度合并数组，axis=0表示第0维，axis=1表示第1维
print(np.concatenate((c, d), axis=0)) # c与d的shape都是(2, 3)，合并后的shape为(4, 3)
print(np.concatenate((c, d), axis=1)) # c与d的shape都是(2, 3)，合并后的shape为(2, 6)
---------
对一维数组:
[[1 2 3]
[4 5 6]]
[1 2 3 4 5 6]
[1 2 3 4 5 6]
对二维数组:
[[ 10 20 30]
[ 40 50 60]
[100 200 300]
[400 500 600]]
[[ 10 20 30 100 200 300]
[ 40 50 60 400 500 600]]
[[ 10 20 30]
[ 40 50 60]
[100 200 300]
[400 500 600]]
[[ 10 20 30 100 200 300]
[ 40 50 60 400 500 600]]
Numpy数组的分割
arr = np.arange(12).reshape(3, 4)
print(arr)
# np.split()对数组进行行与列的均等分割，返回的是列表；分割后的行或列还是数组类型，并且都是列表的元素；如果不是均等分割会报错
print('split:')
print(np.split(arr, 3, axis=0)) # 在列向上把arr数组均等分割成3个部分，即按行分割，每一个部分都是列表的一个元素
print(np.split(arr, 2, axis=1)) # 在行向上把arr数组均等分割成2个部分，即按列分割，每一个部分都是列表的一个元素
# np.array_split可以进行行与列的非均等分割，返回的是列表；分割后的行或列还是数组类型，并且都是列表的元素
print('array_split:')
print(np.array_split(arr, 2, axis=0)) # 在列向上把arr数组分割成2个部分，即按行分割，每一个部分都是列表的一个元素
print(np.array_split(arr, 3, axis=1)) # 在行向上把arr数组均等分割成3个部分，即按列分割，每一个部分都是列表的一个元素
print('vsplit & hsplit:')
# np.vsplit() & np.hsplit()也是对数组进行行与列的均等分割，返回的是列表；分割后的行或列还是数组类型，并且都是列表的元素；如果不是均等分割会报错
print(np.vsplit(arr, 3))
print(np.hsplit(arr, 2))
---------
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
split:
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
array_split:
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
vsplit & hsplit:
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
Numpy数组的赋值与copy
a = np.array([1, 2, 3, 4])
b = a
c = b
print('赋值:')
print(a)
print(b)
print(c)
# 把numpy数组a赋值给b，改变a则b也会改变；再把b赋值给c，改变a同样会改变c
a[2] = 9
print(a)
print(b)
print(c)
# 把numpy数组a赋值给b，改变b则a也会改变；再把b赋值给c，改变b同样会改变c
b[3] = 16
print(a)
print(b)
print(c)
# numpy数组本身与赋值后的变量是同一个东西，即a就是b就是c
print(a is b is c)
d = a.copy()
print('copy:')
print(a)
print(d)
# 改变a，d不会改变
a[0] = 10
print(a)
print(d)
# 改变d，a不会改变
d[1] = 4
print(a)
print(d)
# numpy数组本身与np.copy()后的变量是相互独立的
print(a is d)
---------
赋值:
[1 2 3 4]
[1 2 3 4]
[1 2 3 4]
[1 2 9 4]
[1 2 9 4]
[1 2 9 4]
[ 1 2 9 16]
[ 1 2 9 16]
[ 1 2 9 16]
True
copy:
[ 1 2 9 16]
[ 1 2 9 16]
[10 2 9 16]
[ 1 2 9 16]
[10 2 9 16]
[ 1 4 9 16]
False
版权声明：本文为weixin_48158964原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。