[学习笔记Day05]Python 数据分析与应用：科学计算库 NumPy 的使用

介绍

NumPy 作为高性能科学计算和数据分析的基础包，他是本节数据分析相关库的基础。

数组、维度、轴和秩的相关概念：

• 数组：是编程语言中重要且复杂的数据结构，它由相同类型元素按照一定顺序排列的集合。
• 维度（维数）：在数学领域中是指描述对象状态所需独立参数的数目。

• 轴（axis）：是 NumPy 数组中重要的概念，他其实代表维度。
• 秩：轴的个数。

NumPy 数组的属性：

NumPy 中最重要的一个特点就是其 n 维数组对象，即 ndarray （别名 array）对象，该对象具有矢量算术能力和复杂的广播能力。

属性	说明
ndarray.ndim	数组轴的个数，比如二维数组有两个轴，则它的属性值为2
ndarray.shape	数组维度的元组，元组中各个元素表示每个维度上数组的大小，比如 n x m 的数组，它的属性值为 (n,m)
ndarray.size	数组元素的总个数，等于 shape 属性中元组元素的乘积
ndarray.dtype	描述数组中元素类型的对象，既可以使用标准的 Python 类型来创建或指定，也可以使用 NumPy 特有的数据类型来指定。
ndarray.itemsize	数组中每个元素占有的内存大小，单位为字节。

# 创建二维数组
arr = np.array([[1,2,3],[1,2,3]])
arr.shape

# 结果：(2, 3)

# 创建二维数组
arr = np.array([[1,2,3],[1,2,3]])
arr.shape

# 结果：2

# 创建二维数组
arr = np.array([[1,2,3],[1,2,3]])
arr.size

# 结果：6

# 创建二维数组
arr = np.array([[1,2,3],[1,2,3]])
arr.itemsize

# 结果：4

# 创建二维数组
arr = np.array([[1,2,3],[1,2,3]])
type(arr)

# 结果：numpy.ndarry

补充：numpy.ndarray 是 NumPy 库中 N 维数组的核心类，所有通过 np.array() 创建的数组，类型都是这个。如果是普通的 Python 列表 ls = [[1,2,],[3,4]]，则他的类型为 <class 'list'>

创建数组

首先需要先导入包：import numpy as np

# 创建一维数组
arr = np.array([1,2,3])               # 数据为整数类型
arr = np.array([0.1 ,0.2 ,0.3])       # 数据为小数类型
arr = np.array([1,2,3],dtype = float) # 指定数据类型

# 创建二维数组
arr1 = np.array([[1,2,3],[1,2,3]])

# 创建三维数组
arr2 = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])

其他方式：

• 使用 zeros 函数

# 创建数组，维度大小为 3 x 3
np.zeros((3,3));

# 结果：
# array([[0.,0.,0.],
#        [0.,0.,0.],
#        [0.,0.,0.])

• 使用 ones 函数

# 创建数组，维度大小为 3 x 3
np.ones((3,3));

# 结果：
# array([[1.,1.,1.],
#        [1.,1.,1.],
#        [1.,1.,1.])

• 使用 empty 函数

注意：该数组只分配内存空间，里面填充的元素都是随机的

# 创建数组，维度大小为 3 x 3
np.empty((3,3));

# 结果：
# array([[5.,2.,1.],
#        [6.,7.,7.],
#        [3.,5.,9.])

# 创建数组，维度大小为 3 x 3
np.empty((3,3),dtype = int);

# 结果：
# array([[0,0,0],
#        [0,0,0],
#        [0,0,0])

• 使用 arange 函数

注意：它的功能类似于 range() 函数，只不过 arange() 函数的返回结果为一维数组，而不是列表！

# 创建数组，参数：(起始值,终止值,步长)
np.arange(1,20,5);

# 结果：
# array([1,6,11,16])

• 使用 full() 函数

# 创建数组，参数：([行,列]，填充值)
np.full([3,3],8);

# 结果：
# array([[8,8,8],[8,8,8],[8,8,8]])

• 使用 linspace(start ,stop ,num = 50 ,endpoint = True ,retstep = False ,dtype = None) 函数
  • 核心：在 [start ,end] 区间内生成 num 个等间距的数值。
  • 重点：控制生成的数量，不指定步长
  • 参数：
    • start：序列的起始值（必填）
    • stop：序列的终止值（必填）
    • num：生成的样本数量，默认50个，必须是非负整数
    • endpoint：是否包含 stop 值，默认 True（包含），设为 False 则不包含
    • retstop：是否返回步长，默认 False

