numpy.reshape

numpy.reshape(a, newshape, order='C')

Функция reshape() изменяет форму массива без изменения его данных.

Данная функция аналогична методу базового класса ndarray.reshape(), который, в общем-то удобней, так как позволяет задавать форму числами, а не кортежем чисел. Однако, если вам необходимо передавать форму в виде кортежа, то придется использовать numpy.reshape().

Параметры:
а - подобный массиву объект
Массив, форму которого необходимо изменить.
newshape - целое число или кортеж целых чисел
Определяет форму выходного массива. Указанный параметр должен быть совместим с формой исходного массива. Целое число сжимает исходный массив до одной оси. Одно из измерений может быть равно -1, что приводит к автоматическому вычислению длинны оси.
order - 'C' или 'F' (необязательный)
Этот параметр определяет в каком порядке массивы должны храниться в памяти: строчном C-стиле или столбчатом стиле Fortran; флаг 'A' установит макет памяти выходного массива в 'F' если массив a является смежным со столбчатым стилем Fortran, в противном случае макет памяти будет установлен в 'C'. По умолчанию флаг установлен в значение 'С'.
Возвращает:
ndarray - массив NumPy
Массив с исходными данными, но новой формой. Возвращаемый массив, если это возможно, является представлением исходного массива, в противном случае, происходит полное копирование данных.
Смотрите так же: resize, ravel, ndarray.flat, ndarray.T

Замечание

Нет гарантии, того что макет массива в памяти будет сохранен, т.е. стиль 'C' может измениться на 'F' и наоборот. Дело в том, что по умолчанию параметр order установлен в значение C т.е. чтение данных исходного массива выполняется "построчно" (индекс первой оси меняется медленнее чем последней). Если исходный массив организован в памяти в стиле Fortran, при котором чтение данных массива выполняется "по столбцам" (индекс первой оси меняется быстрее чем последней), а order = 'С', то данные которые должны быть прочитаны "по столбцам" будут считаны "построчно", что приведет к транспонированию (транспозиционированию) элементов исходного массива.

>>> a = np.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]], order = 'C')
>>> a
array([[1, 1, 1, 1],
       [2, 2, 2, 2],
       [3, 3, 3, 3]])
>>>
>>> np.reshape(a, (4, 3))    #  чтение по строкам
array([[1, 1, 1],
       [1, 2, 2],
       [2, 2, 3],
       [3, 3, 3]])
>>> 
>>> np.reshape(a, (4, 3), order = 'F')    #  чтение по столбцам
array([[1, 2, 3],
       [2, 3, 1],
       [3, 1, 2],
       [1, 2, 3]])
>>>
>>>
>>> a = np.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]], order = 'F')
>>> a
array([[1, 1, 1, 1],
       [2, 2, 2, 2],
       [3, 3, 3, 3]])
>>>
>>> np.reshape(a, (4, 3), order = 'F')
array([[1, 2, 3],
       [2, 3, 1],
       [3, 1, 2],
       [1, 2, 3]])
>>>
>>> np.reshape(a, (4, 3), order = 'C')
array([[1, 1, 1],
       [1, 2, 2],
       [2, 2, 3],
       [3, 3, 3]])

Флаг 'A' автоматически установит порядок чтения исходя из того в каком порядке массив хранится в памяти. Если это Fortran-смежный массив, то чтение данных будет "по столбцам", если C-смежный, то чтение будет построчным.

ndarray.reshape()

Базовый класс ndarray обладает полностью аналогичным методом, который отличается от reshape тем, что позволяет передавать новые размеры в виде отдельных аргументов, а не кортежа:

>>> a = np.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]])
>>> 
>>> np.reshape(a, (2, 6))
array([[1, 1, 1, 1, 2, 2],
       [2, 2, 3, 3, 3, 3]])
>>> 
>>> a.reshape(2, 6)
array([[1, 1, 1, 1, 2, 2],
       [2, 2, 3, 3, 3, 3]])
>>> 
>>> a.reshape(2, 6, order = 'F')
array([[1, 3, 2, 1, 3, 2],
       [2, 1, 3, 2, 1, 3]])


Примеры


>>> import numpy as np
>>> 
>>> a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> 
>>> np.reshape(a, (3, 3))
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> 
>>> b = np.reshape(a, (3, 3))
>>> 
>>> b     #  'b' это представление массива 'a'
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> 
>>> a[0] = 99     #  Изменения в 'a'
>>> a
array([99,  2,  3,  4,  5,  6,  7,  8,  9])
>>> 
>>> b    # повлекут изменения в 'b'
array([[99,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9]])
>>> 
>>> 
>>> a = np.ones((4, 4))
>>> a
array([[ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.]])
>>> 
>>> b = np.reshape(a, (2, -1))
>>> b    #  Длинна второй оси вычислена автоматически
array([[ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.]])