numpy.block#

numpy.блок(массивы)[источник]#

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

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

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

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

Параметры:

массивывложенный список array_like или скаляров (но не кортежей)

Если передан один 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: Разделить массив на несколько подмассивов по вертикали (по строкам).
unstack: Разделение массива на кортеж подмассивов вдоль оси.

Примечания

При вызове только со скалярами, 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, ...]]).

Примеры

Наиболее частое использование этой функции — построение блочной матрицы:

>>> import numpy as np
>>> 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]])