Python中NumPy库——数组的基本操作

Python中NumPy库——数组的基本操作

1.数组的创建

（1）使用array()函数创建数组

- 创建一维数组

import numpy as np
a1=np.array([1,2,3],dtype=np.float32)  #使用array创建一维数组，元素数据类型为32位浮点型
print(a1)

输出结果为：

[1. 2. 3.]

- 创建多维数组

import numpy as np
a2=np.array([[1,2,3],[4,5,6]],dtype=np.int32) #使用array创建二维数据，元素数据类型为32位整形
print(a2)

创建几维数组，就有几层中括号
其中元素的数据类型可以使用dtype进行指定，若不指定，默认为整形int32

（2）使用zeros()函数创建全0数组

import numpy as np
a3=np.zeros((2,3),dtype=np.float32)   #使用zeros函数创建一个2行3列的全为0的二维数组
print(a3)

输出结果为：

[[0. 0. 0.]
 [0. 0. 0.]]

若要创建多维的全0数组，例如：

a4=np.zeros((2,2,3),dtype=np.float32)   #使用zeros函数创建一个三维的2行3列的
全为0的数组，其中第一个2表示三维，第二个2表示2行，第三个数字3表示数组列数为3列
print(a4)

执行结果为：

[[[0. 0. 0.]
  [0. 0. 0.]]

 [[0. 0. 0.]
  [0. 0. 0.]]]

（3）使用ones()函数创建全1数组

a5=np.ones((2,3),dtype=np.float32)   #使用ones函数创建一个2行3列的全为1的数组
print(a5)

执行结果为：

[[1. 1. 1.]
 [1. 1. 1.]]

（4）使用empty()函数创建一个空的ndarray数组

a6=np.empty((2,3))   #使用empty函数创建一个2行3列的接近于0（不等于0）的数组
print(a6)

执行结果为（结果中的元素值没有实际意义）：

[[0. 0. 0.]
 [0. 0. 0.]]

（5）使用arange()函数创建一个固定步长的数组

a9=np.arange(2,10,2)    #使用arange函数创建一个2至9，步长为2的一维数组
print(a9)

执行结果为：

[2 4 6 8]

若要对arange函数生成的一维数据进行维度的变换，可使用reshape函数，例如：

a10=np.arange(1,13).reshape(2,3,2)   #使用reshape函数将arange函数生成的一维数组
转化为三维3行2列数组
print(a10)

执行结果为：

[[[ 1  2]
  [ 3  4]
  [ 5  6]]

 [[ 7  8]
  [ 9 10]
  [11 12]]]

（6）使用linspace()函数创建一个固定步长的数组

linspace（）函数使用时需要指定生成数组的初始值、终止值以及元素个数，进而生成一个等步长的数组；arange函数在生成等步长的数组中需要指定生成数组的初始值、终止值（该值不取）以及步长，linspace函数的用法如下：

arr2=np.linspace(1,10,5)    #linspace函数需要指定生成数组的初始值、终止值和元素个数
print(arr2)

执行结果为：

[ 1.    3.25  5.5   7.75    10.  ]

2.数组的属性查询

（1）查询数组的维度

a1=np.array([[1,2,3],[4,5,6]])
print(a1.ndim)  #数组的维度

执行结果为：

2

（2）查询数组的形状

a1=np.array([[1,2,3],[4,5,6]])
print(a1.shape) #数组的形状

执行结果为：

(2, 3)

（3）查询数组的元素

a1=np.array([[1,2,3],[4,5,6]])
print(a1.size)  #数组的大小，即包含的元素个数

执行结果为：

6

（4）查询数组的元素类型

a1=np.array([[1,2,3],[4,5,6]])
print(a1.dtype)  #数组中元素的数据类型

执行结果为：

int32

3.数组的运算

（1）基本的算术运算

可以对数组进行加、兼、乘、除、取余、取整的基本算术运算，例如：
相加：

import numpy as np
arry1=np.array([[1,2,3],[4,5,6]])
arry2=np.array([[2,3,4],[5,6,7]])
arry3=arry1+arry2   #对应元素相加
print(arry3)

执行结果为：

[[ 3  5  7]
 [ 9 11 13]]

相减：

arry4=arry1-arry2   #对应元素相减
print(arry4)

执行结果为：

[[-1 -1 -1]
 [-1 -1 -1]]

相乘：

arry5=arry1*arry2   #对应元素相乘
print(arry5))

执行结果为：

[[ 2  6 12]
 [20 30 42]]

相除：

arry6=arry1/arry2   #对应元素相除
print(arry6)

执行结果为：

[[0.5        0.66666667 0.75      ]
 [0.8        0.83333333 0.85714286]]

取余：

arry7=arry1%arry2   #对应元素取余
print(arry7)

执行结果为：

[[1 2 3]
 [4 5 6]]

取商：

