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扩展包学习与使用——数组数据处理的主要内容,如果未能解决你的问题,请参考以下文章

学机器学习,不会数据分析怎么行?之NumPy详解

Python数据分析之numpy学习

python基础之numpy.reshape详解

(转)Python数据分析之numpy学习

numpy与Matplotlib

Python 之 Numpy库以及Matplotlib库的学习