# 创建一个等差数组，参数：(起始值,终止值,数量)
np.arange(1,20,5);

# 结果：
# array([1. ,5.75 ,10.5 ,15.25 ,20.])

• 使用 matrix() 函数：通过字符串创建矩阵

# 通过字符串创建矩阵
np.matrix('1 2;3 4')

# 结果：matrix([[1, 2],[3, 4]])

数组的数据类型

如果想要获取数组中元素数据类型的名称，则需要先通过数组访问 dtype 属性得到 numpy.dtype 类型的对象，再通过该对象访问 name 属性进行获取。

arr_one = np.array()
arr_one.dtype.name

# 结果：int32

数据类型	说明	简写
bool	布尔类型，值为 True 或 False	b
int8、unit8	有符号和无符号的8位整数	i、u
int16、unit16	有符号和无符号的16位整数	i2、u2
int32、unit32	有符号和无符号的32位整数	i4、u4
int64、unit64	有符号和无符号的64位整数	i8、u8
float16	半精度浮点数（16位，其中正负号1位，指数5位，精度10位）	f2
float32	单精度浮点数（32位，其中正负号1位，指数8位，精度23位）	f4
float64	双精度浮点数（64位，其中正负号1位，指数11位，精度52位）	f8
complex64	复数，分别用两个32位浮点数表示实部和虚部	c8
complex128	复数，分别用两个64位浮点数表示实部和虚部	c16
object_	Python 对象	O
string_	固定长度的字符串类型	S
unicode_	固定长度的 unicode 类型	U

数据类型转换：

data = np.array([[1,2,3],[4,5,6]])
data.dtype.name
# 结果：int32

floatData = data.astype(np.float32)
floatData.dtype.name
# 结果：float32

数组的索引方式

NumPy 数组支持索引和切片操作，且提供了比 Python 序列更丰富的索引功能。

整数索引和切片：

arr = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
arr[2]

# 结果：[7,8,9]

arr = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])

# 索引第三行第二列的元素
arr[2,1]

# 结果：8

arr = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])

# 索引第一行和第二行的数据
arr[:2]

# 结果：[[1,2,3],[4,5,6]]

arr = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])

# 索引第一行的第一列和第二列、第二行的第一行和第二列
arr[:2 ,:2]

# 结果：[[1,2],[4,5]]

arr = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])

# 索引第三列的所有元素
arr[:,2]

# 结果：[3,6,9,12]

花式索引

花式索引是 NumPy 的一个术语，是指整数数组或整数列表作为索引。

arr = np.array([1,2,3,13,4,5,6,14,7,8,9,15,10,11,12,16])
arr1 = np.array([[17,1,2,3,13],[18,4,5,6,14],[19,7,8,9,15],[20,10,11,12,16],[21,22,23,24,25]])

# 分别获取索引位0、1、5对应的元素
arr[[0,1,5]]

# 结果：[1,2,5]

# 分别获取行索引位1、3对应的元素
arr[[1,3]]

# 结果：[[18,4,5,6,14],[21,22,23,24,25]]

arr = np.array([[17,1,2,3,13],[18,4,5,6,14],[19,7,8,9,15],[20,10,11,12,16],[21,22,23,24,25]])

# 获取第二行四列和第五行三列交叉的元素
arr[[1,4],[2,3]]

# 结果：[6,9]

布尔索引

布尔索引指将一个布尔数组或布尔列表作为数组索引。

studentScore = np.array([[79,88,80],[89,90,92],[83,78,85],[78,76,80]])
studentScore > 80
print(studentScore)

# 结果：[[False,True,Flase],[True,True,True],[True,False,True],[False,False,False]]

studentScore = np.array([[79,88,80],[89,90,92],[83,78,85],[78,76,80]])

# [True,False,True,False]:先获取行，表示保留第一行和第三行
# :2：表示在获取到的第一行和第三行中保留两行的前2列
studentScore[[True,False,True,False],:2]
print(studentScore)

# 结果：[[79,88],[83,78]]

数组的算术运算

NumPy 数组不需要循环遍历，即可对每个元素执行批量的算术运算。

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr2 = np.array([[5,6,7,8],[9,10,11,12],[13,14,15,16]])

# 两数组对应位置相加
arr1 + arr2

# 结果：[[6,8,10,12],[14,16,18,20],[22,24,26,28]]

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr2 = np.array([[5,6,7,8],[9,10,11,12],[13,14,15,16]])

# 两数组对应位置相减
arr1 - arr2

