NumPy-1-26-中文文档-八-

NumPy 1.26 中文文档（八）

原文：numpy.org/doc/

`numpy.arange`

原文：numpy.org/doc/1.26/reference/generated/numpy.arange.html

numpy.arange([start, ]stop, [step, ]dtype=None, *, like=None)

返回给定区间内均匀间隔的值。

arange可以根据不同数量的位置参数进行调用：

arange(stop)：生成的值在半开区间[0, stop)内（换句话说，该区间包括start但不包括stop）。
arange(start, stop)：生成的值在半开区间[start, stop)内。
arange(start, stop, step)：生成的值在半开区间[start, stop)内，其间隔由step给出。

对于整数参数，该函数大致等同于 Python 内置的range，但返回的是一个 ndarray 而不是一个range实例。

当使用非整数步长（如 0.1）时，通常最好使用numpy.linspace。

更多信息请参见下面的警告部分。

参数：

start 整数或实数，可选

区间的起始。该区间包括此值。默认起始值为 0。

stop 整数或实数

区间结束。该区间不包括这个值，除非某些情况下step不是整数，浮点舍入会影响out的长度。

step 整数或实数，可选

值之间的间距。对于任何输出out，这是两个相邻值之间的距离，out[i+1] - out[i]。默认步长为 1。如果step被指定为一个位置参数，则start也必须给出。

dtype dtype，可选

输出数组的类型。如果未提供dtype，则从其他输入参数推断数据类型。

like array_like，可选

引用对象，允许创建不是 NumPy 数组的数组。如果传递给like的数组支持__array_function__协议，则其结果将由其定义。在这种情况下，它确保创建与通过该参数传递的对象兼容的数组对象。

版本 1.20.0 中新增。

arange ndarray

一系列均匀间隔的值。

对于浮点参数，结果的长度为ceil((stop - start)/step)。由于浮点溢出，此规则可能导致out的最后一个元素大于stop。

警告

输出的长度可能在数值上不稳定。

另一个稳定性问题源于numpy.arange的内部实现。用于填充数组的实际步长值为dtype(start + step) - dtype(start)而不是step。在这里可能会出现精度损失，由于转换或者在start远大于step时使用浮点数。这可能导致意外行为。例如：

>>> np.arange(0, 5, 0.5, dtype=int)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
>>> np.arange(-3, 3, 0.5, dtype=int)
array([-3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8])

在这种情况下，应优先使用numpy.linspace。

内置的range生成具有任意大小的 Python 内置整数，而numpy.arange生成 numpy.int32 或 numpy.int64 数字。这可能会导致大整数值的错误结果：

>>> power = 40
>>> modulo = 10000
>>> x1 = [(n ** power) % modulo for n in range(8)]
>>> x2 = [(n ** power) % modulo for n in np.arange(8)]
>>> print(x1)
[0, 1, 7776, 8801, 6176, 625, 6576, 4001]  # correct
>>> print(x2)
[0, 1, 7776, 7185, 0, 5969, 4816, 3361]  # incorrect

另请参阅

numpy.linspace

平均间隔的数字，对端点进行仔细处理。

numpy.ogrid

N 维空间中平均间隔的数字数组。

numpy.mgrid

N 维空间中网格状平均间隔的数字数组。

如何创建具有定期间隔值的数组

示例

>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0.,  1.,  2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
>>> np.arange(3,7,2)
array([3, 5])

`numpy.linspace`

原文：numpy.org/doc/1.26/reference/generated/numpy.linspace.html

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

在指定区间内返回均匀间隔的数字。

返回在区间[start, stop]上计算的num个等间距样本。

区间的结束点可以选择排除。

在版本 1.16.0 中更改：现在支持非标量的start和stop。

在版本 1.20.0 中更改：当指定整数dtype时，值向-inf舍入而不是0。仍可以通过np.linspace(start, stop, num).astype(int)获取旧的行为。

参数：

startarray_like

序列的起始值。

stoparray_like

序列的结束值，除非将endpoint设置为 False。在这种情况下，序列由num + 1个均匀间距的样本组成，因此stop被排除在外。注意，当endpoint为 False 时，步长会发生变化。

numint，可选

要生成的样本数。默认为 50。必须是非负数。

endpointbool，可选

如果为 True，则stop是最后一个样本。否则，不包含它。默认为 True。

retstepbool，可选

如果为 True，则返回(samples, step)，其中step是样本之间的间距。

dtypedtype，可选

输出数组的类型。如果未给出dtype，则从start和stop推断数据类型。推断的 dtype 不会是整数；即使参数生成整数数组也会选择浮点数。

在版本 1.9.0 中新增。

axisint，可选

结果中存储样本的轴。仅当 start 或 stop 为数组时才相关。默认为 0，样本将沿着插入的新轴排列。使用-1 可以在最后插入一个轴。

新版本中新增。

samplesndarray

在闭区间[start, stop]或半开区间start, stop)（取决于endpoint是 True 还是 False）中有num个等间距样本。

stepfloat，可选

仅在retstep为 True 时返回

采样之间的间距大小。

另请参阅

[arange

类似于linspace，但使用步长（而不是样本数）。

geomspace

类似于linspace，但其数字在对数刻度上均匀间隔（几何级数）。

logspace

类似于geomspace，但端点指定为对数。

如何创建具有等间距值的数组

示例

>>> np.linspace(2.0, 3.0, num=5)
array([2\.  , 2.25, 2.5 , 2.75, 3\.  ])
>>> np.linspace(2.0, 3.0, num=5, endpoint=False)
array([2\. ,  2.2,  2.4,  2.6,  2.8])
>>> np.linspace(2.0, 3.0, num=5, retstep=True)
(array([2\.  ,  2.25,  2.5 ,  2.75,  3\.  ]), 0.25)

图形示例：

>>> import matplotlib.pyplot as plt
>>> N = 8
>>> y = np.zeros(N)
>>> x1 = np.linspace(0, 10, N, endpoint=True)
>>> x2 = np.linspace(0, 10, N, endpoint=False)
>>> plt.plot(x1, y, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.plot(x2, y + 0.5, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.ylim([-0.5, 1])
(-0.5, 1)
>>> plt.show()

../../_images/numpy-linspace-1.png

`numpy.logspace`

原文：numpy.org/doc/1.26/reference/generated/numpy.logspace.html

numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)

返回在对数尺度上平均分布的数字。

在线性空间中，序列从 base ** start（base 的 start 次幂）开始，并以 base ** stop 结束（见下面的 endpoint）。

在版本 1.16.0 中更改：现在支持非标量 start 和 stop。

在版本 1.25.0 中更改：现在支持非标量 base。

参数：

start 数组

base ** start 是序列的起始值。

stop 数组

base ** stop 是序列的最终值，除非 endpoint 为 False。在这种情况下，在对数空间中间隔有 num + 1 个值，其中除了最后一个（长度为 num 的序列）外，其他都会返回。

num 整数，可选

要生成的样本数。默认为 50。

endpoint 布尔值，可选

如果为 true，则 stop 是最后一个样本。否则，它不包括在内。默认为 True。

base 数组，可选

对数空间的底数。ln(samples) / ln(base) 中元素之间的步长（或 log_base(samples)）是均匀的。默认为 10.0。

dtype 数据类型

输出数组的类型。如果没有给出 dtype，则从 start 和 stop 推断数据类型。推断的类型永远不会是整数；如果参数产生整数数组，则选择float类型。

axis 整数，可选

在结果中存储样本的轴。仅在 start、stop 或 base 是类似数组的情况下相关。默认为 0，样本将沿着在开头插入的一个新轴。使用 -1 可以得到一个末尾的轴。

在版本 1.16.0 中新增。

samples 数组

num 个样本，在对数尺度上等间距分布。

另请参阅

arange

类似于 linspace，指定步长而不是样本数。请注意，当与浮点数端点一起使用时，端点可能包括也可能不包括。

linspace

类似于 logspace，但在线性空间中均匀分布的样本，而不是对数空间。

geomspace

类似于 logspace，但直接指定端点。

如何创建具有等间距值的数组

注：

如果 base 是标量，则 logspace 等同于以下代码

>>> y = np.linspace(start, stop, num=num, endpoint=endpoint)
... 
>>> power(base, y).astype(dtype)
...

示例

>>> np.logspace(2.0, 3.0, num=4)
array([ 100\.        ,  215.443469  ,  464.15888336, 1000\.        ])
>>> np.logspace(2.0, 3.0, num=4, endpoint=False)
array([100\.        ,  177.827941  ,  316.22776602,  562.34132519])
>>> np.logspace(2.0, 3.0, num=4, base=2.0)
array([4\.        ,  5.0396842 ,  6.34960421,  8\.        ])
>>> np.logspace(2.0, 3.0, num=4, base=[2.0, 3.0], axis=-1)
array([[ 4\.        ,  5.0396842 ,  6.34960421,  8\.        ],
 [ 9\.        , 12.98024613, 18.72075441, 27\.        ]])

图解：

>>> import matplotlib.pyplot as plt
>>> N = 10
>>> x1 = np.logspace(0.1, 1, N, endpoint=True)
>>> x2 = np.logspace(0.1, 1, N, endpoint=False)
>>> y = np.zeros(N)
>>> plt.plot(x1, y, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.plot(x2, y + 0.5, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.ylim([-0.5, 1])
(-0.5, 1)
>>> plt.show()

../../_images/numpy-logspace-1.png

`numpy.geomspace`

原文：numpy.org/doc/1.26/reference/generated/numpy.geomspace.html

numpy.geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0)

在对数刻度上均匀分布的数字。

这类似于logspace，但端点直接指定。每个输出样本是前一个的常数倍。

在 1.16.0 版本更改：现在支持非标量start和stop。

参数：

startarray_like

序列的起始值。

stoparray_like

序列的最终值，除非endpoint为 False。在这种情况下，在对数空间内间隔num + 1个值，除了最后一个（长度为num的序列）都返回。

num整数，可选

要生成的样本数。默认为 50。

endpoint布尔值，可选

如果为 true，则stop是最后一个样本。否则，它不包括在内。默认为 True。

dtypedtype

输出数组的类型。如果dtype未给出，则数据类型将从start和stop推断出来。推断的 dtype 永远不会是整数；float会被选择，即使参数会产生整数数组。

axis整数，可选

结果中存储样本的轴。仅当 start 或 stop 为类似数组时相关。默认值（0），样本将沿着插入在开头的新轴。使用-1 以在末尾获得一个轴。

1.16.0 版本中的新功能。

samplesndarray

num个样本，在对数刻度上均匀间隔。

另请参见

logspace

类似于 geomspace，但端点使用对数和基数指定。

linspace

类似于 geomspace，但是使用算术而不是几何级数。

arange

类似于 linspace，步长指定而不是样本数。

如何创建具有定期间隔数值的数组

注意

如果输入或 dtype 为复数，则输出将在复平面上遵循对数螺旋。（通过两点有无限多个螺旋线通过；输出将遵循最短的路径。）

示例

>>> np.geomspace(1, 1000, num=4)
array([    1.,    10.,   100.,  1000.])
>>> np.geomspace(1, 1000, num=3, endpoint=False)
array([   1.,   10.,  100.])
>>> np.geomspace(1, 1000, num=4, endpoint=False)
array([   1\.        ,    5.62341325,   31.6227766 ,  177.827941  ])
>>> np.geomspace(1, 256, num=9)
array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.])

请注意，以上可能不会产生精确的整数：

>>> np.geomspace(1, 256, num=9, dtype=int)
array([  1,   2,   4,   7,  16,  32,  63, 127, 256])
>>> np.around(np.geomspace(1, 256, num=9)).astype(int)
array([  1,   2,   4,   8,  16,  32,  64, 128, 256])

允许负数、递减和复数输入：

>>> np.geomspace(1000, 1, num=4)
array([1000.,  100.,   10.,    1.])
>>> np.geomspace(-1000, -1, num=4)
array([-1000.,  -100.,   -10.,    -1.])
>>> np.geomspace(1j, 1000j, num=4)  # Straight line
array([0\.   +1.j, 0\.  +10.j, 0\. +100.j, 0.+1000.j])
>>> np.geomspace(-1+0j, 1+0j, num=5)  # Circle
array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,
 6.12323400e-17+1.00000000e+00j,  7.07106781e-01+7.07106781e-01j,
 1.00000000e+00+0.00000000e+00j])

endpoint参数的图示：

>>> import matplotlib.pyplot as plt
>>> N = 10
>>> y = np.zeros(N)
>>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.axis([0.5, 2000, 0, 3])
[0.5, 2000, 0, 3]
>>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both')
>>> plt.show()

../../_images/numpy-geomspace-1.png

`numpy.meshgrid`

原文：numpy.org/doc/1.26/reference/generated/numpy.meshgrid.html

numpy.meshgrid(*xi, copy=True, sparse=False, indexing='xy')

从坐标向量返回坐标矩阵列表。

为 N-D 格点数组创建一维坐标数组，以便在 N-D 格点上对 N-D 标量/向量场进行矢量化评估，给定一维坐标数组 x1, x2,…, xn。

在 1.9 版中更改：允许 1-D 和 0-D 情况。

参数：

x1, x2,…, xnarray_like

表示网格坐标的 1-D 数组。

indexing，可选

输出的笛卡尔（‘xy’，默认）或矩阵（‘ij’）索引。更多细节请参阅注释。

新版本 1.7.0 中的新功能。

sparsebool，可选

如果为 True，则使得用于第 i 维的返回坐标数组的形状从（N1, ..., Ni, ... Nn）减少为（1，...，1，Ni，1，...，1）。这些稀疏坐标网格用于与广播。当在表达式中使用所有坐��时，广播仍然导致完全维数的结果数组。

默认值为 False。

新版本 1.7.0 中的新功能。

copybool，可选

如果为 False，则会视图返回到原始数组，以便节省内存。默认为 True。请注意，sparse=False, copy=False 可能会返回非连续数组。此外，广播数组的一个以上元素可能指向单个内存位置。如果您需要向数组写入内容，请先制作副本。

新版本 1.7.0 中的新功能。

返回值：

X1, X2，…，XNndarray 列表

对于向量 x1、x2，...、xn，其长度为 Ni=len(xi)，如果 indexing=’ij’，则返回形状为 (N1, N2, N3,..., Nn) 的数组；如果 indexing=’xy’，则返回形状为 (N2, N1, N3,..., Nn) 的数组，其中 xi 的元素重复以填充矩阵中的第一维度，x1 的第二维度，依此类推。

另请参阅

mgrid

使用索引表示的多维“网格”。

ogrid

使用索引表示的多维“网格”。

how-to-index

注释

此函数通过索引关键字参数支持两种索引约定。使用字符串 ‘ij’ 返回带有矩阵索引的 meshgrid，而 ‘xy’ 返回带有笛卡尔索引的 meshgrid。在输入长度为 M 和 N 的 2-D 情况下，对于‘xy’索引，输出的形状为（N，M），对于‘ij’索引，输出的形状为（M，N）。在输入长度为 M、N 和 P 的 3-D 情况下，对于‘xy’索引，输出形状为（N，M，P），对于‘ij’索引，输出形状为（M，N，P）。下面的代码片段说明了区别：

