Comment extraire une colonne d'un tableau multidimensionnel?

Quelqu'un sait-il 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: (Allocation d'un tableau avec mise en forme de matrice (3x4))

nrows = 3
ncols = 4
my_array = numpy.arange(nrows*ncols, dtype='double')
my_array = my_array.reshape(nrows, ncols)

Serait-ce que vous utilisez un tableau NumPy ? Python a le module tableau , mais cela ne prend pas en charge les tableaux multidimensionnels. Les listes Python normales sont également unidimensionnelles.

Cependant, si vous avez une simple liste bidimensionnelle comme celle-ci:

A = [[1,2,3,4],
     [5,6,7,8]]

alors vous pouvez extraire une colonne comme celle-ci:

def column(matrix, i):
    return [row[i] for row in matrix]

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

Le résultat ressemble donc à 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 propre le zip fait le travail mais nécessite des tableaux simples comme arguments, la syntaxe * a décompresse le tableau multidimensionnel en arguments de 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 de carte en Python est une autre façon de procéder.

>>> 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 que vous pouvez utiliser

>>> x[:, 1]
array([ 1,  6, 11, 16])

[matrix[i][column] for i in range(len(matrix))]

L'opérateur itemgetter peut également vous aider, si vous aimez le python de style de réduction de carte, plutôt que les compréhensions 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 également l'utiliser:

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

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 au 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 par élément comme vous le feriez dans Excel.

disons que nous avons une n X mmatrice ( nlignes et mcolonnes) 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 la 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] ]

array = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]

col1 = [val[1] for val in array]
col2 = [val[2] for val in array]
col3 = [val[3] for val in array]
col4 = [val[4] for val in array]
print(col1)
print(col2)
print(col3)
print(col4)

Output:
[1, 5, 9, 13]
[2, 6, 10, 14]
[3, 7, 11, 15]
[4, 8, 12, 16]

Une autre façon d'utiliser les 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])

Si vous avez un tableau à deux dimensions en Python (pas numpy), vous pouvez extraire toutes les colonnes comme ça,

data = [
['a', 1, 2], 
['b', 3, 4], 
['c', 5, 6]
]

columns = list(zip(*data))

print("column[0] = {}".format(columns[0]))
print("column[1] = {}".format(columns[1]))
print("column[2] = {}".format(columns[2]))

L'exécution de ce code donnera,

>>> print("column[0] = {}".format(columns[0]))
column[0] = ('a', 'b', 'c')

>>> print("column[1] = {}".format(columns[1]))
column[1] = (1, 3, 5)

>>> print("column[2] = {}".format(columns[2]))
column[2] = (2, 4, 6)

Bien sûr, vous pouvez extraire une seule colonne par index (par exemple columns[0])

Bien que vous utilisiez zip(*iterable)pour transposer une liste imbriquée, vous pouvez également utiliser ce qui suit si les listes imbriquées varient en longueur:

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)

Et bien un peu tard ...

Si les performances sont importantes et que vos données sont de forme rectangulaire, vous pouvez également les stocker dans une seule 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 indices négatifs ne fonctionnent pas ici! Vous ne pouvez donc pas accéder à la dernière colonne ou ligne par l'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]

Si vous voulez saisir plus d'une colonne, utilisez simplement slice:

 a = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
    print(a[:, [1, 2]])
[[2 3]
[5 6]
[8 9]]

Je préfère le conseil suivant: avoir la matrice nommée matrix_aet 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]

Utilisez simplement transpose (), alors vous pouvez obtenir les colonnes aussi facilement que vous obtenez des lignes

matrix=np.array(originalMatrix).transpose()
print matrix[NumberOfColum]

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