numpy.block

numpy.block(arrays) [source]

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

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

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

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

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

Параметры:	arrays : nested list of array_like or scalars (but not tuples) Если передан единственный 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]])