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

Question

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

Matrix = [][]

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

मैंने नीचे कोड की कोशिश की है, लेकिन यह भी गलत है:

Matrix = [5][5]

त्रुटि:

Traceback ...

IndexError: list index out of range

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

Comments

एक सरणियों , या किसी अन्य चीज को परिभाषित नहीं करता है। हालाँकि, आप बहुआयामी अनुक्रम बना सकते हैं, जैसा कि उत्तर यहाँ दिखाते हैं। याद रखें कि अजगर चर अयोग्य हैं, लेकिन मान दृढ़ता से टाइप किए जाते हैं।

— सिंगलएनजेशन इलिमिनेशन

मैं उलझन में हूं। अन्य भाषाओं से आ रहा है: यह 1D-Arrays और 1d-Array युक्त 1D-Array के बीच का अंतर है। और AFAIK में अजगर में एक बहु-आयामी-सरणी (या सूची) होने का कोई तरीका नहीं है। यहाँ कहा जाना चाहिए ...

— डिर्क रीचेल

पायथन 3 एफएक्यू भी देखें कि मैं एक बहुआयामी सूची कैसे बना सकता हूं?

— केविन डब्ल्यू मैथ्यू

Answer 1

आप तकनीकी रूप से एक असिंचित सरणी को अनुक्रमित करने का प्रयास कर रहे हैं। आपको आइटम जोड़ने से पहले सूची के साथ बाहरी सूची को पहले इनिशियलाइज़ करना होगा; अजगर इस "सूची समझ" कहता है।

# Creates a list containing 5 lists, each of 8 items, all set to 0
w, h = 8, 5;
Matrix = [[0 for x in range(w)] for y in range(h)] 

अब आप सूची में आइटम जोड़ सकते हैं:

Matrix[0][0] = 1
Matrix[6][0] = 3 # error! range... 
Matrix[0][6] = 3 # valid

ध्यान दें कि मैट्रिक्स "y" पता प्रमुख है, दूसरे शब्दों में, "y इंडेक्स" "x इंडेक्स" से पहले आता है।

print Matrix[0][0] # prints 1
x, y = 0, 6 
print Matrix[x][y] # prints 3; be careful with indexing! 

यद्यपि आप उन्हें अपनी इच्छानुसार नाम दे सकते हैं, मैं इसे इस तरह से देखता हूं कि कुछ भ्रम से बचने के लिए जो अनुक्रमण के साथ उत्पन्न हो सकते हैं, यदि आप आंतरिक और बाहरी दोनों सूचियों के लिए "x" का उपयोग करते हैं, और एक गैर-वर्ग मैट्रिक्स चाहते हैं।

Comments

[[0 फॉर x इन रेंज (cols_count)] एक्स के लिए रेंज में (पंक्तियाँ_काउंट)]

— गीत

अजीब ademar111190 द्वारा संपादित करें। पायथन 3 में कोई व्यवस्था नहीं है, लेकिन यदि आपको पायथन 2 का उपयोग करना चाहिए, तो यदि आप अनावश्यक रूप से ऑब्जेक्ट नहीं बनाना चाहते हैं, तो xrange उपयोग करने का सही कार्य है।

— डेव

@ यदि आपको इसकी आवश्यकता शून्य नहीं है, तो आप rangeसीधे आंतरिक सूचियाँ बनाने के लिए उपयोग कर सकते हैं :[range(5) for x in range(5)]

— alanjds

@alanjds - यह सच है, लेकिन आप अभी भी बाहरी पुनरावृत्ति के लिए पायथन 2 में संभावित रूप से कई अनावश्यक वस्तु संदर्भ बनाते हैं (यह बहुत बड़ी रेंज के साथ प्रयास करें)। इसके अलावा, कुछ मूल्य का आरंभीकरण लगभग हमेशा वही होता है जो आप चाहते हैं - और यह अधिक बार नहीं 0 से अधिक होता है। रेंज एक पुनरावृत्ति संग्रह प्राप्त करता है - xrange एक जनरेटर देता है। मेरा कहना यह था कि एडेमर ने "सुधार" किया जो वास्तव में उसके सुधार की तुलना में अधिक सामान्य रूप से सही और कुशल था।

— डेव

