Numpy对数组的操作：创建／变形(升降维等)／计算／取值／复制／分割／合并

1. 简介

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。最主要的数据结构是ndarray数组。

NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab。
SciPy 是一个开源的 Python 算法库和数学工具包。SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。
Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。

2. 创建

• 创建一维数组

（1）直接创建：np.array([1, 2, 3, 4, 5, 6])
（2）从python的list中建立：np.array(list([1, 2, 3, 4, 5, 6]))

• 创建常量值的一维数据

（1）创建以0为常量值：np.zeros(n,dytpe=float/int)
（2）创建以1为常量值：np.ones(n)
（3）创建一个空数组：np.empty(4)

• 创建一个元素递增的数组

（1）从0开始增长的递增数组：np.arange(8)
（2）给定区间，自定义步长：np.arange(0,1,0.2)
（3）给定区间，自定义个数：np.linspace(-1,1,50)

• 创建多维数组：创建单维数组，再添加进多维数组

# 数组的结构一定是np.array([]) 无论数组中间存放的是多少“层”数据# 二维数组相当于存放的是“两层”数组而已arr1=np.array(list([1, 2, 3, 4, 5]))arr2=np.array([arr1,[1,0,0,1,0]]) # 2*5的两维数组arr3=np.array(list([[0,0,1,1,1],[1,1,1,0,0],[2,3,4,5,6]])) # 3*5的两维数组arrx=np.array([arr1,list([1, 2, 3, 4, 5],[1,1,1,0,0])]) # 报错arry=np.array([list([[ 1,2,3, 7, 11],[2,3,4,5,6]]),[1, 2, 3, 4, 5]]) # 报错

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

• 创建常量值的(n*m)维数据

（1）创建以0为常量值：np.zeros((n*m),dytpe=float/int)
（2）创建以1为常量值：np.ones((n*m))
（3）创建一个空数组：np.empty((n*m))

• 创建随机数字的数组

• 生成随机数种子：

（1）np.random.seed()
（2）np.random.RandomState()

• 生成随机数：

	函数	取值	说明
1	np.random.rand(d0,d1,…,dn)	[0,1)	根据给定维度生成数组，服从均匀分布
2	np.random.randint(low, high=None, size=None, dtype=’l’)	[0,low)或者[low,high)	根据size生成离散均匀分布的整数值
3	np.random.randn(d0,d1,…,dn)		根据给定维度生成数组，服从标准正态分布
4	np.random.random_sample(size=None)	[0,1)	根据给定维度生成随机浮点数
5	np.random.random(size=None)	[0,1)	根据给定维度生成随机浮点数
6	np.random.ranf(size=None)	[0,1)	根据给定维度生成随机浮点数
7	np.random.sample(size=None)	[0,1)	根据给定维度生成随机浮点数

• 生成有分布规律的随机数组

（1）二项分布：np.random.binomial(n, p, size)
（2）正态分布：np.random.normal(loc, scale, size)

• 将csv文件转化成数组或阵列

使用 np.genfromtxt( ‘csv文件名’，delimiter = ‘文件中的分割符’ )函数将文件转化成数组

 csv_array = np.genfromtxt('sample.csv', delimiter=',') print(csv_array)
1
2

3. 数组的变形

• 生成数组／矩阵转置的函数，即行列数字交换，使用.T

a = np.array([[32, 15, 6, 9, 14], [12, 10, 5, 23, 1], [2, 16, 13, 40, 37]])print(a.T)-------------------# 结果如下[[32 12 2] [15 10 16] [ 6 5 13] [ 9 23 40] [14 1 37]]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

• 改变数组的形状：

（1）arr.resize(n,m) ：arr.resize(n,m)函数是原地修改数组，要求：元素的个数必须一致

a=np.arange(8)a.resize(2,4)print(a)---------------------------[[0 1 2 3] [4 5 6 7]]
1
2
3
4
5
6
7