# 结果：[[-4,-4,-4,-4][-4,-4,-4,-4],[-4,-4,-4,-4]]

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr2 = np.array([[5,6,7,8],[9,10,11,12],[13,14,15,16]])

# 两数组对应位置相乘
arr1 * arr2

# 结果：[[5,12,21,32],[45,60,77,86],[117,140,154,168]]

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr2 = np.array([[5,6,7,8],[9,10,11,12],[13,14,15,16]])

# 两数组对应位置相除
arr1 * arr2

# 结果：[[0.2,0.333...,0.42...,0.5],[0.555...,0.6,0.611...,0.6...],[0.69...,0.71...,0.733...,0.75]]

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr2 = np.array([[5,6,7,8],[9,10,11,12],[13,14,15,16]])

# 两数组对应位置幂运算
arr1 ** arr2

# 结果：array([[            1,             64,            2187,             65536],
              [      1953125,       60466176,      1977326743,       68719476736],
              [2541865828329,100000000000000,4177248169415651,184884258895036416]])

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr2 = np.array([[5,6,7,8],[9,10,11,12],[13,14,15,16]])

# 两数组对应位置取整
arr1 // arr2

# 结果：array([[0, 0, 0, 0],
              [0, 0, 0, 0],
              [0, 0, 0, 0]])

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr2 = np.array([[5,6,7,8],[9,10,11,12],[13,14,15,16]])

# 两数组对应位置取模
arr1 % arr2

# 结果：array([[ 1,  2,  3,  4],
              [ 5,  6,  7,  8],
              [ 9, 10, 11, 12]])

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])

# 两数组对应位置取反
- arr1

# 结果：array([[ -1,  -2,  -3,  -4],
              [ -5,  -6,  -7,  -8],
              [ -9, -10, -11, -12]])

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])

# 两数组对应位置取反
1 / arr1

# 结果：array([[1.        , 0.5       , 0.33333333, 0.25      ],
              [0.2       , 0.16666667, 0.14285714, 0.125     ],
              [0.11111111, 0.1       , 0.09090909, 0.08333333]])

不同形状的数组间的算术运算

在 NumPy 中，形状不同的数组在执行算术运算时可能触发广播机制，该机制会对参与运算的数组进行扩展，是扩展出相同的具有相同的形状，这样就可以对数组进行算术运算了。

arr1 = np.array([[1],[4],[5],[9]])
arr2 = np.array([1,2,3,4])

# 从左向右从上到下进行扩展
arr1 + arr2

# 结果：[[2,3,4,5],[5,6,7,8],[6,7,8,9],[10,11,12,13]]

数组与标量的算术运算

形状相同的数组之间的任何算术运算都会应用到各个元素。

arr = np.array([[1,2,3],[4,5,6]])
data = 10

arr + data

# 结果：[[11,12,13],[14,15,16]]

arr = np.array([[1,2,3],[4,5,6]])
data = 10

arr - data

# 结果：[[-9,-8,-7],[-6,-5,-4]]

arr = np.array([[1,2,3],[4,5,6]])
data = 10

arr * data

# 结果：[[10,20,30],[40,50,60]]

arr = np.array([[1,2,3],[4,5,6]])
data = 10

arr / data

# 结果：[[0.1,0.2,0.3],[0.4,0.5,0.6]]

集合运算

• np.intersect1d(arr1 , arr2) 函数（交集运算）
  • 找出两数组 / 序列中共同存在的元素，并返回一个排序后的一维数组

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr2 = np.array([[5,6,7,8],[9,10,11,12],[13,14,15,16]])

# 交集运算
np.intersect1d(arr1 , arr2)

# 结果：array([ 5,  6,  7,  8,  9, 10, 11, 12])

• np.union1d(arr1 , arr2) 函数（并集运算）

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr2 = np.array([[5,6,7,8],[9,10,11,12],[13,14,15,16]])

# 并集运算
np.union1d(arr1 , arr2)

# 结果：array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])

• np.in1d(arr1 , arr2) 函数
  • 查看 arr1 在 arr2 中是否存在

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr2 = np.array([[5,6,7,8],[9,10,11,12],[13,14,15,16]])

# 并集运算
np.in1d(arr1 , arr2)

# 结果：array([False, False, False, False,  True,  True,  True,  True,  True,   True,  True,  True])

• np.setdiff1d(arr1 , arr2) 函数（补集运算）

arr1 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
arr2 = np.array([[5,6,7,8],[9,10,11,12],[13,14,15,16]])

# 并集运算
np.setdiff1d(arr1 , arr2)

# 结果：array([1, 2, 3, 4])

数组的广播机制

• 纵向广播机制：