@ 6 पैककीड [0] * wभाग अच्छा है, लेकिन [[0] * w] * h]अप्रत्याशित व्यवहार पैदा करेगा। कोशिश करो mat = [[0] * 3] * 3; mat[0][1] = 10; print(mat == [[0, 10, 0], [0, 10, 0], [0, 10, 0]])और mat = [[0] * 3 for i in range(3)]; mat[0][1] = 10; print(mat == [[0, 10, 0], [0, 0, 0], [0, 0, 0]])।

— प्रेषित

Answer 2

यदि आप वास्तव में एक मैट्रिक्स चाहते हैं, तो आप का उपयोग करना बेहतर हो सकता है numpy। मैट्रिक्स ऑपरेशन numpyज्यादातर अक्सर दो आयामों के साथ एक सरणी प्रकार का उपयोग करते हैं। एक नई सरणी बनाने के कई तरीके हैं; सबसे उपयोगी में से एक zerosफ़ंक्शन है, जो एक आकार पैरामीटर लेता है और दिए गए आकार की एक सरणी देता है, जिसमें शून्य को आरंभीकृत मान है:

>>> import numpy
>>> numpy.zeros((5, 5))
array([[ 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.]])

2-डी एरेज़ और मैट्रेस बनाने के कुछ अन्य तरीके यहां दिए गए हैं (कॉम्पैक्टनेस के लिए निकाले गए आउटपुट के साथ):

numpy.arange(25).reshape((5, 5))         # create a 1-d range and reshape
numpy.array(range(25)).reshape((5, 5))   # pass a Python range and reshape
numpy.array([5] * 25).reshape((5, 5))    # pass a Python list and reshape
numpy.empty((5, 5))                      # allocate, but don't initialize
numpy.ones((5, 5))                       # initialize with ones

numpyएक matrixप्रकार प्रदान करता है , लेकिन यह अब किसी भी उपयोग के लिए अनुशंसित नहीं है , और numpyभविष्य में इसे हटाया जा सकता है ।

Comments

जब भी आप मैट्रिस चाहते हैं, तो आप सुन्न का उपयोग करना चाहते हैं। यह उत्तर पहले होना चाहिए।

— पैट बी

तथ्य यह है कि सवाल अंग्रेजी शब्द "मैट्रिक्स" का उपयोग करता है इसका मतलब यह नहीं है कि उन्हें इसका np.matrixप्रतिनिधित्व करने के लिए उपयोग करना चाहिए । एक मैट्रिक्स को सुपीरियर में दर्शाने का उचित तरीका है array।

— user2357112

@ user2357112, और जैसा कि आप देख सकते हैं, अधिकांश उदाहरण arrayमैट्रिसेस के बजाय आउटपुट s के ऊपर सूचीबद्ध हैं । हालांकि यह हमेशा प्रोत्साहित नहीं किया जाता है, matrixसंदर्भ मामलों के उपयोग के लिए वैध कारण हैं।

— 21

क्या आप उपयोग करने के कारणों पर विस्तार कर सकते हैं matrix? चूंकि @ऑपरेटर पेश किया गया था, इसलिए यह पोस्ट लिखे जाने के बाद एक कम कारण प्रतीत होता है।

— जप

@jpp, जैसा कि पहले पोस्ट में कहा गया है, मतलाब से आने वाले लोग इसे उपयोगी पा सकते हैं। लेकिन numpyडॉक्स अब संकेत देते हैं कि वर्ग को भविष्य में हटा दिया जा सकता है और हटाया जा सकता है , इसलिए मैंने इसे उत्तर से निकाल लिया है।

— प्रेषक

Answer 3

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

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

Comments

क्या आप "छोटी" विफलता के पीछे के तर्क की व्याख्या कर सकते हैं? इस मामले में अजगर एक ही सूची की उत्पादन प्रतियां, और मामले में विभिन्न कोशिकाओं की एक सरणी क्यों करता है [0]*5?

— mike622867

उपरोक्त टिप्पणियां बिल्कुल सच नहीं हैं: [०] * ५ अभी भी ५ नंबर के एक ही ऑब्जेक्ट के संदर्भ में ५ बार के साथ एक अनुक्रम बनाता है। लेकिन आप इसे कभी नोटिस नहीं करेंगे क्योंकि ० अपरिवर्तनीय है (मैं कहूंगा कि ० मान की तरह व्यवहार करता है - या आप इसे एक आदिम डेटा प्रकार के रूप में सोच सकते हैं - क्योंकि यह अपरिवर्तनीय है, इसलिए आपको कभी भी प्रतियां रखने के बजाय एक ही वस्तु के संदर्भ में समस्याएं नहीं आती हैं।)

