numpy.block

numpy.block(arrays) [source]

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

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

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

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

Введено в версии 1.13.0.

Параметры:	arrays : вложенный список array_like или скаляров (но не кортежей) Если передано единственное ndarray или скаляр (вложенный список глубины 0), он возвращается без изменений (и не копируется). Формы элементов должны совпадать вдоль соответствующих осей (без широковещательной передачи), но ведущие 1 будут добавлены к форме по мере необходимости, чтобы сделать размерности одинаковыми.
Возвращает:	block_array : ndarray Массив, собранный из заданных блоков. Размерность выходного значения равна наибольшей из: * размерности всех входов * глубины вложенности входного списка
Возможные исключения:	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]])