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_arrayndarray

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

Размерность выходного значения равна наибольшей из:

• размерности всех входов
• глубины вложения входного списка

Исключения:

ValueError

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

См. также

concatenate

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

stack

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

vstack

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

hstack

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

dstack

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

column_stack

Упорядочить одномерные массивы как столбцы в двумерный массив.

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([4, 5, 6])
>>> np.block([a, b, 10])             # hstack([a, b, 10])
array([ 1,  2,  3,  4,  5,  6, 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([4, 5, 6])
>>> np.block([[a], [b]])             # vstack([a, b])
array([[1, 2, 3],
       [4, 5, 6]])

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