— dreua

अधिक pythonic: [[0]*5 for _ in range(5)]गुमनाम पाश काउंटर के साथ आपके द्वारा उपयोग नहीं

— जीन फ़्राँस्वा Fabre

अच्छा लगा कि आप दूसरे उदाहरण में उथली नकल की समस्या बताते हैं।

— व्हाटसकोल्ड

धन्यवाद @ ड्रेउआ, मैं वास्तव में उलझन में था कि कैसे [0]*5ठीक काम करता है। अब मैं समझता हूं कि [{0}]*8एक बुरा विचार भी क्यों होगा।

— कुकू

Answer 4

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

matrix = [[]]

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

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

Comments

@KorayTugay क्योंकि मैट्रिक्स को पायथन सूची (एस) (पंक्तियों) का उपयोग करके किसी अन्य सूची (कॉलम) के अंदर नेस्टेड दर्शाया गया है।

— 13

पायथन -3 के लिए रेंज फंक्शन की जगह xrange दुर्गंध

— राकेश चौधरी

Answer 5

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

Matrix = {}

तो आप कर सकते हैं:

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

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

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

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

Comments

फिर आप यह भी कर सकते हैं import collections; Matrix = collections.defaultdict(float), असंगठित तत्वों के लिए शून्य स्थानापन्न करने के लिए।

— osa

Tuple (1,2) के लिए एक तानाशाह तक नहीं पहुंचेगा क्योंकि कुंजी में O (n) की सबसे खराब स्थिति है। आंतरिक रूप से यह टुपल्स हैश होगा। जबकि 2 डी सरणी का उपयोग करने से सूचकांक (1,2] का उपयोग करने के लिए ओ (1) समय की जटिलता मिलेगी। इसलिए इसके लिए तानाशाही का इस्तेमाल करना अच्छा विकल्प नहीं होना चाहिए।

— वत्सल

@Vatsal wiki.python.org/moin/TimeComplexity का कहना है कि औसत मामला O (1) है, लेकिन आप सबसे खराब स्थिति के बारे में सही हैं। वैसे भी, जब तक आप AEM OF ITEMS के बारे में बात नहीं कर रहे हैं, आप इस अंतर की परवाह नहीं करेंगे। तथ्य की बात के रूप में, मुझे एक्सेस टाइम की तुलना में मेमोरी के बारे में अधिक चिंता होगी।

— एनोबायराम

इसके अलावा, हम हमेशा डायट के उपयोग से बचने की कोशिश करते हैं जब तक कि एल्गोरिथ्म की समग्र जटिलता O (n ^ 2) के बराबर या उससे अधिक न हो। 'N' समय O (n) एक्सेस के रूप में O (n ^ 2) जटिलता देगा।

— वत्सल

@enobayram, क्षमा करें, लेकिन मैं सहमत नहीं हूँ। असममित विश्लेषण हमेशा O (n ^ 2) देगा, यदि सबसे खराब स्थिति O (n) का उपयोग 'n' बार किया जाता है। जहां के रूप में परिशोधित विश्लेषण एक कम बाध्य दे सकता है। और परिशोधन और औसत मामले के बीच एक बड़ा अंतर है ... कृपया किसी भी धारणा और अस्पष्ट टिप्पणी करने से पहले देखें

— वत्सल

Answer 6

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

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

Comments

extendपहले मामले में भी मददगार होगा: यदि आप के साथ शुरू करते हैं m = [[]], तो आप आंतरिक सूची में जोड़ सकते हैं (एक पंक्ति का विस्तार करें) m[0].extend([1,2]), और बाहरी सूची में जोड़ें (एक नई पंक्ति को जोड़ m.append([3,4])दें ) , उन कार्यों को आपके साथ छोड़ देगा [[1, 2], [3, 4]]।

— आस्किवन

Answer 7

स्वीकृत उत्तर अच्छा और सही है, लेकिन मुझे यह समझने में थोड़ा समय लगा कि मैं इसका उपयोग पूरी तरह से खाली सरणी बनाने में भी कर सकता हूं।

l =  [[] for _ in range(3)]

का परिणाम

[[], [], []]

Answer 8

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