（2）arr.reshape(n,m)：如果某一个维度的参数为-1，则表示元素总个数会迁就另一个维度来计算

a=np.arange(8).reshape(-1,1)print(a)-----------------[[0] [1] [2] [3] [4] [5] [6] [7]]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

• 将一维升至二维：np.newaxis

np.newaxis实际上是直接增加维度的意思，我们一般不会给数组增加太多维度，这里以一维增加到二维为例：

（1）增加行维度：arr[np.newaxis, :]
（2）增加列维度：arr[: , np.newaxis]

a=np.arange(8)a							# array([0, 1, 2, 3, 4, 5, 6, 7])a.shape						# (8,)a[np.newaxis, :]			# array([[0, 1, 2, 3, 4, 5, 6, 7]])a.shape						# (8,)a[: , np.newaxis]			# array([[0],[1],[2],[3],[4],[5],[6],[7]])a.shape						# (8,)
1
2
3
4
5
6
7
8

• 降维：arr.ravel()

arr.ravel()函数在降维时：默认是行序优先生成新数组（就是一行行读）；如果传入参数“F”则是列序降维生成新数组

a=np.array([[1,2],[3,4]])a.ravel() a.ravel('F') ----------------------------# 结果 array([1, 2, 3, 4])# 结果 array([1, 3, 2, 4])

• 1
• 2
• 3
• 4
• 5
• 6
• 7

4. 计算

• 对数组进行计算操作

（1）对元素进行加减计算

a=np.arange(8).reshape(2,4)				# array([[0, 1, 2, 3], [4, 5, 6, 7]])b=np.random.randint(8,size=(2,4))		# array([[1, 2, 5, 3], [4, 1, 0, 6]])a+ba-b----------------------------# a+b和a-b结果分别是：array([[ 1,  3,  7,  6],       [ 8,  6,  6, 13]])array([[-1, -1, -3,  0],       [ 0,  4,  6,  1]])
1
2
3
4
5
6
7
8
9
10
11

（2）乘法：平方／矩阵中元素相乘

a=np.arange(8).reshape(2,4) # array([[0, 1, 2, 3], [4, 5, 6, 7]])b=np.random.randint(8,size=(2,4)) # array([[1, 2, 5, 3], [4, 1, 0, 6]])a**2a*b-----------------------# a矩阵平方／a*b矩阵中元素相乘结果分别：array([[ 0, 1, 4, 9], [16, 25, 36, 49]])array([[ 0, 2, 10, 9], [16, 5, 0, 42]])

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

（3）矩阵*矩阵：

# 要求a矩阵的行要等于b矩阵的列数；且a矩阵的列等于b矩阵的行数a=np.arange(8).reshape(2,4)				# array([[0, 1, 2, 3], [4, 5, 6, 7]])b=np.random.randint(8,size=(4,2))		# array([[3, 0],[3, 3],[5, 6],[6, 7]])c1 = np.dot(a,b)c2 = a.dot(b)----------------------# ab矩阵相乘的结果：c1=c2 array([[ 31,  36],       [ 99, 100]])
1
2
3
4
5
6
7
8
9
10

（4）逻辑计算

【注】列表是无法作为一个整体对其中的各个元素进行逻辑判断的！

# 结果返回：一个数组，其中每个元素根据逻辑判断的布尔类型的结果a > 3 -----------------------------# 结果如下：array([[False, False, False, False], [ True, True, True, True]])

• 1
• 2
• 3
• 4
• 5
• 6

5. 取值

• 获取一维数组中的某个元素：操作和list列表的index一样

a = np.array([5, 2, 7, 0, 11])a[0]			# 结果为 5a[:4]			# 结果为 从头开始到索引为4结束a[2:]			# 结果为 从索引为2的开始到结尾a[::2]			# 结果为 从头开始到结尾，每2个取一个值
1
2
3
4
5
6

• 获取多维数组的某个元素，某行或列值