四则运算同理，两数组的列数必须相等，且其中一个数组的行数为 1

n1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
n2 = np.array([1,2,3])

n1 * n2

# 结果：array([[ 1,  4,  9],
              [ 4, 10, 18],
              [ 7, 16, 27]])

• 横向广播机制：

四则运算同理，两数组的列数必须相等，且其中一个数组的列数为 1

n1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
n2 = np.array([[1],[2],[3]])

n1 * n2

# 结果：array([[ 1,  2,  3],
              [ 8, 10, 12],
              [21, 24, 27]])

通用函数

除了直接使用运算符对数组进行基本的算术运算以外，还可以使用 NumPy 提供的通用函数（ufunc）对数组进行基本算术运算以及更复杂的数学运算。

通用函数是一种针对 ndarray 对象中的逐个元素进行运算的函数，这些函数都会产生一个新的数组。

函数	说明
abs(x)	求数组 x 中各个元素的绝对值，元素值可以是整数、浮点数或复数
fabs(x)	求数组 x 中各个元素的绝对值，绝对值都是浮点数
sqrt(x)	求数组 x 中各个元素的算术平方根
square(x)	求数组 x 中各个元素的平方
exp(x)	求数组 x 中各个元素的指数
log(x)	求数组 x 中各个元素以 e 为底数的对数
log10(x)	求数组 x 中各个元素以 10 为底的对数
log2(x)	求数组 x 中各个元素以 2 为底的对数
ceil(x)	求数组 x 中各个元素的 ceiling 值，即大于或等于该值的最小整数
floor(x)	求数组 x 中各个元素的 floor 值，即小于或等于该值的最大整数
rint(x)	将数组 x 中各个元素四舍五入到整数
sign(x)	返回数组 x 中各个元素的符号值，包括 1、0、-1，其中 1 表示正数，-1 表示负数
modf(x)	将数组 x 个各个元素的小数部分和整数部分以两个独立数组的形式返回
isnan(x)	判断数组 x 中各个元素的值是否为 NaN，返回包含判断结果的数组，该数组中的元素的值都是布尔值
isfinite(x)	返回表示数组 x 中各个元素是否是有限的布尔型数组
isinf(x)	返回表示数组 x 中各个元素是否是无限的布尔型数组
sin(x)	求数组 x 中各个元素的正弦值
sinh(x)	求数组 x 中各个元素的双曲正弦值
cos(x)	求数组 x 中各个元素的余弦值
cosh(x)	求数组 x 中各个元素的双曲余弦值
tan(x)	求数组 x 中各个元素的正切值
tanh(x)	求数组 x 中各个元素的双曲正切值
arccos(x)	求数组 x 中各个元素的反余弦值
arccosh(x)	求数组 x 中各个元素的双曲反余弦值
arcsin(x)	求数组 x 中各个元素的反正弦值
diff()	求沿给定轴的 n 阶离散差，返回一个由相邻元素的差值构成的数组
std(x)	求数组 x 中各个元素的标准差

arr_int = np.array([1,-5,8,-10])
arr_float = np.array([1.3,-5.5,8.0,-10.7])
arr_bool = np.array([np.NAN,np.NAN,8.0,-10.7])

# 计算数组中各个元素的绝对值，每个绝对值都是浮点数
np.fabs(arr_int)

# 结果：[1.,5.,8.,10.]

# 计算数组中各个元素的平方
np.square(arr_int)

# 结果：[1,25,64,100]

# 计算数组中各个元素的 ceiling 值
np.ceil(arr_float)

# 结果：[2.,-5.,8.,-10.]

# 计算数组中各个元素 floor 值
np.floor(arr_float)

# 结果：[1.，-6.，8.，-11.]

# 计算数组中各个元素四舍五入的值
np.rint(arr_float)

# 结果：[1.,-6.,8.,-10.]

# 返回数组中各个元素的小数部分和整数部分
np.modf(arr_float)

# 结果：[0.3,-0.5,0.,-0.7]和[1.,-5.,8.,-10.]

# 判断数组中各个元素的值是否为 NaN
np.isnan(arr_bool)

# 结果：[True,True,False,False]