xv, yv = np.meshgrid(x, y, indexing='ij')
for i in range(nx):
    for j in range(ny):
        # treat xv[i,j], yv[i,j]

xv, yv = np.meshgrid(x, y, indexing='xy')
for i in range(nx):
    for j in range(ny):
        # treat xv[j,i], yv[j,i]

在 1-D 和 0-D 情况下，索引和 sparse 关键字无效。

示例

>>> nx, ny = (3, 2)
>>> x = np.linspace(0, 1, nx)
>>> y = np.linspace(0, 1, ny)
>>> xv, yv = np.meshgrid(x, y)
>>> xv
array([[0\. , 0.5, 1\. ],
 [0\. , 0.5, 1\. ]])
>>> yv
array([[0.,  0.,  0.],
 [1.,  1.,  1.]])

meshgrid 的结果是坐标网格：

>>> import matplotlib.pyplot as plt
>>> plt.plot(xv, yv, marker='o', color='k', linestyle='none')
>>> plt.show()

../../_images/numpy-meshgrid-1_00_00.png

您可以创建稀疏输出数组以节省内存和计算时间。

>>> xv, yv = np.meshgrid(x, y, sparse=True)
>>> xv
array([[0\. ,  0.5,  1\. ]])
>>> yv
array([[0.],
 [1.]])

meshgrid非常有用，可以在网格上评估函数。如果函数依赖于所有坐标，则可以使用密集和稀疏输出。

>>> x = np.linspace(-5, 5, 101)
>>> y = np.linspace(-5, 5, 101)
>>> # full coordinate arrays
>>> xx, yy = np.meshgrid(x, y)
>>> zz = np.sqrt(xx**2 + yy**2)
>>> xx.shape, yy.shape, zz.shape
((101, 101), (101, 101), (101, 101))
>>> # sparse coordinate arrays
>>> xs, ys = np.meshgrid(x, y, sparse=True)
>>> zs = np.sqrt(xs**2 + ys**2)
>>> xs.shape, ys.shape, zs.shape
((1, 101), (101, 1), (101, 101))
>>> np.array_equal(zz, zs)
True

>>> h = plt.contourf(x, y, zs)
>>> plt.axis('scaled')
>>> plt.colorbar()
>>> plt.show()

../../_images/numpy-meshgrid-1_01_00.png

`numpy.mgrid`

原文：numpy.org/doc/1.26/reference/generated/numpy.mgrid.html

numpy.mgrid = <numpy.lib.index_tricks.MGridClass object>

一个返回密集多维“网格”的实例。

一个实例，当索引时返回密集（或填充）的网格，以便每个返回的参数具有相同的形状。输出数组的维数和数量等于索引维度的数量。如果步长不是复数，则停止不是包含在内的。

但是，如果步长是一个复数（例如 5j），那么它的大小的整数部分将被解释为指定在起始值和停止值之间创建点的数量，其中停止值是包含在内的。

网格ndarrays的所有相同维度

另请参见

ogrid

类似于 mgrid 但返回开放的（未填充）网格

meshgrid

从坐标向量返回坐标矩阵

r_

数组连接器

如何创建具有定期间隔值的数组

示例

>>> np.mgrid[0:5, 0:5]
array([[[0, 0, 0, 0, 0],
 [1, 1, 1, 1, 1],
 [2, 2, 2, 2, 2],
 [3, 3, 3, 3, 3],
 [4, 4, 4, 4, 4]],
 [[0, 1, 2, 3, 4],
 [0, 1, 2, 3, 4],
 [0, 1, 2, 3, 4],
 [0, 1, 2, 3, 4],
 [0, 1, 2, 3, 4]]])
>>> np.mgrid[-1:1:5j]
array([-1\. , -0.5,  0\. ,  0.5,  1\. ])

`numpy.ogrid`

原文：numpy.org/doc/1.26/reference/generated/numpy.ogrid.html

numpy.ogrid = <numpy.lib.index_tricks.OGridClass object>

一个实例，返回一个开放的多维“网格”。

一个实例，当索引时返回一个开放式的网格（即未完全实现），以便返回的数组中只有一个维度大于 1。输出数组的维度和数量等于索引维度的数量。如果步长不是一个复数，则停止值不包括在内。

然而，如果步长是一个复数（例如 5j），那么其幅度的整数部分被解释为指定在起始值和停止值之间创建的点的数量，其中停止值是包括在内的。

mesh-grid

ndarrays，只有一个维度不等于 1

另请参阅

mgrid

类似于ogrid，但返回密集的网格

meshgrid

从坐标向量返回坐标矩阵

r_

数组连接器

如何创建具有常规间隔值的数组

示例

>>> from numpy import ogrid
>>> ogrid[-1:1:5j]
array([-1\. , -0.5,  0\. ,  0.5,  1\. ])
>>> ogrid[0:5,0:5]
[array([[0],
 [1],
 [2],
 [3],
 [4]]), array([[0, 1, 2, 3, 4]])]

`numpy.diag`

原文：numpy.org/doc/1.26/reference/generated/numpy.diag.html

numpy.diag(v, k=0)

提取对角线或构造对角线数组。

如果您使用此函数提取对角线并希望写入结果数组，请参阅numpy.diagonal的更详细文档；返回副本还是视图取决于您使用的 numpy 版本。

参数：

varray_like

如果v是一个二维数组，则返回其第k个对角线的副本。如果v是一个一维数组，则返回一个二维数组，其中v位于第k个对角线上。

kint，可选

感兴趣的对角线。默认值为 0。对于在主对角线上方的对角线，请使用k>0，对于在主对角线下方的对角线，请使用k<0。

返回值：

outndarray

提取的对角线或构造的对角线数组。

另请参阅

diagonal

返回指定的对角线。

diagflat

使用扁平化的输入创建一个二维数组作为对角线。

trace

沿对角线求和。

triu

数组的上三角。

tril

数组的下三角。

示例

>>> x = np.arange(9).reshape((3,3))
>>> x
array([[0, 1, 2],
 [3, 4, 5],
 [6, 7, 8]])

>>> np.diag(x)
array([0, 4, 8])
>>> np.diag(x, k=1)
array([1, 5])
>>> np.diag(x, k=-1)
array([3, 7])

>>> np.diag(np.diag(x))
array([[0, 0, 0],
 [0, 4, 0],
 [0, 0, 8]])

`numpy.diagflat`

原文：numpy.org/doc/1.26/reference/generated/numpy.diagflat.html

numpy.diagflat(v, k=0)

创建一个两维数组，用平铺的输入作为对角线。

参数：

varray_like

输入数据，将其平铺并设置为输出的第 k 对角线。

k整数，可选

要设置的对角线；0 是默认值，对应于“主”对角线，正（负）k表示主对角线上方（下方）的对角线数。

out数组

2-D 输出数组。

请参阅

diag

1-D 和 2-D 数组的 MATLAB 工作方式。

diagonal

返回指定的对角线。

trace

沿对角线求和。

示例

>>> np.diagflat([[1,2], [3,4]])
array([[1, 0, 0, 0],
 [0, 2, 0, 0],
 [0, 0, 3, 0],
 [0, 0, 0, 4]])

>>> np.diagflat([1,2], 1)
array([[0, 1, 0],
 [0, 0, 2],
 [0, 0, 0]])

`numpy.tri`

原文：numpy.org/doc/1.26/reference/generated/numpy.tri.html

numpy.tri(N, M=None, k=0, dtype=<class 'float'>, *, like=None)

一个数组，其给定对角线及其以下位置填充为 1，其他位置填充为 0。

参数：

N整数

数组中的行数。

M整数，可选

数组中的列数。默认情况下，M 等于 N。

k整数，可选

数组填充的次对角线及其以下位置。k = 0 是主对角线，而 k < 0 在其下方，k > 0 在其上方。默认值为 0。

dtypedtype，可选

返回数组的数据类型。默认值为浮点数。

likearray_like，可选

参考对象允许创建不是 NumPy 数组的数组。如果传入 like 的类似数组支持 __array_function__ 协议，则结果将由它定义。在这种情况下，它确保创建与通过此参数传入的对象兼容的数组对象。

版本 1.20.0 中的新功能。

tri形状为(N, M)的数组

其下三角填充为 1，其他位置填充为 0 的数组；换句话说，对于 j <= i + k，T[i,j] == 1，否则为 0。

示例

>>> np.tri(3, 5, 2, dtype=int)
array([[1, 1, 1, 0, 0],
 [1, 1, 1, 1, 0],
 [1, 1, 1, 1, 1]])

>>> np.tri(3, 5, -1)
array([[0.,  0.,  0.,  0.,  0.],
 [1.,  0.,  0.,  0.,  0.],
 [1.,  1.,  0.,  0.,  0.]])

`numpy.tril`

原文：numpy.org/doc/1.26/reference/generated/numpy.tril.html

numpy.tril(m, k=0)

数组的下三角形。

返回一个将第 k 条对角线以上的元素清零的数组副本。对于超过 2 维的数组，tril 将应用于最后两个轴。

参数：

m 类似数组，形状为（…，M，N）

输入数组。

k 整数，可选

在其上清零元素的对角线。k = 0（默认值）是主对角线，k < 0 是其下方，k > 0 是其上方。

tril 数组，形状为（…，M，N）

m 的下三角形，形状和数据类型与 m 相同。

另请参阅

triu

相同的事情，只是对于上三角形

示例

>>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
array([[ 0,  0,  0],
 [ 4,  0,  0],
 [ 7,  8,  0],
 [10, 11, 12]])

>>> np.tril(np.arange(3*4*5).reshape(3, 4, 5))
array([[[ 0,  0,  0,  0,  0],
 [ 5,  6,  0,  0,  0],
 [10, 11, 12,  0,  0],
 [15, 16, 17, 18,  0]],
 [[20,  0,  0,  0,  0],
 [25, 26,  0,  0,  0],
 [30, 31, 32,  0,  0],
 [35, 36, 37, 38,  0]],
 [[40,  0,  0,  0,  0],
 [45, 46,  0,  0,  0],
 [50, 51, 52,  0,  0],
 [55, 56, 57, 58,  0]]])

`numpy.triu`

原文：numpy.org/doc/1.26/reference/generated/numpy.triu.html

numpy.triu(m, k=0)

数组的上三角。

返回一个将第 k 条对角线以下的元素置零的数组副本。对于维度超过 2 的数组，triu 将应用于最后两个轴。

请参阅 tril 的文档以获取更多详细信息。

另请参见

tril

数组的下三角

示例

>>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
array([[ 1,  2,  3],
 [ 4,  5,  6],
 [ 0,  8,  9],
 [ 0,  0, 12]])

>>> np.triu(np.arange(3*4*5).reshape(3, 4, 5))
array([[[ 0,  1,  2,  3,  4],
 [ 0,  6,  7,  8,  9],
 [ 0,  0, 12, 13, 14],
 [ 0,  0,  0, 18, 19]],
 [[20, 21, 22, 23, 24],
 [ 0, 26, 27, 28, 29],
 [ 0,  0, 32, 33, 34],
 [ 0,  0,  0, 38, 39]],
 [[40, 41, 42, 43, 44],
 [ 0, 46, 47, 48, 49],
 [ 0,  0, 52, 53, 54],
 [ 0,  0,  0, 58, 59]]])

`numpy.vander`

原文：numpy.org/doc/1.26/reference/generated/numpy.vander.html

numpy.vander(x, N=None, increasing=False)

生成 Vandermonde 矩阵。

输出矩阵的列是输入向量的幂。幂的顺序由 increasing 布尔参数确定。具体来说，当 increasing 为 False 时，第 i 列输出是元素级别地将输入向量提高到 N - i - 1 次幂。每行具有等比级数的这种矩阵以 Alexandre-Theophile Vandermonde 命名。

参数：

x array_like

1-D 输入数组。

N int，可选

输出中的列数。如果未指定 N，则返回一个方阵（N = len(x)）。

increasing bool，可选

列幂的顺序。如果为 True，则幂从左到右增加；如果为 False（默认），则反转。

新版本 1.9.0 中的内容。

out ndarray

Vandermonde 矩阵。如果 increasing 为 False，则第一列是 x^(N-1)，第二列是 x^(N-2)，依此类推。如果 increasing 为 True，则列是 x⁰, x¹, ..., x^(N-1)。

另请参阅

polynomial.polynomial.polyvander

示例

>>> x = np.array([1, 2, 3, 5])
>>> N = 3
>>> np.vander(x, N)
array([[ 1,  1,  1],
 [ 4,  2,  1],
 [ 9,  3,  1],
 [25,  5,  1]])

>>> np.column_stack([x**(N-1-i) for i in range(N)])
array([[ 1,  1,  1],
 [ 4,  2,  1],
 [ 9,  3,  1],
 [25,  5,  1]])

>>> x = np.array([1, 2, 3, 5])
>>> np.vander(x)
array([[  1,   1,   1,   1],
 [  8,   4,   2,   1],
 [ 27,   9,   3,   1],
 [125,  25,   5,   1]])
>>> np.vander(x, increasing=True)
array([[  1,   1,   1,   1],
 [  1,   2,   4,   8],
 [  1,   3,   9,  27],
 [  1,   5,  25, 125]])

方阵 Vandermonde 矩阵的行列式是输入向量值之间差异的乘积：

>>> np.linalg.det(np.vander(x))
48.000000000000043 # may vary
>>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)
48

`numpy.mat`

原文：numpy.org/doc/1.26/reference/generated/numpy.mat.html

numpy.mat(data, dtype=None)

将输入解释为矩阵。

与matrix不同，asmatrix如果输入已经是矩阵或 ndarray，则不会复制。相当于matrix(data, copy=False)。

参数：

data：array_like

输入数据。

dtype：数据类型

输出矩阵的数据类型。

返回值：

mat：matrix

data 解释为矩阵。

示例

>>> x = np.array([[1, 2], [3, 4]])

>>> m = np.asmatrix(x)

>>> x[0,0] = 5

>>> m
matrix([[5, 2],
 [3, 4]])

`numpy.bmat`

numpy.org/doc/1.26/reference/generated/numpy.bmat.html

numpy.bmat(obj, ldict=None, gdict=None)

从字符串、嵌套序列或数组构建一个矩阵对象。

参数:

objstr 或 array_like

输入数据。如果是字符串，则可以通过名称引用当前域中的变量。

ldict字典，可选

一个在当前帧中替换本地操作数的字典。如果obj不是字符串或gdict为 None，则忽略。

gdict字典，可选

一个在当前帧中替换全局操作数的字典。如果obj不是字符串，则忽略。

out矩阵

返回一个矩阵对象，这是一个专门的 2-D 数组。

另请参阅

block

该函数对 N 维数组的推广，返回普通的 ndarray。

示例

>>> A = np.mat('1 1; 1 1')
>>> B = np.mat('2 2; 2 2')
>>> C = np.mat('3 4; 5 6')
>>> D = np.mat('7 8; 9 0')

