numpy.block

numpy.block(arrays) [source]

Сборка nd-массива из вложенных списков блоков.

Блоки во вложенных списках конкатенируются (см. concatenate) вдоль последнего измерения (-1), затем эти блоки конкатенируются вдоль предпоследнего измерения (-2) и так далее, пока не будет достигнут самый внешний список.

Блоки могут быть любой размерности, но не будут транслироваться по обычным правилам. Вместо этого, ведущие оси размера 1 вставляются, чтобы сделать block.ndim одинаковым для всех блоков. Это в первую очередь полезно для работы со скалярами и означает, что такой код как np.block([v, 1]) является корректным, где v.ndim == 1.

Когда вложенный список имеет глубину две, это позволяет строить блочные матрицы из их компонентов.

Новое в версии 1.13.0.

Параметры

arraysnested list of array_like or scalars (but not tuples)

Если передан один ndarray или скаляр (вложенный список глубины 0), он возвращается без изменений (и не копируется).

Формы элементов должны совпадать вдоль соответствующих осей (без трансляции), но ведущие 1 будут добавлены к форме по мере необходимости, чтобы сделать размерности одинаковыми.

Возвращает

block_arrayndarray

Массив, собранный из заданных блоков.

Размерность вывода равна максимальной из: * размерности всех входных данных * глубины вложенности входного списка

Возбуждает

ValueError

• Если глубины списков не совпадают - например, [[a, b], c] является незаконным, и должно быть записано как [[a, b], [c]]
• Если списки пусты - например, [[a, b], []]

См. также

concatenate

Объединить последовательность массивов вместе.

stack

Устанавливает массивы в последовательности вдоль нового измерения.

hstack

Устанавливает массивы в последовательности по горизонтали (по столбцам).

vstack

Устанавливает массивы в последовательности по вертикали (по строкам).

dstack

Устанавливает массивы в последовательности по глубине (по третьему измерению).

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([2, 3, 4])
>>> np.block([a, b, 10])             # hstack([a, b, 10])
array([ 1,  2,  3,  2,  3,  4, 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([2, 3, 4])
>>> np.block([[a], [b]])             # vstack([a, b])
array([[1, 2, 3],
       [2, 3, 4]])

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