Транспонирование массива NumPy

Я использую Python и NumPy и у меня есть некоторые проблемы с «transpose»:

import numpy as np
a = np.array([5,4])
print(a)
print(a.T)

Вызов a.Tне транспонирует массив. Если aэто, например, [[],[]]то он правильно транспонирует, но мне нужно транспонировать [...,...,...].

Это работает точно так, как и должно. Транспонирование одномерного массива все еще является одномерным массивом! (Если вы привыкли к matlab, у него принципиально нет концепции одномерного массива. Матрицы "1D" в Matlab являются двумерными.)

Если вы хотите превратить свой 1D-вектор в 2D-массив, а затем транспонировать его, просто нарежьте его np.newaxis(или Noneони одинаковы, newaxisпросто более читабельно).

import numpy as np
a = np.array([5,4])[np.newaxis]
print(a)
print(a.T)

Вообще говоря, вам не нужно беспокоиться об этом. Добавление дополнительного измерения обычно не то, что вы хотите, если вы просто делаете это по привычке. Numpy автоматически транслирует одномерный массив при выполнении различных вычислений. Обычно нет необходимости различать вектор строки и вектор столбца (ни один из которых не является вектором . Они оба 2D!), Когда вам нужен только вектор.

Используйте две пары скобок вместо одной. Это создает 2D-массив, который можно транспонировать, в отличие от 1D-массива, который вы создаете, если используете одну пару скобок.

import numpy as np    
a = np.array([[5, 4]])
a.T

Более подробный пример:

>>> a = [3,6,9]
>>> b = np.array(a)
>>> b.T
array([3, 6, 9])         #Here it didn't transpose because 'a' is 1 dimensional
>>> b = np.array([a])
>>> b.T
array([[3],              #Here it did transpose because a is 2 dimensional
       [6],
       [9]])

Используйте shapeметод numpy, чтобы увидеть, что здесь происходит:

>>> b = np.array([10,20,30])
>>> b.shape
(3,)
>>> b = np.array([[10,20,30]])
>>> b.shape
(1, 3)

Для одномерных массивов :

a = np.array([1, 2, 3, 4])
a = a.reshape((-1, 1)) # <--- THIS IS IT

print a
array([[1],
       [2],
       [3],
       [4]])

Как только вы поймете, что здесь -1 означает «столько строк, сколько необходимо», я нахожу, что это наиболее читаемый способ «транспонирования» массива. Если ваш массив имеет большую размерность, просто используйте a.T.

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

from numpy import *
v=array([5,4]) ## create a numpy vector
array([v]).T ## transpose a vector into a matrix

Numpy также имеет matrixкласс (см. массив против матрицы ) ...

matrix(v).T ## transpose a vector into a matrix

массив 1D -> матрица столбец / строка:

>>> a=np.array([1,2,4])
>>> a[:, None]    # col
array([[1],
       [2],
       [4]])
>>> a[None, :]    # row, or faster `a[None]`
array([[1, 2, 4]])

И как сказал @ Джо-Kington, вы можете заменить Noneс np.newaxisдля удобства чтения.

Чтобы «транспонировать» 1d массив в 2d столбец, вы можете использовать numpy.vstack:

>>> numpy.vstack(numpy.array([1,2,3]))
array([[1],
       [2],
       [3]])

Это также работает для списков ванили:

>>> numpy.vstack([1,2,3])
array([[1],
       [2],
       [3]])

Вы можете только транспонировать 2D-массив. Вы можете использовать numpy.matrixдля создания 2D-массива. Это на три года позже, но я просто добавляю к возможному набору решений:

import numpy as np
m = np.matrix([2, 3])
m.T

вместо этого используйте arr[:,None]для создания вектора столбца

Транспонирование

x = [[0 1],
     [2 3]]

является

xT = [[0 2],
      [1 3]]

ну код такой:

x = array([[0, 1],[2, 3]]);
np.transpose(x)        

это ссылка для получения дополнительной информации:

http://docs.scipy.org/doc/numpy/reference/generated/numpy.transpose.html

Другое решение .... :-)

import numpy as np

a = [1,2,4]

[1, 2, 4]