函数	说明	类似
add(x1,x2)	将数组 x1 和 x2 中位置对应的元素相加	x1 + x2
subtract(x1,x2)	将数组 x1 和 x2 中位置对应的元素相减	x1 – x2
multiply(x1,x2)	将数组 x1 和 x2 中位置对应的元素相乘	x1 * x2
divide(x1,x2)	将数组 x1 和 x2 中位置对应的元素相除	x1 / x2
floor_divide(x1,x2)	将数组 x1 和 x2 中位置对应的元素整除	x1 // x2
maximum(x1,x2)	返回数组 x1 和 x2 中位置对应的元素的最大值	–
minimum(x1,x2)	返回数组 x1 和 x2 中位置对应的元素的最小值	–
mod(x1,x2)	返回数组 x1 和 x2 中位置对应的元素取模后的结果	x1 % x2
copysign(x1,x2)	将数组 x2 中的元素的符号赋值给数组 x1 中位置对应的元素	–
greater(x1,x2)	比较数组 x1 的元素是否大于 x2 的元素	x1 > x2
greater_equal(x1,x2)	比较数组 x1 的元素是否大于或等于 x2 的元素	x1 >= x2
less(x1,x2)	比较数组 x1 的元素是否小于 x2 的元素	x1 < x2
less_equal(x1,x2)	比较数组 x1 的元素是否小于或等于 x2 的元素	x1 <= x2
equal(x1,x2)	比较数组 x1 的元素是否等于 x2 的元素	x1 == x2
not_equal(x1,x2)	比较数组 x1 的元素是否不等于 x2 的元素	x1 != x2
logical_add(x1,x2)	将数组 x1 和 x2 进行逻辑与运算	x1 & x2
logical_or(x1,x2)	将数组 x1 和 x2 进行逻辑或运算	x1 | x2

arr1 = np.array([1,5,10,4])
arr2 = np.array([6,2,8,9])

# 计算两数组中各个元素相加的结果
np.add(arr1 ,arr2)

# 结果：[7,7,18,13]

# 计算两数组中各个元素的最大值
np.maximum(arr1 ,arr2)

# 结果：[6,5,10,9]

# 计算两数组中各个元素取模的结果
np.mod(arr1 ,arr2)

# 结果：array([1,1,2,4] ,dtype = int32)

# 比较两数组的小于或等于的关系
np.less_equal(arr1 ,arr2)

# 结果：[True,False,False,True]

数组的重塑与转置

数组的重塑是指重新将数组的形状变成指定的形状，需要注意的是，重塑前后的数组中的元素的总数量是不变的，并且数组新形状应与原始状态兼容（新形状行数 X 新形状的列数 = 原始形状的行数 X 原始形状的列数）。

arr = np.arange(1,13)

arr.shape
# 原始形状：(12,)
arr
# 原始数组：[1,2,3,4,5,6,7,8,9,10,11,12]

arr1 = arr.reshape(3,4)
# 新数组：[[1,2,3,4],
          [5,6,7,8],
          [9,10,11,12]]

注意：重塑后的元素个数一定相同！

arr = np.arange(12).reshape(3,4)
arr

# 结果：[[0,1,2,3],
        [4,5,6,7],
        [8,9,10,11]]

# 使用 T 属性对数组进行转置
arr.T

# 结果：[[0,4,8],
        [1,5,9],
        [2,6,10],
        [3,7,11]]

resize() 函数：重塑前后的元素可以不一致，重塑后会修改原数组。

• 如果新数组的元素个数 <= 原数组，则截断多余的元素
• 如果新数组的元素个数 > 原数组，则补充 0 填充
• 参数：(数组形状 , refcheck)
  • 数组形状：需要转换后的形状
  • refcheck：见下图

refcheck 值	含义
True（默认）	检查元素组是否有其他引用（如被其他变量，对象指向），如果有则拒绝修改，抛出错误
False	跳出引用检查，强制修改数组形状，无论原数组是否有其他引用

arr = np.array([[0,1,2],[3,4,5]])

# 使用 resize 函数进行转换(新数组元素个数 < 原数组元素个数)
arr.resize([2,2] ,refcheck = False)

# 结果：array([[0, 1],[2, 3]])

# 使用 resize 函数进行转换(新数组元素个数 > 原数组元素个数)
arr.resize([3,3] ,refcheck = False)

# 结果：array([[0, 1, 2],[3, 4, 5],[0, 0, 0]])

数组的转置是指将数组中的每个元素按照一定的规则进行位置变换。NumPy 中提供了 transpose() 方法和 T 属性来转置数组。

T 属性：行和列进行互换。

arr = np.arange(24).reshape(2,3,4)
arr

# 结果：[[[0,1,2,3],
        [4,5,6,7],
        [8,9,10,11]],

       [[12,13,14,15],
        [16,17,18,19],
        [20,21,22,23]]

# 使用 transpose 属性对数组进行转置
# 0为页，1为行，2为列
arr.transpose(0,1,2)

