Transponieren eines NumPy-Arrays

Ich benutze Python und NumPy und habe einige Probleme mit "transponieren":

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

Beim Aufrufen a.Twird das Array nicht transponiert. Wenn azum Beispiel, [[],[]]dann transponiert es richtig, aber ich brauche die Transponierung von [...,...,...].

Es funktioniert genau so, wie es soll. Die Transponierung eines 1D- Arrays ist immer noch ein 1D- Array! (Wenn Sie an Matlab gewöhnt sind, gibt es grundsätzlich kein Konzept für ein 1D-Array. Matlabs "1D" -Arrays sind 2D.)

Wenn Sie Ihren 1D-Vektor in ein 2D-Array verwandeln und dann transponieren möchten, schneiden Sie ihn einfach mit np.newaxis(oder None, sie sind gleich, newaxissind nur besser lesbar).

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

Im Allgemeinen müssen Sie sich darüber jedoch nie Sorgen machen. Das Hinzufügen der zusätzlichen Dimension ist normalerweise nicht das, was Sie wollen, wenn Sie es nur aus Gewohnheit tun. Numpy sendet automatisch ein 1D-Array, wenn verschiedene Berechnungen durchgeführt werden. Normalerweise müssen Sie nicht zwischen einem Zeilenvektor und einem Spaltenvektor unterscheiden (keiner davon ist ein Vektor . Beide sind 2D!), Wenn Sie nur einen Vektor möchten.

Verwenden Sie zwei Klammerpaare anstelle von einem. Dadurch wird ein 2D-Array erstellt, das im Gegensatz zu dem 1D-Array, das Sie erstellen, wenn Sie ein Klammerpaar verwenden, transponiert werden kann.

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

Gründlicheres Beispiel:

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

Verwenden Sie die shapeMethode von numpy, um zu sehen, was hier vor sich geht:

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

Für 1D-Arrays :

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

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

Sobald Sie verstehen, dass -1 hier "so viele Zeilen wie nötig" bedeutet, ist dies für mich die am besten lesbare Methode, ein Array zu "transponieren". Wenn Ihr Array eine höhere Dimensionalität aufweist, verwenden Sie einfach a.T.

Sie können einen vorhandenen Vektor in eine Matrix konvertieren, indem Sie ihn in einen zusätzlichen Satz eckiger Klammern setzen ...

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

numpy hat auch eine matrixKlasse (siehe Array vs. Matrix ) ...

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

numpy 1D Array -> Spalten- / Zeilenmatrix:

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

Und wie @ joe-kington sagte, können Sie ersetzen Nonemit np.newaxiszur besseren Lesbarkeit.

Um ein 1d-Array in eine 2d-Spalte zu transponieren, können Sie Folgendes verwenden numpy.vstack:

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

Es funktioniert auch für Vanille-Listen:

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

Sie können nur ein 2D-Array transponieren. Sie können numpy.matrixdamit ein 2D-Array erstellen. Dies ist drei Jahre zu spät, aber ich füge nur die möglichen Lösungen hinzu:

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

Verwenden Sie stattdessen arr[:,None], um einen Spaltenvektor zu erstellen

Die Transponierung von

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

ist

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

Nun, der Code lautet:

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

Dies ist ein Link für weitere Informationen:

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

Eine andere Lösung.... :-)

import numpy as np

a = [1,2,4]

[1, 2, 4]

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

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

Ich konsolidiere nur den obigen Beitrag und hoffe, dass er anderen hilft, Zeit zu sparen:

Das folgende Array hat eine (2, )Dimension, es ist ein 1-D-Array,

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

Es gibt zwei Möglichkeiten, ein 1-D-Array zu transponieren:

schneide es mit "np.newaxis" oder keiner.!

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

andere Schreibweise, die oben ohne TOperation.!

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

Das Umschließen von [] oder die Verwendung von np.matrix bedeutet das Hinzufügen einer neuen Dimension.!

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

Wie einige der oben erwähnten Kommentare zeigen, handelt es sich bei der Transponierung von 1D-Arrays um 1D-Arrays. Eine Möglichkeit zum Transponieren eines 1D-Arrays besteht darin, das Array in eine Matrix wie folgt umzuwandeln:

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

Der Name der Funktion in numpylautet column_stack .

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

Es gibt eine Methode, die nicht in den Antworten, sondern in der Dokumentation der numpy.ndarray.transposeMethode beschrieben ist:

Für ein 1-D-Array hat dies keine Auswirkung, da ein transponierter Vektor einfach der gleiche Vektor ist. Um ein 1-D-Array in einen 2D-Spaltenvektor zu konvertieren, muss eine zusätzliche Dimension hinzugefügt werden. np.atleast2d (a) .T erreicht dies ebenso wie a [:, np.newaxis].

Man kann tun:

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

Welches (imo) ist schöner als zu verwenden newaxis.

Grundsätzlich besteht die Transponierungsfunktion darin, die Form und die Schritte des Arrays zu vertauschen:

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

Im Fall eines 1D-Numpy-Arrays (Rang-1-Array) sind Form und Schritte 1-Element-Tupel und können nicht ausgetauscht werden, und die Transponierung eines solchen 1D-Arrays gibt sie unverändert zurück. Stattdessen können Sie einen "Zeilenvektor" (numpy Array of Shape (1, n)) in einen "Spaltenvektor" (numpy Array of Shape (n, 1)) transponieren . Um dies zu erreichen, müssen Sie zuerst Ihr 1D-Numpy-Array in einen Zeilenvektor konvertieren und dann die Form und die Schritte vertauschen (transponieren). Unten ist eine Funktion, die es tut:

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

Beispiel:

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

Natürlich müssen Sie dies nicht auf diese Weise tun, da Sie ein 1D-Array haben und es (n, 1)durch a.reshape((-1, 1))oder direkt in ein Array umformen können a[:, None]. Ich wollte nur zeigen, wie das Transponieren eines Arrays funktioniert.

So habe ich bisher gelernt, dies für 1-D-Arrays kompakt und lesbar zu implementieren:

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_ und numpy.c_ übersetzen Slice-Objekte in Verkettung entlang der ersten bzw. zweiten Achse. Daher das Schneiden v2 [:, 0] beim Zurücktransponieren des vertikalen Arrays v2 in das horizontale Array h2

numpy.vstack entspricht der Verkettung entlang der ersten Achse, nachdem 1-D-Arrays der Form (N,) in (1, N) umgeformt wurden. Erstellt durch vsplit geteilte Arrays neu .