जवाबों:
>>> 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])
यह भी देखें: मेमोरी को आवंटित करने के लिए "numpy.arange" और "reshape"
उदाहरण: मैट्रिक्स को आकार देने के साथ एक सरणी आवंटित करना (3x4)
nrows = 3
ncols = 4
my_array = numpy.arange(nrows*ncols, dtype='double')
my_array = my_array.reshape(nrows, ncols)
[row, col]। अल्पविराम अलग हो जाता है।
क्या ऐसा हो सकता है कि आप एक न्यूपी सरणी का उपयोग कर रहे हैं ? पायथन में सरणी मॉड्यूल है, लेकिन यह बहु-आयामी सरणियों का समर्थन नहीं करता है। सामान्य पायथन सूची एकल आयामी भी हैं।
हालांकि, अगर आपके पास इस तरह की एक सरल दो आयामी सूची है:
A = [[1,2,3,4],
[5,6,7,8]]
तो आप इस तरह एक कॉलम निकाल सकते हैं:
def column(matrix, i):
return [row[i] for row in matrix]
दूसरा कॉलम निकालना (इंडेक्स 1):
>>> column(A, 1)
[2, 6]
या वैकल्पिक रूप से, बस:
>>> [row[1] for row in A]
[2, 6]
यदि आपके पास एक सरणी है
a = [[1, 2], [2, 3], [3, 4]]फिर आप उस तरह पहला कॉलम निकालें:
[row[0] for row in a]तो परिणाम इस तरह दिखता है:
[1, 2, 3]इसकी जांच - पड़ताल करें!
a = [[1, 2], [2, 3], [3, 4]]
a2 = zip(*a)
a2[0]यह उसी तरह से ऊपर के रूप में है जैसे किसी को छोड़कर यह शून्य काम करता है लेकिन तर्क के रूप में एकल सरणियों की आवश्यकता होती है, * एक सिंटैक्स एकल सरणी तर्क में बहुआयामी सरणी को अनपैक करता है
a2 = zip(*a); a2 = list(a2); a2[0]
>>> 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]])यदि आप दूसरा कॉलम चाहते हैं तो आप उपयोग कर सकते हैं
>>> x[:, 1]
array([ 1, 6, 11, 16])arange()Python3 के लिए किसी भी दस्तावेज को खसखस के बाहर नहीं ढूंढ सकता । किसी को?
आइटमगेटर ऑपरेटर भी मदद कर सकता है, अगर आपको लिस्ट कम करने के बजाय मैप-कम स्टाइल पाइथन पसंद है, तो थोड़ी विविधता के लिए!
# 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)मुझे लगता है कि आप एक सरणी से एक स्तंभ निकालना चाहते हैं जैसे नीचे एक सरणी
import numpy as np
A = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])अब यदि आप प्रारूप में तीसरा कॉलम प्राप्त करना चाहते हैं
D=array[[3],
[7],
[11]]फिर आपको पहले सरणी को एक मैट्रिक्स बनाने की आवश्यकता है
B=np.asmatrix(A)
C=B[:,2]
D=asarray(C)और अब आप तत्व वार गणना कर सकते हैं जैसे आप एक्सेल में करेंगे।
मान लीजिए कि हमारे पास n X mमैट्रिक्स ( nपंक्तियाँ और mस्तंभ) हैं, 5 पंक्तियाँ और 4 स्तंभ हैं
matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16],[17,18,19,20]]अजगर में कॉलम निकालने के लिए, हम इस तरह की सूची समझ का उपयोग कर सकते हैं
[ [row[i] for row in matrix] for in range(4) ]आपके मैट्रिक्स में जितने भी कॉलम हैं, आप उनमें से 4 को बदल सकते हैं। परिणाम है
[ [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]यदि आपके पास पायथन में दो-आयामी सरणी है (सुन्न नहीं), तो आप सभी कॉलम को इस तरह निकाल सकते हैं,
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]))
इस कोड को निष्पादित करने से उपज होगी,
>>> 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)बेशक, आप इंडेक्स द्वारा एकल कॉलम निकाल सकते हैं (उदाहरण के लिए columns[0])
zip(*iterable)नेस्टेड सूची को स्थानांतरित करने के लिए उपयोग करने के बावजूद , यदि नेस्टेड सूची लंबाई में भिन्न हो, तो आप निम्नलिखित का भी उपयोग कर सकते हैं:
map(None, *[(1,2,3,), (4,5,), (6,)])का परिणाम:
[(1, 4, 6), (2, 5, None), (3, None, None)]पहला कॉलम इस प्रकार है:
map(None, *[(1,2,3,), (4,5,), (6,)])[0]
#>(1, 4, 6)खैर एक 'बिट' देर से ...
मामले के प्रदर्शन के मामलों में और आपके डेटा को आयताकार आकार दिया जाता है, आप इसे एक आयाम में संग्रहीत कर सकते हैं और नियमित रूप से स्लाइसिंग करके कॉलम तक पहुंच सकते हैं ...
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]साफ बात यह है कि यह वास्तव में तेज है। हालांकि , नकारात्मक सूचकांक यहां काम नहीं करते हैं! इसलिए आप इंडेक्स -1 द्वारा अंतिम कॉलम या रो को एक्सेस नहीं कर सकते।
अगर आपको नेगेटिव इंडेक्सिंग की जरूरत है तो आप एक्सेसर-फंक्शन को थोड़ा ट्यून कर सकते हैं, जैसे
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]मैं अगले संकेत को प्राथमिकता देता हूं : उदाहरण के लिए मैट्रिक्स नाम matrix_aऔर उपयोग करना column_number:
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]बस ट्रांसपोज़ () का उपयोग करें, फिर आप जितनी आसानी से पंक्तियाँ प्राप्त कर सकते हैं, उतने ही कोलमन्स प्राप्त कर सकते हैं
matrix=np.array(originalMatrix).transpose()
print matrix[NumberOfColum]मैट्रिक्स से एक नई सूची में सभी कॉलम:
N = len(matrix)
column_list = [ [matrix[row][column] for row in range(N)] for column in range(N) ]