numpy.block #

麻木的。数组[来源] #

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

最里面列表中的块concatenate沿着最后一个维度 (-1) 连接(请参阅 ),然后沿着倒数第二个维度 (-2) 连接,依此类推,直到到达最外面的列表。

块可以是任何维度,但不会使用正常规则进行广播。相反,插入尺寸为 1 的引导轴,以使block.ndim 所有块都相同。这主要用于处理标量,并且意味着类似的代码是有效的,其中 .np.block([v, 1])v.ndim == 1

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

1.13.0 版本中的新增功能。

参数
数组类似 array 或标量的嵌套列表(但不是元组)

如果传递单个 ndarray 或标量(深度为 0 的嵌套列表),则返回未修改的(且不复制)。

元素形状必须沿适当的轴匹配(不广播),但将根据需要在形状前面添加前导 1 以使尺寸匹配。

返回
块数组ndarray

由给定块组装而成的数组。

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

加薪
值错误
  • 如果列表深度不匹配 - 例如,这是非法的,应该拼写[[a, b], c][[a, b], [c]]

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

也可以看看

concatenate

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

stack

沿新轴连接一系列数组。

vstack

垂直(按行)顺序堆叠数组。

hstack

按水平顺序堆叠数组(按列)。

dstack

按深度顺序(沿第三轴)堆叠数组。

column_stack

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

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]])