Risposte:
>>> 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)
[row, col]
. la virgola si separa.
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]
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]
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
a2 = zip(*a); a2 = list(a2); a2[0]
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.
>>> 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])
arange()
Python3 al di fuori di numpy. Chiunque?
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)
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.
diciamo che abbiamo una n X m
matrice ( n
righe e m
colonne) 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] ]
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]
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]
)
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)
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]
Preferisco il suggerimento successivo: avere la matrice denominata matrix_a
e 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]
Basta usare transpose (), quindi è possibile ottenere le colonne come è facile ottenere righe
matrix=np.array(originalMatrix).transpose()
print matrix[NumberOfColum]
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) ]