「日拱一码」013 Python常用库——Numpy
目录
数组创建
numpy.array ：创建一个 ndarray 对象
numpy.zeros ：创建一个指定形状和数据类型的全零数组
numpy.ones ：创建一个指定形状和数据类型的全 1 数组
numpy.empty ：创建一个指定形状和数据类型的未初始化数组。其元素值是随机的，取决于内存中的初始状态
numpy.arange ：类似于 Python 内置的 range 函数，但返回的是 ndarray
numpy.linspace ：在指定的起始值和终止值之间生成指定数量的等间隔样本
numpy.logspace ：在对数刻度上生成等间隔的样本
numpy.eye ：创建一个指定大小的单位矩阵
数组属性
ndarray.shape ：返回数组的形状，即各维度的大小
ndarray.ndim ：返回数组的维度数
ndarray.size：返回数组中元素的总个数
ndarray.dtype ：返回数组中元素的数据类型
数组索引与切片
基本索引：通过方括号和索引值来访问数组中的元素。对于多维数组，可以使用逗号分隔各维度的索引
切片：使用冒号来获取数组的子集
布尔索引：使用布尔数组来对数组进行索引
花式索引：使用整数数组来索引
数组操作
数学运算
加减乘除：可以直接对数组进行加、减、乘、除等运算
幂运算：使用 ** 或 np.power 进行幂运算
取模运算：使用 % 或 np.mod 进行取模运算
其他数学函数：np.sin 、 np.cos 、 np.exp 、 np.log 等，可以对数组中的每个元素进行相应的数学运算
矩阵运算
矩阵乘法：使用 @ 或 np.dot 进行矩阵乘法
矩阵转置：使用 .T 或 np.transpose 对矩阵进行转置
矩阵求逆：使用 np.linalg.inv 求矩阵的逆
数组重塑
numpy.reshape ：在不改变数组元素总数的前提下，改变数组的形状
numpy.flatten ：将多维数组展平为一维数组
numpy.ravel ：数组内存连续时与 flatten 类似，返回一个副本，对返回数组进行修改不影响原数组；数组内存不连续时返回一个视图，对返回数组进行修改原数组也会相应改变
数组拼接
numpy.concatenate ：沿指定轴拼接多个数组
numpy.vstack ：沿垂直方向（行）堆叠数组
numpy.hstack ：沿水平方向（列）堆叠数组
numpy.dstack ：沿高度方向（第 2 轴）堆叠数组
数组拆分
numpy.split ：将数组沿指定轴拆分为多个子数组
numpy.hsplit ：沿水平方向（列）拆分数组
numpy.vsplit ：沿垂直方向（行）拆分数组
numpy.dsplit ：沿高度方向（第 2 轴）拆分数组
统计函数
求和：使用 np.sum 计算数组中元素的总和
求平均值：使用 np.mean 计算数组中元素的平均值
求最大值和最小值：使用 np.max 和 np.min 分别求数组中的最大值和最小值
求标准差和方差：使用 np.std 和 np.var 分别求数组的标准差和方差
累计和与累计积：使用 np.cumsum 和 np.cumprod 分别计算数组的累计和与累计积
随机数生成
均匀分布：使用 np.random.rand 生成指定形状的 [0, 1) 区间内的均匀分布随机数
正态分布：使用 np.random.randn 生成指定形状的标准正态分布（均值为 0，标准差为 1）随机数
整数随机数：使用 np.random.randint 生成指定范围内的整数随机数
排序
numpy.sort ：对数组进行排序
numpy.argsort ：返回数组值从小到大的索引值
广播机制
NumPy（Numerical Python）是 Python 中用于科学计算的一个基础库。它提供了高性能的多维数组对象 ndarray，以及用于操作这些数组的工具。以下是按照不同功能分类介绍 NumPy 的常用方法：
数组创建
-
numpy.array ：创建一个 ndarray 对象
-
numpy.zeros ：创建一个指定形状和数据类型的全零数组
-
numpy.ones ：创建一个指定形状和数据类型的全 1 数组
-
numpy.empty ：创建一个指定形状和数据类型的未初始化数组。其元素值是随机的，取决于内存中的初始状态
-
numpy.arange ：类似于 Python 内置的 range 函数，但返回的是 ndarray
-
numpy.linspace ：在指定的起始值和终止值之间生成指定数量的等间隔样本
-
numpy.logspace ：在对数刻度上生成等间隔的样本
-
numpy.eye ：创建一个指定大小的单位矩阵
## 数组创建
import numpy as np
# 创建一个ndarray对象
arr = np.array([1, 2, 3])
print(arr) # [1 2 3]
# 创建一个指定形状和数据类型的全0数组
zeros_arr = np.zeros((2, 3))
print(zeros_arr)
# [[0. 0. 0.]
# [[0. 0. 0.]
# 创建一个指定形状和数据类型的全1数组
ones_arr = np.ones((3, 2))
print(ones_arr)
# [[1. 1.]
# [[1. 1.]
# [[1. 1.]
# 创建一个指定形状和数据类型的未初始化数组，其元素值是随机的，取决于内存中的初始状态
empty_arr = np.empty((2, 2))
print(empty_arr)
# [[9.90263869e+067 8.01304531e+262]
# [2.60799828e-310 1.99392167e-077]]
# 类似于Python内置的range函数，但返回的是ndarray
arange_arr = np.arange(1, 10, 2)
print(arange_arr) # [1 3 5 7 9]
# 在指定的起始值和终止值之间生成指定数量的等间隔样本
linspace_arr = np.linspace(0, 1, 5)
print(linspace_arr) # [0. 0.25 0.5 0.75 1. ]
# 在对数刻度上生成等间隔的样本，如生成从 10^0 到 10^2 的 4 个等间隔对数样本
logspace_arr = np.logspace(0, 2, 4)
print(logspace_arr) # [ 1. 4.64158883 21.5443469 100. ]
# 创建一个指定大小的单位矩阵
eye_arr = np.eye(3)
print(eye_arr)
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]数组属性
-
ndarray.shape ：返回数组的形状，即各维度的大小
-
ndarray.ndim ：返回数组的维度数
-
ndarray.size：返回数组中元素的总个数
-
ndarray.dtype ：返回数组中元素的数据类型
## 数组属性
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 返回数组的形状，即各维度的大小
print(arr.shape) # (2, 3)
# 返回数组的维度数
print(arr.ndim) # 2
# 返回数组中元素的总个数
print(arr.size) # 6
# 返回数组中元素的数据类型
print(arr.dtype) # int32数组索引与切片
-
基本索引：通过方括号和索引值来访问数组中的元素。对于多维数组，可以使用逗号分隔各维度的索引
-
切片：使用冒号来获取数组的子集
-
布尔索引：使用布尔数组来对数组进行索引
-
花式索引：使用整数数组来索引
## 数组索引与切片
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 基本索引
print(arr[0, 1]) # 2
# 切片
print(arr[1:3])
# [[4 5 6]
# [7 8 9]]
# 布尔索引
print(arr[arr > 5]) # [6 7 8 9]
# 花式索引
print(arr[[0, 2], [1, 2]]) # [2 9]数组操作
数学运算
-
加减乘除：可以直接对数组进行加、减、乘、除等运算
-
幂运算：使用 ** 或 np.power 进行幂运算
-
取模运算：使用 % 或 np.mod 进行取模运算
-
其他数学函数：np.sin 、 np.cos 、 np.exp 、 np.log 等，可以对数组中的每个元素进行相应的数学运算
## 数组操作
# 数学运算
import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
# 加减乘除
print(arr1 + arr2) # [5 7 9]
print(arr1 - arr2) # [-3 -3 -3]
print(arr1 * arr2) # [ 4 10 18]
print(arr1 / arr2) # [0.25 0.4 0.5 ]
# 幂运算
print(arr1 ** 2) # [1 4 9]
# 其他数学函数
print(np.sin(arr1)) # [0.84147098 0.90929743 0.14112001]
print(np.exp(arr1)) # [ 2.71828183 7.3890561 20.08553692]矩阵运算
-
矩阵乘法：使用 @ 或 np.dot 进行矩阵乘法
-
矩阵转置：使用 .T 或 np.transpose 对矩阵进行转置
-
矩阵求逆：使用 np.linalg.inv 求矩阵的逆
# 矩阵运算
import numpy as np
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
# 矩阵乘法
print(arr1 @ arr2)
# [[19 22]
# [43 50]]
# 矩阵转置
print(arr1.T)
# [[1 3]
# [2 4]]
# 矩阵求逆
print(np.linalg.inv(arr1))
# [[-2. 1. ]
# [ 1.5 -0.5]]
数组重塑
-
numpy.reshape ：在不改变数组元素总数的前提下，改变数组的形状
-
numpy.flatten ：将多维数组展平为一维数组
-
numpy.ravel ：数组内存连续时与 flatten 类似，返回一个副本，对返回数组进行修改不影响原数组；数组内存不连续时返回一个视图，对返回数组进行修改原数组也会相应改变
## 数组重塑
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 在不改变数组元素总数的前提下，改变数组的形状
print(np.reshape(arr, (3, 2)))
# [[1 2]
# [3 4]
# [5 6]]
# 使用 arr.flatten()
flattened_arr = arr.flatten()
print("arr.flatten():", flattened_arr) # [1 2 3 4 5 6]
# 修改展平后的数组
flattened_arr[0] = 100
print("修改后的 arr.flatten():", flattened_arr) # [100 2 3 4 5 6]
print("原数组 arr:", arr)
# [[1 2 3]
# [4 5 6]]
# 使用 arr.ravel()
raveled_arr = arr.ravel()
print("arr.ravel():", raveled_arr) # [1 2 3 4 5 6]
# 修改展平后的数组
raveled_arr[0] = 100
print("修改后的 arr.ravel():", raveled_arr) # [100 2 3 4 5 6]
print("原数组 arr:", arr)
# [[100 2 3]
# [ 4 5 6]]
# 创建一个不连续的数组
arr_transposed = arr.T
print("转置后的数组 arr.T:", arr_transposed)
# [[100 4]
# [ 2 5]
# [ 3 6]]
# 使用 arr.ravel() 对不连续的数组进行展平
raveled_arr_transposed = arr_transposed.ravel()
print("arr.T.ravel():", raveled_arr_transposed) # [100 4 2 5 3 6]
# 修改展平后的数组
raveled_arr_transposed[0] = 200
print("修改后的 arr.T.ravel():", raveled_arr_transposed) # [200 4 2 5 3 6]
print("原数组 arr.T:", arr_transposed)
# [[100 4]
# [ 2 5]
# [ 3 6]]数组拼接
-
numpy.concatenate ：沿指定轴拼接多个数组
-
numpy.vstack ：沿垂直方向（行）堆叠数组
-
numpy.hstack ：沿水平方向（列）堆叠数组
-
numpy.dstack ：沿高度方向（第 2 轴）堆叠数组
## 数组拼接
import numpy as np
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
# 沿指定轴拼接多个数组，0行1列
print(np.concatenate((arr1, arr2), axis=0))
#[[1 2]
# [3 4]
# [5 6]
# [7 8]]
# 沿垂直方向（行）堆叠数组
print(np.vstack((arr1, arr2)))
#[[1 2]
# [3 4]
# [5 6]
# [7 8]]
# 沿水平方向（列）堆叠数组
print(np.hstack((arr1, arr2)))
# [[1 2 5 6]
# [3 4 7 8]]
# 沿高度方向（第 2 轴）堆叠数组
print(np.dstack((arr1, arr2)))
# [[[1 5]
# [2 6]]
# [[3 7]
# [4 8]]]数组拆分
-
numpy.split ：将数组沿指定轴拆分为多个子数组
-
numpy.hsplit ：沿水平方向（列）拆分数组
-
numpy.vsplit ：沿垂直方向（行）拆分数组
-
numpy.dsplit ：沿高度方向（第 2 轴）拆分数组
## 数组拆分
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 将数组沿指定轴拆分为多个子数组, 0行1列
print(np.split(arr, 3, axis=0)) # [array([[1, 2, 3]]), array([[4, 5, 6]]), array([[7, 8, 9]])]
# 沿水平方向（列）拆分数组
print(np.hsplit(arr, 3))
# [array([[1],
# [4],
# [7]]), array([[2],
# [5],
# [8]]), array([[3],
# [6],
# [9]])]
# 沿垂直方向（行）拆分数组
print(np.vsplit(arr, 3)) # [array([[1, 2, 3]]), array([[4, 5, 6]]), array([[7, 8, 9]])]
# 将二维数组转化为三维数组, np.dsplit()只能用于三维或更高维度的数组
arr_3d = arr.reshape(3, 3, 1)
# 将三维数组沿高度方向（第 2 轴）拆分3个子数组
print(np.dsplit(arr_3d, 1))
# [array([[[1],
# [2],
# [3]],
#
# [[4],
# [5],
# [6]],
#
# [[7],
# [8],
# [9]]])]统计函数
-
求和：使用 np.sum 计算数组中元素的总和
-
求平均值：使用 np.mean 计算数组中元素的平均值
-
求最大值和最小值：使用 np.max 和 np.min 分别求数组中的最大值和最小值
-
求标准差和方差：使用 np.std 和 np.var 分别求数组的标准差和方差
-
累计和与累计积：使用 np.cumsum 和 np.cumprod 分别计算数组的累计和与累计积
## 统计函数
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 求和
print("求和:", np.sum(arr)) # 21
# 求平均值
print("求平均值:", np.mean(arr)) # 3.5
# 求最大值和最小值
print("求最大值:", np.max(arr)) # 6
print("求最小值:", np.min(arr)) # 1
# 求标准差和方差
print("求标准差:", np.std(arr)) # 1.707825127659933
print("求方差:", np.var(arr)) # 2.9166666666666665
# 累计和与累计积
print("累计和:", np.cumsum(arr)) # [ 1 3 6 10 15 21]
print("累计积:", np.cumprod(arr)) # [ 1 2 6 24 120 720]随机数生成
-
均匀分布：使用 np.random.rand 生成指定形状的 [0, 1) 区间内的均匀分布随机数
-
正态分布：使用 np.random.randn 生成指定形状的标准正态分布（均值为 0，标准差为 1）随机数
-
整数随机数：使用 np.random.randint 生成指定范围内的整数随机数
## 随机数生成
import numpy as np
# 均匀分布
print("均匀分布:", np.random.rand(3, 4))
# [[0.43810361 0.73280483 0.2456159 0.83288006]
# [0.02499081 0.39803829 0.64658084 0.47021348]
# [0.74515312 0.80496327 0.82236107 0.33336326]]
# 正态分布
print("正态分布:", np.random.randn(2, 3))
# [[ 1.79937316 2.85380898 -1.29202445]
# [-0.23200518 0.33213876 0.09304969]]
# 整数随机数
print("整数随机数:", np.random.randint(1, 10, size=(3, 2)))
# [[6 9]
# [3 4]
# [9 4]]排序
-
numpy.sort ：对数组进行排序
-
numpy.argsort ：返回数组值从小到大的索引值
## 排序
import numpy as np
arr = np.array([[8, 4], [7, 1]])
# 沿0轴对数组进行排序
print(np.sort(arr, axis=0))
# [[7 1]
# [8 4]]
# 返回数组值从小到大的索引值
print(np.argsort(arr))
# [[1 0]
# [1 0]]广播机制
广播机制允许在某些条件下对不同形状的数组进行算术运算。其规则包括：
- 如果两个数组的维度数不同，形状较小的数组会在前面补 1
- 如果两个数组的形状在某个维度上不相等，但其中一个数组在该维度上的大小为 1，则可以对该维度进行广播
- 如果两个数组的形状在所有维度上都不相等且不能通过广播规则进行匹配，则会抛出错误
## 广播机制
import numpy as np
# 创建一个二维数组
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
# 创建一个一维数组
arr1d = np.array([10, 20, 30])
# 广播机制：arr1d 会在前面补 1，变成形状为 (1, 3) 的数组
result = arr2d + arr1d
print("广播后的结果 result:")
print(result)
# [[11 22 33]
# [14 25 36]]
# 创建一个形状为 (2, 1) 的二维数组
arr2d_1 = np.array([[10], [20]])
# 广播机制：arr2d_1 会在第 1 轴上广播，变成形状为 (2, 3) 的数组
result = arr2d + arr2d_1
print("广播后的结果 result:")
print(result)
# [[11 12 13]
# [24 25 26]]
# 创建一个形状为 (2, 4) 的二维数组
arr2d_2 = np.array([[10, 20, 30, 40], [50, 60, 70, 80]])
# 尝试进行广播
try:
result = arr2d + arr2d_2
except ValueError as e:
print("错误:", e)
# 错误: operands could not be broadcast together with shapes (2,3) (2,4)