numpy.block#

numpy.block(arrays)[source]#

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

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

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

当嵌套列表的深度为两层时，这允许从其组件构造块矩阵。

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

如果传入单个 ndarray 或标量（深度为 0 的嵌套列表），则会原样返回（不进行复制）。

元素的形状必须沿着适当的轴匹配（不进行广播），但会在形状前面根据需要添加 1，以使维度匹配。

返回：
block_arrayndarray

从给定块组装的数组。

输出的维度等于以下两者中的较大者：

  • 所有输入的维度

  • 输入列表的嵌套深度

引发：
ValueError

  • 如果列表深度不匹配——例如，[[a, b], c] 是非法的，应该写成 [[a, b], [c]]

  • 如果列表为空——例如，[[a, b], []]

另请参阅

concatenate

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

stack

沿着新轴连接数组序列。

vstack

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

hstack

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

dstack

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

column_stack

将一维数组堆叠为列，形成一个二维数组。

vsplit

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

unstack

沿着一个轴将数组分割成子数组元组。

备注

当只使用标量调用时，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, ...]])。

示例

此函数最常见的用途是构建块矩阵：

>>> import numpy as np
>>> 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]])
本页内容