Come si estrae una colonna da un array multidimensionale?


Risposte:


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

Vedi anche: "numpy.arange" e "reshape" per allocare memoria

Esempio: (Allocazione di una matrice con modellatura della matrice (3x4))

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

8
Mi ci sono volute 2 ore per scoprire [:, 2] indovinare questa funzione non nella letteratura ufficiale sull'affettatura?
niken,

Cosa significa la virgola?
Phil

3
@Phil [row, col]. la virgola si separa.
AsheKetchum,

11
Come può questa risposta avere così tanti voti positivi? OP non ha mai detto che è un array
insensibile

3
per estrarre 2 colonne: A [:, [1,3]] per esempio estrarre la seconda e la quarta colonna
sadalsuud,

177

Potrebbe essere che stai usando un array NumPy ? Python ha il modulo array , ma questo non supporta array multidimensionali. Anche gli elenchi Python normali sono monodimensionali.

Tuttavia, se si dispone di un semplice elenco bidimensionale come questo:

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

quindi puoi estrarre una colonna come questa:

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

Estrazione della seconda colonna (indice 1):

>>> column(A, 1)
[2, 6]

O in alternativa, semplicemente:

>>> [row[1] for row in A]
[2, 6]

80

Se hai un array come

a = [[1, 2], [2, 3], [3, 4]]

Quindi estrai la prima colonna in questo modo:

[row[0] for row in a]

Quindi il risultato è simile al seguente:

[1, 2, 3]

38

controlla!

a = [[1, 2], [2, 3], [3, 4]]
a2 = zip(*a)
a2[0]

è la stessa cosa di cui sopra, tranne per il fatto che in qualche modo è più ordinata la zip fa il lavoro ma richiede matrici singole come argomenti, la sintassi * a decomprime l'array multidimensionale in argomenti a array singolo


7
Cosa c'è sopra? Ricorda che le risposte non sono sempre ordinate allo stesso modo.
Muhd,

2
Questo è pulito, ma potrebbe non essere il più efficiente se le prestazioni sono un problema, poiché traspone l'intera matrice.
IceArdor

6
Cordiali saluti, questo funziona in Python 2, ma in Python 3 otterrai l'oggetto generatore, che ovviamente non è sottoscrivibile.
Rishabh Agrahari,

@RishabhAgrahari Comunque per fare questo zip in Py3?
CtrlAltF2

2
@WarpDriveEnterprises yup, dovrai convertire l'oggetto del generatore in elenco e poi fare la sottoscrizione. esempio:a2 = zip(*a); a2 = list(a2); a2[0]
Rishabh Agrahari

14
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 funzione mappa in Python è un'altra strada da percorrere.


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

se vuoi la seconda colonna puoi usare

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

1
Questo sta usando numpy?
sempre il

1
Non riesco a trovare alcuna documentazione per arange()Python3 al di fuori di numpy. Chiunque?
Kevin W Matthews,

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

9

Anche l'operatore itemgetter può essere d'aiuto, se ti piace lo stile pitone riduttore di mappe, piuttosto che la comprensione dell'elenco, per una piccola varietà!

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

1
usa itertools.imap per dati di grandi dimensioni
Paweł Polewicz,

L'approccio itemgetter ha funzionato circa 50 volte più velocemente dell'approccio alla comprensione dell'elenco per il mio caso d'uso. Python 2.7.2, use case erano molte iterazioni su una matrice con poche centinaia di righe e colonne.
joelpt

7

Puoi usare anche questo:

values = np.array([[1,2,3],[4,5,6]])
values[...,0] # first column
#[1,4]

Nota: questo non funziona per l'array incorporato e non allineato (ad es. Np.array ([[1,2,3], [4,5,6,7]]))


6

Penso che tu voglia estrarre una colonna da una matrice come una matrice di seguito

import numpy as np
A = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])

Ora se vuoi ottenere la terza colonna nel formato

D=array[[3],
[7],
[11]]

Quindi devi prima rendere l'array una matrice

B=np.asmatrix(A)
C=B[:,2]
D=asarray(C)

E ora puoi eseguire calcoli saggi sugli elementi proprio come faresti in Excel.


1
Sebbene ciò mi abbia aiutato molto, penso che la risposta possa essere molto più breve: 1. A = np.array ([[1,2,3,4], [5,6,7,8], [9,10, 11,12]]) 2. A [:, 1] >> array ([2, 6, 10])
Ufo

6

diciamo che abbiamo una n X mmatrice ( nrighe e mcolonne) diciamo 5 righe e 4 colonne

matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16],[17,18,19,20]]

Per estrarre le colonne in Python, possiamo usare la comprensione dell'elenco in questo modo

[ [row[i] for row in matrix] for in range(4) ]

Puoi sostituire 4 con qualunque numero di colonne abbia la tua matrice. Il risultato è

[ [1,5,9,13,17],[2,10,14,18],[3,7,11,15,19],[4,8,12,16,20] ]


Questo crea un elenco completamente nuovo?
Kevin W Matthews,

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

4

Un altro modo usando le matrici

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

3

Se hai una matrice bidimensionale in Python (non numpy), puoi estrarre tutte le colonne in questo modo,

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'esecuzione di questo codice produrrà,

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

Ovviamente, puoi estrarre una singola colonna per indice (ad es. columns[0])


2

Nonostante utilizzi zip(*iterable)per trasporre un elenco nidificato, puoi anche utilizzare quanto segue se gli elenchi nidificati variano in lunghezza:

map(None, *[(1,2,3,), (4,5,), (6,)])

risulta in:

[(1, 4, 6), (2, 5, None), (3, None, None)]

La prima colonna è quindi:

map(None, *[(1,2,3,), (4,5,), (6,)])[0]
#>(1, 4, 6)

2

Beh, un po 'in ritardo ...

Nel caso in cui le prestazioni contino e i tuoi dati siano di forma rettangolare, puoi anche memorizzarli in una dimensione e accedere alle colonne mediante suddivisioni regolari, ad esempio ...

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 cosa bella è che è molto veloce. però , gli indici negativi non funzionano qui! Quindi non puoi accedere all'ultima colonna o riga per indice -1.

Se hai bisogno di indicizzazione negativa puoi regolare un po 'le funzioni accessor, ad es

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]

Ho controllato questo metodo e il costo del recupero della colonna è molto più economico di quello nidificato per i loop. Tuttavia, ridurre una matrice 2d a 1d è costoso se la matrice è grande, diciamo 1000 * 1000.
Zhongjun 'Mark' Jin

2

Se vuoi prendere più di una sola colonna usa solo slice:

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

2

Preferisco il suggerimento successivo: avere la matrice denominata matrix_ae usare column_number, ad esempio:

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]

1

Basta usare transpose (), quindi è possibile ottenere le colonne come è facile ottenere righe

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

0

Tutte le colonne da una matrice in un nuovo elenco:

N = len(matrix) 
column_list = [ [matrix[row][column] for row in range(N)] for column in range(N) ]
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.