Python之Numpy扩展包学习与使用——数组数据处理
Posted 蔺WIT
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python之Numpy扩展包学习与使用——数组数据处理相关的知识，希望对你有一定的参考价值。
写在前面：👀python小白，关于numpy包的学习总结🌲希望大家多多支持，欢迎评论交流🍀
Numpy是一个高性能科学计算与数据分析的Python软件包，也是很多其他Python包（如pandas、matplotlib等）的依赖。目前，Numpy是开源项目，在众多开发者的支持下，它的功能在不断扩展。详细介绍可参考Numpy官网——https://numpy.org/
文章目录
通常Numpy的引入约定是 import numpy as np
1️⃣ ndarray(数组)对象
Numpy的核心是ndarray（N-dimensional array）对象，即数组对象，用于表达多维结构的数据，由相同类型的元素所构成。
数组对象的主要属性：
| 属性 | 解释 |
|---|---|
| ndim | 数组维数 |
| shape | 数组形状（数组的维度集每一维度长度） |
| size | 数组长度（组成数组的元素个数） |
| dtype | 数组元素类型 |
一个数组的长度是固定的，但是数组形状和维数是可变的。
例:
import numpy as np
L = [1, 3, 2, 6]
a = np.array(L)
print(a.ndim) # 输出 1 一维数组
print(a.shape) # 输出 (4,)长度为4的一维数组
print(a.size) # 输出 4 长度为4
print(a.dtype) # 输出 int32 有符号32位的整数
数组中的元素可以是数字型，也可以是其他类型（如布尔型、字符串型、python对象型等）。
利用数组对象的astype(‘dtype’)方法可以转换数组元素为新的类型,转换类型后的数组赋值给另一个新的数组，新数组除了数据类型不一样，维数、长度都与原数组一致。
例：
b = a.astype('float')
print(b.dtype) # 输出 float64
2️⃣ 创建数组
🔘1.根据已有序列数据创建数组
如上面示例，Numpy中的array函数用于将序列数据（列表、元组、数组或其他序列类型）转换为数组对象。并且可以进行序列的嵌套从而创建不太维度的数组。
dtype属性用于在创建时指定数组的元素类型。
例：
L = [[1, 2, 3, 4]]
a = np.array(L) # 创建一个1*4的二维数组（类型缺省）
L = [[1], [2], [3], [4]]
a = np.array(L, dtype="f") # 创建一个4*1的二维数组（类型为float32）
创建结构数组
详细参考
数组的元素也可以是一个结构（对象），即可以包含多个不同类型的值。元素类型为结构的数组称为结构数组。结构数组类似于数据库中的表格，数组中的一个元素可认为是表格中的一个记录。
结构数组的数据类型是一个字典，字典有两个键：“names” 和 “formats”，键值分别为结构中每个值的名称序列（类似于字段名）和值的类型序列（类似于字段类型）；
结构元素用元组表示，多个元组组成的列表则构成一个一维的结构数组(类似于多个字段的多个记录值
例（根据城市列表创建结构数组）：
c = "names": ["city_name", "lon", "lat", "pop"], "formats": ["S32", "f", "f", "i"] # 定义一个字典表示结构数组的数据类型
c_type = np.dtype(c) # 字典转换为数组数据类型对象（可省略此步直接用字典赋予dtype）
cities = [("beijing", 116.37, 39.92, 21707000),
("shanghai", 121.53, 31.26, 24183300),
("guangzhou", 113.25, 23.13, 14498400)] # 创建结构数组的值
a = np.array(cities, dtype=c_type)
print(a)
'''输出：
[(b'beijing', 116.37, 39.92, 21707000)
(b'shanghai', 121.53, 31.26, 24183300)
(b'guangzhou', 113.25, 23.13, 14498400)]'''
print(a["pop"])
'''输出：[21707000 24183300 14498400]'''
print(a[0]["city_name"])
'''输出：
b'beijing' ''' # 前面的 b 表示bytes字节类型
🔘2.创建由规则数据组成的数组
Numpy中的arange()函数和linspace()函数用于产生由规则数据组成的一维数组，两者都是按照等间隔产生数据，前者产生为整数，后者产生为浮点数。
a = np.arange(1, 10, 1) # 前两个参数分别为设置开始值和终值，第三个参数为设置产生间隔
print(a) # 输出：[1 2 3 4 5 6 7 8 9]
a = np.linspace(1, 10, 5, endpoint=True) # 前面个分别为设置开始值和终值，第三个参数为设置产生元素个数，endpoint参数设置是否包含终值
print(a) # 输出：[ 1. 3.25 5.5 7.75 10. ]
🔘3.创建由随机数据组成的数组
创建由随机数（包括指定分布的随机数）组成的数组可利用numpy.random模块中的相关函数。下面以该模块中的主要函数做个示例：
a1 = np.random.rand(5) # 产生5个0~1之间的随机数组成的一维数组
print(a1) # 输出：[0.16497572 0.3738955 0.35744013 0.12073388 0.32096764]
a1 = np.random.rand(5, 5) # 产生5*5个0~1之间的随机数组成的二维数组
a2 = np.random.randn(5) # 产生正态分布随机数（浮点数）组成的数组
print(a2) # 输出：[ 0.39700688 0.3065918 -0.22865804 0.41525148 0.65744546]
a3 = np.random.randint(low=1, high=10, size=5) # 产生最小值为low，最大值为high，长度为size的随机数组成的一维数组
print(a3) # 输出：[3 2 6 6 3]
a4 = np.random.normal(loc=0, scale=1, size=5) # 产生产生均值为0，标准偏差为scale，长度为size的正态（高斯）分布的样本数组
print(a4) # 输出：[ 1.00790278 0.57669319 -1.17706228 -0.51110038 1.29667758]
a4 = np.random.permutation([2, 8, 3, 4, 1]) # 对一个序列进行随机排序，返回数组。若参数x为一个整数则利用range(x)产生序列
print(a4) # 输出：[3 1 2 4 8]
🔘4.创建特定数组
Numpy提供以下函数用于创建特定数组：
（1）ones()函数，根据指定形状和dtype创建一个全是1的数组
a = np.ones((3, 3), dtype='int')
'''输出：
[[1 1 1]
[1 1 1]
[1 1 1]]'''
ones_like()函数，以另一个数组为参数（包括形状和dtype）创建一个全是1的数组
a = np.random.rand(3, 3)
b = np.ones_like(a)
print(b)
'''输出：
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]'''
（2）zeros()函数，根据指定形状和dtype创建一个全是0的数组
b = np.zeros((3, 3))
print(b)
'''输出：
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]'''
zeros_like()函数，以另一个数组为参数（包括形状和dtype）创建一个全是0的数组
a = np.random.rand(3, 3)
b = np.zeros_like(a)
print(b)
'''输出：
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]'''
【→👆→（1）和（2）中的函数生成的数组的默认类型都是float64。】
（3）empty()函数，根据指定形状和dtype创建一个元素全为空的数组
b = np.empty((3, 3))
empty_like()函数，以另一个数组为参数（包括形状和dtype）创建一个元素全为空的数组
a = np.random.rand(3, 3)
b = np.empty_like(a)
空数组的输出如下形式：
[[0.00000000e+000 0.00000000e+000 0.00000000e+000]
[0.00000000e+000 0.00000000e+000 2.52961611e-321]
[1.69115935e-306 8.91238232e-313 1.44635573e-307]]
（4）eye(N, M=None)函数，创建一个二维的单位数组（对角线为1，其余全为0）
b = np.eye(N=3, M=3) # N参数为行数，M参数为列数
print(b)
'''输出：
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]'''
3️⃣改变数组形状
🔘1.通过shape属性值改变
通过设置数组对象的shape属性值可以改变数组形状，如果shape属性中某一维的长度不确定，可以-1表示，最终的长度会根据其他维的长度自动计算。
例：
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) # 定义一个3*4二维数组
print(a.shape) # 输出：(3, 4)
a.shape = 4, 3 # 将数组改为4*3二维数组
print(a.shape) # 输出：(4, 3)
a.shape = 2, 2, -1 # 将数组改为前两维长度为2的三维数组（第三维长度根据总长度自动计算为3）
print(a.shape) # 输出：(2, 2, 3)
🔘2.通过数组对象方法改变
（1） reshape()方法，改变数组为新的形状，如下：
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(a.shape) # 输出：(3, 4)
a_reshape = a.reshape(1, 3, -1)
print(a_reshape.shape) # 输出：(1, 3, 4)
print(a_reshape)
'''输出：
[[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]]'''
（2） transpose()方法，数组转置（类似矩阵的转置），如下：
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(a.shape) # 输出：(3, 4)
print(a)
'''输出：
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]'''
a_transpose = a.transpose()
print(a_transpose.shape) # 输出：(4,3)
print(a_transpose)
'''输出：
[[ 1 5 9]
[ 2 6 10]
[ 3 7 11]
[ 4 8 12]]'''
如果是多维数组，还可以通过维的顺序列表定义转置的方向，
如transpose(1, 0, 2)，表示第0维变为第1维，第1维变为第0维，第2维不变。
如下（将上面的二维数组a_transpose第0维与第1维交换）：
a_transpose1 = a_transpose.transpose(1, 0)
print(a_transpose1)
'''输出：
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]'''
（3） flatten()方法，用于将数组展平（变为一维数组），如下：
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
a_flatten = a.flatten()
print(a_flatten)
'''输出：
[ 1 2 3 4 5 6 7 8 9 10 11 12]'''
(4) squeeze()方法，用于去除数组中长度为1的轴。如果想要指定轴（axis=i），则指去除指定的长度为1的轴（如长度不为1，则会保错）
a = np.array([[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]) # 三维数组，第0维长度为1
a_squeeze = a.squeeze()
print(a_squeeze)
'''输出：
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]'''
4️⃣数组的索引和切片
数组的索引和切片用于返回数组中某个元素或某个范围的元素，也可以用于对数组中某个元素或某个元素范围进行重新赋值。
🔘1.数组的索引操作
数组的索引是通过在方括号内指定每一维的索引值来操作，如下：
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(a[1, 2]) # 输出第二行第三列的元素：7
print(a[1][2]) # 输出第二行第三列的元素：7
🔘2.数组的切片操作
数组的切片是通过在方括号定义每一维的范围来实现，每一维的用i:j:k的形式表示，i、j、k分别表示开始索引值、结束索引值（但不包括该位置元素）、步长。切片和索引往往都是结合使用，即切片后通过索引返回数组的元素：
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(a[0:2]) # 输出第一行到第三行（不包括第三行）的所有元素
print(a[0:2, 0:2]) # 输出第一行、列到第三行、列（不包括第三行、列）的所有元素
注：切片操作返回的是引用的数据，对切片数据的修改会反映到原始数据中（同样原始数据的修改也会影响到切片数据），如下：
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(a[0, 0]) # 输出：1
b = a[0, 0:2]
print(b) # 输出：[1 2]
b[0] = 0
print(a[0, 0]) # 输出：0
5️⃣数组的连接与切分
🔘1.数组的连接操作
（数组的连接是把多个数组连接到一起产生一个新的数组）
（1） vstack()函数 或 row_stack()函数，用于垂直方向连接
a = np.zeros((3, 3))
b = np.ones((3, 3))
print(np.vstack((a, b)).shape) # 输出：(6, 3)
（2） hstack()函数 或 column_stack()函数，用于水平方向连接
a = np.zeros((3, 3))
b = np.ones((3, 3))
print(np.hstack((a, b)).shape) # 输出：(3, 6)
注：column_stack()函数与hstack()函数，在对一维数组的连接操作有一定的区别，column_stack()函数得到一个二维数据，hstack()函数还是一维数组，如下：
a = np.zeros((3,))
b = np.ones((3,))
print(np.hstack((a, b)))
'''输出：[0. 0. 0. 1. 1. 1.]'''
print(np.column_stack((a, b)))
'''输出：
[[0. 1.]
[0. 1.]
[0. 1.]]'''
🔘2.数组的切分操作
（数组的切分是数组连接的逆操作）
（1） hsplit()函数，用于沿水平方向对数组进行均匀切分
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
b, c = np.hsplit(a, 2)
print(b)
'''输出：
[[ 1 2]
[ 5 6]
[ 9 10]]'''
print(c)
'''输出：
[[ 3 4]
[ 7 8]
[11 12]]'''
（2） vsplit()函数，用于沿垂直方向对数组进行均匀切分
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
b, c, d = np.vsplit(a, 3)
print(b)
'''输出：
[[1 2 3 4]]'''
print(c)
'''输出：
[[5 6 7 8]]'''
print(d)
'''输出：
[[ 9 10 11 12]]'''
6️⃣数组的运算
🔘1.基本数学运算
数组可以进行加、减、乘、除等基本数学运算，可以是数据间的运算，也可以是数组与标量之间的运算。
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
b = np.array([[12, 11, 10, 9], [8, 7, 6, 5], [4, 3, 2, 1]])
print(a + b)
'''输出：
[[13 13 13 13]
[13 13 13 13]
[13 13 13 13]]'''
print(a + 1)
'''输出：
[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]'''
c = np.array([10, 20, 30, 40])
print(a + c) # 通过broadcast机制进行不同形状数组运算
'''输出：
[[11 22 33 44]
[15 26 37 48]
[19 30 41 52]]'''
🔘2.数学函数运算
Numpy中常用的数学函数如下（图源网络）：
🔘3.比较和逻辑运算
（1） 数组之间及数组和标量之间可以进行>、>=、<、<=、==、！=等比较运算，运算结果返回的数组是一个布尔型数组（True或False）。
例：
a = np.array([[1以上是关于Python之Numpy扩展包学习与使用——数组数据处理的主要内容，如果未能解决你的问题，请参考以下文章