Transposer un tableau NumPy

J'utilise Python et NumPy et j'ai quelques problèmes avec "transposer":

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

L'appel a.Tne transpose pas le tableau. Si ac'est par exemple [[],[]]alors il transpose correctement, mais j'ai besoin de la transposition de [...,...,...].

Cela fonctionne exactement comme il est censé le faire. La transposition d'un tableau 1D est toujours un tableau 1D ! (Si vous êtes habitué à matlab, il n'a fondamentalement pas de concept de tableau 1D. Les tableaux "1D" de Matlab sont 2D.)

Si vous souhaitez transformer votre vecteur 1D en un tableau 2D, puis le transposer, découpez-le simplement avec np.newaxis(ou None, ils sont identiques, newaxisc'est juste plus lisible).

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

De manière générale cependant, vous n'avez jamais à vous en soucier. L'ajout d'une dimension supplémentaire n'est généralement pas ce que vous voulez, si vous le faites simplement par habitude. Numpy diffusera automatiquement un tableau 1D lors de divers calculs. Il n'est généralement pas nécessaire de faire la distinction entre un vecteur ligne et un vecteur colonne (ni l'un ni l'autre ne sont des vecteurs . Ils sont tous deux 2D!) Lorsque vous voulez juste un vecteur.

Utilisez deux paires de supports au lieu d'une. Cela crée un tableau 2D, qui peut être transposé, contrairement au tableau 1D que vous créez si vous utilisez une paire de crochets.

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

Exemple plus approfondi:

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

Utilisez la shapeméthode de numpy pour voir ce qui se passe ici:

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

Pour les baies 1D :

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

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

Une fois que vous comprenez que -1 signifie ici "autant de lignes que nécessaire", je trouve que c'est la manière la plus lisible de "transposer" un tableau. Si votre tableau est de dimensionnalité supérieure, utilisez simplement a.T.

Vous pouvez convertir un vecteur existant en matrice en l'enveloppant dans un jeu supplémentaire de crochets ...

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

numpy a aussi une matrixclasse (voir tableau vs matrice ) ...

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

tableau numpy 1D -> matrice colonne / ligne:

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

Et comme @ joe-kington l'a dit, vous pouvez remplacer Nonepar np.newaxispour plus de lisibilité.

Pour 'transposer' un tableau 1d dans une colonne 2d, vous pouvez utiliser numpy.vstack:

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

Cela fonctionne également pour les listes vanille:

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

Vous ne pouvez transposer qu'un tableau 2D. Vous pouvez utilisernumpy.matrix pour créer un tableau 2D. C'est trois ans de retard, mais j'ajoute simplement à l'ensemble possible de solutions:

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

utilisez plutôt arr[:,None]pour créer un vecteur de colonne

La transposition de

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

est

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

eh bien le code est:

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

voici un lien pour plus d'informations:

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

Une autre solution.... :-)

import numpy as np

a = [1,2,4]

[1, 2, 4]

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

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

Je ne fais que consolider le post ci-dessus, j'espère que cela aidera les autres à gagner du temps:

Le tableau ci-dessous a une (2, )dimension, c'est un tableau 1-D,

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

Il existe deux façons de transposer un tableau 1-D:

tranchez-le avec "np.newaxis" ou aucun.!

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

autre manière d'écrire, ce qui précède sans Topération.!

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

Envelopper [] ou utiliser np.matrix, c'est ajouter une nouvelle dimension.!

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

Comme certains des commentaires ci-dessus mentionnés, la transposition des tableaux 1D sont des tableaux 1D, donc une façon de transposer un tableau 1D serait de convertir le tableau en une matrice comme ceci:

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

Le nom de la fonction dans numpyest column_stack .

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

Il existe une méthode non décrite dans les réponses mais décrite dans la documentation de la numpy.ndarray.transposeméthode:

Pour un tableau 1D, cela n'a aucun effet, car un vecteur transposé est simplement le même vecteur. Pour convertir un tableau 1D en vecteur de colonne 2D, une dimension supplémentaire doit être ajoutée. np.atleast2d (a) .T y parvient, tout comme a [:, np.newaxis].

On peut faire:

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

Ce qui (imo) est plus agréable que d'utiliser newaxis.

Fondamentalement, ce que fait la fonction de transposition est d'échanger la forme et les enjambées du tableau:

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

Dans le cas d'un tableau numpy 1D (tableau de rang 1), la forme et les enjambées sont des tuples à 1 élément et ne peuvent pas être échangés, et la transposition d'un tel tableau 1D le renvoie inchangé. Au lieu de cela, vous pouvez transposer un "vecteur-ligne" (tableau numpy de forme (1, n)) en un "vecteur-colonne" (tableau numpy de forme (n, 1)). Pour y parvenir, vous devez d'abord convertir votre tableau numpy 1D en vecteur de ligne, puis permuter la forme et les enjambées (transposer). Voici une fonction qui le fait:

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

Exemple:

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

Bien sûr, vous n'êtes pas obligé de le faire de cette façon puisque vous avez un tableau 1D et vous pouvez directement le remodeler en (n, 1)tableau par a.reshape((-1, 1))ou a[:, None]. Je voulais juste montrer comment la transposition d'un tableau fonctionne.

La façon dont j'ai appris à implémenter cela de manière compacte et lisible pour les tableaux 1-D, jusqu'à présent:

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_ et numpy.c_ traduisent les objets de tranche en concaténation le long du premier et du deuxième axe, respectivement. Donc le slicing v2 [:, 0] en transposant le tableau vertical v2 dans le tableau horizontal h2

numpy.vstack équivaut à la concaténation le long du premier axe après que les tableaux 1-D de forme (N,) ont été remodelés en (1, N). Reconstruit les tableaux divisés par vsplit .