# 结果：[[[0,1,2,3],
        [4,5,6,7],
        [8,9,10,11]],

       [[12,13,14,15],
        [16,17,18,19],
        [20,21,22,23]]

transpose() 函数：对数组进行转置

arr = np.arange(24).reshape(2,3,4)
arr

# 结果：[[[0,1,2,3],
        [4,5,6,7],
        [8,9,10,11]],

       [[12,13,14,15],
        [16,17,18,19],
        [20,21,22,23]]

# 使用 transpose 属性对数组进行转置
# 0为页，1为行，2为列
arr.transpose((1,0,2))

# 结果：[[[0,1,2,3],
        [12,13,14,15]]

        [[4,5,6,7],
        [16,17,18,19]]

       [[8,9,10,11]],
        [20,21,22,23]]]

arr = np.arange(24).reshape(2,3,4)
arr

# 结果：[[[0,1,2,3],
        [4,5,6,7],
        [8,9,10,11]],

       [[12,13,14,15],
        [16,17,18,19],
        [20,21,22,23]]

# 使用 transpose 属性对数组进行转置
# 0为页，1为行，2为列
arr.transpose((0,2,1))

# 结果：[[[0,4,8],
         [1,5,9],
         [2,6,10],
         [3,7,11]],

        [[12,16,20],
         [13,17,21],
         [14,18,22],
         [15,19,23]]]

arr = np.arange(24).reshape(2,3,4)
arr

# 结果：[[[0,1,2,3],
        [4,5,6,7],
        [8,9,10,11]],

       [[12,13,14,15],
        [16,17,18,19],
        [20,21,22,23]]

# 使用 transpose 属性对数组进行转置
# 0为页，1为行，2为列
arr.transpose((2，1，0))

# 结果：[[[0,4,8],
         [12,16,20]],

        [[1,5,9],
         [13,17,21]],

        [[2,6,10],
         [14,18,22]],

        [[3,7,11],
       ]

数组的其他操作

在 NumPy 中，where() 函数相当于三元表达式 x if condition else y 的矢量化版本，用于根据条件返回 x 或者 y 中的元素，如果满足条件返回 x 中的元素，不满足则返回 y 中的元素。

arrX = np.array([1,5,7])
arrY = np.array([2,6,8])
arrCon = np.array([True,False,True])

np.where(arrCon ,arrX ,arrY)

# 结果：[1,6,7]

通过 NumPy 库中的相关方法可以很方便的运用 Python 进行数组的统计汇总，比如计算数组极大值、极小值以及平均值等。

方法	说明
sum()	对数组中全部或某个轴向的元素求和
mean()	算术平均值
min()	计算数组中的最小值
max()	计算数组中的最大值
argmin()	表示最小值的索引
argmax()	表示最大值的索引
cumsum()	所有元素的累加和
cumprod()	所有元素的累积乘

注意：使用 cumsum() 和 cumprod() 方法后，产生的结果是一个由中间结果组成的数组。

arr = np.arange(10)

# 求和
arr.sun()

# 结果：45

# 求平均值
arr.mean()

# 结果：4.5

# 求最小值
arr.min()

# 结果：0

# 求最大值
arr.max()

# 结果：9

# 求最小值的索引
arr.argmin()

# 结果：0

# 求最大值的索引
arr.argmax()

# 结果：9

# 计算元素的累加和
arr.cumsum()

# 结果：array([0,1,3,6,10,15,21,28,36,45] ,dtype = int32)

# 计算元素的累积乘
arr.cumprod()

# 结果：array([0,0,0,0,0,0,0,0,0,0] ,dtype = int32)

数组元素排序

如果希望对 NumPy 数组中的元素进行排序，可以通过 sort(axis) 方法实现。

arr = np.array([[6,2,7],
                [3,6,2],
                [4,3,2]])

# 对每一行按照从小到大的顺序排序
arr.sort()

# 结果：[[2,6,7],
        [3,6,7],
        [2,3,4]]

arr = np.array([[6,2,7],
                [3,6,2],
                [4,3,2]])

# 沿着编号为 0 的轴对元素排序（纵向）
arr.sort(0)

# 结果：[[3,2,2],
        [4,3,2],
        [6,6,7]]

axis 取值	对应轴	方向含义
0	第 0 轴	纵向
1	第 1 轴	横向
-1	倒数第 1 轴	横向
None	展平	全部元素

axis 取值	对应轴	方向含义
0	第 0 轴	深度
1	第 1 轴	纵向
2	第 2 轴	横向
-1	倒数第 1 轴	横向
-2	倒数第 2 轴	纵向