以下所有表达式都构造相同的块矩阵:

>>> np.bmat([[A, B], [C, D]])
matrix([[1, 1, 2, 2],
 [1, 1, 2, 2],
 [3, 4, 7, 8],
 [5, 6, 9, 0]])
>>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]])
matrix([[1, 1, 2, 2],
 [1, 1, 2, 2],
 [3, 4, 7, 8],
 [5, 6, 9, 0]])
>>> np.bmat('A,B; C,D')
matrix([[1, 1, 2, 2],
 [1, 1, 2, 2],
 [3, 4, 7, 8],
 [5, 6, 9, 0]])

数组操作程序

原文：numpy.org/doc/1.26/reference/routines.array-manipulation.html

基本操作

`copyto`(dst, src[, casting, where])	将值从一个数组复制到另一个数组，如有必要进行广播。
`shape`(a)	返回数组的形状。

改变数组形状

`reshape`(a, newshape[, order])	给数组赋予新��状而不更改其数据。
`ravel`(a[, order])	返回一个连续的展平数组。
`ndarray.flat`	数组的一维迭代器。
`ndarray.flatten`([order])	返回折叠为一维的数组的副本。

转置类操作

`moveaxis`(a, source, destination)	将数组的轴移动到新位置。
`rollaxis`(a, axis[, start])	将指定轴向后滚动，直到它位于给定位置。
`swapaxes`(a, axis1, axis2)	交换数组的两个轴。
`ndarray.T`	转置数组的视图。
`transpose`(a[, axes])	返回具有转置轴的数组。

改变维度个数

`atleast_1d`(*arys)	将输入转换为至少有一个维度的数组。
`atleast_2d`(*arys)	将输入视为至少有两个维度的数组。
`atleast_3d`(*arys)	将输入视为至少有三个维度的数组。
`broadcast`	生成模拟广播的对象。
`broadcast_to`(array, shape[, subok])	将数组广播到新形状。
`broadcast_arrays`(*args[, subok])	对多个数组进行广播。
`expand_dims`(a, axis)	扩展数组的形状。
`squeeze`(a[, axis])	从 a 中删除长度为一的轴。

改变数组类型

`asarray`(a[, dtype, order, like])	将输入转换为数组。
`asanyarray`(a[, dtype, order, like])	将输入转换为 ndarray，但传递 ndarray 子类。
`asmatrix`(data[, dtype])	将输入解释为矩阵。
`asfarray`(a[, dtype])	返回转换为浮点类型的数组。
`asfortranarray`(a[, dtype, like])	返回按 Fortran 顺序在内存中布局的数组（ndim >= 1）。
`ascontiguousarray`(a[, dtype, like])	返回内存中连续的数组（ndim >= 1）（C 顺序）。
`asarray_chkfinite`(a[, dtype, order])	将输入转换为数组，检查 NaN 或 Infs。
`require`(a[, dtype, requirements, like])	返回满足要求的提供类型的 ndarray。

合并数组

`concatenate`([axis, out, dtype, casting])	沿现有轴连接一系列数组。
`stack`(arrays[, axis, out, dtype, casting])	沿新轴连接一系列数组。
`block`(arrays)	从块的嵌套列表中组装 nd 数组。
`vstack`(tup, *[, dtype, casting])	垂直（行方向）按顺序堆叠数组。
`hstack`(tup, *[, dtype, casting])	按顺序水平（列方向）堆叠数组。
`dstack`(tup)	深度逐层（沿第三轴）按顺序堆叠数组。
`column_stack`(tup)	将 1-D 数组按列堆叠成 2-D 数组。
`row_stack`(tup, *[, dtype, casting])	垂直（行方向）按顺序堆叠数组。

拆分数组

`split`(ary, indices_or_sections[, axis])	将数组拆分为多个子数组，作为对ary的视图。
`array_split`(ary, indices_or_sections[, axis])	将数组拆分为多个子数组。
`dsplit`(ary, indices_or_sections)	沿第 3 轴（深度）将数组分割为多个子数组。
`hsplit`(ary, indices_or_sections)	水平（沿列）分割数组为多个子数组。
`vsplit`(ary, indices_or_sections)	垂直（沿行）分割数组为多个子数组。

平铺数组

`tile`(A, reps)	通过重复 A 的次数构建一个数组。
`repeat`(a, repeats[, axis])	将数组的每个元素重复多次。

添加和删除元素

`delete`(arr, obj[, axis])	返回删除指定轴上子数组的新数组。
`insert`(arr, obj, values[, axis])	在给定索引之前沿指定轴插入值。
`append`(arr, values[, axis])	将值附加到数组的末尾。
`resize`(a, new_shape)	返回指定形状的新数组。
`trim_zeros`(filt[, trim])	从 1-D 数组或序列中修剪前导和/或尾随零。
`unique`(ar[, return_index, return_inverse, ...])	找到数组的唯一元素。

重新排列元素

`flip`(m[, axis])	反转数组中给定轴上的元素顺序。
`fliplr`(m)	反转沿轴 1（左/右）的元素顺序。
`flipud`(m)	反转沿轴 0（上/下）的元素顺序。
`reshape`(a, newshape[, order])	给数组赋予新的形状，但不更改其数据。
`roll`(a, shift[, axis])	沿指定轴滚动数组元素。
`rot90`(m[, k, axes])	将数组在指定的平面上旋转 90 度。

基本操作

`copyto`(dst, src[, casting, where])	将一个数组的值复制到另一个数组，必要时进行广播。
`shape`(a)	返回数组的形状。

更改数组形状

`reshape`(a, newshape[, order])	为数组赋予一个新的形状，但不改变其数据。
`ravel`(a[, order])	返回一个连续的扁平化数组。
`ndarray.flat`	数组的一维迭代器。
`ndarray.flatten`([order])	返回折叠成一维的数组的副本。

类似转置的操作

`moveaxis`(a, source, destination)	将数组的轴移动到新的位置。
`rollaxis`(a, axis[, start])	将指定轴向后滚动，直到它位于给定位置为止。
`swapaxes`(a, axis1, axis2)	交换数组的两个轴。
`ndarray.T`	转置后的数组的视图。
`transpose`(a[, axes])	返回一个转置后的数组。

改变维数

`atleast_1d`(*arys)	将输入转换为至少具有一维的数组。
`atleast_2d`(*arys)	将输入视为至少具有两个维度的数组。
`atleast_3d`(*arys)	将输入视为至少具有三个维度的数组。
`broadcast`	生成类似广播的对象。
`broadcast_to`(array, shape[, subok])	将数组广播到新的形状。
`broadcast_arrays`(*args[, subok])	将任意数量的数组相互广播。
`expand_dims`(a, axis)	扩展数组的形状。
`squeeze`(a[, axis])	从a中删除长度为一的轴。

改变数组类型

`asarray`(a[, dtype, order, like])	将输入转换为数组。
`asanyarray`(a[, dtype, order, like])	将输入转换为 ndarray，但传递 ndarray 子类。
`asmatrix`(data[, dtype])	将输入解释为矩阵。
`asfarray`(a[, dtype])	返回转换为浮点类型的数组。
`asfortranarray`(a[, dtype, like])	返回以 Fortran 顺序排列在内存中的数组（ndim >= 1）。
`ascontiguousarray`(a[, dtype, like])	返回内存中连续的数组（ndim >= 1）（C 顺序）。
`asarray_chkfinite`(a[, dtype, order])	将输入转换为数组，检查 NaN 或 Inf。
`require`(a[, dtype, requirements, like])	返回满足要求的提供类型的 ndarray。

数组连接

`concatenate`([axis, out, dtype, casting])	沿着已有的轴连接一系列数组。
`stack`(arrays[, axis, out, dtype, casting])	沿新轴连接一系列数组。
`block`(arrays)	从块的嵌套列表中组装一个 nd 数组。
`vstack`(tup, *[, dtype, casting])	沿垂直方向（行）顺序堆叠数组。
`hstack`(tup, *[, dtype, casting])	沿水平方向（列）顺序堆叠数组。
`dstack`(tup)	沿深度方向（第三个轴）顺序堆叠数组。
`column_stack`(tup)	将 1-D 数组作为列堆叠成 2-D 数组。
`row_stack`(tup, *[, dtype, casting])	沿垂直方向（行）顺序堆叠数组。

数组分割

`split`(ary, indices_or_sections[, axis])	将数组分割为多个子数组作为ary的视图。
`array_split`(ary, indices_or_sections[, axis])	将数组分割为多个子数组。
`dsplit`(ary, indices_or_sections)	沿第 3 轴（深度）将数组分割为多个子数组。
`hsplit`(ary, indices_or_sections)	沿水平方向（列）将数组分割为多个子数组。
`vsplit`(ary, indices_or_sections)	沿垂直方向（行）将数组分割为多个子数组。

瓷砖数组

`tile`(A, reps)	通过重复 A 给定的次数构造数组。
`repeat`(a, repeats[, axis])	在数组中的每个元素之后重复它们自己。

添加和删除元素

`delete`(arr, obj[, axis])	返回一个删除指定轴上子数组的新数组。
`insert`(arr, obj, values[, axis])	在给定索引之前沿着给定轴插入值。
`append`(arr, values[, axis])	在数组末尾添加值。
`resize`(a, new_shape)	返回具有指定形状的新数组。
`trim_zeros`(filt[, trim])	从 1-D 数组或序列中修剪前导和/或后导零。
`unique`(ar[, return_index, return_inverse, ...])	查找数组的唯一元素。

重新排列元素

`flip`(m[, axis])	反转数组沿着给定轴的元素顺序。
`fliplr`(m)	反转数组 m 沿着轴 1 的元素顺序（左/右）。
`flipud`(m)	反转数组 m 沿着轴 0 的元素顺序（上/下）。
`reshape`(a, newshape[, order])	为数组重新定义形状，不改变数据。
`roll`(a, shift[, axis])	沿着给定轴滚动数组元素。
`rot90`(m[, k, axes])	将数组顺时针旋转 90 度，指定旋转平面。

`numpy.copyto`

原文：numpy.org/doc/1.26/reference/generated/numpy.copyto.html

numpy.copyto(dst, src, casting='same_kind', where=True)

将值从一个数组复制到另一个数组，必要时进行广播。

如果违反了 casting 规则，则引发 TypeError，如果提供了where ，则选择要复制的元素。

自 1.7.0 版引入。

参数：

dst ndarray

被复制值的数组。

src array_like

从中复制值的数组。

casting, 可选

控制复制时可能发生的数据转换类型。

‘no’ 意味着根本不应进行数据类型转换。

‘equiv’ 意味着只允许字节顺序更改。

‘safe’ 意味着只允许保留值的转换。

‘same_kind’ 意味着只允许安全转换或在同一种类内的转换，例如从 float64 到 float32。

‘unsafe’ 表示可以进行任何数据转换。

where array_like of bool, 可选

一个布尔数组，进行广播以匹配dst的维度，并选择从src复制到dst的元素，其中包含值 True。

示例

>>> A = np.array([4, 5, 6])
>>> B = [1, 2, 3]
>>> np.copyto(A, B)
>>> A
array([1, 2, 3])

>>> A = np.array([[1, 2, 3], [4, 5, 6]])
>>> B = [[4, 5, 6], [7, 8, 9]]
>>> np.copyto(A, B)
>>> A
array([[4, 5, 6],
 [7, 8, 9]])

`numpy.shape`

原文：numpy.org/doc/1.26/reference/generated/numpy.shape.html

numpy.shape(a)

返回数组的形状。

参数：

aarray_like

输入数组。

shapeint 类型的元组

形状元组的元素给出了相应数组维度的长度。

另请参阅

len

len(a)对于N>=1的 N 维数组等同于np.shape(a)[0]。

ndarray.shape

等效的数组方法。

示例

>>> np.shape(np.eye(3))
(3, 3)
>>> np.shape([[1, 3]])
(1, 2)
>>> np.shape([0])
(1,)
>>> np.shape(0)
()

>>> a = np.array([(1, 2), (3, 4), (5, 6)],
...              dtype=[('x', 'i4'), ('y', 'i4')])
>>> np.shape(a)
(3,)
>>> a.shape
(3,)

`numpy.reshape`

原文：numpy.org/doc/1.26/reference/generated/numpy.reshape.html

numpy.reshape(a, newshape, order='C')

给数组一个新的形状，而不改变其数据。

参数:

aarray_like

要重新构造的数组。

newshapeint 或 int 的元组

新的形状应与原始形状兼容。如果是整数，则结果将是该长度的 1-D 数组。一个形状维度可以为-1。在这种情况下，该值将从数组的长度和剩余维度推导出。

order, 可选择

使用这个索引顺序读取a的元素，并使用这个索引顺序将元素放入重新构造的数组中。‘C’意味着使用类似于 C 的索引顺序读取/写入元素，最后一个轴索引变化最快，回到第一个轴索引变化最慢。‘F’意味着使用类似于 Fortran 的索引顺序读取/写入元素，第一个索引变化最快，最后一个索引变化最慢。请注意，‘C’和‘F’选项不考虑底层数组的内存布局，并且只是指索引顺序。‘A’意味着如果a在内存中是 Fortran contiguous，则使用类似于 Fortran 的索引顺序读取/写入元素, 否则使用 C-like 顺序。

reshaped_arrayndarray

如果可能的话，这将是一个新的视图对象；否则，它将是一个副本。请注意，不能保证返回的数组的内存布局（C- 或 Fortran- 连续）。

另请参见

ndarray.reshape

等效方法。

注意

不总是可以在不复制数据的情况下改变数组的形状。

order 关键字给出了fetching值的索引顺序，以及将这些值放入输出数组的索引顺序。例如，假设您有一个数组：

>>> a = np.arange(6).reshape((3, 2))
>>> a
array([[0, 1],
 [2, 3],
 [4, 5]])

您可以将重新构造视为首先展平数组（使用给定的索引顺序），然后使用与展平时相同类型的索引顺序将元素插入到新数组中。

>>> np.reshape(a, (2, 3)) # C-like index ordering
array([[0, 1, 2],
 [3, 4, 5]])
>>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape
array([[0, 1, 2],
 [3, 4, 5]])
>>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering
array([[0, 4, 3],
 [2, 1, 5]])
>>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F')
array([[0, 4, 3],
 [2, 1, 5]])

示例

>>> a = np.array([[1,2,3], [4,5,6]])
>>> np.reshape(a, 6)
array([1, 2, 3, 4, 5, 6])
>>> np.reshape(a, 6, order='F')
array([1, 4, 2, 5, 3, 6])

>>> np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2
array([[1, 2],
 [3, 4],
 [5, 6]])

`numpy.ravel`

原文：numpy.org/doc/1.26/reference/generated/numpy.ravel.html

numpy.ravel(a, order='C')

返回一个连续的扁平数组。

返回一个包含输入元素的 1-D 数组。只有在需要时才会复制。