a = np.array([[32, 15, 6, 9, 14], [12, 10, 5, 23, 1], [2, 16, 13, 40, 37]])a[2,1] # 结果是一个元素 16a[2][1] # 结果是一个元素 16a[1] # 第2行 array([12, 10, 5, 23, 1])a[：，2] # 取出全部行，第2列 [15,10,16]a[1:3, :] # 取出[1，3)行，全部列a[1,1:] # array([10, 5, 23, 1])

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

• 获取满足逻辑运算的

# 需要注意的是，我们数据进行逻辑计算操作得到的仍然是一个数组# 如果我们想要的是一个过滤后的数组，就需要将'逻辑判断'传入数组中a = np.array([[32, 15, 6, 9, 14],               [12, 10, 5, 23, 1],              [2, 16, 13, 40, 37]])a[a > 3]a[(a > 3) | (a < 2)]	------------------------------# 结果分别是：array([32, 15,  6,  9, 14, 12, 10,  5, 23, 16, 13, 40, 37])array([32, 15,  6,  9, 14, 12, 10,  5, 23,  1, 16, 13, 40, 37])
1
2
3
4
5
6
7
8
9
10
11
12
13

• 遍历：结果是按行输出

a = np.array([[32, 15, 6, 9, 14], [12, 10, 5, 23, 1], [2, 16, 13, 40, 37]])for x in a: print(x)--------------------[32 15 6 9 14][12 10 5 23 1][ 2 16 13 40 37]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

6. 复制／分割／合并

• 复制：arr.cope()
• 分割：

（1）等分：np.split(arr, n, axis=0/1)（即行数或列数可以整除n时才可以）
（2）不等分：np.array_split(arr, n) 默认按行分n份

a = np.array([[32, 15, 6, 9, 14, 21],               [12, 10, 5, 23, 1, 10],              [2, 16, 13, 40, 37, 8]])              # 可以看到a矩阵是(3*6)，所以使用np.split()只能尝试行分成3份；或者列分成2/3/6份 np.split(a,3,axis=0)	np.split(a,3,axis=1)np.array_split(a,2)np.array_split(a,4,axis=1)-------------------------------------------[array([[32, 15,  6,  9, 14, 21]]), array([[12, 10,  5, 23,  1, 10]]), array([[ 2, 16, 13, 40, 37,  8]])]   [array([[32, 15],        [12, 10],        [ 2, 16]]), array([[ 6,  9],        [ 5, 23],        [13, 40]]), array([[14, 21],        [ 1, 10],        [37,  8]])]        [array([[32, 15,  6,  9, 14, 21],        [12, 10,  5, 23,  1, 10]]), array([[ 2, 16, 13, 40, 37,  8]])]        [array([[32, 15],        [12, 10],        [ 2, 16]]), array([[ 6,  9],        [ 5, 23],        [13, 40]]), array([[14],        [ 1],        [37]]), array([[21],        [10],        [ 8]])]      
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
27
28
29
30
31
32
33
34
35
36

• 合并：np.concatenate((arr1,arr2,arr3), axis=0/1) 默认接在数据下面

a=np.random.rand(2,3)b=np.random.randint(1,size=(2,3))np.concatenate((a,b,a)) # 接在下面np.concatenate((a,b,a),axis=1) # 接在后面------------------------array([[0.95912866, 0.81396527, 0.809493 ], [0.4539276 , 0.24173315, 0.63931439], [0. , 0. , 0. ], [0. , 0. , 0. ], [0.95912866, 0.81396527, 0.809493 ], [0.4539276 , 0.24173315, 0.63931439]])​array([[0.95912866, 0.81396527, 0.809493 , 0. , 0. , 0. , 0.95912866, 0.81396527, 0.809493 ], [0.4539276 , 0.24173315, 0.63931439, 0. , 0. , 0. , 0.4539276 , 0.24173315, 0.63931439]])

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18