numpy.block

numpy.block(arrays) [source]

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

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

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

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

New in version 1.13.0.

Параметры

arraysnested list of array_like or scalars (but not tuples)

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

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

Возвращает

block_arrayndarray

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

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

Возбуждает

ValueError

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

См. также

concatenate

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

stack

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

vstack

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

hstack

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

dstack

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

column_stack

Уложить массивы 1-D в качестве столбцов в массив 2-D.

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