从 NumPy 1.10 起，返回的数组将与输入数组具有相同的类型。（例如，对于掩码数组输入，将返回掩码数组）

参数：

a类似于数组

输入数组。按order指定的顺序读取a中的元素，并打包为 1-D 数组。

order, 可选

使用该索引顺序读取a的元素。‘C’表示按行主要、C 风格顺序索引元素，最后一个轴索引最快，回到第一个轴索引最慢。‘F’表示按列主要、Fortran 风格顺序索引元素，第一个索引最快，最后一个索引最慢。请注意，‘C’和‘F’选项不考虑底层数组的内存布局，只是指轴索引的顺序。‘A’表示如果a在内存中是 Fortran 型连续的，则按类似 Fortran 的索引顺序读取元素，否则按 C 型顺序。‘K’表示按它们在内存中出现的顺序读取元素，除了当 strides 为负时颠倒数据。默认情况下，使用‘C’索引顺序。

y类似于数组

y 是与a相同子类型的连续 1-D 数组，形状为(a.size,)。请注意，矩阵对于向后兼容性而言是特殊的情况，如果 a 是矩阵，则 y 是一个 1-D ndarray。

另见

ndarray.flat

数组的 1-D 迭代器。

ndarray.flatten

按行主要顺序复制数组中元素的 1-D 数组。

ndarray.reshape

改变数组的形状而不改变其数据。

注意事项

在行主要、C 风格顺序的二维数组中，行索引变化最慢，列索引最快。这可以推广到多维，其中行主要顺序意味着沿第一个轴的索引变化最慢，最后一个轴的索引变化最快。与此相反，列主要、Fortran 风格的索引顺序则相反。

在尽可能多的情况下需要视图时，可能更喜欢arr.reshape(-1)。但是，ravel支持K作为可选的order参数，而reshape不支持。

例子

它相当于reshape(-1, order=order)。

>>> x = np.array([[1, 2, 3], [4, 5, 6]])
>>> np.ravel(x)
array([1, 2, 3, 4, 5, 6])

>>> x.reshape(-1)
array([1, 2, 3, 4, 5, 6])

>>> np.ravel(x, order='F')
array([1, 4, 2, 5, 3, 6])

当order为‘A’时，它将保留数组的‘C’或‘F’顺序:

>>> np.ravel(x.T)
array([1, 4, 2, 5, 3, 6])
>>> np.ravel(x.T, order='A')
array([1, 2, 3, 4, 5, 6])

当order为‘K’时，它将保留既不是‘C’也不是‘F’的顺序，但不会颠倒轴:

>>> a = np.arange(3)[::-1]; a
array([2, 1, 0])
>>> a.ravel(order='C')
array([2, 1, 0])
>>> a.ravel(order='K')
array([2, 1, 0])

>>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
array([[[ 0,  2,  4],
 [ 1,  3,  5]],
 [[ 6,  8, 10],
 [ 7,  9, 11]]])
>>> a.ravel(order='C')
array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
>>> a.ravel(order='K')
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

`numpy.ndarray.flat`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.flat.html

属性

ndarray.flat

一个数组的一维迭代器。

这是一个numpy.flatiter实例，它类似于但不是 Python 内置的迭代器对象的子类。

另请参阅

flatten

返回数组的一维折叠副本。

flatiter

示例

>>> x = np.arange(1, 7).reshape(2, 3)
>>> x
array([[1, 2, 3],
 [4, 5, 6]])
>>> x.flat[3]
4
>>> x.T
array([[1, 4],
 [2, 5],
 [3, 6]])
>>> x.T.flat[3]
5
>>> type(x.flat)
<class 'numpy.flatiter'>

一个赋值示例：

>>> x.flat = 3; x
array([[3, 3, 3],
 [3, 3, 3]])
>>> x.flat[[1,4]] = 1; x
array([[3, 1, 3],
 [3, 1, 3]])

`numpy.ndarray.flatten`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.flatten.html

方法

ndarray.flatten(order='C')

返回一个折叠为一维的数组的副本。

参数：

order，可选

‘C’表示按行主排列（C 样式）展平。‘F’表示按列主排列（Fortran 样式）展平。‘A’表示如果a在内存中是 Fortran 连续的话按列主排列展平，否则按行主排列。‘K’表示按内存中元素发生的顺序展平a。默认值为‘C’。

yndarray

输入数组的一个拷贝，展平为一维。

另请参阅

ravel

返回一个展平的数组。

flat

一个数组上的 1-D 平坦迭代器。

示例

>>> a = np.array([[1,2], [3,4]])
>>> a.flatten()
array([1, 2, 3, 4])
>>> a.flatten('F')
array([1, 3, 2, 4])

`numpy.moveaxis`

原文：numpy.org/doc/1.26/reference/generated/numpy.moveaxis.html

numpy.moveaxis(a, source, destination)

将数组的轴移动到新位置。

其他轴保持在它们的原始顺序中。

1.11.0 版本中的新内容。

参数：

anp.ndarray

应重新排序其轴的数组。

sourceint 或 int 序列

要移动的轴的原始位置。这些位置必须是唯一的。

destinationint 或 int 序列

每个原始轴的目标位置。这些位置也必须是唯一的。

resultnp.ndarray

移动了轴的数组。该数组是输入数组的视图。

另请参见

transpose

排列数组的维度。

swapaxes

交换数组的两个轴。

示例

>>> x = np.zeros((3, 4, 5))
>>> np.moveaxis(x, 0, -1).shape
(4, 5, 3)
>>> np.moveaxis(x, -1, 0).shape
(5, 3, 4)

所有这些都可以实现相同的结果：

>>> np.transpose(x).shape
(5, 4, 3)
>>> np.swapaxes(x, 0, -1).shape
(5, 4, 3)
>>> np.moveaxis(x, [0, 1], [-1, -2]).shape
(5, 4, 3)
>>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape
(5, 4, 3)

`numpy.rollaxis`

原文：numpy.org/doc/1.26/reference/generated/numpy.rollaxis.html

numpy.rollaxis(a, axis, start=0)

将指定的轴向后滚动，直到它位于给定位置。

此函数继续得到支持是为了向后兼容性，但是你应该更喜欢 moveaxis。moveaxis 函数是在 NumPy 1.11 版本中添加的。

参数：

andarray

输入数组。

axisint

要滚动的轴。其他轴的位置相对于彼此不改变。

startint, optional

当 start <= axis 时，该轴向后滚动，直到它位于此位置。当 start > axis 时，该轴滚动直到它位于此位置之前。默认值 0 表示“完全”滚动。以下表格描述了 start 的负值如何被解释：

`start`	规范化的 `start`
---	---
`-(arr.ndim+1)`	抛出 `AxisError`
`-arr.ndim`	0
⋮	⋮
`-1`	`arr.ndim-1`
`0`	`0`
⋮	⋮
`arr.ndim`	`arr.ndim`
`arr.ndim + 1`	抛出 `AxisError`

resndarray

对于 NumPy >= 1.10.0，总是会返回 a 的视图。对于较早的 NumPy 版本，仅当轴的顺序改变时才返回 a 的视图，否则返回输入数组。

另请参见

moveaxis

移动数组轴到新的位置。

roll

沿着给定的轴向移动数组元素的数量。

例子

>>> a = np.ones((3,4,5,6))
>>> np.rollaxis(a, 3, 1).shape
(3, 6, 4, 5)
>>> np.rollaxis(a, 2).shape
(5, 3, 4, 6)
>>> np.rollaxis(a, 1, 4).shape
(3, 5, 6, 4)

`numpy.swapaxes`

原文：numpy.org/doc/1.26/reference/generated/numpy.swapaxes.html

numpy.swapaxes(a, axis1, axis2)

交换数组的两个轴。

参数：

aarray_like

输入数组。

axis1int

第一个轴。

axis2int

第二个轴。

返回值：

a_swappedndarray

对于 NumPy >= 1.10.0，如果a是一个 ndarray，那么将返回a的一个视图；否则将创建一个新数组。对于较早版本的 NumPy，只有当轴的顺序改变时才返回a的一个视图，否则返回输入数组。

示例

>>> x = np.array([[1,2,3]])
>>> np.swapaxes(x,0,1)
array([[1],
 [2],
 [3]])

>>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
>>> x
array([[[0, 1],
 [2, 3]],
 [[4, 5],
 [6, 7]]])

>>> np.swapaxes(x,0,2)
array([[[0, 4],
 [2, 6]],
 [[1, 5],
 [3, 7]]])

`numpy.ndarray.T`

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.T.html

属性

ndarray.T

转置数组的视图。

与self.transpose()相同。

另请参阅

transpose

示例

>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
 [3, 4]])
>>> a.T
array([[1, 3],
 [2, 4]])

>>> a = np.array([1, 2, 3, 4])
>>> a
array([1, 2, 3, 4])
>>> a.T
array([1, 2, 3, 4])

`numpy.transpose`

原文：numpy.org/doc/1.26/reference/generated/numpy.transpose.html

numpy.transpose(a, axes=None)

返回带有轴转置的数组。

对于 1-D 数组，这将返回原始数组的不变视图，因为转置的向量简单地是相同的向量。要将 1-D 数组转换为 2-D 列向量，必须添加额外的维度，例如，np.atleast2d(a).T 可以实现这一点，a[:, np.newaxis] 也可以。对于 2-D 数组，这是标准的矩阵转置。对于 n-D 数组，如果提供了轴，则它们的顺序表示轴如何被重排（请参见示例）。如果未提供轴，则 transpose(a).shape == a.shape[::-1]。

参数：

a类似数组

输入数组。

axes元组或整数列表，可选

如果指定，则必须是一个包含[0,1,...,N-1]的排列的元组或列表，其中 N 是a的轴数。返回数组的第 i 个轴将对应于输入的轴编号为axes[i]的轴。如果未指定，默认为range(a.ndim)[::-1]，该操作将颠倒轴的顺序。

p ndarray

对具有其轴重排的a。尽可能返回视图。

另请参见

ndarray.transpose

等效方法。

移动轴

将数组的轴移动到新位置。

argsort

返回对数组进行排序的索引。

注意

使用 transpose(a, argsort(axes)) 反转张量的变换，当使用 axes 关键字参数时。

示例

>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
 [3, 4]])
>>> np.transpose(a)
array([[1, 3],
 [2, 4]])

>>> a = np.array([1, 2, 3, 4])
>>> a
array([1, 2, 3, 4])
>>> np.transpose(a)
array([1, 2, 3, 4])

>>> a = np.ones((1, 2, 3))
>>> np.transpose(a, (1, 0, 2)).shape
(2, 1, 3)

>>> a = np.ones((2, 3, 4, 5))
>>> np.transpose(a).shape
(5, 4, 3, 2)

`numpy.atleast_1d`

原文：numpy.org/doc/1.26/reference/generated/numpy.atleast_1d.html

numpy.atleast_1d(*arys)

将输入转换为至少具有一维的数组。

标量输入被转换为 1 维数组，而高维输入被保留。

参数：

arys1, arys2, …类似数组

一个或多个输入数组。

ret数组

一个数组，或者包含a.ndim >= 1的数组列表。只在必要时才进行复制。

另请参阅

atleast_2d, atleast_3d

示例

>>> np.atleast_1d(1.0)
array([1.])

>>> x = np.arange(9.0).reshape(3,3)
>>> np.atleast_1d(x)
array([[0., 1., 2.],
 [3., 4., 5.],
 [6., 7., 8.]])
>>> np.atleast_1d(x) is x
True

>>> np.atleast_1d(1, [3, 4])
[array([1]), array([3, 4])]

`numpy.atleast_2d`

原文：numpy.org/doc/1.26/reference/generated/numpy.atleast_2d.html

numpy.atleast_2d(*arys)

将输入视图作为至少有两个维度的数组。

参数：

arys1, arys2, …array_like

一个或多个类似数组的序列。非数组输入将转换为数组。已经具有两个或更多维度的数组将被保留。

res, res2, …ndarray

一个数组，或数组列表，每个数组都有 a.ndim >= 2。尽可能避免复制，并返回两个或更多维度的视图。

另请参见

atleast_1d, atleast_3d

示例

>>> np.atleast_2d(3.0)
array([[3.]])

>>> x = np.arange(3.0)
>>> np.atleast_2d(x)
array([[0., 1., 2.]])
>>> np.atleast_2d(x).base is x
True

>>> np.atleast_2d(1, [1, 2], [[1, 2]])
[array([[1]]), array([[1, 2]]), array([[1, 2]])]

`numpy.atleast_3d`

原文：numpy.org/doc/1.26/reference/generated/numpy.atleast_3d.html

numpy.atleast_3d(*arys)

将输入视为至少具有三个维度的数组。

参数：

arys1, arys2, ...类似数组

一个或多个类似数组的序列。非数组输入将被转换为数组。已经有三个或更多维度的数组将被保留。

返回值：

res1，res2，...ndarray

一个数组或数组列表，每个数组的 a.ndim >= 3。可能避免复制，并返回至少有三个维度的视图。例如，形状为 (N,) 的一维数组将变为形状为 (1, N, 1) 的视图，形状为 (M, N) 的二维数组将变为形状为 (M, N, 1) 的视图。

另请参见

atleast_1d, atleast_2d

示例

>>> np.atleast_3d(3.0)
array([[[3.]]])

>>> x = np.arange(3.0)
>>> np.atleast_3d(x).shape
(1, 3, 1)

>>> x = np.arange(12.0).reshape(4,3)
>>> np.atleast_3d(x).shape
(4, 3, 1)
>>> np.atleast_3d(x).base is x.base  # x is a reshape, so not base itself
True

>>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):
...     print(arr, arr.shape) 
...
[[[1]
 [2]]] (1, 2, 1)
[[[1]
 [2]]] (1, 2, 1)
[[[1 2]]] (1, 1, 2)

`numpy.broadcast`

原文：numpy.org/doc/1.26/reference/generated/numpy.broadcast.html

class numpy.broadcast

生成一个模拟广播的对象。

参数:

in1, in2, …array_like

输入参数。

b广播对象

将输入参数相互广播，并返回封装结果的对象。其中包括形状和nd属性，并且可以用作迭代器。

另请参阅

broadcast_arrays

broadcast_to

广播形状

示例

手动添加两个向量，使用广播:

>>> x = np.array([[1], [2], [3]])
>>> y = np.array([4, 5, 6])
>>> b = np.broadcast(x, y)

>>> out = np.empty(b.shape)
>>> out.flat = [u+v for (u,v) in b]
>>> out
array([[5.,  6.,  7.],
 [6.,  7.,  8.],
 [7.,  8.,  9.]])

与内置广播进行比较:

>>> x + y
array([[5, 6, 7],
 [6, 7, 8],
 [7, 8, 9]])

属性:

索引

广播结果中的当前索引

迭代器

以self“组件”的迭代器元组。

nd

广播结果的维度数。

维度

广播结果的维度数。

numiter

广播结果拥有的迭代器数量。

形状

广播结果的形状。

大小

广播结果的总大小。

方法

`重置`()	重置广播结果的迭代器。

