Trasposizione di un array NumPy

Uso Python e NumPy e ho dei problemi con "transpose":

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

Il richiamo a.Tnon sta trasponendo l'array. Se aè per esempio, [[],[]]allora traspone correttamente, ma ho bisogno del recepimento di [...,...,...].

Funziona esattamente come dovrebbe. La trasposizione di un array 1D è ancora un array 1D ! (Se sei abituato a matlab, fondamentalmente non ha un concetto di array 1D. Gli array "1D" di Matlab sono 2D.)

Se vuoi trasformare il tuo vettore 1D in un array 2D e poi trasporlo, taglialo con np.newaxis(o None, sono gli stessi, newaxisè solo più leggibile).

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

In generale, però, non devi mai preoccuparti di questo. Aggiungere la dimensione extra di solito non è quello che vuoi, se lo fai solo per abitudine. Numpy trasmetterà automaticamente un array 1D quando esegue vari calcoli. Di solito non è necessario distinguere tra un vettore di riga e un vettore di colonna (nessuno dei due sono vettori . Sono entrambi in 2D!) Quando si desidera solo un vettore.

Utilizzare due coppie di parentesi anziché una. Questo crea un array 2D, che può essere trasposto, diversamente dall'array 1D che crei se usi una coppia di parentesi.

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

Esempio più approfondito:

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

Usa il shapemetodo numpy per vedere cosa sta succedendo qui:

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

Per array 1D :

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

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

Una volta compreso che -1 qui significa "tutte le righe necessarie", trovo che questo sia il modo più leggibile di "trasporre" un array. Se il tuo array ha una dimensionalità superiore, utilizza semplicemente a.T.

Puoi convertire un vettore esistente in una matrice avvolgendolo in un set aggiuntivo di parentesi quadre ...

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

numpy ha anche una matrixclasse (vedi array vs. matrice ) ...

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

matrice 1D intorpidita -> matrice colonna / riga:

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

E come ha detto @ joe-kington, puoi sostituirlo Nonecon np.newaxisper leggibilità.

Per 'trasporre' un array 1d in una colonna 2d, puoi usare numpy.vstack:

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

Funziona anche con elenchi di vaniglia:

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

È possibile trasporre solo un array 2D. È possibile utilizzare numpy.matrixper creare un array 2D. Sono in ritardo di tre anni, ma sto solo aggiungendo alla possibile serie di soluzioni:

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

utilizzare invece arr[:,None]per creare il vettore di colonna

Il recepimento di

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

è

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

bene il codice è:

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

questo un link per ulteriori informazioni:

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

Un'altra soluzione .... :-)

import numpy as np

a = [1,2,4]

[1, 2, 4]

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

array ([[1], [2], [4]])

Sto solo consolidando il post sopra, spero che possa aiutare gli altri a risparmiare un po 'di tempo:

L'array di seguito ha (2, )dimensione, è un array 1-D,

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

Esistono due modi per trasporre un array 1-D:

taglialo con "np.newaxis" o nessuno.!

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

altro modo di scrivere, quanto sopra senza Toperazione.!

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

Avvolgere [] o usare np.matrix significa aggiungere una nuova dimensione.!

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

Come alcuni dei commenti sopra menzionati, la trasposizione degli array 1D è array 1D, quindi un modo per trasporre un array 1D sarebbe quello di convertire l'array in una matrice in questo modo:

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

Il nome della funzione in numpyè column_stack .

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

Esiste un metodo non descritto nelle risposte ma descritto nella documentazione per il numpy.ndarray.transposemetodo:

Per un array 1-D questo non ha alcun effetto, poiché un vettore trasposto è semplicemente lo stesso vettore. Per convertire un array 1-D in un vettore di colonna 2D, è necessario aggiungere una dimensione aggiuntiva. np.atleast2d (a) .T ottiene questo, così come un [:, np.newaxis].

Si può fare:

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

Quale (imo) è più bello dell'uso newaxis.

Fondamentalmente ciò che la funzione di trasposizione fa è scambiare la forma e i passi dell'array:

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

Nel caso di array numpy 1D (array di rango 1) la forma e i passi sono tuple a 1 elemento e non possono essere scambiati, e la trasposizione di tale array 1D lo restituisce invariato. Invece, puoi trasporre un "vettore di riga" (matrice numpy di forma (1, n)) in un "vettore di colonna" (matrice numpy di forma (n, 1)). Per raggiungere questo obiettivo, devi prima convertire l'array numpy 1D in vettore riga e quindi scambiare la forma e i passi (trasponilo). Di seguito è una funzione che lo fa:

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

Esempio:

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

Ovviamente non è necessario farlo in questo modo poiché si dispone di un array 1D e è possibile rimodellarlo direttamente in (n, 1)array con a.reshape((-1, 1))o a[:, None]. Volevo solo dimostrare come funziona la trasposizione di un array.

Finora ho imparato a implementarlo in modo compatto e leggibile per gli array 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_ e numpy.c_ traducono gli oggetti slice in concatenazione rispettivamente lungo il primo e il secondo asse. Pertanto lo slicing v2 [:, 0] nel trasporre l'array verticale v2 nell'array orizzontale h2

numpy.vstack è equivalente alla concatenazione lungo il primo asse dopo che le matrici 1-D di forma (N,) sono state rimodellate in (1, N). Ricostruisce le matrici divise per vsplit .