arry8=arry1//arry2  #对应元素相除取商
print(arry8)

执行结果为：

[[0 0 0]
 [0 0 0]]

幂：

arry9=arry1**arry2   #以arry2中的对应元素作为arry1的元素的幂次
print(arry9)

执行结果为：

[[     1      8     81]
 [  1024  15625 279936]]

若要计算数组的二次、三次或者N次幂，可按以下方法：

arry10=arry1**2
print(arry10)

执行结果为：

[[ 1  4  9]
 [16 25 36]]

（2）多维数组的矩阵运算

矩阵乘法，使用dot函数：

import numpy as np
arry1=np.array([[1,2,3],[4,5,6]])
arry2=np.array([[2,3],[4,5],[6,7]])
arry11=np.dot(arry1,arry2)
print(arry11)

执行结果为：

[[28 34]
 [64 79]]

矩阵的转置：
可通过两种方法实现，如下：

arry12=arry1.T               #实现矩阵转置的方法一
print(arry12)
arry13=np.transpose(arry1)   #实现矩阵转置的方法二
print(arry13)

两种方法的执行结果均为：

[[1 4]
 [2 5]
 [3 6]]

（3）生成随机数

使用random()函数的方法生成随机数，如下：

#生成0至1之间的3行2列的随机浮点数
sample1=np.random.random(size=(3,2))           
print(sample1)
结果为：
[[0.81333679 0.87568373]
 [0.56494543 0.05231339]
 [0.027998   0.49710617]]
 
 #生成1至20之间的3行2列的随机浮点数
sample2=np.random.uniform(1,20,size=(3,2))     
print(sample2)
输出结果为：
[[ 3.34467128 12.3910501 ]
 [ 5.39161739 14.45541567]
 [ 2.28037259 14.12669351]]
 
  #生成1至10之间的3行2列的随机整数
sample3=np.random.randint(1,10,size=(3,2))    
print(sample3)
输出结果为：
[[1 7]
 [7 7]
 [2 9]]
 
 #随机选取字符串
sample4=np.random.choice(['张三','李四','王五'])  
print(sample4)
输出结果为：
张三

（4）ufunc函数运算

ufunc函数是universal function的缩写，是一种对数组的每个元素进行运算的函数。以求最小值的函数min函数为例（取最大值函数max，求和函数sum，平均值函数mean的用法相同）

arr1=np.array([[1,2,3],[4,5,6]])
m1=np.min(arr1)          #整个数组所有元素中的最小值
m2=np.min(arr1,axis=0)   #数组按列求最小值
m3=np.min(arr1,axis=1)   #数组按行求最小值
print("数组所有元素中的最小值为：",m1)
print("数组各列元素中的最小值为：",m2)
print("数组各行元素中的最小值为：",m3)

执行结果为：

数组所有元素中的最小值为： 1
数组各列元素中的最小值为： [1 2 3]
数组各行元素中的最小值为： [1 4]

4.数组的索引

可根据数组中元素的位置对数组元素进行索引，对于一维数组的索引使用方法如下：

arry1=np.arange(1,15)
print(arry1)
print(arry1[2])          #取数组的第3个位置的元素(元素的位置从0开始）
print(arry1[:5])         #取数组中第1至第5个位置的元素
print(arry1[-3:])        #取数组中倒数第三个至最后一个位置的元素

执行结果如下：

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14]
3
[1 2 3 4 5]
[12 13 14]

对于二维数组的索引使用方法如下：

arry2=arry1.reshape(2,7)   #生成7行2列的二维数组
print(arry2)
输出结果为：
[[ 1  2  3  4  5  6  7]
 [ 8  9 10 11 12 13 14]]
 
print(arry2[1,0])        #取数组中第2行第1列的元素
输出结果为；
8

print(arry2[:,1])        #取数组中所有行第2列的元素
输出结果为：
[2 9]

数组中元素的遍历：

for i in arry2:          #对二维数组中的元素进行遍历，默认为按行进行遍历
    print(i)
输出结果为：
[1 2 3 4 5 6 7]
[ 8  9 10 11 12 13 14]

for i in arry2.T:        #想对元素中的元素按列进行遍历，可将数组进行转置
    print(i)
输出结果为：
[1 8]
[2 9]
[ 3 10]
[ 4 11]
[ 5 12]
[ 6 13]
[ 7 14]

5. 数组的合并

可使用vstack、hstack函数对多个数组中的元素按照垂直或者水平进行合并，如下：

arry1=np.array([1,2,3])
arry2=np.array([4,5,6])
arry3=np.array([5,6,7])
arry4=np.vstack((arry1,arry2,arry3))     #将两个数组的元素进行垂直合并
print(arry4)
输出结果为：
[[1 2 3]
 [4 5 6]
 [5 6 7]]

