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