`numpy.broadcast_to`

原文：numpy.org/doc/1.26/reference/generated/numpy.broadcast_to.html

numpy.broadcast_to(array, shape, subok=False)

将数组广播到新形状。

参数：

arrayarray_like

要广播的数组。

shapetuple 或 int

所需数组的形状。单个整数 i 被解释为 (i,)。

subokbool，可选

如果为 True，则子类将被传递，否则返回的数组将被强制成为基类数组（默认）。

broadcastarray

对给定形状的原始数组的只读视图。它通常不是连续的。此外，广播数组的多个元素可能引用单个内存位置。

异常：

ValueError

如果根据 NumPy 的广播规则，数组与新形状不兼容。

另请参见

broadcast

broadcast_arrays

broadcast_shapes

注意

1.10.0 版中的新内容。

示例

>>> x = np.array([1, 2, 3])
>>> np.broadcast_to(x, (3, 3))
array([[1, 2, 3],
 [1, 2, 3],
 [1, 2, 3]])

`numpy.broadcast_arrays`

原文：numpy.org/doc/1.26/reference/generated/numpy.broadcast_arrays.html

numpy.broadcast_arrays(*args, subok=False)

广播任意数量的数组。

参数：

*argsarray_likes

要广播的数组。

subokbool，可选

如果为 True，则子类将被传递，否则返回的数组将被强制为基类数组（默认）。

broadcasted数组列表

这些数组是对原始数组的视图。它们通常不是连续的。此外，广播数组的多个元素可能引用单个内存位置。如果需要写入数组，请先复制。虽然您可以将writable标志设置为 True，但写入单个输出值可能会导致更改输出数组中的多个位置。

自版本 1.17 起弃用：输出当前标记，因此如果写入，则会发出弃用警告。将来的版本将设置writable标志为 False，因此写入它将引发错误。

另请参见

broadcast

broadcast_to

broadcast_shapes

示例

>>> x = np.array([[1,2,3]])
>>> y = np.array([[4],[5]])
>>> np.broadcast_arrays(x, y)
[array([[1, 2, 3],
 [1, 2, 3]]), array([[4, 4, 4],
 [5, 5, 5]])]

这里有一个有用的习惯用法，可以获取连续的副本而不是非连续的视图。

>>> [np.array(a) for a in np.broadcast_arrays(x, y)]
[array([[1, 2, 3],
 [1, 2, 3]]), array([[4, 4, 4],
 [5, 5, 5]])]

`numpy.expand_dims`

原文：numpy.org/doc/1.26/reference/generated/numpy.expand_dims.html

numpy.expand_dims(a, axis)

扩展数组的形状。

插入一个新轴，该轴将出现在扩展数组形状的axis位置。

参数：

aarray_like

输入数组。

axisint 或整数元组

新轴（或轴）放置的扩展轴的位置。

自版本 1.13.0 起已弃用：当axis > a.ndim时，将视为axis == a.ndim，当axis < -a.ndim - 1时，将视为axis == 0。此行为已被弃用。

在版本 1.18.0 中发生了变化：现在支持轴的元组。如上所述，超出范围的轴现在被禁止并引发AxisError。

resultndarray

a的视图，其维度数量增加。

另请参阅

squeeze

逆操作，删除单维度

reshape

插入，删除和组合维度，并调整现有维度的大小

doc.indexing, atleast_1d, atleast_2d, atleast_3d

例子

>>> x = np.array([1, 2])
>>> x.shape
(2,)

以下等同于x[np.newaxis, :]或x[np.newaxis]：

>>> y = np.expand_dims(x, axis=0)
>>> y
array([[1, 2]])
>>> y.shape
(1, 2)

以下等同于x[:, np.newaxis]：

>>> y = np.expand_dims(x, axis=1)
>>> y
array([[1],
 [2]])
>>> y.shape
(2, 1)

axis也可以是一个元组：

>>> y = np.expand_dims(x, axis=(0, 1))
>>> y
array([[[1, 2]]])

>>> y = np.expand_dims(x, axis=(2, 0))
>>> y
array([[[1],
 [2]]])

请注意，一些示例可能使用None而不是np.newaxis。这些是相同的对象：

>>> np.newaxis is None
True

`numpy.squeeze`

原文：numpy.org/doc/1.26/reference/generated/numpy.squeeze.html

numpy.squeeze(a, axis=None)

从a中移除长度为 1 的轴。

参数：

a类似数组

输入数据。

axisNone 或 int 或 int 元组，可选

版本 1.7.0 中新加入。

选择形状中长度为一的条目的子集。如果选择具有大于一的形状条目的轴，则会引发错误。

压缩ndarray

输入数组，但移除所有或部分长度为 1 的维度。这始终是a本身或a的视图。请注意，如果压缩所有轴，则结果是一个零维数组而不是标量。

引发：

ValueError

如果axis不为 None，并且被压缩的轴长度不为 1

参见

expand_dims

逆操作，添加长度为一的条目

reshape

插入、移除和组合维度，并调整现有维度大小

示例

>>> x = np.array([[[0], [1], [2]]])
>>> x.shape
(1, 3, 1)
>>> np.squeeze(x).shape
(3,)
>>> np.squeeze(x, axis=0).shape
(3, 1)
>>> np.squeeze(x, axis=1).shape
Traceback (most recent call last):
...
ValueError: cannot select an axis to squeeze out which has size not equal to one
>>> np.squeeze(x, axis=2).shape
(1, 3)
>>> x = np.array([[1234]])
>>> x.shape
(1, 1)
>>> np.squeeze(x)
array(1234)  # 0d array
>>> np.squeeze(x).shape
()
>>> np.squeeze(x)[()]
1234

`numpy.asarray`

原文：numpy.org/doc/1.26/reference/generated/numpy.asarray.html

numpy.asarray(a, dtype=None, order=None, *, like=None)

将输入转换为数组。

参数：

a类似数组

输入数据，以任何可以转换为数组的形式。这包括列表，元组列表，元组，元组列表，列表和 ndarrays 的元组。

dtype数据类型，可选

默认情况下，数据类型是从输入数据推断出来的。

order，可选

存储器布局。‘A’和‘K’取决于输入数组 a 的顺序。‘C’行主要（C 风格），‘F’列主要（Fortran 风格）存储器表示。‘A’（任意）意味着如果a是 Fortran 连续的，则‘F’，否则是‘C’。‘K’（保持）保留输入顺序，默认为‘K’。

like类似数组，可选

引用对象，允许创建不是 NumPy 数组的数组。如果传递给like的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建与通过该参数传递的数组兼容的数组对象。

在版本 1.20.0 中新增。

outndarray

a的数组解释。如果输入已经是具有匹配 dtype 和顺序的 ndarray，则不执行复制。如果a是 ndarray 的子类，则返回基类 ndarray。

另请参阅

asanyarray

通过子类的类似函数。

ascontiguousarray

将输入转换为连续数组。

asfarray

将输入转换为浮点 ndarray。

asfortranarray

将输入转换为具有列主内存顺序的 ndarray。

asarray_chkfinite

检查输入中的 NaN 和 Infs 的类似函数。

fromiter

从迭代器创建数组。

fromfunction

通过在网格位置上执行函数构造数组。

示例

将列表转换为数组：

>>> a = [1, 2]
>>> np.asarray(a)
array([1, 2])

不复制现有数组：

>>> a = np.array([1, 2])
>>> np.asarray(a) is a
True

如果设置了dtype，则仅在 dtype 不匹配时才复制数组：

>>> a = np.array([1, 2], dtype=np.float32)
>>> np.asarray(a, dtype=np.float32) is a
True
>>> np.asarray(a, dtype=np.float64) is a
False

与asanyarray相反，不会通过 ndarray 子类：

>>> issubclass(np.recarray, np.ndarray)
True
>>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
>>> np.asarray(a) is a
False
>>> np.asanyarray(a) is a
True

`numpy.asanyarray`

原文：numpy.org/doc/1.26/reference/generated/numpy.asanyarray.html

numpy.asanyarray(a, dtype=None, order=None, *, like=None)

将输入转换为一个 ndarray，但通过 ndarray 子类。

参数：

aarray_like

以任何可以转换为数组的形式输入的数据，包括标量，列表，元组的列表，元组，元组的元组，元组的列表和 ndarrays。

dtype数据类型，可选

默认情况下，从输入数据推断出数据类型。

order，可选

内存布局。 ‘A’和‘K’取决于输入数组 a 的顺序。 ‘C’行优先（C 风格），‘F’列优先（Fortran 风格）内存表示。 ‘A’（任意）如果 a 是 Fortran 连续的，则表示‘F’，否则表示‘C’‘K’（保持）保留输入顺序，默认为‘C’。

likearray_like，可选

引用对象，允许创建不是 NumPy 数组的数组。如果like作为数组样式传入支持__array_function__协议，则结果将由该协议定义。在这种情况下，它确保创建与该参数通过此参数传入的兼容的数组对象。

版本 1.20.0 中新增。

返回值：

outndarray 或 ndarray 子类

a的数组解释。如果a是 ndarray 或 ndarray 的子类，则返回它本身并且不执行任何复制操作。

另请参见

asarray

始终返回 ndarrays 的类似函数。

ascontiguousarray

将输入转换为连续数组。

asfarray

将输入转换为浮点型 ndarray。

asfortranarray

将输入转换为具有列优先内存顺序的 ndarray。

asarray_chkfinite

类似的函数，用于检查输入是否包含 NaN 和 Inf。

fromiter

从迭代器创建数组。

fromfunction

通过在网格位置执行函数来构建数组。

示例

将列表转换为数组：

>>> a = [1, 2]
>>> np.asanyarray(a)
array([1, 2])

通过如下方式传递的ndarray子类实例as-is：

>>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
>>> np.asanyarray(a) is a
True

`numpy.asmatrix`

原文：numpy.org/doc/1.26/reference/generated/numpy.asmatrix.html

numpy.asmatrix(data, dtype=None)

将输入解释为矩阵。

与matrix不同，asmatrix如果输入已经是矩阵或 ndarray，则不会进行复制。等同于matrix(data, copy=False)。

参数：

data数组样式

输入数据。

dtype数据类型

输出矩阵的数据类型。

mat矩阵

data 解释为矩阵。

示例

>>> x = np.array([[1, 2], [3, 4]])

>>> m = np.asmatrix(x)

>>> x[0,0] = 5

>>> m
matrix([[5, 2],
 [3, 4]])

`numpy.asfarray`

原文：numpy.org/doc/1.26/reference/generated/numpy.asfarray.html

numpy.asfarray(a, dtype=<class 'numpy.double'>)

返回转换为浮点类型的数组。

参数：

aarray_like

输入数组。

dtypestr 或 dtype 对象，可选

强制转换输入数组a的浮点类型代码。如果dtype是‘int’ dtypes 之一，则替换为 float64。

outndarray

输入a作为浮点数 ndarray。

示例

>>> np.asfarray([2, 3])
array([2.,  3.])
>>> np.asfarray([2, 3], dtype='float')
array([2.,  3.])
>>> np.asfarray([2, 3], dtype='int8')
array([2.,  3.])

`numpy.asfortranarray`

原文：numpy.org/doc/1.26/reference/generated/numpy.asfortranarray.html

numpy.asfortranarray(a, dtype=None, *, like=None)

在内存中以 Fortran 顺序排列的返回数组（ndim >= 1）。

参数：

aarray_like

输入数组。

dtypestr 或 dtype 对象，可选

默认情况下，数据类型是从输入数据中推断出来的。

likearray_like, optional

参考对象允许创建不是 NumPy 数组的数组。如果作为like传入的类数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建与通过此参数传入的对象兼容的数组对象。

自 1.20.0 版开始。

outndarray

输入 a 进行 Fortran 或列主序排序。

另请参阅

ascontiguousarray

将输入转换为连续的（C 顺序）数组。

asanyarray

将输入转换为具有行或列主要内存顺序的 ndarray。

require

返回一个满足要求的 ndarray。

ndarray.flags

数组的内存布局信息。

示例

以 C-contiguous 数组开始：

>>> x = np.ones((2, 3), order='C')
>>> x.flags['C_CONTIGUOUS']
True

调用asfortranarray会创建一个 Fortran-contiguous 的副本：

>>> y = np.asfortranarray(x)
>>> y.flags['F_CONTIGUOUS']
True
>>> np.may_share_memory(x, y)
False

现在，从 Fortran-contiguous 数组开始：

>>> x = np.ones((2, 3), order='F')
>>> x.flags['F_CONTIGUOUS']
True

然后，调用asfortranarray返回相同的对象：

>>> y = np.asfortranarray(x)
>>> x is y
True

注意：此函数返回至少一维（1-d）的数组，因此不会保留 0-d 数组。

`numpy.ascontiguousarray`

原文：numpy.org/doc/1.26/reference/generated/numpy.ascontiguousarray.html

numpy.ascontiguousarray(a, dtype=None, *, like=None)

返回一个（维度大于等于 1）内存中的连续数组（C 顺序）。

参数：

a类似数组

输入数组。

dtypestr 或 dtype 对象，可选

返回数组的数据类型。

like类似数组，可选

参考对象，以允许创建不是 NumPy 数组的数组。如果通过like传入的类似于数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保生成与通过此参数传入的兼容的数组对象。

1.20.0 版中的新功能。

outndarray

与a相同形状和内容的连续数组，如果指定则为dtype类型。

另请参见

asfortranarray

将输入转换为具有列主内存顺序的 ndarray。

require

返回满足要求的 ndarray。

ndarray.flags

关于数组的内存布局信息。

示例

从 Fortran 连续数组开始：

>>> x = np.ones((2, 3), order='F')
>>> x.flags['F_CONTIGUOUS']
True

调用ascontiguousarray会生成一个 C 连续的副本：

>>> y = np.ascontiguousarray(x)
>>> y.flags['C_CONTIGUOUS']
True
>>> np.may_share_memory(x, y)
False

现在，从 C 连续数组开始：

>>> x = np.ones((2, 3), order='C')
>>> x.flags['C_CONTIGUOUS']
True

然后，调用ascontiguousarray返回相同的对象：

>>> y = np.ascontiguousarray(x)
>>> x is y
True

注意：此函数返回至少具有一个维度（1-d）的数组，因此它不会保留 0-d 数组。

`numpy.asarray_chkfinite`

原文：numpy.org/doc/1.26/reference/generated/numpy.asarray_chkfinite.html

numpy.asarray_chkfinite(a, dtype=None, order=None)

将输入转换为数组，检查 NaN 或 Infs。

参数：

aarray_like

输入数据，以任何可以转换为数组的形式。包括列表、元组列表、元组、元组列表、列表和 ndarrays 的元组。成功不需要 NaN 或 Infs。

dtype数据类型，可选

默认情况下，数据类型是根据输入数据推断的。

order，可选

存储布局。’A‘和’K‘取决于输入数组 a 的顺序。’C‘行主要（C 风格），’F‘列主要（Fortran 风格）存储表示。如果 a 是 Fortran 连续的，则‘A‘（任意）意味着‘F‘，否则意味着‘C‘；’K‘（保持）保留输入顺序，默认为‘C‘。