检索数组元素是否满足条件

在 NumPy 中，all() 函数用于判断整个数组中的元素的值是否全部满足条件；any() 函数用于判断整个数组中的元素至少有一个满足条件。

arr = np.array([[1,-2,-7],
                [-3,6,2],
                [-4,3,2]])

# arr 的所有元素是否有一个大于 0
np.any(arr > 0)

# 结果：True

arr = np.array([[1,-2,-7],
                [-3,6,2],
                [-4,3,2]])

# arr 的所有元素是否有都大于 0
np.all(arr > 0)

# 结果：False

查找数组的唯一元素

为例便于用户从数组中查找唯一的元素，NumPy 针对一维数组提供了 unique() 函数，该函数用于找出数组的唯一元素，并返回一个升序排列的数组。

arr = np.array([12,11,34,23,12,8,11])

np.unque(arr)

# 结果：[8,11,12,23,34]

判断元素是否在其他数组中

inId() 函数用于判断一维数组中的元素是否在另外一个数组中，该函数返回的是一个布尔数组（数组长度相等）。

语法格式：inId(arr1 ,arr2 ,assume_unique = False ,invert = False)

• arr1：待判断的数组
• arr2：判断 arr1 的每个元素所依据的值
• assume_unique：是否假设数组 arr1 的唯一性，默认值为 False
• invert：是否倒转数组的元素，默认值为 False

arr1 = np.array([12,11,34,23,12,8,11])
arr2 = np.array([11,12])

np.inId(arr1 ,arr2)

# 结果：[True,True,False,False,True,False,True]

线性代数模块

线性代数是数学运算中的一个重要工具，他在图形信号处理、音频信号处理中有非常重要的作用。numpy.linalg 模块中有一组标准的矩阵分解运算以及诸如逆和行列式之类的方法。

如果通过 * 对两个数组相乘，得到的是一个元素级的积，而不是一个矩阵点积。NumPy 中提供了一个用于矩阵乘法的 dot() 方法。

arrX = np.array([[1,2,3],[4,5,6]])
arrY = np.array([[7,8],[9,10],[11,12]])

# 等价于 np.dot(arrX ,arrY)
arrX.dot(arrY)

# 结果：[[58,64],[139,154]]

注意：假设 A 为 m x n 的矩阵，B 为 p x q 的矩阵，那么需要满足 m = q

函数	说明
diag()	从一个数组中提取对角线元素或构造一个对角矩阵
trace()	计算对角线元素和
det()	计算矩阵的行列式
eig()	计算矩阵的特征值和特征向量
inv()	计算矩阵的逆
qr()	计算矩阵的 QR 分解。QR 分解将矩阵分解为一个正交矩阵 Q 和一个上三角矩阵 R
svd()	对矩阵进行奇异值 （SVD）分解
solve()	解线性方程组 Ax = b，其中 A 是一个矩阵，b 是一个向量
lstsq()	计算 Ax = b 的最小二乘解

# 创建对角矩阵
np.eye(4, 4)

# 结果：array([[1, 0, 0, 0],
              [0, 1, 0, 0],
              [0, 0, 1, 0],
              [0, 0, 0, 1]])

随机数模块

与 Python 的 random 模块相比，NumPy 的 random 模块功能更多，它增加了一些可以高效生成多种概率分布样本的函数。

# 随机生成一个二维数组
np.random.rand(3,3)

# 生成结果：[[0.84507246,0.69417139,0.85966956],
           [0.65997549,0.47116919,0.82689148],
           [0.74321602,0.06301557,0.51254789]]

# 随机生成一个三维数组
np.random.rand(2,3,3)

# 生成结果：[[[0.84507246,0.69417139,0.85966956],
            [0.65997549,0.47116919,0.82689148],
            [0.74321602,0.06301557,0.51254789]],

           [[0.51254893,0.62148413,0.62415878],
            [0.55115478,0.62215887,0.55125122],
            [0.32121587,0.84856318,0.13146849]]]

函数	说明
seed()	生成随机数的种子（使相同代码每次产生的数据相同）
rand()	产生均匀分布的样本值
randint()	从给定的上下限范文内随机选取整数
normal()	产生正态分布的样本值
beta()	产生 Beta 分布的样本值
uniform()	产生在 [0,1] 中均匀分布的样本值

# 生成随机数的种子
np.random.seed(0)
# 随机生成包含 5 个元素的数组
np.random.rand(5)

# 生成结果：[0.71518937,0.59743521,0.92463521,0.59823547,0.23569513]