rry5=np.hstack((arry1,arry2,arry3))     #将两个数组的元素进行水平合并
print(arry5)
输出结果为：
[1 2 3 4 5 6 5 6 7]

使用concatenate函数进行多维数组的垂直与水平合并，使用方法如下：

arry6=np.arange(1,5).reshape(2,2)
arry7=np.arange(2,6).reshape(2,2)
arry8=np.concatenate((arry6,arry7),axis=1)   #将多个多维数组水平合并
print("arry8=",arry8)

执行结果为：
arry8= [[1 2 2 3]
 [3 4 4 5]]

arry9=np.concatenate((arry6,arry7),axis=0)   #将多个多维数组垂直合并
print("arry9=",arry9)

执行结果为：
arry9= [[1 2]
 [3 4]
 [2 3]
 [4 5]]

6. 数组维度的变化

可将一维数组转换为二维数组，实现方式如下：

arr1=np.array([1,2,3,4,5])
print(arr1.shape)
arr1_1=arr1[np.newaxis,:]    #将一维数组转换为一行多列的二维数组
print(arr1_1,arr1_1.shape)
print(arr1_1.shape)

执行结果为：
(5,)
[[1 2 3 4 5]]
(1, 5)

arr1_2=arr1[:,np.newaxis]    #将一维数组转换为多行一列的二维数组
print(arr1_2,arr1_2.shape)

执行结果为：
[[1]
 [2]
 [3]
 [4]
 [5]]
 (5, 1)

7. 数组的分割

使用**split()**函数进行分割，实现方式如下：

arr1=np.arange(12).reshape(3,4)
print("arr1=",arr1)
arr2_1,arr3_1=np.split(arr1,2,axis=1)          #axis=1，表示水平分割，分割成两份
print(arr2_1)
print(arr3_1)

执行结果如下：
arr1= [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
arr2_1= [[0 1]
 [4 5]
 [8 9]]
arr3_1= [[ 2  3]
 [ 6  7]
 [10 11]]

arr2_2,arr3_2,arr4_2=np.split(arr1,3,axis=0)   #axis=0，表示垂直分割，分成3份
print("arr2_2=",arr2_2)
print("arr3_2=",arr3_2)
print("arr4_2=",arr4_2)

执行结果为：
arr2_2= [[0 1 2 3]]
arr3_2= [[4 5 6 7]]
arr4_2= [[ 8  9 10 11]]

arrh1,arrh2=np.hsplit(arr1,2)                #hsplit，表示水平分割，分割成2份
print("arrh1=",arrh1)
print("arrh2=",arrh2)

执行结果为：
arrh1= [[0 1]
 [4 5]
 [8 9]]
arrh2= [[ 2  3]
 [ 6  7]
 [10 11]]

arrv1,arrv2,arrv3=np.vsplit(arr1,3)         #vsplit，表示垂直分割，分割成3份
print("arrv1=",arrv1,"arrv2=",arrv2,"arrv3=",arrv3)

执行结果为：
arrv1= [[0 1 2 3]] arrv2= [[4 5 6 7]] arrv3= [[ 8  9 10 11]]

arrv1_1,arrv2_1,arrv3_1=np.array_split(arr1,3,axis=1)    #水平分割，不等分
print("arrv1_1=",arrv1_1)
print("arrv2_1=",arrv2_1)
print("arrv3_1=",arrv3_1)

执行结果为：
arrv1_1= [[0 1]
 [4 5]
 [8 9]]
arrv2_1= [[ 2]
 [ 6]
 [10]]
arrv3_1= [[ 3]
 [ 7]
 [11]]

arrv1_2,arrv2_2=np.array_split(arr1,2,axis=0)            #垂直分割，不等分
print("arrv1_2=",arrv1_2)
print("arrv2_2=",arrv2_2)

执行结果为：
arrv1_2= [[0 1 2 3]
 [4 5 6 7]]
arrv2_2= [[ 8  9 10 11]]

8. 数组的浅拷贝与深拷贝

赋值属于浅拷贝，即多个对象指向同一个内存地址；使用copy()函数可进行深拷贝，不同对象指向不同的内存地址，具体实现代码如下：

arr1=np.array([1,2,3])
print("arr1=",arr1)
arr2=arr1                  #直接赋值属于浅拷贝，arr1与arr2指向同一个内存地址，因此修改任何一个对象的元素值，另外一个对象的元素值也会改变
arr2[0]=3
print("arr1=",arr1)
print("arr2=",arr2)

执行结果为：
arr1= [1 2 3]
arr1= [3 2 3]
arr2= [3 2 3]

arr3=arr1.copy()           #深拷贝，对于对象arr3又重新在内存中开辟了一块存储空间，因此改变一个对象的中的元素值，另外的对象不改变
arr3[0]=20
print("arr1=",arr1)
print("arr3=",arr3)

执行结果为：
arr1= [3 2 3]
arr3= [20  2  3]