outndarray

a的数组解释。如果输入已经是 ndarray，则不执行复制。如果a是 ndarray 的子类，则返回基类 ndarray。

引发：

ValueError

如果a包含 NaN（非数字）或 Inf（无穷大），引发 ValueError。

另请参阅

创建数组。

通过子类的类似函数。

将输入转换为连续数组。

将输入转换为浮点数 ndarray。

将输入转换为具有列主存储顺序的 ndarray。

fromiter

从迭代器创建数组。

fromfunction

通过在网格位置执行函数创建数组。

例子

将列表转换为数组。如果所有元素都是有限的asarray_chkfinite和asarray相同。

>>> a = [1, 2]
>>> np.asarray_chkfinite(a, dtype=float)
array([1., 2.])

如果 array_like 包含 Nans 或 Infs，则引发 ValueError。

>>> a = [1, 2, np.inf]
>>> try:
...     np.asarray_chkfinite(a)
... except ValueError:
...     print('ValueError')
...
ValueError

`numpy.require`

原文：numpy.org/doc/1.26/reference/generated/numpy.require.html

numpy.require(a, dtype=None, requirements=None, *, like=None)

返回一个满足要求的提供类型的 ndarray。

此函数对于确保返回具有正确标志的数组以便传递给编译代码（可能通过 ctypes）非常有用。

参数：

aarray_like

要转换为类型和要求满足数组的对象。

dtype数据类型

所需的数据类型。如果为 None，则保留当前 dtype。如果应用程序要求数据以本机字节顺序存储，请将字节顺序规范包含在 dtype 规范的一部分中。

requirementsstr 或 str 序列

要求列表可以是以下任何一种

‘F_CONTIGUOUS’（‘F’）- 确保一个 Fortran 连续数组
‘C_CONTIGUOUS’（‘C’）- 确保一个 C 连续数组
‘ALIGNED’（‘A’）- 确保一个数据类型对齐的数组
‘WRITEABLE’（‘W’）- 确保一个可写数组
‘OWNDATA’（‘O’）- 确保一个具有自己数据的数组
‘ENSUREARRAY’，（‘E’）- 确保一个基础数组，而不是一个子类

likearray_like，可选

引用对象，允许创建不是 NumPy 数组的数组。如果传递给like的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建与通过此参数传递的兼容的数组对象。

在 1.20.0 版本中新增。

outndarray

如果给定，则为具有指定要求和类型的数组。

参见

asarray

将输入转换为 ndarray。

asanyarray

转换为 ndarray，但直接通过 ndarray 子类。

ascontiguousarray

将输入转换为连续数组。

asfortranarray

将输入转换为按列存储顺序的 ndarray。

ndarray.flags

数组的内存布局信息。

注意

通过复制，返回的数组将保证具有所列的要求。

示例

>>> x = np.arange(6).reshape(2,3)
>>> x.flags
 C_CONTIGUOUS : True
 F_CONTIGUOUS : False
 OWNDATA : False
 WRITEABLE : True
 ALIGNED : True
 WRITEBACKIFCOPY : False

>>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])
>>> y.flags
 C_CONTIGUOUS : False
 F_CONTIGUOUS : True
 OWNDATA : True
 WRITEABLE : True
 ALIGNED : True
 WRITEBACKIFCOPY : False

`numpy.concatenate`

原文：numpy.org/doc/1.26/reference/generated/numpy.concatenate.html

numpy.concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting="same_kind")

沿现有轴连接一系列数组。

参数：

a1, a2, …数组序列

除了与axis（默认情况下是第一个）相对应的维度之外，数组的形状必须相同。

axisint，可选

数组将要连接的轴。如果 axis 为 None，则在使用之前数组将被展平。默认为 0。

outndarray，可选

如果提供了，是放置结果的目标位置。形状必须正确，与如果没有指定 out 参数，concatenate 将返回的形状相匹配。

dtypestr 或 dtype

如果提供，目标数组将具有此 dtype。不能与out一起提供。

版本 1.20.0 中的新功能。

casting，可选

控制可能发生的数据转换类型。默认为‘same_kind’。

版本 1.20.0 中的新功能。

resndarray

连接的数组。

参见

ma.concatenate

保留输入掩码的连接函数。

array_split

将数组分割成相等或接近相等大小的多个子数组。

split

将数组分割成相同大小的多个子数组的列表。

hsplit

沿水平方向（列方向）将数组分割成多个子数组。

vsplit

沿垂直方向（行方向）将数组分割成多个子数组。

dsplit

沿第 3 轴（深度）将数组分割成多个子数组。

stack

沿着新轴堆叠一系列数组。

block

从块中组合数组。

hstack

沿序列水平（列方向）堆叠数组。

vstack

沿序列垂直（行方向）堆叠数组。

dstack

按深度方向顺序堆叠数组（沿第三维度）。

column_stack

将 1-D 数组作为列堆叠成 2-D 数组。

注意

当待连接的一个或多个数组是 MaskedArray 时，此函数将返回一个 MaskedArray 对象而不是 ndarray，但输入的掩码不被保留。在需要 MaskedArray 作为输入的情况下，请使用来自掩码数组模块的 ma.concatenate 函数。

示例

>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> np.concatenate((a, b), axis=0)
array([[1, 2],
 [3, 4],
 [5, 6]])
>>> np.concatenate((a, b.T), axis=1)
array([[1, 2, 5],
 [3, 4, 6]])
>>> np.concatenate((a, b), axis=None)
array([1, 2, 3, 4, 5, 6])

此函数不会保留输入的 MaskedArray 的屏蔽。

>>> a = np.ma.arange(3)
>>> a[1] = np.ma.masked
>>> b = np.arange(2, 5)
>>> a
masked_array(data=[0, --, 2],
 mask=[False,  True, False],
 fill_value=999999)
>>> b
array([2, 3, 4])
>>> np.concatenate([a, b])
masked_array(data=[0, 1, 2, 2, 3, 4],
 mask=False,
 fill_value=999999)
>>> np.ma.concatenate([a, b])
masked_array(data=[0, --, 2, 2, 3, 4],
 mask=[False,  True, False, False, False, False],
 fill_value=999999)

`numpy.stack`

原文：numpy.org/doc/1.26/reference/generated/numpy.stack.html

numpy.stack(arrays, axis=0, out=None, *, dtype=None, casting='same_kind')

沿着新轴连接数组序列。

axis参数指定结果维度中新轴的索引。例如，如果axis=0，它将是第一个维度，如果axis=-1，它将是最后一个维度。

新版本 1.10.0 中新增。

参数：

arrays数组序列

每个数组必须具有相同的形状。

axisint，可选

结果数组中的轴，沿着其中堆叠输入数组。

outndarray，可选

如果提供，目标位置放置结果。形状必须正确，与如果未指定 out 参数，则 stack 将返回的形状匹配。

dtypestr 或 dtype

如果提供，目标数组将具有此 dtype。不能与out同时提供。

新版本 1.24 中新增。

casting，可选

控制可能发生的数据转换类型。默认为‘same_kind’。

新版本 1.24 中新增。

stackedndarray

堆叠数组比输入数组多一个维度。

另请参阅

concatenate

沿现有轴连接数组序列。

block

从嵌套块列表中组装 nd-array。

split

将数组拆分为多个相等大小的子数组列表。

示例

>>> arrays = [np.random.randn(3, 4) for _ in range(10)]
>>> np.stack(arrays, axis=0).shape
(10, 3, 4)

>>> np.stack(arrays, axis=1).shape
(3, 10, 4)

>>> np.stack(arrays, axis=2).shape
(3, 4, 10)

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.stack((a, b))
array([[1, 2, 3],
 [4, 5, 6]])

>>> np.stack((a, b), axis=-1)
array([[1, 4],
 [2, 5],
 [3, 6]])

`numpy.block`

原文：numpy.org/doc/1.26/reference/generated/numpy.block.html

numpy.block(arrays)

从嵌套的区块列表组装一个多维数组。

内部列表的区块将沿着最后一个维度（-1）进行连接（参见concatenate），然后沿着倒数第二个维度（-2）进行连接，依此类推，直到达到最外部的列表。

区块可以是任何维度，但是不会使用正常规则进行广播。而是插入大小为 1 的前导轴，以使所有区块的 block.ndim 相同。这对于使用标量特别有用，这意味着像 np.block([v, 1]) 这样的代码是有效的，其中 v.ndim == 1。

当嵌套列表有两个等级时，这允许从它们的组件构造区块矩阵。

版本 1.13.0 中的新功能。

参数：

arrays嵌套数组或标量的列表（但不是元组）

如果传递单个 ndarray 或标量（深度为 0 的嵌套列表），则返回未修改的副本（无复制）。

元素的形状必须在适当的轴上匹配（不使用广播），但是会在需要时添加前导 1 使维度匹配。

block_arrayndarray

由给定的区块组装的数组。

输出的维度等于以下两者中的最大值：* 所有输入的维度 * 输入列表嵌套的深度

抛出：

ValueError

如果列表的深度不匹配——例如，[[a, b], c] 是不合法的，应该拼写为 [[a, b], [c]]
如果列表为空——例如，[[a, b], []]

另请参见

concatenate

沿现有轴连接数组的序列。

stack

将一系列数组沿新轴连接。

vstack

按行添加序列地堆叠数组。

hstack

按列序列地堆叠数组。

dstack

按深度顺序沿第三个轴堆叠序列数组。

column_stack

将 1 维数组作为列堆叠到 2 维数组。

vsplit

将数组垂直（按行）分割为多个子数组。

注意

当仅使用标量调用时，np.block 等效于一个 ndarray 调用。因此，np.block([[1, 2], [3, 4]]) 等效于 np.array([[1, 2], [3, 4]])。

此函数不强制区块位于固定网格上。np.block([[a, b], [c, d]]) 不限于以下形式的数组：

AAAbb
AAAbb
cccDD

也允许为一些 a, b, c, d 产生：

AAAbb
AAAbb
cDDDD

由于连接首先沿最后一个轴发生，block 不能直接产生以下结果：

AAAbb
cccbb
cccDD

Matlab 的 “方括号堆叠”, [A, B, ...; p, q, ...], 等同于 np.block([[A, B, ...], [p, q, ...]])。

示例

这个函数最常见的用法是构建一个分块矩阵。

>>> A = np.eye(2) * 2
>>> B = np.eye(3) * 3
>>> np.block([
...     [A,               np.zeros((2, 3))],
...     [np.ones((3, 2)), B               ]
... ])
array([[2., 0., 0., 0., 0.],
 [0., 2., 0., 0., 0.],
 [1., 1., 3., 0., 0.],
 [1., 1., 0., 3., 0.],
 [1., 1., 0., 0., 3.]])

当一个深度为 1 的列表时，block 可以作为 hstack 使用。

>>> np.block([1, 2, 3])              # hstack([1, 2, 3])
array([1, 2, 3])

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.block([a, b, 10])             # hstack([a, b, 10])
array([ 1,  2,  3,  4,  5,  6, 10])

>>> A = np.ones((2, 2), int)
>>> B = 2 * A
>>> np.block([A, B])                 # hstack([A, B])
array([[1, 1, 2, 2],
 [1, 1, 2, 2]])

当一个深度为 2 的列表时，block 可以替代 vstack：

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.block([[a], [b]])             # vstack([a, b])
array([[1, 2, 3],
 [4, 5, 6]])

>>> A = np.ones((2, 2), int)
>>> B = 2 * A
>>> np.block([[A], [B]])             # vstack([A, B])
array([[1, 1],
 [1, 1],
 [2, 2],
 [2, 2]])

它也可以用在 atleast_1d 和 atleast_2d 的地方。

>>> a = np.array(0)
>>> b = np.array([1])
>>> np.block([a])                    # atleast_1d(a)
array([0])
>>> np.block([b])                    # atleast_1d(b)
array([1])

>>> np.block([[a]])                  # atleast_2d(a)
array([[0]])
>>> np.block([[b]])                  # atleast_2d(b)
array([[1]])

`numpy.vstack`

原文：numpy.org/doc/1.26/reference/generated/numpy.vstack.html

numpy.vstack(tup, *, dtype=None, casting='same_kind')

按顺序垂直（行向）堆叠数组。

这相当于在将形状为(N,)的 1-D 数组重新整形为(1,N)之后沿第一轴进行连接。重建由vsplit分割的数组。

此函数对于最多 3 维数组最有意义。例如，对于具有高度（第一轴）、宽度（第二轴）和 r/g/b 通道（第三轴）的像素数据。函数concatenate、stack和block提供了更一般的堆叠和连接操作。

np.row_stack是vstack的别名。它们是相同的函数。

参数：

tupndarray 序列

除第一轴以外的所有轴上，数组必须具有相同的形状。1-D 数组必须具有相同的长度。

dtypestr 或 dtype

如果提供了，目标数组将具有此 dtype。不能与out同时提供。

.. versionadded:: 1.24

casting，可选

控制可能发生的数据转换的类型。默认为‘same_kind’。

.. versionadded:: 1.24

stackedndarray

给定数组的堆叠形成的数组将至少是 2-D。

另请参见

concatenate

沿着现有轴将一个数组序列连接在一起。

stack

沿新轴连接一个数组序列。

block

从块的嵌套列表中组装一个 nd-array。

hstack

按顺序水平（列向）堆叠数组。

dstack

按顺序深度（沿第三轴）堆叠数组。

column_stack

将 1-D 数组作为列堆叠成 2-D 数组。

vsplit

将数组沿垂直（行向）方向拆分为多个子数组。

例子

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],
 [4, 5, 6]])

>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.vstack((a,b))
array([[1],
 [2],
 [3],
 [4],
 [5],
 [6]])

`numpy.hstack`

原文：numpy.org/doc/1.26/reference/generated/numpy.hstack.html

numpy.hstack(tup, *, dtype=None, casting='same_kind')

按顺序水平（列方向）堆叠数组。

这等效于沿第二轴连接，但对于 1-D 数组，它沿第一轴连接。通过hsplit分割的数组重建。

这个函数对于最多有 3 个维度的数组是最有意义的。例如，对于具有高度（第一个轴）、宽度（第二个轴）和 r/g/b 通道（第三个轴）的像素数据。函数concatenate、stack和block提供了更一般的堆叠和连接操作。

参数：

tupndarrays 序列

所有数组除了第二个轴之外的形状必须相同，除非是 1-D 数组，可以是任意长度。

dtypestr 或 dtype

如果提供了，则目标数组将具有此 dtype。不能与out一起提供。

.. versionadded:: 1.24

casting，可选

控制可能发生的数据转换的类型。默认为‘same_kind’。

.. versionadded:: 1.24

stackedndarray

由给定数组堆叠而成的数组。

另请参阅

concatenate

沿现有轴连接数组序列。

stack

沿新轴连接数组序列。

block

从嵌套块列表中组装一个 nd 数组。

vstack

