Bagaimana Anda mengekstrak kolom dari array multi dimensi?

Jawaban:

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

Lihat juga: "numpy.arange" dan "membentuk kembali" untuk mengalokasikan memori

Contoh: (Mengalokasikan array dengan membentuk matriks (3x4))

nrows = 3
ncols = 4
my_array = numpy.arange(nrows*ncols, dtype='double')
my_array = my_array.reshape(nrows, ncols)
Andre Luiz
sumber
8
Butuh waktu 2 jam untuk menemukan [:, 2] rasa fitur ini tidak ada dalam literatur resmi tentang pemotongan?
niken
Apa yang dimaksud dengan koma?
Phil
3
@ Phil [row, col]. koma terpisah.
AsheKetchum
11
Bagaimana jawaban ini memiliki begitu banyak upvotes? OP tidak pernah mengatakan itu array numpy
sziraqui
3
untuk mengekstrak 2 kolom: A [:, [1,3]] misalnya mengekstrak kolom kedua dan keempat
sadalsuud
177

Mungkinkah Anda menggunakan array NumPy ? Python memiliki modul array , tetapi itu tidak mendukung array multi-dimensi. Daftar Python normal juga satu dimensi.

Namun, jika Anda memiliki daftar dua dimensi sederhana seperti ini:

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

maka Anda dapat mengekstrak kolom seperti ini:

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

Mengekstrak kolom kedua (indeks 1):

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

Atau sebagai alternatif, cukup:

>>> [row[1] for row in A]
[2, 6]
Martin Geisler
sumber
80

Jika Anda memiliki array seperti

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

Kemudian Anda mengekstrak kolom pertama seperti itu:

[row[0] for row in a]

Jadi hasilnya terlihat seperti ini:

[1, 2, 3]
Andrei Arsenin
sumber
38

saksikan berikut ini!

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

itu adalah hal yang sama seperti di atas kecuali entah bagaimana itu lebih rapi zip melakukan pekerjaan tetapi membutuhkan array tunggal sebagai argumen, sintaks * a membongkar array multidimensi menjadi argumen array tunggal

Mac D
sumber
7
Apa yang diatas? Ingat bahwa jawabannya tidak selalu diurutkan dengan cara yang sama.
Muhd
2
Ini bersih, tetapi mungkin bukan yang paling efisien jika kinerja menjadi perhatian, karena transpos seluruh matriks.
IceArdor
6
FYI, ini bekerja di python 2, tetapi dalam python 3 Anda akan mendapatkan objek generator, yang tentu saja tidak dapat disubkripkan.
Rishabh Agrahari
@RishabhAgrahari Lagi pula untuk melakukan zip ini di Py3?
CtrlAltF2
2
@WarpDriveEnterprises ya, Anda harus mengubah objek generator ke daftar dan kemudian melakukan subskrip. contoh: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)

Fungsi peta dalam Python adalah cara lain untuk pergi.

Peter Paul
sumber
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]])

jika Anda ingin kolom kedua dapat Anda gunakan

>>> x[:, 1]
array([ 1,  6, 11, 16])
simomod
sumber
1
Ini menggunakan numpy?
Foreever
1
Saya tidak dapat menemukan dokumentasi apa pun arange()di Python3 di luar numpy. Siapa saja?
Kevin W Matthews
10
[matrix[i][column] for i in range(len(matrix))]
renatov
sumber
9

Operator itemgetter juga dapat membantu, jika Anda suka gaya peta-pengurangan python, daripada daftar pemahaman, untuk sedikit variasi!

# 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)
Gregg Lind
sumber
1
gunakan itertools.imap untuk data besar
Paweł Polewicz
Pendekatan itemgetter berjalan sekitar 50x lebih cepat dari pendekatan pemahaman daftar untuk kasus penggunaan saya. Python 2.7.2, use case adalah banyak iterasi pada sebuah matriks dengan beberapa ratus baris dan kolom.
joelpt
7

Anda dapat menggunakan ini juga:

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

Catatan: Ini tidak berfungsi untuk array bawaan dan tidak selaras (mis. Np.array ([[1,2,3], [4,5,6,7]]))

Sergey
sumber
6

Saya pikir Anda ingin mengekstrak kolom dari array seperti array di bawah ini

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

Sekarang jika Anda ingin mendapatkan kolom ketiga dalam format

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

Maka Anda harus terlebih dahulu membuat array menjadi matriks

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

Dan sekarang Anda dapat melakukan perhitungan elemen bijaksana seperti yang Anda lakukan di excel.

danielinthelionsden
sumber
1
Walaupun ini banyak membantu saya, saya pikir jawabannya bisa jauh lebih pendek: 1. A = np.array ([[1,2,3,4], [5,6,7,8], [9,10, 11,12]]) 2. A [:, 1] >> array ([2, 6, 10])
Ufos
6

katakanlah kita memiliki n X mmatriks ( nbaris dan mkolom) katakanlah 5 baris dan 4 kolom

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

Untuk mengekstrak kolom dalam python, kita bisa menggunakan daftar pemahaman seperti ini

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

Anda dapat mengganti 4 dengan jumlah kolom berapa pun yang dimiliki matriks Anda. Hasilnya adalah

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

Serge_k
sumber
Apakah ini membuat daftar yang sama sekali baru?
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]
Lee
sumber
4

Satu lagi cara menggunakan matriks

>>> 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])
Shashwat
sumber
3

Jika Anda memiliki array dua dimensi dalam Python (bukan numpy), Anda dapat mengekstrak semua kolom seperti itu,

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

Menjalankan kode ini akan menghasilkan,

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

Tentu saja, Anda dapat mengekstrak satu kolom berdasarkan indeks (mis. columns[0])

Russell
sumber
2

Meskipun menggunakan zip(*iterable)untuk merefleksikan daftar bersarang, Anda juga dapat menggunakan yang berikut jika panjang daftar bersarang bervariasi:

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

menghasilkan:

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

Kolom pertama adalah sebagai berikut:

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

Yah agak terlambat ...

Dalam hal masalah kinerja dan data Anda berbentuk persegi panjang, Anda mungkin juga menyimpannya dalam satu dimensi dan mengakses kolom dengan mengiris misalnya ...

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]

Yang rapi adalah ini sangat cepat. Namun , indeks negatif tidak berfungsi di sini! Jadi, Anda tidak dapat mengakses kolom atau baris terakhir dengan indeks -1.

Jika Anda memerlukan pengindeksan negatif, Anda dapat sedikit menyetel fungsi-fungsi accessor, misalnya

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]
Zappotek
sumber
Saya memeriksa metode ini dan biaya pengambilan kolom jauh lebih murah daripada bersarang untuk loop. Namun, mengurangi matriks 2d menjadi 1d mahal jika matriks besar, katakanlah 1000 * 1000.
Zhongjun 'Mark' Jin
2

Jika Anda ingin mengambil lebih dari satu kolom, cukup gunakan slice:

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

Saya lebih suka petunjuk selanjutnya: memiliki nama matriks matrix_adan menggunakan column_number, misalnya:

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]
Vik Ermolenko
sumber
1

Cukup gunakan transpose (), maka Anda bisa mendapatkan kolom semudah Anda mendapatkan baris

matrix=np.array(originalMatrix).transpose()
print matrix[NumberOfColum]
David Tatis
sumber
0

Semua kolom dari matriks ke daftar baru:

N = len(matrix) 
column_list = [ [matrix[row][column] for row in range(N)] for column in range(N) ]
pengguna136036
sumber