numpy.block#

numpy.block(arrays)[源代码]#

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

在最内层列表中的块沿着最后一个维度 (-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

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

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]])
On this page