按顺序垂直（行方向）堆叠数组。

dstack

按顺序沿深度方向（第三轴）堆叠数组。

column_stack

将 1-D 数组堆叠为 2-D 数组的列。

hsplit

将数组水平（列方向）分割成多个子数组。

示例

>>> a = np.array((1,2,3))
>>> b = np.array((4,5,6))
>>> np.hstack((a,b))
array([1, 2, 3, 4, 5, 6])
>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[4],[5],[6]])
>>> np.hstack((a,b))
array([[1, 4],
 [2, 5],
 [3, 6]])

`numpy.dstack`

原文：numpy.org/doc/1.26/reference/generated/numpy.dstack.html

numpy.dstack(tup)

按序深度堆叠数组（沿第三轴）。

这相当于在将形状为(M,N)的 2-D 数组重新塑形为(M,N,1)，并将形状为(N,)的 1-D 数组重新塑形为(1,N,1)后，沿第三个轴进行串联。重新构建由dsplit分割的数组。

此函数对于至多具有 3 维的数组最有意义。例如，对于具有高度（第一个轴）、宽度（第二个轴）和 r/g/b 通道（第三个轴）的像素数据。函数concatenate、stack和block提供了更通用的堆叠和串联操作。

参数：

tup数组序列

数组在除第三轴以外的所有轴上必须具有相同的形状。1-D 或 2-D 数组必须具有相同的形状。

stackedndarray

由给定数组堆叠形成的数组，至少为 3-D。

另请参见

concatenate

沿着现有轴连接数组序列。

stack

沿着新轴连接数组序列。

block

从嵌套的块列表中组装 nd-array。

vstack

按顺序垂直（行方向）堆叠数组。

hstack

按顺序水平（列方向）堆叠数组。

column_stack

将 1-D 数组按列堆叠到 2-D 数组中。

dsplit

沿着第三个轴分割数组。

示例

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.dstack((a,b))
array([[[1, 2],
 [2, 3],
 [3, 4]]])

>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[2],[3],[4]])
>>> np.dstack((a,b))
array([[[1, 2]],
 [[2, 3]],
 [[3, 4]]])

`numpy.column_stack`

原文：numpy.org/doc/1.26/reference/generated/numpy.column_stack.html

numpy.column_stack(tup)

将一维数组作为列堆叠成二维数组。

取一个一维数组序列并将它们堆叠成列，以形成一个二维数组。二维数组按原样堆叠，就像使用hstack一样。一维数组首先转换为二维列。

参数：

tup一维或二维数组的序列。

需要堆叠的数组。它们都必须具有相同的第一个维度。

stacked二维数组

由给定数组堆叠而成的数组。

参见

stack，hstack，vstack，concatenate

示例

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.column_stack((a,b))
array([[1, 2],
 [2, 3],
 [3, 4]])

`numpy.row_stack`

原文：numpy.org/doc/1.26/reference/generated/numpy.row_stack.html

numpy.row_stack(tup, *, dtype=None, casting='same_kind')

按照顺序在垂直方向（行方式）堆叠数组。

这相当于在将形状为(N，)的 1-D 数组重新形状为(1，N)之后沿第一轴进行连接。重新构建被vsplit分割的数组。

此函数对于最多有 3 维的数组最有意义。例如，对于具有高度（第一轴）、宽度（第二轴）和 r/g/b 通道（第三轴）的像素数据。函数concatenate、stack和block提供了更通用的堆叠和连接操作。

np.row_stack是vstack的别名。它们是相同的函数。

参数：

tupndarrays 序列

所有数组在除第一轴以外的所有轴上必须具有相同的形状。1-D 数组必须具有相同的长度。

dtypestr 或 dtype

如果提供了，目标数组将具有此 dtype。不能与out一起提供。

.. 版本新增：1.24

casting，可选

控制可能发生的数据类型转换。默认为‘same_kind’。

.. 版本新增：1.24

stackedndarray

由堆叠给定数组形成的数组至少是 2-D。

另请参见

concatenate

沿着现有轴连接数组序列。

stack

沿着新轴连接数组序列。

block

从嵌套块列表装配一个 nd 数组。

hstack

按照顺序在水平方向（列方式）堆叠数组。

dstack

按顺序在深度方向（沿第三轴）堆叠数组。

column_stack

将 1-D 数组作为列堆叠到 2-D 数组中。

vsplit

将数组沿垂直方向（行方式）分割为多个子数组。

示例

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],
 [4, 5, 6]])

>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.vstack((a,b))
array([[1],
 [2],
 [3],
 [4],
 [5],
 [6]])

`numpy.split`

原文：numpy.org/doc/1.26/reference/generated/numpy.split.html

numpy.split(ary, indices_or_sections, axis=0)

将数组分割成多个ary的视图子数组。

参数：

aryndarray

要分割为子数组的数组。

indices_or_sectionsint 或 1-D 数组

如果 indices_or_sections 是整数 N，则数组将沿 axis 被分为 N 个相等的数组。如果这样的分割不可能，则将引发错误。

如果 indices_or_sections 是按排序整数的 1-D 数组，则条目指示数组沿 axis 在哪里分割。例如，[2, 3] 对于axis=0 会导致

ary[:2]

ary[2:3]

ary[3:]

如果索引超过了与 axis 平行的数组的维度，则相应地返回一个空的子数组。

axisint，可选

要沿其分割的轴，默认为 0。

sub-arraysndarrays 的列表

作为ary的视图的子数组列表。

引发：

ValueError

如果 indices_or_sections 作为整数给出，但分割没有导致等分。

另请参阅

array_split

将数组分割成大小相等或接近相等的多个子数组。如果无法做到等分，则不会引发异常。

hsplit

水平（按列）顺序分割数组为多个子数组。

vsplit

沿垂直（按行）方向将数组分割为多个子数组。

dsplit

沿第 3 轴（深度）将数组分割为多个子数组。

concatenate

沿现有轴连接一系列数组。

stack

沿新轴连接一系列数组。

hstack

水平（按列）顺序堆叠数组。

vstack

沿垂直（按行）顺序堆叠数组。

dstack

沿第三个维度方向依次堆叠数组。

示例

>>> x = np.arange(9.0)
>>> np.split(x, 3)
[array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.,  8.])]

>>> x = np.arange(8.0)
>>> np.split(x, [3, 5, 6, 10])
[array([0.,  1.,  2.]),
 array([3.,  4.]),
 array([5.]),
 array([6.,  7.]),
 array([], dtype=float64)]

`numpy.array_split`

原文：numpy.org/doc/1.26/reference/generated/numpy.array_split.html

numpy.array_split(ary, indices_or_sections, axis=0)

将数组分割成多个子数组。

请参考split文档。这些函数之间唯一的区别是，array_split允许indices_or_sections是不能等分轴的整数。对于长度为 l 的数组，应该分成 n 个部分，它返回 l % n 个大小为 l//n + 1 的子数组和剩余大小为 l//n 的子数组。

另请参阅

split

将数组分割成大小相等的多个子数组。

示例

>>> x = np.arange(8.0)
>>> np.array_split(x, 3)
[array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.])]

>>> x = np.arange(9)
>>> np.array_split(x, 4)
[array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]

`numpy.dsplit`

原文：numpy.org/doc/1.26/reference/generated/numpy.dsplit.html

numpy.dsplit(ary, indices_or_sections)

沿着第 3 轴（深度）将数组分割成多个子数组。

请参阅 split 的文档。 dsplit 等同于带有 axis=2 的 split，只要数组维度大于或等于 3，数组就总是沿第三轴分割。

另请参阅

split

将数组分割成大小相等的多个子数组。

示例

>>> x = np.arange(16.0).reshape(2, 2, 4)
>>> x
array([[[ 0.,   1.,   2.,   3.],
 [ 4.,   5.,   6.,   7.]],
 [[ 8.,   9.,  10.,  11.],
 [12.,  13.,  14.,  15.]]])
>>> np.dsplit(x, 2)
[array([[[ 0.,  1.],
 [ 4.,  5.]],
 [[ 8.,  9.],
 [12., 13.]]]), array([[[ 2.,  3.],
 [ 6.,  7.]],
 [[10., 11.],
 [14., 15.]]])]
>>> np.dsplit(x, np.array([3, 6]))
[array([[[ 0.,   1.,   2.],
 [ 4.,   5.,   6.]],
 [[ 8.,   9.,  10.],
 [12.,  13.,  14.]]]),
 array([[[ 3.],
 [ 7.]],
 [[11.],
 [15.]]]),
array([], shape=(2, 2, 0), dtype=float64)]

`numpy.hsplit`

原文：numpy.org/doc/1.26/reference/generated/numpy.hsplit.html

numpy.hsplit(ary, indices_or_sections)

将数组水平分割成多个子数组（按列）。

请参考split文档。hsplit等同于带有axis=1的split，数组总是沿第二轴分割，除了对于 1-D 数组，在这种情况下在axis=0处分割。

另请参见

split

将数组分割成多个相等大小的子数组。

示例

>>> x = np.arange(16.0).reshape(4, 4)
>>> x
array([[ 0.,   1.,   2.,   3.],
 [ 4.,   5.,   6.,   7.],
 [ 8.,   9.,  10.,  11.],
 [12.,  13.,  14.,  15.]])
>>> np.hsplit(x, 2)
[array([[  0.,   1.],
 [  4.,   5.],
 [  8.,   9.],
 [12.,  13.]]),
 array([[  2.,   3.],
 [  6.,   7.],
 [10.,  11.],
 [14.,  15.]])]
>>> np.hsplit(x, np.array([3, 6]))
[array([[ 0.,   1.,   2.],
 [ 4.,   5.,   6.],
 [ 8.,   9.,  10.],
 [12.,  13.,  14.]]),
 array([[ 3.],
 [ 7.],
 [11.],
 [15.]]),
 array([], shape=(4, 0), dtype=float64)]

对于更高维的数组，分割仍沿第二轴进行。

>>> x = np.arange(8.0).reshape(2, 2, 2)
>>> x
array([[[0.,  1.],
 [2.,  3.]],
 [[4.,  5.],
 [6.,  7.]]])
>>> np.hsplit(x, 2)
[array([[[0.,  1.]],
 [[4.,  5.]]]),
 array([[[2.,  3.]],
 [[6.,  7.]]])]

对于 1-D 数组，分割沿轴 0 进行。

>>> x = np.array([0, 1, 2, 3, 4, 5])
>>> np.hsplit(x, 2)
[array([0, 1, 2]), array([3, 4, 5])]

`numpy.vsplit`

原文：numpy.org/doc/1.26/reference/generated/numpy.vsplit.html

numpy.vsplit(ary, indices_or_sections)

将数组垂直（行向）分割成多个子数组。

请参考split文档。vsplit等同于axis=0（默认）的split，数组始终沿着第一个轴分割，与数组维度无关。

另请参阅

split

将数组等分成多个子数组。

示例

>>> x = np.arange(16.0).reshape(4, 4)
>>> x
array([[ 0.,   1.,   2.,   3.],
 [ 4.,   5.,   6.,   7.],
 [ 8.,   9.,  10.,  11.],
 [12.,  13.,  14.,  15.]])
>>> np.vsplit(x, 2)
[array([[0., 1., 2., 3.],
 [4., 5., 6., 7.]]), array([[ 8.,  9., 10., 11.],
 [12., 13., 14., 15.]])]