• uniform(low = 0.0 ,high = 1.0 ,size = None) 函数
  • 核心：在[low .high) 区间内生成符合均匀分布的随机数（即区间内每个数被选中的概率相等），默认生成单个浮点数，也可指定形状生成随机数组
  • 参数：
    • low：随机数的下界（最小值），默认为0
    • high：随机数的上界（最大值，不包含），默认为1.0
    • size：生成随机数的形状（维度），可选参数：不指定（返回单个随机数）、整数 n（生成 n 个元素的唯一数组）、元组(m,n)（返回 m x n 的二维数组）

# 随机生成包含 6 个元素的数组
np.random.uniform(0,10,[2,3])

# 生成结果：[[4.71518937,8.59743521,5.92463521],
            [9.59823547,6.23569513,1.23469513]]

• 使用 randn(d0 ,d1 ,d2 ,... ,dn) 生成正态分布数组
  • 核心：生成服从标准正态分布（均值 μ=0，标准差 σ=1）的随机数 / 随机数组。他不指定区间，而是基于正态分布的概率规律生成数值（大部分集中在 [-3 , 3] 之间，越靠近 0 概率越高）
  • 参数：
    • d0 ,d1 ,d2 ,… ,dn：可选参数，用于指定生成数组的维度（形状）
    • 无参数：返回单个标准正态分布随机数
    • 1个参数 n：生成给 n 个元素的一维数组
    • 多个参数 m n：生成 m x n 的二维数组
  • n 个数的均值（均值 = 总和 / 元素个数）和标准差分别约为 0 和 1.
  • 注意：
    • randn：生成标准正态分布随机数（均值为 0，标准差为 1）
    • rand：生成 [0 , 1)区间内的均匀分布的随机数

# 随机生成包含 10 个元素的正态分布数组
np.random.randn(2,5)

# 生成结果：[[0.71518937,0.59743521,0.92463421,0.59743522,0.92463521],
           [0.59823547,0.23569513,0.23469513,0.23569512,0.23469513]]

• 使用 normal(loc = 均值 ,scale = 标准差 ,size = 数组形状) 函数生成指定参数正态分布的随机数
  • 核心：生成一个包含 size 个元素的随机数组
  • 参数：
    • loc = 0：正态分布的均值（中心位置）
    • scale = 1：正态分布的标准差（离散程度）
    • size = 10：数组的形状
      • 10：表示 10 个元素的一维数组
      • (2,5)：表示 2 x 5 的二维数组

# 随机生成包含 10 个元素的正态分布的一维数组
np.random.normal(0,1,10)

# 生成结果：[1.57887648,0.95825175,-0.69895325,0.60130485,1.03969605,-0.72859233,-0.15192096,0.0163701,-1.2521075,-1.56622255])

# 随机生成包含 6 个元素的正态分布的二维数组
np.random.normal(0,1,(2,3))

# 生成结果：[[ 1.0474415 , -0.30897513,  0.34782563],
           [ 0.39904523,  0.32970156,  0.98194199]]

• 使用 randint(low = 下限 , high = 上限 , size = 数组形状) 函数生成整数数组

# 随机生成包含 10 个元素的一维数组
np.random.randint(0,10,10)

# 生成结果：array([2, 4, 8, 0, 6, 8, 0, 7, 5, 7], dtype=int32)

# 随机生成包含 10 个元素的一维数组
np.random.randint(0,10,(2,3))

# 生成结果：array([[9, 8, 9],
                 [1, 1, 8]], dtype=int32)

打乱数组

使用 shuffle(arr) 函数来打乱数组

• 注意：该函数用于原地随机打乱数组元素的顺序。
• 核心：直接修改传入的数组，将其元素的排列顺序随机重排

# 随机生成包含 10 个元素的一维数组
arr = np.random.randint(0,10,(2,3))

# 打乱数组：
np.random.shuffle(arr)

# 生成结果：array([[8, 6, 2],
                 [9, 7, 6]], dtype=int32)

缺失值处理

np.nan 表示缺失、无效或未定义值的标准方式，本质是一个特殊的浮点数（不是字符串、None或其他类型）

np.array([1,2,np.nan,4])

# 生成结果：array([ 1.,  2., nan,  4.])

扩展

Seaborn 是基于 Matplotlib 开发的高级可视化库，专门用于绘制美观、专业的统计图表。

语法：

import seaborn as sns

# 直方图（看数据分布）
sns.histplot()

# 散点图（看变量关系）
sns.scatterplot()

# 箱线图（看数据离散性）
sns.boxplot()

# 热力图（看相关性）
sns.heatmap()