NumPy（Numerical Python）
NumPy 定义了一个 n 维数组对象，简称 ndarray 对象，它是一个一系列相同类型元素组成的数组集合。数组中的每个元素都占有大小相同的内存块。
- 一个开源的python科学计算库
- 可以方便的使用数组、矩阵进行计算
- 包含线性代数、傅里叶变换、随机数生成等大量函数
1. 创建ndarray数组
numpy.array – 普通数组
numpy.array() 是 NumPy 中最基本的函数之一，用于创建数组。基本语法：
numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)
| | |
|---|---|
| object | 输入数据，可以是任意可迭代对象，如列表、元祖、数组、迭代对象、生成器等。 |
| dtype | 指定数组的数据类型。 如果未指定，NumPy 会自动推断合适的数据类型。 |
| copy | 表示数组能否被复制，默认是 True。 |
| order | 以哪种内存布局创建数组，有4个可选值，分别是 C(行序列)/F(列序列)/A(默认)/K(尽量保持输入顺序，最接近原始数据）。 |
| subok | 类型为bool值，默认False。 True，返回object的内部数据类型； False，返回object数组的数据类型， 即ndarray对象。 |
| ndmin | 指定结果数组的最小维数，默认是0。 |
| 返回值 | subok参数指定的返回对象。 |
常用参数使用示例：
- object
import numpy as np
# 输入元素类型不一致时，会向上转换
arr1 = np.array([[0, 1, 2, 3],('a','b','c','d')]) # 从列表创建
arr2 = np.array((0, 1, 2, 3)) # 从元组创建
arr3 = np.array(arr1) # 从现有数组创建
arr4 = np.array(range(4)) # 可迭代对象
arr5 = np.array([i for i in range(4)]) # 生成器
- dtype
import numpy as np
# 使用 Python原生类型方式（Python 原生类型会自动转换成Numpy的dtype）
arr1 = np.array([[0, 1, 2],('a','b','c','d')],dtype = object) # 生成两行一列，元素为序列的ndarray数组
arr2 = np.array([1.1,2.5,3.8,4,5],dtype='int') # 将浮点型设置为整形，返回截取小数点前的结果# 直接使用np.dtype对象
dt = np.dtype('int32') # 定义 dtype
a = np.array([1, 2, 3], dtype=dt)# 使用字符串别名
a = np.array([1, 2, 3], dtype='i4') # int32
b = np.array([1.0, 2.0], dtype='f8') # float64
数据类型对象dtype
dtype 是 NumPy 中用于表示数组中元素类型的对象。它定义了数组元素的数据类型，比如整数、浮动小数点、字符等。你可以通过 dtype 对象来指定数组元素的类型以及如何存储它们。基本语法：
numpy.dtype(object, align=False, copy=True)
| 参数 | |
|---|---|
| dtype | ● 字符串：如 ‘int32’、‘float64’； ● numpy数据类型对象：如 numpy.int32、numpy.float64； ● 结构化数据类型：使用 list、dict 或 tuple 定义。 |
| align | 布尔值，默认 False。如果为 True，则会根据字段的最大对齐要求自动填充内存。 |
| copy | 布尔值，默认 True。如果为 True，会复制数据类型描述。如果为 False，则直接返回 object 参数的引用。 |
- 基本数据类型：
dt1 = np.dtype('int32') # 32位整数
dt2 = np.dtype(np.float64) # 64位浮点数
dt3 = np.dtype('U10') # 长度10的Unicode字符串
| 名称 | 描述 | 数据类型 | 标识符 |
|---|---|---|---|
| 整数 | 有符号整数 | int8, int16, int32, int64 （英文表示数据类型，数字表示比特数。int 缩写位数取决于操作系统位数和 Python 环境。） | i1, i2, i4, i8 （英文表示数据类型，数字表示字节数，ps：1字节=8比特） |
| 无符号整数 | 无符号整数 | uint8, uint16, uint32, uint64 （英文表示数据类型，数字表示比特位数） | u1, u2, u4, u8 （英文表示数据类型，数字表示字节数，ps：1字节=8比特） |
| 浮点数 | 半/单/双精度 | float16, float32, float64 （英文表示数据类型，数字表示比特数。float 是 float64的简写。） | f1, f2, f4, f8 （英文表示数据类型，数字表示字节数，ps：1字节=8比特） |
| 布尔 | 占1字节，值为True/False | bool 或 bool_ | ? |
| Unicode字符串 | Unicode编码字符串 | str或str_ | U<n> （<n> 为最大长度，如 U10） |
| ASCII 字节串 | bytes类型字节串 | bytes或bytes_ | S<n> （<n> 为最大长度，如 S10） |
| 复数 | 实部和虚部各占一半比特位数 | complex64（双 32 位浮点数）, complex128（双 64 位浮点数） | c8, c16 （英文表示数据类型，数字表示字节数，ps：1字节=8比特） |
| 时间 | 日期时间 | datetime64, timedelta64 | datetime64[unit], timedelta64[unit] （unit= ‘Y’, ‘M’, ‘D’, ‘h’, ‘m’, ‘s’, ‘ms’） |
- 结构化数据类型
除了基本类型外，NumPy 还允许定义由多个字段组成的复合数据类型，每个字段可以有不同的类型，可以通过元组或者字典来定义结构化数据类型。这些字段在内存中按顺序存储，并且可以使用名字来访问。
# 创建方式1：元组列表
dt = np.dtype([('name', 'U10'), # 字段名 + 数据类型('age', 'i4'), # 32位整数('height', 'f4'), # 32位浮点数('weight', 'f4') # 32位浮点数
])# 创建方式2：字典方式
dt = np.dtype({'names': ['name', 'age', 'height', 'weight'],'formats': ['U10', 'i4', 'f4', 'f4']
})# 嵌套结构化类型
dt1 = np.dtype([('name', 'U20'),('grades', [('math', 'f4'), ('physics', 'f4'), ('chemistry', 'f4')]),('passed', '?') # 布尔型
])
data = np.array([('Alice', (90.5, 85.0, 78.5), True),('Bob', (75.0, 82.5, 88.0), False)
], dtype=dt1)
print(data['grades']['math']) # 访问所有 math 成绩
numpy.arange – 区间数组
numpy.arange 是 NumPy 中用于创建均匀间隔数值数组的函数。基本语法：
numpy.arange([start,] stop[, step,], dtype=None)
| 参数 | |
|---|---|
| start | 可选参数，序列的起始值，默认值为0。 |
| stop | 必需参数，序列的结束值（不包含此值）。 |
| step | 可选参数，默认值为1。列中相邻两个值的间隔，可以是浮点数。 |
| dtype | 可选参数，指定输出数组的数据类型。默认值根据输入参数推断。 |
| 返回值 | 返回一个 ndarray 数组，包含从 start 开始到 stop 结束（不包含）的均匀间隔数值。 |
使用示例：
a = np.arange(10)
b = np.arange(0,20,3)
b = np.arange(20,step=3) # 不可写为np.arange(20,3),此时根据函数参数顺序传入值，返回[]
c = np.arange(3.1, dtype = int)
浮点数的精度问题可能影响numpy.arange的结果
print(np.arange(0.1,0.4,0.1)) # 输出结果为：[0.1, 0.2, 0.3, 0.4]这是因为在计算机中，浮点数是以二进制近似存储的，无法精确表示。np.arange通过逐步累加 step 生成序列。对于浮点数，累积误差可能导致实际生成的最后一个值略超过 stop。
- 0.1 → 实际存储为 0.10000000000000000555
- 0.4 → 实际存储为 0.40000000000000002220
0.1 + 0.1 + 0.1 + 0.1 实际为 0.40000000000000002 < 0.40000000000000002220，因此0.4被输出。可采用 numpy.linspace 或整数转换法避免此类问题。
numpy.linspace – 等差数组
numpy.linspace 是 NumPy 中用于创建均匀间隔数值数组的函数（等差数列），与 numpy.arange 不同，通过指定元素数量而不是步长来生成数组。基本语法：
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
| 参数 | |
|---|---|
| start | 序列的起始值。 |
| stop | 序列的结束值。当 endpoint=True 时包含此值。 |
| num | 要生成的样本数，默认为50。必须是非负整数。 |
| endpoint | 布尔值，决定是否包含stop值，默认为 True。 |
| retstep | 布尔值，是否返回步长，默认为False。 False(默认): 只返回数组； True: 返回(数组, 步长)元组。 |
| dtype | 输出数组的数据类型。如果未指定，从输入数据推断。 |
| axis | 结果中用于存储样本的轴，默认为0。 |
| 返回值 | 默认返回ndarray数组，如果 retstep=True，返回(ndarray, step)元组。 |
实现原理：
- 包含终点（endpoint=True）：
x i = s t a r t + i ∗ s t o p − s t a r t n u m − 1 x_i = start + i *\frac {stop - start} {num - 1} xi=start+i∗num−1stop−start - 不包含终点（endpoint=False）：
x i = s t a r t + i ∗ s t o p − s t a r t n u m x_i = start + i *\frac {stop - start} {num} xi=start+i∗numstop−start
使用示例：
a = np.linspace(0, 1, 5) # array([0. 0.25 0.5 0.75 1. ])
b = np.linspace(0, 1, 5, endpoint=False) # array([0. , 0.2, 0.4, 0.6, 0.8])
arr, step = np.linspace(0, 1, 5, retstep=True) # step = 0.25
c = np.linspace(0, 1, 5, dtype=int) # array([0, 0, 0, 0, 1])
d = np.linspace([0, 1], [10, 20], 5)
"""
array([[ 0. 1. ][ 2.5 5.75][ 5. 10.5 ][ 7.5 15.25][10. 20. ]])
"""
numpy.logspace – 等比数组
numpy.logspace 是 NumPy 中用于创建对数刻度上均匀分布的数值数组的函数（等比数列）。基本语法：
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)
| 参数 | |
|---|---|
| start | 对数空间的起始指数值。 |
| stop | 对数空间的结束指数值。当 endpoint=True 时包含此值。 |
| num | 要生成的样本数，默认为50。必须是非负整数。 |
| endpoint | 布尔值，决定是否包含stop值，默认为 True。 |
| base | 对数的底数，默认为10.0，可以是任何正数。 |
| dtype | 输出数组的数据类型。如果未指定，从输入数据推断。 |
| axis | 结果中用于存储样本的轴，默认为0。 |
| 返回值 | 默认返回ndarray数组，如果 retstep=True，返回(ndarray, step)元组。 |
numpy.logspace 是对数版本的 numpy.linspace，数学等价于： n u m p y . l o g s p a c e ( s t a r t , s t o p , n u m ) = b a s e n u m p y . l i n s p a c e ( s t a r t , s t o p , n u m ) numpy.logspace(start, stop, num) = base ^{numpy.linspace(start, stop, num)} numpy.logspace(start,stop,num)=basenumpy.linspace(start,stop,num)
使用示例：
a = np.logspace(0, 2, 3) # array([ 1., 10., 100.])
b = np.logspace(0, 3, 4, base=2) # array([1., 2., 4., 8.])
c = np.logspace(0, 4, 4,endpoint=False) # array([ 1. 10. 100. 1000.])
d = np.logspace([1, 0], [3, 2], 3, axis=0)
"""
array([[ 10., 1.],[100., 10.],[1000., 100.]])
"""
numpy.zeros – 全0数组
numpy.zeros 是 NumPy 中用于创建全0数组的函数。基本语法：
numpy.zeros(shape, dtype=float, order='C', *, like=None)
| 参数 | |
|---|---|
| shape | 定义数组的维度形状，输入整数或整数元组。 |
| dtype | 指定数组元素的数据类型。 |
| order | 控制数组的内存布局，默认为 C。 C：行优先存储；F：列优先存储。 |
| like | 输入数组对象，参考输入数组的特性创建新数组(NumPy 1.20+新增)，默认为None。 |
| 返回值 | 指定形状和数据类型的ndarray且所有元素为0。 |
使用示例：
# 一维数组
a = np.zeros(3) # array([0., 0., 0.])# 二维数组
b = np.zeros((2, 3))
"""
array([[0., 0., 0.],[0., 0., 0.]])
"""# 创建与template具有相同特性的全零数组
template = np.array([1, 2, 3], dtype=np.int16)
c = np.zeros(5, like=template) # array([0. 0. 0. 0. 0.])
numpy.ones – 全1数组
numpy.ones 是 NumPy 中用于创建全1数组的函数，基本语法：
numpy.ones(shape, dtype=None, order='C', *, like=None)
| 参数 | |
|---|---|
| shape | 定义数组的维度形状，输入整数或整数元组。 |
| dtype | 指定数组元素的数据类型。 |
| dtype | 控制数组的内存布局，默认为 C。 C：行优先存储；F：列优先存储。 |
| like | 输入数组对象，参考输入数组的特性创建新数组(NumPy 1.20+新增)，默认为None。 |
| 返回值 | 指定形状和数据类型的ndarray且所有元素为1。 |
使用示例：
# 一维数组
a = np.ones(3) # array([1., 1., 1.])# 二维数组
b = np.ones((2, 3))
"""
array([[1., 1., 1.],[1., 1., 1.]])
"""# 三维数组
c = np.ones((2, 2, 2)) # 创建与template具有相同特性的全零数组
template = np.array([1, 2, 3])
c = np.ones(5, like=template) # array([1. 1. 1. 1. 1.])
2. 数组属性
| 属性 | |
|---|---|
| ndarray.ndim | 返回数组的维度数（秩）。 |
| ndarray.shape | 返回数组的维度（形状），是一个表示各维度大小的元组。 |
| ndarray.size | 返回数组的总元素个数（等于各维度大小的乘积）。 |
| ndarray.dtype | 返回数组元素的数据类型（如 int32、float64、bool 等）。 |
| ndarray.itemsize | 返回数组中每个元素占用的字节数。 |
| ndarray.nbytes | 返回数组所有元素占用的总字节数（size × itemsize）。 |
3. 数组变形
reshape – 元素不变变形
numpy.reshape() 是 NumPy 中用于改变数组形状的函数，它可以重新排列数组的元素以适应新的形状，常用于对数组进行维度转换，目标形状元素数量必须与原数组元素数量一致。基本语法：
numpy.reshape(ndarray, newshape, order='C')
ndarray数组方法，基本语法：
ndarray.reshape(newshape, order='C')
| | |
|---|---|
| ndarray | 原始数组（必须是一个 NumPy 数组）。 |
| newshape | 目标形状，可以是一个整数（表示新的一维大小），也可以是一个元组，表示多维数组的新形状。 |
| order | 指定元素排列顺序，默为为 C。 C 表示按行优先顺序，F 表示按列优先顺序，A 表示按原始数组的顺序，K 表示尽量保持原数组内存布局。 |
| 返回值 | 如果原数组的内存布局与目标形状兼容，将返回一个视图；否则，可能会返回副本。 |
使用示例：
import numpy as np
# 创建一个包含 6 个元素的数组
arr = np.array([1, 2, 3, 4, 5, 6])# 简单的数组重塑，重塑为2行3列
reshaped_arr1 = arr.reshape(2, 3)
# 使用 -1 自动推断某一维的大小
reshaped_arr2 = arr.reshape(2, -1)
# 控制元素排列顺序，按列优先顺序
reshaped_arr3 = arr.reshape(2, 3, order='F')
resize – 元素改变变形
numpy.resize() 是 NumPy 中用于改变数组大小的函数，与 reshape() 不同，它可以改变数组的总元素数量，通过重复数据或截断来适应新的大小。基本语法：
numpy.resize(a, new_shape)
| 参数 | |
|---|---|
| a | 要调整大小的数组 |
| new_shape | 新形状的整数或整数元组 |
| 返回值 | 调整大小后的新数组。如果新形状的大小与原数组的大小不同，NumPy 会填充或截断原数组的元素数据。 |
使用示例：
import numpy as np# 创建一个包含 6 个元素的数组
arr = np.array([1, 2, 3, 4, 5, 6])# 将数组大小扩展到 10 个元素
resized_arr = np.resize(arr, 10) # array([1 2 3 4 5 6 1 2 3 4])
# 将数组大小减少到 4 个元素
resized_arr = np.resize(arr, 4) # array([1 2 3 4])# 多维数组调整
arr = np.array([[1, 2], [3, 4]])
resized = np.resize(arr, (3, 3))
"""
array([[1 2 3][4 1 2][3 4 1]])
"""
ndarray数组也有resize方法，基本语法：
ndarray.resize(new_shape, refcheck=True)
| | |
|---|---|
| ndarray | 要调整大小的数组 |
| new_shape | 新形状的整数或整数元组 |
| refcheck | 是否检查引用计数（默认为True） |
| 返回值 | 直接修改原数组，返回修改后的数组。如果新形状的大小与原数组的大小不同，NumPy 会填充 0 或截断原数组的元素数据。 |
使用实例：
arr = np.array([1, 2, 3])
arr.resize((5,), refcheck=True) # array([1 2 3 0 0])
flatten – 展平(副本)
numpy.ndarray.flatten() 是 NumPy 中用于将多维数组转换为一维数组的重要方法。基本语法：
numpy.ndarray.flatten(order='C')
| 参数 | |
|---|---|
| ndarray | 要调整大小的数组 |
| order | 制数组元素在展平时的读取顺序，默认为C. C 行优先，F 列优先，A 原数组顺序，K 元素在内存中的出现顺序 |
| 返回值 | 返回原数组的副本。 |
使用示例：
import numpy as nparr = np.array([[1, 2], [3, 4]])
arr.flatten() # array([1 2 3 4])
arr.flatten(order='F') # array([1 3 2 4])
ravel – 展平(视图)
numpy.ravel() 是 NumPy 中的一个函数，用于将多维数组展平为一维数组。与 flatten() 类似，ravel() 也将数组展平，但有一些区别，尤其是在内存管理方面。基本语法：
numpy.ravel(ndarray, order='C')
ndarray数组方法，基本语法：
ndarray.ravel(order='C')
| 参数 | |
|---|---|
| ndarray | 要调整大小的数组 |
| order | 制数组元素在展平时的读取顺序，默认为C. C 行优先，F 列优先，A 原数组顺序，K 元素在内存中的出现顺序。 |
| 返回值 | 尽可能返回原数组的视图，仅当无法返回视图时才返回副本。 |
使用示例：
import numpy as nparr = np.array([[1, 2], [3, 4]])print(np.ravel(arr)) # [1 2 3 4] (行优先)
print(np.ravel(arr, order='F')) # [1 3 2 4] (列优先)
transpose / T – 转置
numpy.transpose() 函数用于对数组进行转置操作，即交换数组的维度。基本语法：
numpy.transpose(a, axes=None)
| 参数 | |
|---|---|
| a | 输入数组，可以是任何类似数组的对象（如列表、元组、numpy数组等）。 |
| axes | 指定新轴顺序的整数元组或列表，默认反转所有轴的顺序。如果提供，则必须包含所有轴索引的排列（从0开始）。 |
| 返回值 | 返回输入数组的转置视图。 |
使用实例：
x = np.ones((1, 2, 3))
print(np.transpose(x, (1, 0, 2)).shape) # 输出: (2, 1, 3)x = np.ones((2, 3, 4, 5))
print(np.transpose(x, (0, 2, 1, 3)).shape) # 输出: (2, 4, 3, 5)
除了numpy.transpose() 函数形式转置，还有ndarray.T属性访问方式。基本语法：
numpy.ndarray.flatten(order='C')
| 参数 | |
|---|---|
| ndarray | 要转置的数组。 |
| 返回值 | 返回的是原始数组的转置视图。 |
使用示例：
arr = np.array([[1, 2], [3, 4]])
print(arr.T)
# 输出：
# [[1 3]
# [2 4]]
4. 切片和索引
ndarray对象的内容可以通过索引或切片来访问和修改。索引是指获取数组中单个元素的值，每个维度索引为整数且从0开始；切片是指通过索引获取数组的部分数据。
单元素索引
NumPy 的单元素索引是最基础也是最常用的数组访问方式，它允许我们精确地访问数组中的单个元素，返回Python/Numpy 标量值。
# 一维数组
arr1d = np.array([10, 20, 30, 40, 50])
print(arr1d[2]) # 30 (正索引)
print(arr1d[-1]) # 50 (负索引)# 二维数组
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr2d[1, 2]) # 6 (第2行第3列)
print(arr2d[1][2]) # 6 (等效写法)
print(arr2d[-1, -1]) # 9（最后一行最后一列）
切片索引
切片用于获取数组的一个子集，可以通过指定开始位置、结束位置和步长来控制提取的范围。
一维数组基本语法：array[start:stop:step]
| 参数 | |
|---|---|
| start | 切片开始的位置（包含），默认为0。负数指从数组的尾部开始计数的位置。 |
| stop | 切片结束的位置（不包含）， 默认为数组的长度。负数指从数组的尾部开始计数的位置。 |
| step | 切片的步长，默认为1。array[ : : -1] 指对数组元素逆序。 |
| 返回值 | 返回原数组视图。 |
使用实例：
arr = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
print(arr[2:7]) # [2 3 4 5 6]
print(arr[::2]) # [0 2 4 6 8]
print(arr[::-1]) # 逆序 [9 8 ... 0]
二维数组基本语法：arr[start_row:end_row:row_step, start_col:end_col:col_step]
| 参数 | |
|---|---|
| start_row | 行切片开始的位置（包含），默认为0。 |
| end_row | 行切片结束的位置（不包含）， 默认为数组的长度。 |
| row_step | 行切片的步长，默认为1。 |
| start_col | 列切片开始的位置（包含），默认为0。 |
| end_col | 列切片结束的位置（不包含）， 默认为数组的长度。 |
| col_step | 列切片的步长，默认为1。 |
| 返回值 | 返回原数组视图。 |
使用示例：
import numpy as np# 多维数组切片
arr2d = np.arange(9).reshape(3,3)
print(arr2d[1:3, 0:2]) # 第2-3行，第1-2列
print(arr2d[1:]) # 输出从第二行到结束的所有行
print(arr2d[:, 1:]) # 输出所有行的第二列到结束的列
整数数组索引（花式索引）
整数数组索引允许你使用整数数组来选择多个元素。通过传递一个整数列表或数组，可以同时获取多个指定位置的元素，返回原数组副本。
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr[[0, 2, 4]]) # 输出索引为0、2、4的元素，即[1, 3, 5]arr = np.arange(12).reshape(3,4)
print(arr[[0, 1, 2], [0, 1, 0]]) # [0 5 8] (选择(0,0),(1,1),(2,0))
print(arr[[1, 2]]) # 选择第2行和第3行
print(arr[:, [0, 2]]) # 选择第1列和第3列
print(a3_4[[1],[0,2]]) # 广播机制，选择第2行第1,3列
布尔数组索引
布尔索引是根据条件生成一个布尔数组，然后根据这个布尔数组来选择元素。这种方式非常适合用于基于条件筛选数组中的元素，返回原数组副本。
import numpy as np
arr = np.array([10, 20, 30, 40, 50])
print(arr[arr > 25]) # 输出 [30 40 50]
print(arr[(arr > 15) & (arr < 40)]) # 输出 [20 30]
5.数学运算
NumPy 提供了丰富的数学运算功能，包括算术运算、矩阵运算、统计运算等。
算术运算
NumPy 数组支持逐元素的算术运算，如加法、乘法、平方、对数等。对以下两个数组进行不同的算术运算。
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
| 运算类型 | 函数形式 | 运算符形式 | 使用示例 | |
|---|---|---|---|---|
| 加法运算 | np.add() | + |
| |
| 减法运算 | np.subtract() | - |
| |
| 乘法运算 | np.multiply() | * |
| |
| 除法运算 | np.divide() | / |
| |
| 幂运算 | np.power() | ** |
| |
| 整数除法 | np.floor_divide() | // |
| |
| 取模运算 | np.mod() | % |
|
矩阵运算
NumPy 提供了丰富的线性代数运算功能，主要通过 numpy.linalg 模块实现。
numpy.dot --点积
import numpy as np# 一维数组的点积（内积）
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
dot_product = np.dot(a, b) # 1*4 + 2*5 + 3*6 = 32# 二维数组的矩阵乘法
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
matrix_product = np.dot(A, B)
# [[19 22]
# [43 50]]# 对高维数组执行 张量点积（沿最后一个轴和倒数第二个轴求和）：
# 计算规则：对于 a.shape=(x,y,z) 和 b.shape=(a,b,c)，np.dot(a,b).shape=(x,y,a,c)。
a = np.random.rand(2, 3, 4) # 形状 (2,3,4)
b = np.random.rand(2, 4, 5) # 形状 (2,4,5)
np.dot(a, b).shape # 输出 (2,3,2,5)
numpy.matmul / @ --矩阵乘法
NumPy 进行矩阵乘法有np.matmul() 函数，在Python 3.5+还可使用运算符@。
# 二维数组的矩阵乘法
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
result = np.matmul(A, B) # 等同于 A @ B# 对高维数组执行 批量矩阵乘法（将前N-2维视为批次维度）：
a = np.random.rand(2, 3, 4) # 形状 (2,3,4)
b = np.random.rand(2, 4, 5) # 形状 (2,4,5)
np.matmul(a, b).shape # 输出 (2,3,5)
numpy.linalg.inv – 矩阵求逆
只有方阵且行列式不为零的矩阵才有逆矩阵。对于奇异矩阵会抛出 LinAlgError。
A = np.array([[1, 2], [3, 4]])
A_inv = np.linalg.inv(A)
# [[-2. 1. ]
# [ 1.5 -0.5]]# 验证逆矩阵
identity = np.dot(A, A_inv) # 应近似于单位矩阵
广播运算
广播规则允许 NumPy 在数组的形状不同但相容的情况下，自动扩展小数组的维度，使得其形状与大数组一致，然后再进行逐元素的计算。通过这种机制，NumPy 可以避免显式地复制数组，从而节省内存并提高计算效率。所有算术运算和运算都支持广播。
广播遵循两个基本原则：
维度补全：将两个数组的维度竖排右对齐，分别从最后一个维度开始向前比较，要么维度大小相同，要么其中一个维度大小为1或者缺失该维度则补1。
维度扩展：在缺失的维度或大小为1的维度上，数组会被"拉伸"或"复制"以匹配另一个数组的相应维度大小。
- 标量与数组相加
import numpy as np
a = np.array([1, 2, 3]) # 形状 (3,)
b = 5 # 标量（可视为形状 ()）
print(a + b) """
输出: [6 7 8]
广播顺序：
1.a 的形状是 (3,)，b 的形状是 ()（标量）。
2.b 补全维度为 (1,)
3.b 在补全维度上扩展，最终为 [5, 5, 5]，然后与 a 逐元素相加。
"""
- 一维数组与二维数组
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]]) # 形状 (2, 3)
b = np.array([10, 20, 30]) # 形状 (3,)
print(a + b)
"""
输出:
[[11 22 33][14 25 36]]
广播顺序：
1.a 的形状是 (2, 3)，b 的形状是 (3,)。
2.b 补全维度为 (1, 3)
3.b 在补全维度上扩展，最终为 [[10, 20, 30], [10, 20, 30]]，然后与 a 逐元素相加。
"""arr1 = np.array([1, 2, 3]) # 形状 (3,)
arr2 = np.array([[10], [20]]) # 形状 (2, 1)
print(arr1 + arr2)
"""
输出:
[[11 12 13][21 22 23]]
广播顺序：
1.arr1 的形状是 (3,)，b 的形状是 (2, 1)。
2.arr1 补全维度为 (1, 3)
3.arr1 在补全维度上扩展，最终为 [[1, 2, 3], [1, 2, 3]]；arr2 在大小为1的维度上扩展，最终为[[10, 10, 10], [20, 20, 20]]。然后 arr1与 arr2 逐元素相加。
"""
统计运算
NumPy提供了丰富的统计函数，可以直接对整个数组或沿特定轴进行统计计算。这些函数既可作为NumPy模块的函数使用，也可作为ndarray对象的方法调用。
sum – 求和
numpy函数，基本语法：
numpy.sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
ndarray数组方法，基本语法：
ndarray.sum(axis=None, dtype=None, out=None, keepdims=False, initial=<no value>, where=<no value>)
| | |
|---|---|
| a | 输入的数组，可以是一个 NumPy 数组或类似数组的对象。 |
| axis | 可选参数，用于指定在哪个轴上求和，默认值为None。 None：对整个数组的所有元素求和。 输入值类型为int：沿指定的轴进行求和。 输入值类型为tuple：指定多个轴，对这些轴进行广播后求和。 |
| dtype | 指定计算时的结果数据类型，默认为None，使用输入数组的类型。但如果结果可能超出范围（例如整型溢出），可以设置为更高的精度（如 float64 或 int64）。 |
| out | 将结果存储到指定的数组中，而不是返回新的数组，默认值为None。 |
| keepdims | 是否保持求和操作后数组的维度。默认值为False，会丢弃求和的维度。 |
| initial | 求和的初始值，默认是 0。 |
| where | 条件选择，一个布尔数组，指定在哪些位置进行求和操作。 |
| 返回值 | 返回求和结果。如果指定 axis，返回一个降维后的数组，否则返回一个标量。 |
使用示例：
arr = np.array([[1, 2], [3, 4]])# 全局求和
print(np.sum(arr)) # 输出: 10# 沿列求和
print(arr.sum(axis=0)) # 输出: [4 6]# 带条件求和
print(np.sum(arr, where=arr>2)) # 输出: 7 (只计算大于2的元素)
mean – 均值
numpy函数，基本语法：
numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>, where=<no value>)
ndarray数组方法，基本语法：
ndarray.mean(axis=None, dtype=None, out=None, keepdims=False, where=<no value>)
| | |
|---|---|
| a | 输入的数组，可以是一个 NumPy 数组或类似数组的对象。 |
| axis | 可选参数，用于指定在哪个轴上计算平均值，默认值为None。 None：对整个数组的所有元素求均值。 输入值类型为int：沿指定的轴进行求均值。 输入值类型为tuple：指定多个轴，对这些轴进行广播后求均值。 |
| dtype | 指定计算时的结果数据类型，默认为None，使用输入数组的类型。但如果结果可能超出范围（例如整型溢出），可以设置为更高的精度（如 float64 或 int64）。 |
| out | 将结果存储到指定的数组中，而不是返回新的数组，默认值为None。 |
| keepdims | 是否保持求均值操作后数组的维度。默认值为False，会丢弃求均值的维度。 |
| where | 条件选择，一个布尔数组，指定在哪些位置进行求均值操作。 |
| 返回值 | 返回求和结果。如果指定 axis，返回一个降维后的数组，否则返回一个标量。 |
使用示例：
arr = np.array([[1, 2], [3, 4]])print(np.mean(arr)) # 2.5
print(arr.mean(axis=0, dtype=np.float32)) # [2. 3.]# 条件均值
print(np.mean(arr, where=arr>2)) # 3.5 (只计算大于2的元素)
median – 中位数
无数组均值方法。
numpy函数，基本语法：
numpy.median(a, axis=None, out=None, overwrite_input=False, keepdims=False)
| | |
|---|---|
| a | 输入的数组，可以是一个 NumPy 数组或类似数组的对象。 |
| axis | 可选参数，用于指定在哪个轴上计算中位数，默认值为None。 None：对整个数组的所有元素求中位数。 输入值类型为int：沿指定的轴进行求中位数。 输入值类型为tuple：指定多个轴，对这些轴进行广播后求中位数。 |
| out | 将结果存储到指定的数组中，而不是返回新的数组，默认值为None。 |
| overwrite_input | 可选参数，如果为True，则允许在计算中使用输入数组的内存。这可能会在某些情况下提高性能，但可能会修改输入数组的内容。 |
| keepdims | 是否保持求中位数操作后数组的维度。默认值为False，会丢弃求中位数的维度。 |
| 返回值 | 返回求中位数结果。如果指定 axis，返回一个降维后的数组，否则返回一个标量。 |
使用示例：
arr = np.array([1, 2, 3, 4, 5])
median_value = np.median(arr)
print(median_value) # 输出: 3.0
std – 标准差
numpy函数，基本语法：
numpy.std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, where=<no value>)
ndarray数组方法，基本语法：
ndarray.std(axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, where=<no value>)
| | |
|---|---|
| a | 输入的数组，可以是一个 NumPy 数组或类似数组的对象。 |
| axis | 可选参数，用于指定在哪个轴上计算标准差，默认值为None。 None：对整个数组的所有元素求标准差。 输入值类型为int：沿指定的轴进行求标准差。 输入值类型为tuple：指定多个轴，对这些轴进行广播后求标准差。 |
| dtype | 指定计算时的结果数据类型，默认为None，使用输入数组的类型。但如果结果可能超出范围（例如整型溢出），可以设置为更高的精度（如 float64 或 int64）。 |
| out | 将结果存储到指定的数组中，而不是返回新的数组，默认值为None。 |
| ddof | 自由度修正（0=总体标准差，1=样本标准差） |
| keepdims | 是否保持求标准差操作后数组的维度。默认值为False，会丢弃求标准差的维度。 |
| where | 条件选择，一个布尔数组，指定在哪些位置进行求标准差操作。 |
| 返回值 | 返回求标准差结果。如果指定 axis，返回一个降维后的数组，否则返回一个标量。 |
使用示例：
data = np.array([1, 2, 3, 4, 5])print(np.std(data)) # 总体标准差 1.4142
print(data.std(ddof=1)) # 样本标准差 1.5811
var – 方差
numpy函数，基本语法：
numpy.var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, where=<no value>)
ndarray数组方法，基本语法：
ndarray.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, where=<no value>)
| | |
|---|---|
| a | 输入的数组，可以是一个 NumPy 数组或类似数组的对象。 |
| axis | 可选参数，用于指定在哪个轴上计算方差，默认值为None。 None：对整个数组的所有元素求方差。 输入值类型为int：沿指定的轴进行求方差。 输入值类型为tuple：指定多个轴，对这些轴进行广播后求方差。 |
| dtype | 指定计算时的结果数据类型，默认为None，使用输入数组的类型。但如果结果可能超出范围（例如整型溢出），可以设置为更高的精度（如 float64 或 int64）。 |
| out | 将结果存储到指定的数组中，而不是返回新的数组，默认值为None。 |
| ddof | 自由度修正（0=总体方差，1=样本方差） |
| keepdims | 是否保持求方差操作后数组的维度。默认值为False，会丢弃求方差的维度。 |
| where | 条件选择，一个布尔数组，指定在哪些位置进行求方差操作。 |
| 返回值 | 返回求方差结果。如果指定 axis，返回一个降维后的数组，否则返回一个标量。 |
max – 最大值
numpy函数，基本语法：
numpy.max(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
ndarray数组方法，基本语法：
ndarray.max(axis=None, out=None, keepdims=False, initial=<no value>, where=<no value>)
| | |
|---|---|
| a | 输入的数组，可以是一个 NumPy 数组或类似数组的对象。 |
| axis | 可选参数，用于指定在哪个轴上求最大值，默认值为None。 None：对整个数组的所有元素求最大值。 输入值类型为int：沿指定的轴进行求最大值。 输入值类型为tuple：指定多个轴，对这些轴进行广播后求最大值。 |
| out | 将结果存储到指定的数组中，而不是返回新的数组，默认值为None。 |
| keepdims | 是否保持求最大值操作后数组的维度。默认值为False，会丢弃求最大值的维度。 |
| initial | 求最大值的初始值，默认是 0。 |
| where | 条件选择，一个布尔数组，指定在哪些位置进行求最大值操作。 |
| 返回值 | 返回求最大值结果。如果指定 axis，返回一个降维后的数组，否则返回一个标量。 |
使用示例：
arr = np.array([[3, 1], [4, 2]])
print(np.max(arr, where=arr<4, initial=-1)) # 3
min – 最小值
numpy函数，基本语法：
numpy.min(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
ndarray数组方法，基本语法：
ndarray.min(axis=None, out=None, keepdims=False, initial=<no value>, where=<no value>)
| | |
|---|---|
| a | 输入的数组，可以是一个 NumPy 数组或类似数组的对象。 |
| axis | 可选参数，用于指定在哪个轴上求最小值，默认值为None。 None：对整个数组的所有元素求最小值。 输入值类型为int：沿指定的轴进行求最小值。 输入值类型为tuple：指定多个轴，对这些轴进行广播后求最小值。 |
| out | 将结果存储到指定的数组中，而不是返回新的数组，默认值为None。 |
| keepdims | 是否保持求最小值操作后数组的维度。默认值为False，会丢弃求最小值的维度。 |
| initial | 求最小值的初始值，默认是 0。 |
| where | 条件选择，一个布尔数组，指定在哪些位置进行求最小值操作。 |
| 返回值 | 返回求最小值结果。如果指定 axis，返回一个降维后的数组，否则返回一个标量。 |
使用示例：
arr = np.array([[3, 1], [4, 2]])print(np.min(arr)) # 1
print(arr.min(axis=0)) # [3 1]
6.文件操作
numpy.loadtxt
numpy.loadtxt 是 NumPy 中用于加载文本文件的函数，能够将文件中的数据读取为 NumPy 数组。该函数能够处理常见的文本格式（如 CSV、空格分隔等），并支持指定分隔符、数据类型以及跳过无关内容等功能。基本语法：
numpy.loadtxt(fname, dtype=<class 'float'>, delimiter=None, comments='#', skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', converters=None, casting='safe', **kwargs)
| | |
|---|---|
| fname： | 类型：字符串或文件类对象 说明：文件名（路径）或文件对象。该文件应包含数值数据。可以是 .txt、.csv 等文本文件，或任何支持文本输入的文件对象。 |
| dtype： | 类型：数据类型（默认：float） 说明：指定返回数组的数据类型。如果未指定，默认将数据加载为 float 类型。你可以使用任何 NumPy 支持的类型（如 int32, float64 等）。 |
| delimiter： | 类型：字符串（默认：None） 说明：指定分隔符。可以是逗号、空格、制表符等。默认情况下，None 表示分隔符为任何空白字符（包括空格和制表符）。对于逗号分隔的文件，可以设置为 ‘,’。 |
| comments： | 类型：字符串（默认：#） 说明：指定注释的标志。默认情况下，以 # 开头的行将被认为是注释行并被跳过。如果文件中的注释使用其他符号，可以调整此参数。 |
| skiprows： | 类型：整数（默认：0） 说明：跳过文件的前 skiprows 行。通常用于跳过表头行。可以设置为整数或可迭代对象。 |
| usecols： | 类型：整数或整数元组、列表（默认：None） 说明：指定要读取的列。如果为整数，读取该列；如果为元组或列表，读取多个指定的列。索引从 0 开始。 |
| unpack： | 类型：布尔值（默认：False） 说明：如果为 True，返回的数组会“解包”成多个数组，每列作为一个数组返回。这在你希望直接访问各列数据时非常有用。 |
| ndmin： | 类型：整数（默认：0） 说明：指定返回数组的最小维数。如果数据只有一维，且 ndmin=2，则返回一个二维数组。 |
| encoding： | 类型：字符串（默认：‘bytes’） 说明：文件的编码格式。对于包含文本数据的文件，可以设置为 ‘utf-8’ 等编码。 |
| converters： | 类型：字典（默认：None） 说明：用于将文件中某些列的值转换为指定类型的字典。例如，指定某列需要自定义的解析函数。 |
| casting： | 类型：字符串（默认：‘safe’） 说明：指定数据类型转换的规则。可以是 no、safe、equiv、unsafe，决定是否允许不同类型间的转换以及如何转换。 |
| kwargs： | 说明：其他参数，可能会传递给文件读取的底层函数。 |
| 返回值 | 返回一个包含文件数据的 NumPy 数组。其形状和维度取决于输入文件的结构。 |