>>> np.vsplit(x, np.array([3, 6]))
[array([[ 0.,  1.,  2.,  3.],
 [ 4.,  5.,  6.,  7.],
 [ 8.,  9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([], shape=(0, 4), dtype=float64)]

对于更高维的数组，分割仍然沿着第一个轴进行。

>>> x = np.arange(8.0).reshape(2, 2, 2)
>>> x
array([[[0.,  1.],
 [2.,  3.]],
 [[4.,  5.],
 [6.,  7.]]])
>>> np.vsplit(x, 2)
[array([[[0., 1.],
 [2., 3.]]]), array([[[4., 5.],
 [6., 7.]]])]

`numpy.tile`

原文：numpy.org/doc/1.26/reference/generated/numpy.tile.html

numpy.tile(A, reps)

通过重复给定的次数来构造数组 A。

如果 reps 的长度为 d，结果将具有 max(d, A.ndim) 维度。

如果 A.ndim < d，通过在前面添加新的轴来将 A 提升为 d 维。因此，形状为 (3,) 的数组被提升为 2-D 复制的 (1, 3)，或形状为 (1, 1, 3) 的数组被提升为 3-D 复制。如果这不是期望的行为，请在调用此函数之前手动将 A 提升到 d 维。

如果 A.ndim > d，通过向 reps 前置 1 来将其提升到 A.ndim。因此，对于形状为 (2, 3, 4, 5) 的 A，形状为 (2, 2) 的 reps 被视为 (1, 1, 2, 2)。

注意：虽然 tile 可以用于广播，但强烈建议使用 numpy 的广播操作和函数。

参数：

Aarray_like

输入数组。

repsarray_like

沿每个轴重复 A 的次数。

cndarray

平铺输出数组。

另请参阅

repeat

重复数组的元素。

broadcast_to

将数组广播到新的形状

示例

>>> a = np.array([0, 1, 2])
>>> np.tile(a, 2)
array([0, 1, 2, 0, 1, 2])
>>> np.tile(a, (2, 2))
array([[0, 1, 2, 0, 1, 2],
 [0, 1, 2, 0, 1, 2]])
>>> np.tile(a, (2, 1, 2))
array([[[0, 1, 2, 0, 1, 2]],
 [[0, 1, 2, 0, 1, 2]]])

>>> b = np.array([[1, 2], [3, 4]])
>>> np.tile(b, 2)
array([[1, 2, 1, 2],
 [3, 4, 3, 4]])
>>> np.tile(b, (2, 1))
array([[1, 2],
 [3, 4],
 [1, 2],
 [3, 4]])

>>> c = np.array([1,2,3,4])
>>> np.tile(c,(4,1))
array([[1, 2, 3, 4],
 [1, 2, 3, 4],
 [1, 2, 3, 4],
 [1, 2, 3, 4]])

`numpy.repeat`

原文：numpy.org/doc/1.26/reference/generated/numpy.repeat.html

numpy.repeat(a, repeats, axis=None)

将数组中的每个元素重复其自身

参数：

a类似数组

输入数组。

重复整数或整数数组

每个元素的重复次数。repeats被广播以适应给定轴的形状。

轴整数，可选

重复值的轴。默认情况下，使用扁平化的输入数组，并返回一个扁平化的输出数组。

repeated_array ndarray

输出数组，其形状与a相同，除了沿着给定轴。

参见

tile

对数组进行平铺。

unique

找到数组的唯一元素。

示例

>>> np.repeat(3, 4)
array([3, 3, 3, 3])
>>> x = np.array([[1,2],[3,4]])
>>> np.repeat(x, 2)
array([1, 1, 2, 2, 3, 3, 4, 4])
>>> np.repeat(x, 3, axis=1)
array([[1, 1, 1, 2, 2, 2],
 [3, 3, 3, 4, 4, 4]])
>>> np.repeat(x, [1, 2], axis=0)
array([[1, 2],
 [3, 4],
 [3, 4]])

`numpy.delete`

原文：numpy.org/doc/1.26/reference/generated/numpy.delete.html

numpy.delete(arr, obj, axis=None)

返回删除沿轴的子数组的新数组。对于一维数组，这会返回arr[obj]未返回的条目。

参数：

arrarray_like

输入数组。

obj切片，整数或整数数组

指示要沿指定轴删除的子数组的索引。

自 1.19.0 版更改：布尔索引现在被视为要移除的元素的掩码，而不是转换为整数 0 和 1。

axisint，可选

定义由obj定义的子数组要删除的轴。如果axis为 None，则将obj应用于扁平化的数组。

outndarray

一个移除了obj指定的元素的arr的副本。请注意，delete不是就地进行的。如果axis为 None，则out是一个扁平化的数组。

另请参见

insert

将元素插入数组。

append

在数组末尾附加元素。

注释

通常最好使用布尔掩码。例如：

>>> arr = np.arange(12) + 1
>>> mask = np.ones(len(arr), dtype=bool)
>>> mask[[0,2,4]] = False
>>> result = arr[mask,...]

等效于np.delete(arr, [0,2,4], axis=0)，但允许进一步使用mask。

示例

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

>>> np.delete(arr, np.s_[::2], 1)
array([[ 2,  4],
 [ 6,  8],
 [10, 12]])
>>> np.delete(arr, [1,3,5], None)
array([ 1,  3,  5,  7,  8,  9, 10, 11, 12])

`numpy.insert`

原文：numpy.org/doc/1.26/reference/generated/numpy.insert.html

numpy.insert(arr, obj, values, axis=None)

在给定索引之前沿着给定轴插入值。

参数：

arrarray_like

输入数组。

objint，切片或整数序列

定义插入values之前的索引或索引的对象。

在 1.8.0 版中新增功能。

当obj是单个标量或具有一个元素的序列时，支持多个插入（类似于多次调用 insert）。

valuesarray_like

要插入到arr中的值。如果values的类型与arr的类型不同，则将values转换为arr的类型。values应该被塑造为arr[...,obj,...] = values是合法的形式。

axisint，可选

要插入values的轴。如果axis为 None，则首先对arr进行展平。

outndarray

复制由插入values而生成的arr。请注意insert不是就地进行的：将返回一个新数组。如果axis为 None，则out是一个扁平化的数组。

另请参阅

append

在数组末尾追加元素。

concatenate

沿着现有轴连接一系列数组。

delete

从数组中删除元素。

笔记

请注意，对于更高维度的插入，obj=0的行为与obj=[0]截然不同，就像arr[:,0,:] = values与arr[:,[0],:] = values不同。

示例

>>> a = np.array([[1, 1], [2, 2], [3, 3]])
>>> a
array([[1, 1],
 [2, 2],
 [3, 3]])
>>> np.insert(a, 1, 5)
array([1, 5, 1, ..., 2, 3, 3])
>>> np.insert(a, 1, 5, axis=1)
array([[1, 5, 1],
 [2, 5, 2],
 [3, 5, 3]])

序列与标量之间的差异：

>>> np.insert(a, [1], [[1],[2],[3]], axis=1)
array([[1, 1, 1],
 [2, 2, 2],
 [3, 3, 3]])
>>> np.array_equal(np.insert(a, 1, [1, 2, 3], axis=1),
...                np.insert(a, [1], [[1],[2],[3]], axis=1))
True

>>> b = a.flatten()
>>> b
array([1, 1, 2, 2, 3, 3])
>>> np.insert(b, [2, 2], [5, 6])
array([1, 1, 5, ..., 2, 3, 3])

>>> np.insert(b, slice(2, 4), [5, 6])
array([1, 1, 5, ..., 2, 3, 3])

>>> np.insert(b, [2, 2], [7.13, False]) # type casting
array([1, 1, 7, ..., 2, 3, 3])

>>> x = np.arange(8).reshape(2, 4)
>>> idx = (1, 3)
>>> np.insert(x, idx, 999, axis=1)
array([[  0, 999,   1,   2, 999,   3],
 [  4, 999,   5,   6, 999,   7]])

`numpy.append`

原文：numpy.org/doc/1.26/reference/generated/numpy.append.html

numpy.append(arr, values, axis=None)

将值追加到数组末尾。

参数：

arrarray_like

值追加到该数组的副本中。

valuesarray_like

这些值被追加到arr的副本中。它必须具有正确的形状（与arr相同的形状，不包括axis）。如果未指定axis，则values可以是任何形状，在使用之前将被展平。

axisint, optional

values附加的轴线。如果未给出axis，则在使用之前arr和values都会被展平。

appendndarray

arr的副本，values附加到axis。请注意，append不是就地发生的：一个新的数组被分配并填充。如果axis为 None，则out是一个展平的数组。

参见

insert

将元素插入数组中。

delete

从数组中删除元素。

示例

>>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]])
array([1, 2, 3, ..., 7, 8, 9])

当指定axis时，values必须具有正确的形状。

>>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)
array([[1, 2, 3],
 [4, 5, 6],
 [7, 8, 9]])
>>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)
Traceback (most recent call last):
  ...
ValueError: all the input arrays must have same number of dimensions, but
the array at index 0 has 2 dimension(s) and the array at index 1 has 1
dimension(s)

`numpy.resize`

原文：numpy.org/doc/1.26/reference/generated/numpy.resize.html

numpy.resize(a, new_shape)

返回具有指定形状的新数组。

如果新数组比原始数组大，则新数组将被填充为a的重复副本。注意，这与 a.resize(new_shape)的行为不同，后者用零填充而不是a的重复副本。

参数：

a类似数组

要调整大小的数组。

new_shapeint 或 int 元组

调整大小后的数组形状。

返回值：

reshaped_arrayndarray

新数组由旧数组中的数据形成，必要时重复以填满所需的元素数量。数据按 C 顺序在数组上循环重复。

另请参见

numpy.reshape

重新形状一个数组而不更改总大小。

numpy.pad

扩大并填充数组。

numpy.repeat

重复数组的元素。

ndarray.resize

原位调整数组大小。

注意

当数组的总大小不变时，应使用reshape。在其他大多数情况下，索引（缩小大小）或填充（增加大小）可能是更合适的解决方案。

警告：此功能不分别考虑轴，即不应用插值/外推。它用所需数量的元素填充返回数组，按 C 顺序在a上迭代，忽略轴（如果新形状较大，则从开始处循环返回）。因此，此功能不适用于调整图像或每个轴表示单独和不同实体的数据。

示例

>>> a=np.array([[0,1],[2,3]])
>>> np.resize(a,(2,3))
array([[0, 1, 2],
 [3, 0, 1]])
>>> np.resize(a,(1,4))
array([[0, 1, 2, 3]])
>>> np.resize(a,(2,4))
array([[0, 1, 2, 3],
 [0, 1, 2, 3]])

`numpy.trim_zeros`

原文：numpy.org/doc/1.26/reference/generated/numpy.trim_zeros.html

numpy.trim_zeros(filt, trim='fb')

修剪一维数组或序列中的前导和/或尾随零。

参数：

filt一维数组或序列

输入数组。

trimstr，可选

一个字符串，其中‘f’表示从前面修剪，‘b’表示从后面修剪。默认为'fb'，从数组的前面和后面修剪零。

返回值：

trimmed一维数组或序列

修剪输入的结果。保留输入数据类型。

示例

>>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0))
>>> np.trim_zeros(a)
array([1, 2, 3, 0, 2, 1])

>>> np.trim_zeros(a, 'b')
array([0, 0, 0, ..., 0, 2, 1])

保留输入数据类型，表示输入为列表/元组，则输出为列表/元组。

>>> np.trim_zeros([0, 1, 2, 0])
[1, 2]

`numpy.unique`

numpy.org/doc/1.26/reference/generated/numpy.unique.html

numpy.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None, *, equal_nan=True)

查找数组的唯一元素。

返回数组的排序唯一元素。除了唯一元素外，还有三个可选输出：

给出唯一值的输入数组的索引
重建输入数组的唯一数组的索引
输入数组中每个唯一值出现的次数

参数：

ar类数组

输入数组。除非指定了axis，否则如果它不是已经是 1-D 的话将被展平。

return_index布尔值，可选

如果为真，还应返回ar的索引（沿指定轴，如果提供，则在展平的数组中）导致唯一数组的结果。

return_inverse布尔值，可选

如果为真，还应返回唯一数组的索引（对于指定的轴，如果提供）可以用于重组ar。

return_counts布尔值，可选

如果为真，还应返回每个唯一项在ar中出现的次数。

axisint 或 None，可选

操作的轴。如果为 None，则ar将被展平。如果为整数，则由给定轴索引的子数组将被展平，并被视为具有给定轴维度的元素的 1-D 数组，有关更多详细信息，请参见注释。如果使用axis kwarg，则不支持对象数组或包含对象的结构化数组。默认值为 None。

在 1.13.0 版中新增。

equal_nan布尔值，可选

如果为真，则将返回数组中的多个 NaN 值合并为一个。

在 1.24 版中新增。

uniquendarray

排序后的唯一值。

unique_indicesndarray，可选

原始数组中唯一值第一次出现的索引。仅在return_index为真时提供。

unique_inversendarray，可选

重建原始数组的索引从唯一数组。仅在return_inverse为 True 时提供。

unique_countsndarray，可选

原始数组中每个唯一值出现的次数。仅在return_counts为真时提供。

在 1.19.0 版中新增。

另请参见

numpy.lib.arraysetops

模块中有许多其他用于在数组上执行集合操作的函数。

repeat

重复数组的元素。

注释

当指定轴时，按轴索引的子数组进行排序。这是通过将指定的轴作为数组的第一个维度（将轴移动到第一个维度以保持其他轴的顺序）然后按 C 顺序展平子数组来实现的。然后，展平的子数组被视为具有标签的结构类型，从而使每个元素都被赋予一个标签，结果我们得到了一个可以像任何其他 1-D 数组一样处理的结构类型的 1-D 数组。结果是展平的子数组按字典顺序排序，从第一个元素开始。

示例

>>> np.unique([1, 1, 2, 2, 3, 3])
array([1, 2, 3])
>>> a = np.array([[1, 1], [2, 3]])
>>> np.unique(a)
array([1, 2, 3])

返回 2D 数组的唯一行

>>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
>>> np.unique(a, axis=0)
array([[1, 0, 0], [2, 3, 4]])

返回给定唯一值的原始数组的索引：

>>> a = np.array(['a', 'b', 'b', 'c', 'a'])
>>> u, indices = np.unique(a, return_index=True)
>>> u
array(['a', 'b', 'c'], dtype='<U1')
>>> indices
array([0, 1, 3])
>>> a[indices]
array(['a', 'b', 'c'], dtype='<U1')

从唯一值和逆向重建输入数组：

>>> a = np.array([1, 2, 6, 4, 2, 3, 2])
>>> u, indices = np.unique(a, return_inverse=True)
>>> u
array([1, 2, 3, 4, 6])
>>> indices
array([0, 1, 4, 3, 1, 2, 1])
>>> u[indices]
array([1, 2, 6, 4, 2, 3, 2])

从唯一值和计数中重建输入值：

>>> a = np.array([1, 2, 6, 4, 2, 3, 2])
>>> values, counts = np.unique(a, return_counts=True)
>>> values
array([1, 2, 3, 4, 6])
>>> counts
array([1, 3, 1, 1, 1])
>>> np.repeat(values, counts)
array([1, 2, 2, 2, 3, 4, 6])    # original order not preserved

posted @ 2024-06-24 14:54 绝不原创的飞龙阅读(3) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

NumPy-1-26-中文文档-八-

NumPy 1.26 中文文档（八）

numpy.arange

numpy.linspace

numpy.logspace

numpy.geomspace

numpy.meshgrid

numpy.mgrid

numpy.ogrid

numpy.diag

numpy.diagflat

numpy.tri

numpy.tril

numpy.triu

numpy.vander

numpy.mat

numpy.bmat

数组操作程序

基本操作

改变数组形状

转置类操作

改变维度个数

改变数组类型

合并数组

拆分数组

平铺数组

添加和删除元素

重新排列元素

基本操作

更改数组形状

类似转置的操作

改变维数

改变数组类型

数组连接

数组分割

瓷砖数组

添加和删除元素

重新排列元素

numpy.copyto

numpy.shape

numpy.reshape

numpy.ravel

numpy.ndarray.flat

numpy.ndarray.flatten

numpy.moveaxis

numpy.rollaxis

numpy.swapaxes

numpy.ndarray.T

numpy.transpose

numpy.atleast_1d

numpy.atleast_2d

numpy.atleast_3d

numpy.broadcast

numpy.broadcast_to

numpy.broadcast_arrays

numpy.expand_dims

numpy.squeeze

numpy.asarray

numpy.asanyarray

numpy.asmatrix

numpy.asfarray

numpy.asfortranarray

numpy.ascontiguousarray

numpy.asarray_chkfinite

numpy.require

numpy.concatenate

numpy.stack

numpy.block

numpy.vstack

numpy.hstack

numpy.dstack

numpy.column_stack

numpy.row_stack

numpy.split

numpy.array_split

numpy.dsplit

numpy.hsplit

numpy.vsplit

`numpy.arange`

`numpy.linspace`

`numpy.logspace`

`numpy.geomspace`

`numpy.meshgrid`

`numpy.mgrid`

`numpy.ogrid`

`numpy.diag`

`numpy.diagflat`

`numpy.tri`

`numpy.tril`

`numpy.triu`

`numpy.vander`

`numpy.mat`

`numpy.bmat`

`numpy.copyto`

`numpy.shape`

`numpy.reshape`

`numpy.ravel`

`numpy.ndarray.flat`

`numpy.ndarray.flatten`

`numpy.moveaxis`

`numpy.rollaxis`

`numpy.swapaxes`

`numpy.ndarray.T`

`numpy.transpose`

`numpy.atleast_1d`

`numpy.atleast_2d`

`numpy.atleast_3d`

`numpy.broadcast`

`numpy.broadcast_to`

`numpy.broadcast_arrays`

`numpy.expand_dims`

`numpy.squeeze`

`numpy.asarray`

`numpy.asanyarray`

`numpy.asmatrix`

`numpy.asfarray`

`numpy.asfortranarray`

`numpy.ascontiguousarray`

`numpy.asarray_chkfinite`

`numpy.require`

`numpy.concatenate`

`numpy.stack`

`numpy.block`

`numpy.vstack`

`numpy.hstack`

`numpy.dstack`

`numpy.column_stack`

`numpy.row_stack`

`numpy.split`

`numpy.array_split`

`numpy.dsplit`

`numpy.hsplit`

`numpy.vsplit`

`numpy.tile`

`numpy.repeat`

`numpy.delete`

`numpy.insert`

`numpy.append`

`numpy.resize`

`numpy.trim_zeros`

`numpy.unique`