Comment extraire une colonne d'un tableau multi-dimensionnel?
Est-ce que quelqu'un sait comment extraire une colonne d'un tableau multidimensionnel en Python?
>>> import numpy as np
>>> A = np.array([[1,2,3,4],[5,6,7,8]])
>>> A
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
>>> A[:,2] # returns the third columm
array([3, 7])
Voir aussi: "numpy.arange" et "remodeler" pour allouer de la mémoire.
Exemple: (Allouer un tableau avec mise en forme de la matrice (3x4))
nrows = 3
ncols = 4
my_array = numpy.arange(nrows*ncols, dtype='double')
my_array = my_array.reshape(nrows, ncols)
Se pourrait-il que vous utilisiez un tableau NumPy ? Python a le module array , mais cela ne supporte pas les tableaux multidimensionnels. Les listes normales Python sont également monodimensionnelles.
Cependant, si vous avez une simple liste à deux dimensions comme celle-ci:
A = [[1,2,3,4],
[5,6,7,8]]
alors vous pouvez extraire une colonne comme ceci:
def column(matrix, i):
return [row[i] for row in matrix]
Extraction de la deuxième colonne (index 1):
>>> column(A, 1)
[2, 6]
Ou bien simplement:
>>> [row[1] for row in A]
[2, 6]
Si vous avez un tableau comme
a = [[1, 2], [2, 3], [3, 4]]
Ensuite, vous extrayez la première colonne comme ça:
[row[0] for row in a]
Donc, le résultat ressemble à ceci:
[1, 2, 3]
vérifiez-le!
a = [[1, 2], [2, 3], [3, 4]]
a2 = Zip(*a)
a2[0]
c'est la même chose que ci-dessus sauf que d'une manière ou d'une autre il est plus net que le Zip fasse le travail mais nécessite des tableaux simples en tant qu'arguments, la syntaxe * a décompresse le tableau multidimensionnel en arguments à tableau unique
def get_col(arr, col):
return map(lambda x : x[col], arr)
a = [[1,2,3,4], [5,6,7,8], [9,10,11,12],[13,14,15,16]]
print get_col(a, 3)
la fonction map dans Python est une autre solution.
>>> x = arange(20).reshape(4,5)
>>> x array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19]])
si vous voulez la deuxième colonne, vous pouvez utiliser
>>> x[:, 1]
array([ 1, 6, 11, 16])
[matrix[i][column] for i in range(len(matrix))]
L'opérateur itemgetter peut aussi vous aider, si vous aimez le style python de type carte réduit, plutôt que la compréhension de liste, pour un peu de variété!
# tested in 2.4
from operator import itemgetter
def column(matrix,i):
f = itemgetter(i)
return map(f,matrix)
M = [range(x,x+5) for x in range(10)]
assert column(M,1) == range(1,11)
Vous pouvez aussi utiliser ceci:
values = np.array([[1,2,3],[4,5,6]])
values[...,0] # first column
#[1,4]
Remarque: cela ne fonctionne pas pour le tableau intégré et n'est pas aligné (par exemple, np.array ([[1,2,3], [4,5,6,7]]))
disons que nous avons n X m matrice (n lignes et m colonnes) disons 5 lignes et 4 colonnes
matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16],[17,18,19,20]]
Pour extraire les colonnes en python, nous pouvons utiliser une compréhension de liste comme celle-ci
[ [row[i] for row in matrix] for in range(4) ]
Vous pouvez remplacer 4 par le nombre de colonnes de votre matrice. Le résultat est
[ [1,5,9,13,17],[2,10,14,18],[3,7,11,15,19],[4,8,12,16,20] ]
Je pense que vous voulez extraire une colonne d'un tableau tel qu'un tableau ci-dessous
import numpy as np
A = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
Maintenant, si vous voulez obtenir la troisième colonne dans le format
D=array[[3],
[7],
[11]]
Ensuite, vous devez d'abord faire du tableau une matrice
B=np.asmatrix(A)
C=B[:,2]
D=asarray(C)
Et maintenant, vous pouvez faire des calculs élémentaires comme vous le feriez dans Excel.
Une autre façon d'utiliser des matrices
>>> from numpy import matrix
>>> a = [ [1,2,3],[4,5,6],[7,8,9] ]
>>> matrix(a).transpose()[1].getA()[0]
array([2, 5, 8])
>>> matrix(a).transpose()[0].getA()[0]
array([1, 4, 7])
Eh bien un peu en retard ...
Si les performances importent et que vos données ont une forme rectangulaire, vous pouvez également les stocker dans une dimension et accéder aux colonnes par découpage régulier, par exemple. ...
A = [[1,2,3,4],[5,6,7,8]] #< assume this 4x2-matrix
B = reduce( operator.add, A ) #< get it one-dimensional
def column1d( matrix, dimX, colIdx ):
return matrix[colIdx::dimX]
def row1d( matrix, dimX, rowIdx ):
return matrix[rowIdx:rowIdx+dimX]
>>> column1d( B, 4, 1 )
[2, 6]
>>> row1d( B, 4, 1 )
[2, 3, 4, 5]
La chose intéressante est que c'est vraiment rapide. Cependant, les index négatifs ne fonctionnent pas ici! Donc, vous ne pouvez pas accéder à la dernière colonne ou ligne par index -1.
Si vous avez besoin d’une indexation négative, vous pouvez régler un peu les fonctions d’accesseur, par exemple:.
def column1d( matrix, dimX, colIdx ):
return matrix[colIdx % dimX::dimX]
def row1d( matrix, dimX, dimY, rowIdx ):
rowIdx = (rowIdx % dimY) * dimX
return matrix[rowIdx:rowIdx+dimX]
Je préfère le conseil suivant: avoir la matrice nommée matrix_a et utiliser column_number, par exemple:
import numpy as np
matrix_a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
column_number=2
# you can get the row from transposed matrix - it will be a column:
col=matrix_a.transpose()[column_number]
Bien que vous utilisiez Zip(*iterable) pour transposer une liste imbriquée, vous pouvez également utiliser les éléments suivants si la longueur des listes imbriquées varie:
map(None, *[(1,2,3,), (4,5,), (6,)])
résulte en:
[(1, 4, 6), (2, 5, None), (3, None, None)]
La première colonne est donc:
map(None, *[(1,2,3,), (4,5,), (6,)])[0]
#>(1, 4, 6)
Toutes les colonnes d'une matrice dans une nouvelle liste:
N = len(matrix)
column_list = [ [matrix[row][column] for row in range(N)] for column in range(N) ]
Si vous voulez récupérer plus d'une colonne, utilisez slice:
a = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
print(a[:, [1, 2]])
[[2 3]
[5 6]
[8 9]]