Een 1D NumPy-array transponeren

Ik gebruik Python en NumPy en heb wat problemen met “transponeren”:

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

Het aanroepen van a.Ttransponeert de array niet. Als abijvoorbeeld [[],[]]is, dan transponeert het correct, maar ik heb het transponeren van [...,...,...].

Antwoord 1, autoriteit 100%

Het werkt precies zoals het hoort. Het transponeren van een 1Darray is nog steeds een 1Darray! (Als je gewend bent aan matlab, heeft het in principe geen concept van een 1D-array. De “1D” -arrays van Matlab zijn 2D.)

Als u uw 1D-vector in een 2D-array wilt veranderen en deze vervolgens wilt transponeren, snijdt u deze in plakjes met np.newaxis(of None, ze zijn hetzelfde , newaxisis gewoon beter leesbaar).

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

Over het algemeen hoeft u zich hier echter nooit zorgen over te maken. Het toevoegen van de extra dimensie is meestal niet wat je wilt, als je het gewoon uit gewoonte doet. Numpy zal automatisch een 1D-array uitzenden bij het uitvoeren van verschillende berekeningen. Het is meestal niet nodig om onderscheid te maken tussen een rijvector en een kolomvector (die geen van beide vectorenzijn. Ze zijn beide 2D!) als je alleen een vector wilt.

Antwoord 2, autoriteit 59%

Gebruik twee paar haakjes in plaats van één. Dit creëert een 2D-array die kan worden getransponeerd, in tegenstelling tot de 1D-array die u maakt als u één paar haakjes gebruikt.

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

Uitgebreider voorbeeld:

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

Gebruik numpy’s shapemethode om te zien wat hier aan de hand is:

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

Antwoord 3, Autoriteit 37%

voor 1D-arrays :

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

Als u eenmaal begrijpt dat -1 hier “zoveel rijen als nodig” betekent, vind ik dit de meest leesbare manier om een ​​array te transponeren. Als uw array van een hogere dimensionaliteit is, gebruikt u gewoon a.T.

Antwoord 4, Autoriteit 7%

U kunt een bestaande vector omzetten in een matrix door deze in een extra set vierkante haakjes te wikkelen …

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

Numpy heeft ook een matrixklasse (zie array versus matrix ) …

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

Antwoord 5, autoriteit 5%

numpy 1D-array –> kolom/rij matrix:

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

En zoals @joe-kington al zei, je kunt Nonevervangen door np.newaxisvoor de leesbaarheid.

Antwoord 6, autoriteit 4%

Als u een 1D-array wilt ‘transponeren’ naar een 2D-kolom, kunt u numpy.vstack:

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

Het werkt ook voor vanillelijsten:

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

Antwoord 7

Je kunt alleen een 2D-array transponeren. U kunt numpy.matrixgebruiken om een 2D-array te maken. Dit is drie jaar te laat, maar ik voeg alleen maar toe aan de mogelijke reeks oplossingen:

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

Antwoord 8

gebruik in plaats daarvan arr[:,None]om een kolomvector te maken

Antwoord 9

Een andere oplossing… 🙂

import numpy as np
a = [1,2,4]

[1, 2, 4]

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

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

Antwoord 10

Wat de transponeerfunctie eigenlijk doet, is de vorm en stappen van de array omwisselen:

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

In het geval van een 1D numpy-array (rang-1-array) zijn de vorm en stappen 1-element-tupels en kunnen ze niet worden verwisseld, en de transponering van zo’n 1D-array geeft deze ongewijzigd terug. In plaats daarvan kun je een “rij-vector” (numpy array van vorm (1, n)) transponeren in een “column-vector” (numpy array van vorm (n, 1)). Om dit te bereiken, moet je eerst je 1D numpy-array converteren naar rij-vector en vervolgens de vorm en passen verwisselen (transponeren). Hieronder is een functie die dit doet:

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

Voorbeeld:

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

Natuurlijk hoeft u dit niet op deze manier te doen, aangezien u een 1D-array hebt en u deze direct kunt omvormen tot een (n, 1)-array door a.reshape((-1, 1))of a[:, None]. Ik wilde alleen laten zien hoe het transponeren van een array werkt.

Antwoord 11

Ik consolideer alleen het bovenstaande bericht, ik hoop dat het anderen zal helpen om wat tijd te besparen:

De onderstaande array heeft een (2, )dimensie, het is een 1-D array,

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

Er zijn twee manieren om een 1-D array te transponeren:

snijd het met “np.newaxis” of geen.!

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

andere manier van schrijven, het bovenstaande zonder Tbewerking.!

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

Inpakken [ ] of np.matrix gebruiken, betekent een nieuwe dimensie toevoegen.!

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

Antwoord 12

Het transponeren van

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

is

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

Nou, de code is:

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

Of de eenvoudige manier:

x.T     

dit is een link voor meer informatie: http:// docs.scipy.org/doc/numpy/reference/generated/numpy.transpose.html

** Het transponeren van een 1-D-array geeft een ongewijzigd beeld van de oorspronkelijke array. Probeer dit voor 1D-array:

b = np.array([a])

Antwoord 13

Zoals sommige van de hierboven genoemde opmerkingen, zijn de transponering van 1D-arrays 1D-arrays, dus een manier om een 1D-array te transponeren zou zijn om de array als volgt naar een matrix te converteren:

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

Antwoord 14

De naam van de functie in numpyis column_stack.

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

Antwoord 15

Er is een methode die niet wordt beschreven in de antwoorden, maar wordt beschreven in de documentatievoor de numpy.ndarray.transposemethode:

Voor een 1-D-array heeft dit geen effect, omdat een getransponeerde vector gewoon dezelfde vector is. Om een 1-D-array om te zetten in een 2D-kolomvector, moet een extra dimensie worden toegevoegd. np.atleast2d(a).T bereikt dit, net als a[:, np.newaxis].

Men kan doen:

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

Welke (IMO) is mooier dan het gebruik van newaxis.

Antwoord 16

De manier waarop ik heb geleerd dit te implementeren op een compacte en leesbare manier voor 1-D-arrays, tot nu toe:

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 _ en Numpy.c _ Vertalen Slice-objecten op respectievelijk aaneenschakeling langs de eerste en tweede as. Daarom de slicing V2 [:, 0] bij het omzetten van de verticale array V2 in de horizontale array H2

Numpy.vstack is gelijk aan de aaneenschakeling langs de eerste as na 1-D-vorm van vorm (N,) zijn opnieuw gevormd tot (1, N). Rebuilds arrays gedeeld door vsplit .