>>> 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 वें आइटम तक पहुंचने का प्रयास करें, और यह स्वाभाविक रूप से एक IndexError उठाता है क्योंकि कोई 5 वीं वस्तु नहीं है:

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

Comments

वास्तव में row_index ('i') और column_index ('j') का क्रम इस प्रकार है: '>>> मैट्रिक्स = [[0 के लिए column_index in रेंज (5)] row_index के लिए श्रेणी (5)' में

— Aniruddha Kalburgi

Answer 9

rows = int(input())
cols = int(input())

matrix = []
for i in range(rows):
  row = []
  for j in range(cols):
    row.append(0)
  matrix.append(row)

print(matrix)

इतना लंबा कोड, वह भी Pythonआप में क्यों पूछें?

बहुत समय पहले जब मैं पायथन के साथ सहज नहीं था, मैंने 2 डी मैट्रिक्स लिखने के लिए एकल पंक्ति के उत्तर देखे और खुद को बताया कि मैं फिर से पायथन में 2-डी मैट्रिक्स का उपयोग नहीं करने जा रहा हूं। (वे एकल लाइनें बहुत डरावनी थीं और इसने मुझे कोई जानकारी नहीं दी कि पायथन क्या कर रहा था। यह भी ध्यान दें कि मुझे इन शॉर्टहैंड के बारे में जानकारी नहीं है।)

वैसे भी, यहाँ एक शुरुआत के लिए कोड है, जो सी, सीपीपी और जावा पृष्ठभूमि से आ रहा है

पायथन लवर्स और एक्सपर्ट्स पर ध्यान दें: कृपया नीचे मत जाएं क्योंकि मैंने एक विस्तृत कोड लिखा था।

Answer 10

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

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

Answer 11

उपयोग:

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

पहले आयाम के लिए * 5 काम करता है क्योंकि इस स्तर पर डेटा अपरिवर्तनीय है।

Comments

मैं शायद के रूप में लिख होगाmatrix = [[0]*cols for _ in range(rows)]

— शीतल शाह

Answer 12

शून्य का मैट्रिक्स घोषित करने के लिए (वाले):

numpy.zeros((x, y))

जैसे

>>> numpy.zeros((3, 5))
    array([[ 0.,  0.,  0.,  0.,  0.],
   [ 0.,  0.,  0.,  0.,  0.],
   [ 0.,  0.,  0.,  0.,  0.]])

या numpy.ones ((x, y)) उदा

>>> np.ones((3, 5))
array([[ 1.,  1.,  1.,  1.,  1.],
   [ 1.,  1.,  1.,  1.,  1.],
   [ 1.,  1.,  1.,  1.,  1.]])

यहां तक ​​कि तीन आयाम संभव हैं। ( http://www.astro.ufl.edu/~warner/prog/python.html देखें -> बहुआयामी सरणियाँ)

Answer 13

यह है कि मैं आमतौर पर अजगर में 2 डी सरणियों का निर्माण करता हूं।

col = 3
row = 4
array = [[0] * col for _ in range(row)]

मुझे इस वाक्यविन्यास को सूची बोध में दो छोरों के लिए उपयोग करने की तुलना में याद रखना आसान है।

Answer 14

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

 # 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

Answer 15

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

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

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

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

Comments

क्या "लिस्ट कॉम्प्रिहेंशन" के बजाय सुपी का उपयोग करने के पक्ष और विपक्ष होंगे?

— मोनिका

Answer 16

मैं इस तरह से अल्पविराम से अलग की गई फ़ाइलों में पढ़ता हूं:

data=[]
for l in infile:
    l = split(',')
    data.append(l)

सूची "डेटा" तब सूचकांक डेटा [पंक्ति] [कॉल] के साथ सूचियों की एक सूची है

Answer 17

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

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

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

Comments

बिना सूची के शून्य के numpy.matrixबराबर हैं numpy.zeros?

— मोनिका

Answer 18

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

matrix = {}

---

आप कुंजी और मान को दो तरीकों से परिभाषित कर सकते हैं:

matrix[0,0] = value

या

matrix = { (0,0)  : value }

परिणाम:

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

Answer 19

उपयोग:

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 जाने का रास्ता है। यदि आप NumPy का उपयोग नहीं करना चाहते हैं तो उपरोक्त एक सामान्य है।

Comments

मुझे यह पसंद है कि वेनीला पायथन के साथ कुछ सरल करने के लिए बिना खतना का उपयोग किए।

— रिक हेंडरसन

Answer 20

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

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

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

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'] आपको O (1) समय में परिणाम देगा

* nb : आपको हैश तालिका में टकराव से निपटने की आवश्यकता है

Answer 21

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

list 1: To store rows
list 2: Actual two-dimensional matrix

पहली सूची में पूरी पंक्ति संग्रहीत करें। एक बार किया, सूची 2 में सूची 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]]