b = np.array([a]).T

массив ([[1], [2], [4]])

Я просто объединяю вышеупомянутый пост, надеюсь, это поможет другим сэкономить время:

Массив ниже имеет (2, )размерность, это 1-D массив,

b_new = np.array([2j, 3j])  

Есть два способа транспонировать одномерный массив:

нарежьте его с "np.newaxis" или без.

print(b_new[np.newaxis].T.shape)
print(b_new[None].T.shape)

Другой способ написания выше, без Tоперации.

print(b_new[:, np.newaxis].shape)
print(b_new[:, None].shape)

Обтекание [] или использование np.matrix означает добавление нового измерения.!

print(np.array([b_new]).T.shape)
print(np.matrix(b_new).T.shape)

Как уже упоминалось в некоторых комментариях, транспонирование 1D-массивов - это 1D-массивы, поэтому одним из способов транспонирования 1D-массива будет преобразование массива в матрицу следующим образом:

np.transpose(a.reshape(len(a), 1))

Имя функции в numpyэто column_stack .

>>>a=np.array([5,4])
>>>np.column_stack(a)
array([[5, 4]])

Существует метод, не описанный в ответах, но описанный в документации к этому numpy.ndarray.transposeметоду:

Для одномерного массива это не имеет никакого эффекта, поскольку транспонированный вектор - это просто один и тот же вектор. Чтобы преобразовать одномерный массив в двухмерный вектор-столбец, необходимо добавить дополнительное измерение. np.atleast2d (a) .T достигает этого, как и [:, np.newaxis].

Можно сделать:

import numpy as np
a = np.array([5,4])
print(a)
print(np.atleast_2d(a).T)

Который (IMO) лучше, чем использовать newaxis.

По сути, функция транспонирования состоит в том, чтобы поменять местами форму и шаг массива:

>>> a = np.ones((1,2,3))

>>> a.shape
(1, 2, 3)

>>> a.T.shape
(3, 2, 1)

>>> a.strides
(48, 24, 8)

>>> a.T.strides
(8, 24, 48)

В случае одномерного массива 1D (массив ранга 1) форма и шаги являются кортежами из 1 элемента и не могут быть заменены, и транспонирование такого массива 1D возвращает его без изменений. Вместо этого вы можете (1, n)преобразовать «вектор- строку» (массив фигур ) в «вектор-столбец» (массив фигур (n, 1)). Чтобы достичь этого, вы должны сначала преобразовать свой массив 1D Numpy в вектор-строку, а затем поменять местами форму и шаг (переставить его). Ниже приведена функция, которая делает это:

from numpy.lib.stride_tricks import as_strided

def transpose(a):
    a = np.atleast_2d(a)
    return as_strided(a, shape=a.shape[::-1], strides=a.strides[::-1])

Пример:

>>> a = np.arange(3)
>>> a
array([0, 1, 2])

>>> transpose(a)
array([[0],
       [1],
       [2]])

>>> a = np.arange(1, 7).reshape(2,3)
>>> a     
array([[1, 2, 3],
       [4, 5, 6]])

>>> transpose(a)
array([[1, 4],
       [2, 5],
       [3, 6]])

Конечно, вам не нужно делать это таким образом, поскольку у вас есть одномерный массив, и вы можете напрямую преобразовать его в (n, 1)массив с помощью a.reshape((-1, 1))или a[:, None]. Я просто хотел продемонстрировать, как работает транспонирование массива.

Как я научился реализовывать это в компактной и удобочитаемой форме для 1-D массивов:

h = np.array([1,2,3,4,5])

v1 = np.vstack(h)
v2 = np.c_[h]

h1 = np.hstack(v1)
h2 = np.r_[v2[:,0]]

numpy.r_ и numpy.c_ переводят объекты среза в конкатенацию по первой и второй осям соответственно. Следовательно, разрезание v2 [:, 0] при перемещении обратно вертикального массива v2 в горизонтальный массив h2

numpy.vstack эквивалентен конкатенации вдоль первой оси после того, как одномерные массивы формы (N,) были преобразованы в (1, N). Восстанавливает массивы, разделенные на всплит .