Numpy

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