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