python - पायथन में दो-आयामी सरणी को कैसे परिभाषित करें




matrix syntax-error (14)

मैं इस तरह की प्रारंभिक लंबाई के बिना एक द्वि-आयामी सरणी को परिभाषित करना चाहता हूं:

Matrix = [][]

लेकिन यह काम नहीं करता है...

मैंने नीचे दिए गए कोड का प्रयास किया है, लेकिन यह भी गलत है:

Matrix = [5][5]

त्रुटि:

Traceback ...

IndexError: list index out of range

मेरी गलती क्या है?


यही है कि शब्दकोश के लिए बनाया गया है!

matrix = {}

आप चाबियाँ और मानों को दो तरीकों से परिभाषित कर सकते हैं:

matrix[0,0] = value

या

matrix = { (0,0)  : value }

परिणाम:

   [ value,  value,  value,  value,  value],
   [ value,  value,  value,  value,  value],
   ...

NumPy का उपयोग करके आप इस तरह खाली मैट्रिक्स शुरू कर सकते हैं:

import numpy as np
mm = np.matrix([])

और बाद में इस तरह के डेटा संलग्न करें:

mm = np.append(mm, [[1,2]], axis=1)

आपको सूचियों की एक सूची बनाना चाहिए, और नेस्टेड समझों का उपयोग करने का सबसे अच्छा तरीका है:

>>> matrix = [[0 for i in range(5)] for j in range(5)]
>>> pprint.pprint(matrix)
[[0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0]]

आपके [5][5] उदाहरण पर, आप अंदर एक पूर्णांक "5" के साथ एक सूची बना रहे हैं, और अपने 5 वें आइटम तक पहुंचने का प्रयास करें, और स्वाभाविक रूप से इंडेक्स एरर उठाता है क्योंकि कोई 5 वां आइटम नहीं है:

>>> l = [5]
>>> l[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

उपयोग:

import copy

def ndlist(*args, init=0):
    dp = init
    for x in reversed(args):
        dp = [copy.deepcopy(dp) for _ in range(x)]
    return dp

l = ndlist(1,2,3,4) # 4 dimensional list initialized with 0's
l[0][1][2][3] = 1

मुझे लगता है कि न्यूमपी जाने का रास्ता है। उपरोक्त एक सामान्य है यदि आप NumPy का उपयोग नहीं करना चाहते हैं।


पायथन में आप सूचियों की एक सूची तैयार करेंगे। आपको समय से पहले आयाम घोषित करने की आवश्यकता नहीं है, लेकिन आप कर सकते हैं। उदाहरण के लिए:

matrix = []
matrix.append([])
matrix.append([])
matrix[0].append(2)
matrix[1].append(3)

अब मैट्रिक्स [0] [0] == 2 और मैट्रिक्स [1] [0] == 3. आप सूची समझ वाक्यविन्यास का भी उपयोग कर सकते हैं। यह उदाहरण "द्वि-आयामी सूची" बनाने के लिए इसे दो बार उपयोग करता है:

from itertools import count, takewhile
matrix = [[i for i in takewhile(lambda j: j < (k+1) * 10, count(k*10))] for k in range(10)]

मैं अपनी पहली पायथन लिपि पर हूं, और मैं वर्ग मैट्रिक्स उदाहरण से थोड़ा उलझन में था इसलिए मुझे उम्मीद है कि नीचे दिया गया उदाहरण आपको कुछ समय बचाने में मदद करेगा:

 # Creates a 2 x 5 matrix
 Matrix = [[0 for y in xrange(5)] for x in xrange(2)]

ताकि

Matrix[1][4] = 2 # Valid
Matrix[4][1] = 3 # IndexError: list index out of range

यदि आप एक खाली मैट्रिक्स बनाना चाहते हैं, तो सही वाक्यविन्यास है

matrix = [[]]

और यदि आप 0 से भरा आकार 5 का मैट्रिक्स जेनरेट करना चाहते हैं,

matrix = [[0 for i in xrange(5)] for i in xrange(5)]

यदि आप चाहते हैं कि कुछ तत्वों को पकड़ने के लिए एक दो आयामी कंटेनर है, तो आप आसानी से इसके बजाय एक शब्दकोश का उपयोग कर सकते हैं:

Matrix = {}

फिर आप कर सकते हैं:

Matrix[1,2] = 15
print Matrix[1,2]

यह काम करता है क्योंकि 1,2 एक ट्यूपल है, और आप इसे शब्दकोश को इंडेक्स करने के लिए एक कुंजी के रूप में उपयोग कर रहे हैं। नतीजा एक गूंगा स्पैर मैट्रिक्स के समान है।

जैसा कि ओएसए और जोसाप वोल्स द्वारा इंगित किया गया है, आप Matrix = collections.defaultdict(lambda:0) .defaultdict Matrix = collections.defaultdict(lambda:0) का भी उपयोग कर सकते हैं ताकि गायब तत्वों का 0 का डिफ़ॉल्ट मान हो।

वत्सल आगे बताते हैं कि यह विधि शायद बड़े मैट्रिस के लिए बहुत ही कुशल नहीं है और केवल कोड के गैर-प्रदर्शन-महत्वपूर्ण भागों में उपयोग की जानी चाहिए।


यदि आप सूचियों की सूची (मेरी राय में अधिक प्राकृतिक) की अवधि में सोचने के लिए मजबूर होने के बजाय इसे 2 डी सरणी के रूप में सोचने में सक्षम होना चाहते हैं, तो आप निम्न कार्य कर सकते हैं:

import numpy
Nx=3; Ny=4
my2Dlist= numpy.zeros((Nx,Ny)).tolist()

नतीजा एक सूची है (नम्पी सरणी नहीं), और आप संख्याओं, तारों, जो कुछ भी के साथ व्यक्तिगत पदों को ओवरराइट कर सकते हैं।


यदि आपके पास शुरू होने से पहले आकार की जानकारी नहीं है तो दो-आयामी सूचियां बनाएं।

सूची 1: पंक्तियों को संग्रहित करने के लिए सूची 2: वास्तविक द्वि-आयामी मैट्रिक्स

पूरी पंक्ति को पहली सूची में स्टोर करें। एक बार हो जाने पर, सूची 1 में सूची 1 जोड़ें:

from random import randint


coordinates=[]
temp=[]
points=int(raw_input("Enter No Of Coordinates >"))
for i in range(0,points):
    randomx=randint(0,1000)
    randomy=randint(0,1000)
    temp=[]
    temp.append(randomx)
    temp.append(randomy)
    coordinates.append(temp)

print coordinates

आउटपुट:

Enter No Of Coordinates >4
[[522, 96], [378, 276], [349, 741], [238, 439]]

सूचियों की सूची आरंभ करने के लिए यहां एक छोटी सी सूचना दी गई है:

matrix = [[0]*5 for i in range(5)]

दुर्भाग्य से इसे 5*[5*[0]] तरह कुछ कम करना वास्तव में काम नहीं करता है क्योंकि आप एक ही सूची की 5 प्रतियों के साथ समाप्त होते हैं, इसलिए जब आप उनमें से एक को संशोधित करते हैं तो वे सभी बदलते हैं, उदाहरण के लिए:

>>> matrix = 5*[5*[0]]
>>> matrix
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
>>> matrix[4][4] = 2
>>> matrix
[[0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2]]

सूची का उपयोग करके:

matrix_in_python  = [['Roy',80,75,85,90,95],['John',75,80,75,85,100],['Dave',80,80,80,90,95]]

dict का उपयोग करके: आप इस जानकारी को हैश टेबल में तेजी से खोज के लिए भी स्टोर कर सकते हैं

matrix = { '1':[0,0] , '2':[0,1],'3':[0,2],'4' : [1,0],'5':[1,1],'6':[1,2],'7':[2,0],'8':[2,1],'9':[2,2]};

मैट्रिक्स ['1'] आपको ओ (1) समय में परिणाम देगा

* एनबी : आपको हैश टेबल में टकराव से निपटने की ज़रूरत है


आसान पढ़ने के लिए एक पुनर्लेखन:

# 2D array/ matrix

# 5 rows, 5 cols
rows_count = 5
cols_count = 5

# create
#     creation looks reverse
#     create an array of "cols_count" cols, for each of the "rows_count" rows
#        all elements are initialized to 0
two_d_array = [[0 for j in range(cols_count)] for i in range(rows_count)]

# index is from 0 to 4
#     for both rows & cols
#     since 5 rows, 5 cols

# use
two_d_array[0][0] = 1
print two_d_array[0][0]  # prints 1   # 1st row, 1st col (top-left element of matrix)

two_d_array[1][0] = 2
print two_d_array[1][0]  # prints 2   # 2nd row, 1st col

two_d_array[1][4] = 3
print two_d_array[1][4]  # prints 3   # 2nd row, last col

two_d_array[4][4] = 4
print two_d_array[4][4]  # prints 4   # last row, last col (right, bottom element of matrix)

# Creates a list containing 5 lists initialized to 0
Matrix = [[0]*5]*5

इस छोटी अभिव्यक्ति के बारे में सावधान रहें, @ एफजे के जवाब में पूर्ण स्पष्टीकरण देखें





syntax-error