NumPy 1.26 中文官方指南（三）（1）https://developer.aliyun.com/article/1510615
通用等价物
| MATLAB | NumPy | 注释 |
help func |
info(func)或help(func)或func?（在 IPython 中） |
获取函数func的帮助信息 |
which func |
见注意事项 HELP | 查找func的定义位置 |
type func |
np.source(func)或func??（在 IPython 中） |
打印func的源代码（如果不是原生函数） |
% comment |
# comment |
使用文本comment对代码行进行注释 |
|
for i=1:3 fprintf('%i\n',i) end
|
for i in range(1, 4): print(i)
使用 for 循环打印数字 1, 2 和 3，使用[range](https://docs.python.org/3/library/stdtypes. html#range “(在 Python v3.11 中)”) |
a && b |
a || b |
|
>> 4 == 4 ans = 1 >> 4 == 5 ans = 0
|
>>> 4 == 4 True >>> 4 == 5 False
在 Python 中，布尔对象是True和False，而不是 MATLAB 的逻辑类型1和0。 |
|
a=4 if a==4 fprintf('a = 4\n') elseif a==5 fprintf('a = 5\n') end
|
a = 4 if a == 4: print('a = 4') elif a == 5: print('a = 5')
创建一个 if-else 语句以检查a是否为 4 或 5，并打印结果 |
1*i、1*j、1i、1j |
eps |
load data.mat |
ode45 |
ode15s |
同等的线性代数
| MATLAB | NumPy | 注释 |
ndims(a) |
np.ndim(a) or a.ndim |
数组 a 的维度数 |
numel(a) |
np.size(a) or a.size |
数组 a 的元素个数 |
size(a) |
np.shape(a) or a.shape |
数组 a 的尺寸 |
size(a,n) |
a.shape[n-1] |
获取数组 a 的第 n 维度的元素个数。（注意 MATLAB 使用基于 1 的索引，而 Python 使用基于 0 的索引，参见注释 INDEXING） |
[ 1 2 3; 4 5 6 ] |
np.array([[1., 2., 3.], [4., 5., 6.]]) |
定义一个 2x3 的 2D 数组 |
[ a b; c d ] |
np.block([[a, b], [c, d]]) |
从块 a、b、c 和 d 构造矩阵 |
a(end) |
a[-1] |
访问 MATLAB 向量（1xn 或 nx1）或长度为 n 的 1D NumPy 数组 a 中的最后一个元素 |
a(2,5) |
a[1, 4] |
访问 2D 数组 a 中第二行第五列的元素 |
a(2,:) |
a[1] or a[1, :] |
2D 数组 a 的第二行 |
a(1:5,:) |
a[0:5] or a[:5] or a[0:5, :] |
2D 数组 a 的前 5 行 |
a(end-4:end,:) |
a[-5:] |
2D 数组 a 的最后 5 行 |
a(1:3,5:9) |
a[0:3, 4:9] |
2D 数组 a 的第一到第三行和第五到第九列 |
a([2,4,5],[1,3]) |
a[np.ix_([1, 3, 4], [0, 2])] |
第 2、4 和 5 行以及第 1 和 3 列。这允许修改矩阵，并且不需要常规切片。 |
a(3:2:21,:) |
a[2:21:2,:] |
从第三行开始，每隔一行的 a，直到第二十一行 |
a(1:2:end,:) |
a[::2, :] |
a 的每隔一行，从第一行开始 |
a(end:-1:1,:) or flipud(a) |
a[::-1,:] |
行顺序相��的 a |
a([1:end 1],:) |
a[np.r_[:len(a),0]] |
a 的副本，附加了第一行的副本到末尾 |
a.' |
a.transpose() or a.T |
a 的转置 |
a' |
a.conj().transpose() or a.conj().T |
a 的共轭转置 |
a * b |
a @ b |
矩阵相乘 |
a .* b |
a * b |
逐元素相乘 |
a./b |
a/b |
逐元素相除 |
a.³ |
a**3 |
逐元素求幂 |
(a > 0.5) |
(a > 0.5) |
矩阵，其第 i、j 个元素为 (a_ij > 0.5)。MATLAB 结果是一个由 0 和 1 组成的逻辑值数组。NumPy 结果是一个由布尔值 False 和 True 组成的数组。 |
find(a > 0.5) |
np.nonzero(a > 0.5) |
找到满足 (a > 0.5) 的索引 |
a(:,find(v > 0.5)) |
a[:,np.nonzero(v > 0.5)[0]] |
提取矩阵 a 中向量 v > 0.5 的列 |
a(:,find(v>0.5)) |
a[:, v.T > 0.5] |
提取矩阵 a 中列向量 v > 0.5 的列 |
a(a<0.5)=0 |
a[a < 0.5]=0 |
小于 0.5 的 a 元素变为零 |
a .* (a>0.5) |
a * (a > 0.5) |
小于 0.5 的 a 元素变为零 |
a(:) = 3 |
a[:] = 3 |
将所有值设置为相同的标量值 |
y=x |
y = x.copy() |
NumPy 通过引用赋值 |
y=x(2,:) |
y = x[1, :].copy() |
NumPy 的切片是通过引用进行的 |
y=x(:) |
y = x.flatten() |
将数组转换成向量（请注意，这会强制执行复制）。为了获得与 MATLAB 中相同的数据排序，使用 x.flatten('F')。 |
1:10 |
np.arange(1., 11.) or np.r_[1.:11.] or np.r_[1:10:10j] |
创建一个递增的向量（参见 范围注释（RANGES）） |
0:9 |
np.arange(10.) or np.r_[:10.] or np.r_[:9:10j] |
创建一个递增的向量（参见 范围注释（RANGES）） |
[1:10]' |
np.arange(1.,11.)[:, np.newaxis] |
创建一个列向量 |
zeros(3,4) |
np.zeros((3, 4)) |
全部为 0 的 3x4 二维数组，64 位浮点类型 |
zeros(3,4,5) |
np.zeros((3, 4, 5)) |
全部为 0 的 3x4x5 三维数组，64 位浮点类型 |
ones(3,4) |
np.ones((3, 4)) |
全部为 1 的 3x4 二维数组，64 位浮点类型 |
eye(3) |
np.eye(3) |
3x3 单位矩阵 |
diag(a) |
np.diag(a) |
返回二维数组 a 对角线上的元素构成的向量 |
diag(v,0) |
np.diag(v, 0) |
返回一个正方形对角矩阵，其非零值为向量 v 的元素 |
|
rng(42,'twister') rand(3,4)
|
from numpy.random import default_rng rng = default_rng(42) rng.random(3, 4)
或者旧版本：random.rand((3, 4)) | 使用默认的随机数生成器和 seed = 42 生成一个随机的 3x4 数组 |
linspace(1,3,4) |
np.linspace(1,3,4) |
在 1 到 3 之间生成 4 个等差样本，包括边界值 |
[x,y]=meshgrid(0:8,0:5) |
np.mgrid[0:9.,0:6.] or np.meshgrid(r_[0:9.],r_[0:6.]) |
两个 2D 数组：一个是 x 值，另一个是 y 值 |
ogrid[0:9.,0:6.] or np.ix_(np.r_[0:9.],np.r_[0:6.] |
在网格上计算函数的最佳方法 | |
[x,y]=meshgrid([1,2,4],[2,4,5]) |
np.meshgrid([1,2,4],[2,4,5]) |
|
np.ix_([1,2,4],[2,4,5]) |
在网格上计算函数的最佳方法 | |
repmat(a, m, n) |
np.tile(a, (m, n)) |
创建大小为 m × n 的 a 的副本 |
[a b] |
np.concatenate((a,b),1) or np.hstack((a,b)) or np.column_stack((a,b)) or np.c_[a,b] |
连接数组 a 和 b 的列 |
[a; b] |
np.concatenate((a,b)) or np.vstack((a,b)) or np.r_[a,b] |
连接数组 a 和 b 的行 |
max(max(a)) |
a.max() or np.nanmax(a) |
a 的最大值（对于 MATLAB，ndims(a)<=2，如果存在 NaN，则 nanmax 会忽略这些 NaN 并返回最大值） |
max(a) |
a.max(0) |
数组 a 每列的最大值 |
max(a,[],2) |
a.max(1) |
数组 a 每行的最大值 |
max(a,b) |
np.maximum(a, b) |
比较 a 和 b 的元素并��个返回最大值 |
norm(v) |
np.sqrt(v @ v) or np.linalg.norm(v) |
向量 v 的 L2 范数 |
a & b |
logical_and(a,b) |
元素逐个进行与运算（NumPy ufunc）查看逻辑操作注释（LOGICOPS） |
a | b |
np.logical_or(a,b) |
元素逐个进行或运算（NumPy ufunc）查看逻辑操作注释（LOGICOPS） |
bitand(a,b) |
a & b |
按位与运算符（Python 原生和 NumPy ufunc） |
bitor(a,b) |
a | b |
按位或运算符（Python 本地和 NumPy ufunc） |
inv(a) |
linalg.inv(a) |
2D 数组a的逆 |
pinv(a) |
linalg.pinv(a) |
2D 数组a的伪逆 |
rank(a) |
np.linalg.matrix_rank(a) |
2D 数组a的矩阵秩 |
a\b |
若a是方阵使用linalg.solve(a, b)；否则使用linalg.lstsq(a, b) |
解线性方程组a x = b得到的解 x |
b/a |
解a.T x.T = b.T |
解方程x a = b得到的解 x |
[U,S,V]=svd(a) |
U, S, Vh = linalg.svd(a); V = Vh.T |
a的奇异值分解 |
chol(a) |
linalg.cholesky(a) |
2D 数组a的 Cholesky 分解 |
[V,D]=eig(a) |
D,V = linalg.eig(a) |
a的特征值(\lambda)和特征向量(v)，其中(\mathbf{a} v = \lambda v) |
[V,D]=eig(a,b) |
D,V = linalg.eig(a, b) |
a和b的特征值(\lambda)和特征向量(v)，其中(\mathbf{a} v = \lambda \mathbf{b} v) |
[V,D]=eigs(a,3) |
D,V = eigs(a, k=3) |
找到 2D 数组a的前k=3个最大特征值和特征向量 |
[Q,R]=qr(a,0) |
Q,R = linalg.qr(a) |
QR 分解 |
[L,U,P]=lu(a)，其中a==P'*L*U |
P,L,U = linalg.lu(a)，其中a == P@L@U |
具有部分主元的 LU 分解（注意：P（MATLAB）==转置 P（NumPy）） |
conjgrad |
cg |
共轭梯度解算器 |
fft(a) |
np.fft.fft(a) |
a的傅里叶变换 |
ifft(a) |
np.fft.ifft(a) |
a的傅里叶逆变换 |
sort(a) |
np.sort(a)或a.sort(axis=0) |
对 2D 数组a的每一列排序 |
sort(a, 2) |
np.sort(a, axis=1)或a.sort(axis=1) |
对 2D 数组a的每一行排序 |
[b,I]=sortrows(a,1) |
I = np.argsort(a[:, 0]); b = a[I,:] |
将数组a按第一列排序后保存为数组b |
x = Z\y |
x = linalg.lstsq(Z, y) |
执行形式为(\mathbf{Zx}=\mathbf{y})的线性回归 |
decimate(x, q) |
signal.resample(x, np.ceil(len(x)/q)) |
通过低通滤波下采样 |
unique(a) |
np.unique(a) |
数组a中的唯一值向量 |
squeeze(a) |
a.squeeze() |
移除数组a的单例维度。请注意，MATLAB 始终返回 2D 或更高阶数组，而 NumPy 将返回 0D 或更高阶数组 |
注释
子矩阵: 可以使用ix_命令和索引列表对子矩阵进行赋值。例如，对于 2D 数组a，可以这样操作：ind=[1, 3]; a[np.ix_(ind, ind)] += 100。
帮助: Python 没有直接相当于 MATLAB 中which命令的命令，但help和numpy.source命令通常会列出函数所在的文件名。Python 还有一个inspect模块（导入import inspect），其中提供了一个getfile函数通常也会起作用。
索引：MATLAB 使用基于一的索引，因此序列的初始元素索引为 1。Python 使用基于零的索引，因此序列的初始元素索引为 0。关于这一点可能会产生混淆和激烈争论，因为每种方式都有其优势和劣势。基于一的索引符合通常的人类语言使用习惯，其中序列的“第一个”元素索引为 1。基于零的索引简化了索引操作。也请参见 Edsger W. Dijkstra 教授的一篇文章。
范围：在 MATLAB 中，0:5既可以用作范围字面量，也可以用作‘切片’索引（放在括号内）；然而在 Python 中，像0:5这样的构造只能作为切片索引（放在方括号内）使用。因此，为了使 NumPy 可以拥有类似简洁的范围构造机制，特别创建了r_对象。需要注意的是，r_ 不像函数或构造函数一样被调用，而是使用方括号进行索引，这样可以在参数中使用 Python 的切片语法。
逻辑操作：在 NumPy 中，& 和 | 是按位与/或运算，而在 MATLAB 中，& 和 | 分别是逻辑与/或运算。这两者看起来可能是一样的，但实际上存在重要的区别。如果你曾经使用过 MATLAB 的 & 或 | 运算符，那么在 NumPy 中应该使用对应的 ufuncs logical_and/logical_or。MATLAB 和 NumPy 的 & 和 | 操作符之间的显著区别包括：
- 非逻辑 {0,1} 输入：NumPy 的输出是输入的按位与。MATLAB 将任何非零值视为 1，并返回逻辑与。例如在 NumPy 中
(3 & 4)的结果是0，而在 MATLAB 中3和4都被视为逻辑 true，因此(3 & 4)的结果是1。 - 优先级：NumPy 的
&运算符的优先级高于诸如<和>的逻辑运算符；而 MATLAB 则相反。
如果你知道参数是布尔值，你可以使用 NumPy 的按位运算符，但是在使用括号时要小心，就像这样：z = (x > 1) & (x < 2)。NumPy 没有形式上的 logical_and 和 logical_or 运算符是 Python 设计的一个不幸的结果。
重塑和线性索引: MATLAB 始终允许使用标量或线性索引访问多维数组，而 NumPy 则不是。线性索引在 MATLAB 程序中很常见，例如，对矩阵进行find()返回它们，而 NumPy 的find()行为有所不同。在转换 MATLAB 代码时，可能需要首先将矩阵重塑为线性序列，执行一些索引操作，然后再进行重塑。由于 reshape（通常）提供对相同存储的视图，因此应该可以相当高效地完成此操作。请注意，NumPy 中 reshape 的扫描顺序默认为‘C’顺序，而 MATLAB 使用 Fortran 顺序。如果你仅仅是将其转换为线性序列然后再转换回来，这并不重要。但如果你正在从依赖扫描顺序的 MATLAB 代码转换 reshape，那么此 MATLAB 代码：z = reshape(x,3,4);应该在 NumPy 中变为z = x.reshape(3,4,order='F').copy()。
‘array’或‘matrix’？我应该使用哪个？
从历史上看，NumPy 提供了一种特殊的矩阵类型，np.matrix，它是 ndarray 的一个子类，使二进制操作变成线性代数操作。你可能会在一些现有代码中看到它，而不是np.array。那么，应该使用哪一个？
简短答案
使用 arrays。
- 它们支持 MATLAB 中支持的多维数组代数运算
- 它们是 NumPy 的标准向量/矩阵/张量类型。许多 NumPy 函数返回数组，而不是矩阵。
- 元素操作与线性代数操作有明显区别。
- 如果你喜欢，可以使用标准向量或行/列向量。
直到 Python 3.5，使用array类型的唯一缺点是你必须使用dot而不是*来乘法（缩减）两个张量（数量积，矩阵向量乘法等）。从 Python 3.5 开始，你可以使用矩阵乘法@运算符。
鉴于上述，我们计划最终弃用matrix。
长答案
NumPy 包含array类和matrix类。array类旨在成为通用的多维数组，用于各种数值计算，而matrix旨在特定地促进线性代数计算。在实践中，这两者之间只有少数几个关键差异。
- 运算符
*和@，函数dot()和multiply()：
- 对于
array，*表示逐元素相乘，而**@表示矩阵乘法**；它们有相关的函数multiply()和dot()。（Python 3.5 之前，@不存在，人们必须使用dot()进行矩阵乘法）。 - 对于
matrix，*表示矩阵乘法，对于逐元素乘法，人们必须使用multiply()函数。
- 向量（一维数组）的处理
- 对于
array来说，向量形状 1xN，Nx1 和 N 是完全不同的事情。像A[:,1]这样的操作返回形状为 N 的一维数组，而不是形状为 Nx1 的二维数组。在一维array上进行转置没有任何效果。 - 对于
matrix，一维数组总是转换为 1xN 或 Nx1 矩阵（行向量或列向量）。A[:,1]返回形状为 Nx1 的二维矩阵。
- 处理更高维数组（ndim > 2）
array对象可以具有大于 2 的维数；matrix对象始终具有确切的两个维度。
- 便利属性
array具有.T 属性，返回数据的转置。matrix还具有.H, .I 和 .A 属性，分别返回矩阵的共轭转置、逆和asarray()。
- 便利构造函数
array构造函数接受（嵌套的）Python 序列作为初始化器。如array([[1,2,3],[4,5,6]])。matrix构造函数另外接受方便的字符串初始化器。如matrix("[1 2 3; 4 5 6]").
使用两者都有利弊：
array
:)逐元素乘法很容易：A*B。:(您必须记住，矩阵乘法有自己的运算符@。:)您可以将一维数组视为行向量或列向量。A @ v将v视为列向量，而v @ A将v视为行向量。这样可以避免您输入许多转置。:)array是 NumPy 的“默认”类型，因此它得到了最多的测试，并且最有可能被使用 NumPy 的第三方代码返回。:)它在处理任意维度的数据时非常方便。:)如果您熟悉张量代数的话，语义上更接近。:)所有操作（*，/，+，-等）都是逐元素的。:(scipy.sparse 中的稀疏矩阵与数组的交互不太好。
matrix
:\\行为更像 MATLAB 矩阵。<:(三维数据需要使用array，或者可能是matrix的 Python 列表。<:(两维矩阵的最小值。不能有向量。它们必须被转换为单列或单行矩阵。<:(由于在 NumPy 中array是默认的，一些函数可能返回array，即使您给它们一个matrix作为参数。这不应该发生在 NumPy 函数中（如果发生了，那是个错误），但基于 NumPy 的第三方代码可能不像 NumPy 那样尊重类型保留。:)A*B是矩阵乘法，所以它看起来就像您在线性代数中写的（对于 Python >= 3.5，普通数组使用@运算符也有同样的便利）。<:(逐元素乘法需要调用一个函数，multiply(A,B)。<:(使用运算符重载有点不合逻辑：*不逐元素工作，但/却是。- 与
scipy.sparse的交互更清晰。
因此，更建议使用array。实际上，我们最终打算停用matrix。
简短答案
使用数组。
- 支持在 MATLAB 中支持的多维数组代数
- 它们是 NumPy 的标准向量/矩阵/张量类型。许多 NumPy 函数返回数组，而不是矩阵。
- 元素级操作和线性代数操作之间有明显的区别。
- 如果需要，你可以使用标准向量或行向量/列向量。
在 Python 3.5 之前，使用 array 类型的唯一不利之处是必须使用 dot 而不是 * 进行乘法（缩减）两个张量（标量积、矩阵向量乘法等）。自从 Python 3.5 以来，可以使用矩阵乘法 @ 运算符。
根据上面的内容，我们打算最终废弃 matrix。
较长的回答
NumPy 中包含 array 类和 matrix 类。array 类旨在成为一种通用的 n 维数组，适用于各种数值计算，而 matrix 则旨在专门用于线性代数计算。实际上，这两者之间只有一小部分关键差异。
- 运算符
*和@，函数dot()和multiply()：
- 对于
array，*表示逐元素乘法，而@表示矩阵乘法；它们分别对应的函数是multiply()和dot()。（在 Python 3.5 之前，@不存在，必须使用dot()进行矩阵乘法）。 - 对于
matrix，*表示矩阵乘法，对于逐元素乘法必须使用multiply()函数。
- 向量（一维数组）的处理
- 对于
array，向量的形状 1xN、Nx1 和 N 是不同的概念。例如，A[:,1]返回形状为 N 的一维数组，而不是形状为 Nx1 的二维数组。对一维array进行转置没有任何变化。 - 对于
matrix，一维数组总是被转换为 1xN 或 Nx1 的矩阵（行向量或列向量）。A[:,1]返回形状为 Nx1 的二维矩阵。
- 高维数组（ndim > 2）的处理
array对象可以具有大于 2 的维数；matrix对象始终仅有两个维度。
- 方便的属性
array具有.T属性，可以返回数据的转置。matrix还有.H、.I和.A属性，它们分别返回矩阵的共轭转置、逆和asarray()。
- 方便的构造函数
array构造函数接受嵌套的 Python 序列作为初始化参数。例如，array([[1,2,3],[4,5,6]])。matrix构造函数还支持方便的字符串初始化。例如，matrix("[1 2 3; 4 5 6]")。
使用它们都有利有弊：
array
:)逐元素乘法很简单：A*B。:(你必须记住矩阵乘法有自己的运算符@。:)你可以将一维数组当作行向量或列向量处理。A @ v将v视为列向量，而v @ A将v视为行向量。这样可以减少输入转置的次数。:)array是“默认”的 NumPy 类型，因此它受到最多的测试，并且是第三方使用 NumPy 的代码可能返回的类型。:)在处理任意维数的数据时都非常便捷。:)与张量代数更接近的语义，如果你熟悉的话。:)所有操作（*、/、+、-等）都是逐个元素进行的。:(使用scipy.sparse的稀疏矩阵与数组的交互效果不太好。
- 矩阵
:\\行为更像 MATLAB 矩阵。<:(二维矩阵的最大值。要保存三维数据，你需要使用array或者可能是一个matrix的 Python 列表。<:(二维矩阵的最小值。你不能有向量。它们必须被转换为单列矩阵或单行矩阵。<:(由于array是 NumPy 的默认选项，所以一些函数可能会返回一个array，即使你将matrix作为参数传递给它们也会如此。 NumPy 函数不应该出现这种情况（如果出现了就是一个 bug），但基于 NumPy 的第三方代码可能不像 NumPy 那样保留类型信息。:)A*B是矩阵乘法，因此它的写法与线性代数中一样（对于 Python >= 3.5，普通数组可以使用@操作符达到相同的方便性）。<:(对元素进行逐个乘法操作需要调用函数multiply(A, B)。<:(操作符重载的使用有点不合逻辑：*不对元素进行操作，但/是对每个元素进行操作的。- 与
scipy.sparse的交互更清晰。
因此，更建议使用 array。事实上，我们打算最终废弃 matrix。
定制环境
在 MATLAB 中，定制环境的主要工具是修改搜索路径以包含你喜欢的函数的位置。你可以将这样的定制放入 MATLAB 在启动时运行的启动脚本中。
NumPy，或者更准确地说是 Python，有类似的功能。
- 若要修改 Python 搜索路径以包含自己模块的位置，请定义
PYTHONPATH环境变量。 - 当启动交互式 Python 解释器时，若要执行特定的脚本文件，请定义
PYTHONSTARTUP环境变量，其包含你启动脚本的名称。
与 MATLAB 不同，你需要先使用 ‘import’ 语句使特定文件中的函数可访问，然后才能立即调用。
例如，你可以创建一个启动脚本，内容如下（注意：此处仅为示例，并不是“最佳实践”的陈述）：
# Make all numpy available via shorter 'np' prefix import numpy as np # # Make the SciPy linear algebra functions available as linalg.func() # e.g. linalg.lu, linalg.eig (for general l*B@u==A@u solution) from scipy import linalg # # Define a Hermitian function def hermitian(A, **kwargs): return np.conj(A,**kwargs).T # Make a shortcut for hermitian: # hermitian(A) --> H(A) H = hermitian
要使用已弃用的 matrix 和其他 matlib 函数：
# Make all matlib functions accessible at the top level via M.func() import numpy.matlib as M # Make some matlib functions accessible directly at the top level via, e.g. rand(3,3) from numpy.matlib import matrix,rand,zeros,ones,empty,eye
链接
在 mathesaurus.sf.net/ 可以找到另一个相对陈旧的 MATLAB/NumPy 相关信息。
可以在 主题软件页面 中找到用于使用 Python 进行科学工作的工具的详尽列表。
请查看 Python 软件列表：脚本语言 获取使用 Python 作为脚本语言的软件列表。
MATLAB® 和 SimuLink® 是 The MathWorks, Inc. 的注册商标。
NumPy 特性
一系列与内置 NumPy 功能相关的笔记。
- n 维数组上的线性代数
- 保存和分享您的 NumPy 数组
- 掩码数组
NumPy 如何操作
这些文档旨在提供使用 NumPy 执行常见任务的方法。有关包中包含的函数和类的详细参考文档，请参见 API 参考。
- 如何编写 NumPy 操作指南
- 读取和写入文件
- 如何索引
ndarrays - 验证 NumPy 中的错误和 bug 修复
- 如何创建具有等距数值的数组
高级用法和互操作性
从源码编译
在本地计算机上构建可以完全控制构建选项。如果你是一名熟悉使用命令行的 MacOS 或 Linux 用户，则可以继续按照下面的说明构建 NumPy。
注意
如果要构建用于开发目的的 NumPy，请参阅 Setting up and using your development environment 获取更多信息。
先决条件
编译 NumPy 需要已安装以下软件：
- Python 3.9.x 或更高版本
请注意，还需要安装 Python 开发头文件，例如，在 Debian/Ubuntu 上需要同时安装 python3 和 python3-dev。在 Windows 和 macOS 上通常不会出现此问题。 - 编译器
NumPy 的很大一部分是用 C 和 C++ 编写的。你需要一个符合 C99 标准的 C 编译器，以及一个符合 C++17 标准的 C++ 编译器。
尽管构建 NumPy 不需要 FORTRAN 77 编译器，在运行numpy.f2py测试时需要它。如果未自动检测到编译器，则会跳过这些测试。
注意，NumPy 主要是使用 GNU 编译器进行开发，并在 MSVC 和 Clang 编译器上进行测试。像 Intel、Absoft、Sun、NAG、Compaq、Vast、Portland、Lahey、HP、IBM 等其他供应商的编译器仅以社区反馈的形式提供支持，并不保证可以直接使用。推荐使用 GCC 6.5（或更高版本）编译器。在 ARM64（aarch64）上推荐使用 GCC 8.x（或更高版本）。 - 线性代数库
NumPy 不需要安装任何外部线性代数库。然而，如果这些库可用，NumPy 的设置脚本可以检测到并用于构建。可以使用多种不同的 LAPACK 库设置，包括优化的 LAPACK 库，如 OpenBLAS 或 MKL。这些库的选择和位置以及包含路径和其他构建选项可以在.pc文件中指定，如 BLAS 和 LAPACK 中所述。 - Cython
构建 NumPy 需要一个较新版本的 Cython。 - NumPy 源代码
按照 Contributing to NumPy 中的说明，克隆仓库。
注意
从版本 1.26 开始，NumPy 将采用 Meson 作为构建系统（详见 Status of numpy.distutils and migration advice 和 Understanding Meson）。
基本安装
要从本地源代码构建和安装 NumPy，请运行：
pip install .
这将安装所有构建依赖项，并使用 Meson 编译和安装 NumPy 的 C 扩展和 Python 模块。如果需要对构建选项和命令有更多控制，请参阅以下各节。
要执行可以从源文件夹运行的就地构建，请运行：
pip install -r build_requirements.txt pip install -e . --no-build-isolation
注意：有关在 NumPy 本身上进行开发工作的构建说明，请参阅 设置和使用开发环境。
使用 Meson 进行高级构建
Meson 支持标准环境变量CC，CXX和FC来选择特定的 C、C++和/或 Fortran 编译器。这些环境变量在Meson 文档中的参考表中有文档说明。
请注意，环境变量仅在干净构建时应用，因为它们影响配置阶段（即 meson setup）。增量重建不会对环境变量的更改做出反应-您必须运行git clean -xdf并进行完全重建，或运行meson setup --reconfigure。
更多选项，包括选择编译器、设置自定义编译器标志和控制并行性，请参阅编译器选择和自定义构建（来自 SciPy 文档）和Meson FAQ。
测试
确保测试你的构建。为了确保一切都正常，查看所有测试是否通过。
测试套件需要额外的依赖项，可以通过以下方式轻松安装：
python -m pip install -r test_requirements.txt
运行完整的测试套件：
cd .. # avoid picking up the source tree pytest --pyargs numpy
有关测试的详细信息，请参阅测试构建。
加速 BLAS/LAPACK 库
NumPy 搜索优化的线性代数库，例如 BLAS 和 LAPACK。搜索这些库有特定的顺序，如下所述和meson_options.txt文件中描述。
交叉编译
对于交叉编译指令，请参阅交叉编译和 Meson 文档。
先决条件
构建 NumPy 需要安装以下软件：
- Python 3.9.x 或更新版本
请注意，还需要安装 Python 开发头文件，例如，在 Debian/Ubuntu 上需要同时安装python3和python3-dev。在 Windows 和 macOS 上，这通常不是问题。 - 编译器
NumPy 的大部分代码是用 C 和 C++编写的。您需要一个符合 C99 标准的 C 编译器，以及一个符合 C++17 标准的 C++编译器。
虽然构建 NumPy 不需要 FORTRAN 77 编译器，但运行numpy.f2py测试需要。如果编译器没有被自动检测到，则这些测试会被跳过。
请注意，NumPy 主要是使用 GNU 编译器开发并在 MSVC 和 Clang 编译器上进行测试。来自其他供应商的编译器（如 Intel、Absoft、Sun、NAG、Compaq、Vast、Portland、Lahey、HP、IBM）仅通过社区反馈的形式支持，并且可能无法直接使用。推荐使用 GCC 6.5（及更高版本）编译器。在 ARM64（aarch64）上，推荐使用 GCC 8.x（及更高版本）。 - 线性代数库
NumPy 不需要安装任何外部线性代数库。但是，如果这些库可用，NumPy 的设置脚本可以检测到并用于构建。可以使用多种不同的 LAPACK 库设置，包括经过优化的 LAPACK 库，如 OpenBLAS 或 MKL。这些库的选择和位置以及包含路径等构建选项可以在.pc文件中指定，如 BLAS 和 LAPACK 中所述。 - Cython
要构建 NumPy，您需要一个较新版本的 Cython。 - NumPy 源代码
按照 为 NumPy 做出贡献 中的说明克隆存储库。
注意
从版本 1.26 开始，NumPy 将采用 Meson 作为其构建系统（请参阅 numpy.distutils 的状态和迁移建议 和 理解 Meson 了解更多细节）。
基本安装
要从源代码的本地副本构建并安装 NumPy，请运行：
pip install .
这将安装所有构建依赖项并使用 Meson 编译并安装 NumPy 的 C 扩展和 Python 模块。如果您需要更多控制构建选项和命令，请参见以下章节。
要执行可以从源文件夹运行的原地构建，请运行：
pip install -r build_requirements.txt pip install -e . --no-build-isolation
注意：有关在 NumPy 上进行开发工作的构建说明，请参阅 配置和使用开发环境。
使用 Meson 进行高级构建
Meson 支持标准环境变量 CC、CXX 和 FC 以选择特定的 C、C++ 和/或 Fortran 编译器。这些环境变量在 Meson 文档中的参考表中 有文档记录。
请注意，环境变量只会在干净构建时生效，因为它们会影响配置阶段（即，meson 设置）。增量重建不会对环境变量的更改做出反应-您必须运行 git clean -xdf 并进行完整重建，或运行 meson setup --reconfigure。
更多选项包括选择编译器、设置自定义编译器标志和控制并行性，请参阅编译器选择和自定义构建（来自 SciPy 文档）和the Meson FAQ。
使用 Meson 进行高级构建
Meson 支持标准环境变量CC、CXX和FC来选择特定的 C、C++和/或 Fortran 编译器。这些环境变量在Meson 文档中的参考表中有文档。
请注意，只有在干净的构建过程中，环境变量才会得到应用，因为它们影响配置阶段（即 meson setup）。增量重新构建不会对环境变量的更改作出反应-您必须运行git clean -xdf并进行全面重建，或者运行meson setup --reconfigure。
更多选项包括选择编译器、设置自定义编译器标志和控制并行性，请参阅编译器选择和自定义构建（来自 SciPy 文档）和the Meson FAQ。
测试
确保测试您的构建。为了确保一切正常，请检查所有测试是否通过。
测试套件需要额外的依赖项，可以通过以下命令轻松安装：
python -m pip install -r test_requirements.txt
运行完整的测试套件：
cd .. # avoid picking up the source tree pytest --pyargs numpy
有关测试的详细信息，请参阅测试构建。
加速 BLAS/LAPACK 库
NumPy 搜索优化的线性代数库，如 BLAS 和 LAPACK。有特定的搜索这些库的顺序，如下所述和meson_options.txt文件中描述的。
交叉编译
如需交叉编译说明，请参阅交叉编译和 Meson 文档。
NumPy 1.26 中文官方指南（三）（3）https://developer.aliyun.com/article/1510618