Answer 22

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

इस संक्षिप्त अभिव्यक्ति के बारे में सावधान रहें, @ FJ के उत्तर में पूर्ण विवरण नीचे देखें

Comments

इस तरह से सावधान रहें, क्योंकि Matrix[0], Matrix[1], ..., Matrix[4]सभी एक ही सरणी की ओर इशारा करते हैं, इसलिए बाद में Matrix[0][0] = 3, आप उम्मीद करेंगे Matrix[0][0] == Matrix[1][0] == ... == Matrix[4][0] == 3।

— gongzhitaao

आपकी टिप्पणी के लिए धन्यवाद gongzhitaao। अगर मैंने इसे पढ़ा होता तो यह मुझे कम से कम आधे घंटे तक बचा लेती। एक मैट्रिक्स होने से जहां प्रत्येक पंक्ति स्मृति में एक ही स्थान पर इंगित होती है, बहुत उपयोगी नहीं लगती है, और यदि आपको पता नहीं है कि आप क्या कर रहे हैं यह भी खतरनाक है! मुझे पूरा यकीन है कि यह मसूद अबासियन नहीं है, जिसने सवाल पूछा था, वह करना चाहता है।

— एड्रियन

आपको यह उत्तर हटा देना चाहिए, क्योंकि यह सही उत्तर नहीं है। शुरुआती भ्रमित हो सकते हैं।

— cxxl

आप किस जवाब का जिक्र कर रहे हैं? मुझे "FJ" नाम वाला उपयोगकर्ता नहीं दिखता (हटाए गए उत्तरों में भी नहीं)।

— पीटर मोर्टेंसन

Answer 23

l=[[0]*(L) for _ in range(W)]

से तेज़ होगा:

l = [[0 for x in range(L)] for y in range(W)] 

Comments

पहले से ही नीचे दिए गए उत्तर का डुप्लिकेट उत्तर। इसके बाद से कहीं भी इस्तेमाल नहीं किया [[0]*(L) for i in range(W)]जाना चाहिए[[0]*(L) for _ in range(W)]i

— आयुष वात्स्यायन

Answer 24

आप []नीचे की तरह, एक वर्ग ब्रेसिंग के साथ दो या दो से अधिक वर्ग ब्रेसिंग या तीसरे ब्रैकेट ( , अल्पविराम द्वारा अलग) के द्वारा एक खाली दो आयामी सूची बना सकते हैं :

Matrix = [[], []]

अब मान लें कि आप 1 Matrix[0][0]टाइप करना चाहते हैं तो आप टाइप करें:

Matrix[0].append(1)

अब, मैट्रिक्स टाइप करें और एंटर दबाएं। उत्पादन होगा:

[[1], []]

Answer 25

इसे इस्तेमाल करे:

rows = int(input('Enter rows\n'))
my_list = []
for i in range(rows):
    my_list.append(list(map(int, input().split())))

Answer 26

यदि आपको पूर्वनिर्धारित संख्याओं के साथ मैट्रिक्स की आवश्यकता है तो आप निम्नलिखित कोड का उपयोग कर सकते हैं:

def matrix(rows, cols, start=0):
    return [[c + start + r * cols for c in range(cols)] for r in range(rows)]


assert matrix(2, 3, 1) == [[1, 2, 3], [4, 5, 6]]

Answer 27

यहाँ अजगर में एक मैट्रिक्स बनाने के लिए कोड स्निपेट है:

# get the input rows and cols
rows = int(input("rows : "))
cols = int(input("Cols : "))

# initialize the list
l=[[0]*cols for i in range(rows)]

# fill some random values in it
for i in range(0,rows):
    for j in range(0,cols):
        l[i][j] = i+j

# print the list
for i in range(0,rows):
    print()
    for j in range(0,cols):
        print(l[i][j],end=" ")

कृपया सुझाव दें कि क्या मैंने कुछ याद किया है।