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

Question

मैं अजगर की शुरुआत कर रहा हूं और मैं एक दो-आयामी सूची का उपयोग करने की कोशिश कर रहा हूं, कि मैं शुरू में हर जगह एक ही चर के साथ भरता हूं। मैं इसके साथ आया:

def initialize_twodlist(foo):
    twod_list = []
    new = []
    for i in range (0, 10):
        for j in range (0, 10):
            new.append(foo)
        twod_list.append(new)
        new = []

यह वांछित परिणाम देता है, लेकिन वर्कअराउंड की तरह महसूस करता है। क्या ऐसा करने का एक आसान / छोटा / अधिक सुरुचिपूर्ण तरीका है?

Comments

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

— अर्नब दत्ता

यह प्रश्न समान है : यह पायथन में बहुआयामी सरणियों के आरंभ पर चर्चा करता है।

— एंडरसन ग्रीन

@ArnabDatta आप एक बहुपद सरणी को अंकुश में कैसे परिभाषित करेंगे?

— एंडरसन ग्रीन

@AndersonGreen docs.scipy.org/doc/numpy/user/…

— अर्नब दत्ता

आप डिफ़ॉल्ट पायथन में संरचना की तरह एक सरणी में डेटा की व्यवस्था कर सकते हैं, लेकिन यह लगभग एक NumPy सरणी के रूप में कुशल या उपयोगी नहीं है। खासकर यदि आप बड़े डेटा सेट से निपटना चाहते हैं। यहाँ कुछ प्रलेखन docs.scipy.org/doc/numpy-1.10.1/user/basics.creation.html

— jmdeamer

Answer 1

एक पैटर्न जो अक्सर पायथन में आता था

bar = []
for item in some_iterable:
    bar.append(SOME EXPRESSION)

जो सूची समझ की शुरूआत को प्रेरित करने में मदद करता है, जो उस स्निपेट को परिवर्तित करता है

bar = [SOME EXPRESSION for item in some_iterable]

जो कभी छोटा और कभी साफ हो। आमतौर पर आप इन्हें पहचानने की आदत डाल लेते हैं और अक्सर लूप को समझ से बदल देते हैं।

आपका कोड इस पैटर्न का दो बार अनुसरण करता है

twod_list = []                                       \                      
for i in range (0, 10):                               \
    new = []                  \ can be replaced        } this too
    for j in range (0, 10):    } with a list          /
        new.append(foo)       / comprehension        /
    twod_list.append(new)                           /

Comments

वैसे, [[foo] * x के लिए x in xrange (10)] का उपयोग एक समझ से छुटकारा पाने के लिए किया जा सकता है। समस्या यह है कि गुणा एक उथली प्रतिलिपि करता है, इसलिए नया = [foo] * 10 नया = [नया] * 10 आपको एक ही सूची में दस बार एक सूची मिलेगा।

— स्कॉट वोल्चोक

इसी तरह, [foo] * 10एक ही सटीक foo10 बार के साथ एक सूची है , जो महत्वपूर्ण हो सकती है या नहीं।

— माइक ग्राहम

हम सरलतम चीज़ का उपयोग कर सकते हैं: wtod_list = [[x in xrange (10))] में x के लिए xrange (10)]

— indi60

यह कभी किसी को दिखाने के लिए दर्द नहीं करता कि मछली कैसी दिखती है।

— 2:55 पर Csteele5

माइक ग्राहम के बारे में टिप्पणी के लिए [foo] * 10: इसका मतलब यह है कि यदि आप यादृच्छिक संख्याओं के साथ एक सरणी भर रहे हैं तो यह काम नहीं करेगा ( इसका मूल्यांकन करता [random.randint(1,2)] * 10है [1] * 10या [2] * 10जिसका अर्थ है कि आपको यादृच्छिक सरणी के बजाय सभी 1s या 2s का सरणी मिलता है।

— Tzu Li

Answer 2

आप एक सूची समझ का उपयोग कर सकते हैं :

x = [[foo for i in range(10)] for j in range(10)]
# x is now a 10x10 array of 'foo' (which can depend on i and j if you want)

Comments

चूँकि आकार (10) समान है, ठीक है, अगर नेस्टेड लूप को पहले नहीं आना है, तो मैं [रेंज में j के लिए foo (रेंज_ऑफ_ज)] के लिए i (रेंज_ऑफ_आई)]

— दिनेशकुमार

यह उत्तर ठीक काम करता है लेकिन जब से हम iपंक्तियों और jस्तंभों के लिए पुनरावृति करते हैं, मुझे लगता है कि बेहतर समझ के लिए स्वैप iऔर jआपके वाक्यविन्यास में बेहतर होना चाहिए और सीमा को 2 अलग-अलग संख्याओं में बदलना चाहिए।

— ड्रैगनट्रैक

Answer 3

यह रास्ता नेस्टेड सूची की समझ से अधिक तेज है

[x[:] for x in [[foo] * 10] * 10]    # for immutable foo!

यहाँ छोटे और बड़े सूचियों के लिए कुछ अजगर 3 समय हैं

$python3 -m timeit '[x[:] for x in [[1] * 10] * 10]'
1000000 loops, best of 3: 1.55 usec per loop

$ python3 -m timeit '[[1 for i in range(10)] for j in range(10)]'
100000 loops, best of 3: 6.44 usec per loop

$ python3 -m timeit '[x[:] for x in [[1] * 1000] * 1000]'
100 loops, best of 3: 5.5 msec per loop

$ python3 -m timeit '[[1 for i in range(1000)] for j in range(1000)]'
10 loops, best of 3: 27 msec per loop

स्पष्टीकरण:

[[foo]*10]*1010 बार दोहराए गए एक ही वस्तु की एक सूची बनाता है। आप इसका उपयोग नहीं कर सकते, क्योंकि एक तत्व को संशोधित करने से प्रत्येक पंक्ति में उसी तत्व को संशोधित किया जाएगा!

x[:]के बराबर है, list(X)लेकिन थोड़ा अधिक कुशल है क्योंकि यह नाम देखने से बचता है। किसी भी तरह से, यह प्रत्येक पंक्ति की उथली प्रतिलिपि बनाता है, इसलिए अब सभी तत्व स्वतंत्र हैं।

fooहालांकि सभी तत्व समान वस्तु हैं, इसलिए यदि आप fooपरिवर्तनशील हैं , तो आप इस योजना का उपयोग नहीं कर सकते। आपको उपयोग करना होगा

import copy
[[copy.deepcopy(foo) for x in range(10)] for y in range(10)]

या एक वर्ग (या समारोह) यह सोचते हैं Fooकि रिटर्न fooरों

[[Foo() for x in range(10)] for y in range(10)]

Comments

@ मायके, क्या आपने बोल्ड में भाग को याद किया? अगर फू परस्पर है, तो यहां कोई भी अन्य जवाब काम नहीं करता है (जब तक कि आप फू को बिल्कुल भी उत्परिवर्तित नहीं कर रहे हैं)

— जॉन ला रोय

आप सही ढंग से मनमानी वस्तुओं का उपयोग करके कॉपी नहीं कर सकते copy.deepcopy। यदि आपके पास एक मनमाना परिवर्तनशील वस्तु है, तो आपको अपने डेटा के लिए विशिष्ट योजना की आवश्यकता होती है।

— माइक ग्राहम

यदि आपको गति की आवश्यकता है कि बुरी तरह से लूप में, यह

— साइथन

@JohnLaRooy मुझे लगता है कि आपने इंटरचेंज किया xऔर y। ऐसा नहीं होना चाहिए[[copy.deepcopy(foo) for y in range(10)] for x in range(10)]

— user3085931

@ नील [foo]*1010 अलग-अलग ऑब्जेक्ट नहीं बनाते हैं - लेकिन यह उस मामले में अंतर को अनदेखा करना आसान है जहां फू अपरिवर्तनीय है, जैसे कि intया str।

— जॉन ला रोय

Answer 4

उपयोग न करें [[v]*n]*n, यह एक जाल है!

>>> a = [[0]*3]*3
>>> a
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> a[0][0]=1
>>> a
[[1, 0, 0], [1, 0, 0], [1, 0, 0]]

परंतु

    t = [ [0]*3 for i in range(3)]

बहुत अच्छा काम करता है।

Comments

हाँ, मैं भी इस जाल में पड़ गया। ऐसा इसलिए *है क्योंकि addressऑब्जेक्ट (सूची) की प्रतिलिपि बना रहा है ।

— चिन्यु

Upvoted, क्योंकि यह मुझे मिल गया। , स्पष्ट होना करने के लिए [[0] * col for _ in range(row)]।

— अभिजीत सरकार

Answer 5

पायथन में दो-आयामी सरणी को आरंभीकृत करने के लिए:

a = [[0 for x in range(columns)] for y in range(rows)]

Comments

सभी मानों को 0 से आरंभ करने के लिए, बस उपयोग करें a = [[0 for x in range(columns)] for y in range(rows)]।

— ZX9

Answer 6

[[foo for x in xrange(10)] for y in xrange(10)]

Comments

xrange () को python3.5 में हटा दिया गया है

— MiaeKim

यह काम क्यों नहीं करता है: [0 * col] * पंक्ति। जब मैं कुछ तत्व को संशोधित करता हूं तो यह अन्य स्थानों पर दोहराता है। लेकिन मुझे समझ नहीं आता कि क्यों?

— कोड मन्चर

क्योंकि यह प्रश्न में कोड के समान ही काम करता है।

— इग्नासियो वाज़क्वेज़-अब्राम्स

@codemuncher वह कारण [[0] * col] * rowजो आप नहीं चाहते हैं, क्योंकि जब आप 2d सूची को इस तरह से शुरू करते हैं, तो पायथन प्रत्येक पंक्ति की अलग-अलग प्रतियां नहीं बनाएगा। इसके बजाय यह उसी की नकल करने के लिए संकेत के साथ बाहरी सूची init जाएगा [0]*col। पंक्तियों में से एक को आप जो भी संपादित करते हैं, वह तब शेष पंक्तियों में परिलक्षित होगा क्योंकि वे सभी वास्तव में स्मृति में एक ही डेटा की ओर इशारा करते हैं।

— Addie

बस एक विचार है, लेकिन इन सभी सूचियों को जोड़ने के लिए अच्छा नहीं है? अर्थात। अगर मुझे आयाम 3 * 6 की खाली 2 डी सूची चाहिए और [0] [0], [1] [0], [2], [2] और सभी 18 तत्वों को भरने के लिए अनुक्रमण करने की इच्छा है। ये जवाब सही काम करेंगे?

— mLstudent33 5

Answer 7

आमतौर पर जब आप बहुआयामी सरणियाँ चाहते हैं तो आप सूचियों की सूची नहीं चाहते हैं, बल्कि एक संख्यात्मक सरणी या संभवतः एक तानाशाही होती है।

उदाहरण के लिए, सुन्न के साथ आप कुछ ऐसा करेंगे

import numpy
a = numpy.empty((10, 10))
a.fill(foo)

Comments

हालाँकि numpyयह बहुत अच्छा है, मुझे लगता है कि यह एक शुरुआत के लिए थोड़ा अधिक हो सकता है।

— एस्टेबन कुबेर

numpy एक बहुआयामी सरणी प्रकार प्रदान करता है। सूचियों से बाहर एक अच्छा बहुआयामी सरणी बनाना संभव है लेकिन कम उपयोगी है और शुरुआती के मुकाबले कठिन है। नेस्टेड सूचियां कुछ अनुप्रयोगों के लिए बहुत अच्छी हैं, लेकिन आमतौर पर किसी को 2 डी सरणी नहीं चाहिए।

— माइक ग्राहम

कुछ वर्षों के बाद कभी-कभी गंभीर अजगर क्षुधा मानक अजगर सरणियों के quirks बस आगे बढ़ने के साथ वारंट लगते हैं numpy। +1

— javadba

Answer 8

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

[[element] * numcols] * numrows

उदाहरण के लिए:

>>> [['a'] *3] * 2
[['a', 'a', 'a'], ['a', 'a', 'a']]

लेकिन इसका अवांछित प्रभाव होता है:

>>> b = [['a']*3]*3
>>> b
[['a', 'a', 'a'], ['a', 'a', 'a'], ['a', 'a', 'a']]
>>> b[1][1]
'a'
>>> b[1][1] = 'b'
>>> b
[['a', 'b', 'a'], ['a', 'b', 'a'], ['a', 'b', 'a']]

Comments

मेरे अनुभव में, यह "अवांछनीय" प्रभाव अक्सर कुछ बहुत खराब तार्किक त्रुटियों का स्रोत होता है। मेरी राय में, इस दृष्टिकोण से बचना चाहिए, इसके बजाय @ विपुल का जवाब बेहतर है।

— एलन ट्यूरिंग

यह दृष्टिकोण अच्छा काम करता है, क्यों टिप्पणियों में कुछ लोग इसे खराब मानते हैं?

— ब्रावो

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

— हितेन ने

Answer 9

twod_list = [[foo for _ in range(m)] for _ in range(n)]

n के लिए पंक्तियों की संख्या है, और m स्तंभ की संख्या है, और foo मान है।

Answer 10

यदि यह एक बहुत आबादी वाला सरणी है, तो आप एक ट्यूल के साथ कुंजीशब्द का उपयोग करके बेहतर हो सकते हैं:

dict = {}
key = (a,b)
dict[key] = value
...

Answer 11

t = [ [0]*10 for i in [0]*10]

प्रत्येक तत्व के लिए एक नया निर्माण किया [0]*10जाएगा ।।

Answer 12

गलत दृष्टिकोण: [[कोई नहीं * एम] * एन]

>>> m, n = map(int, raw_input().split())
5 5
>>> x[0][0] = 34
>>> x
[[34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None]]
>>> id(x[0][0])
140416461589776
>>> id(x[3][0])
140416461589776

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

सही दृष्टिकोण लेकिन अपवाद के साथ:

y = [[0 for i in range(m)] for j in range(n)]
>>> id(y[0][0]) == id(y[1][0])
False

यदि आप डिफ़ॉल्ट मान सेट करते हैं तो यह अच्छा तरीका है लेकिन अपवाद है None

>>> r = [[None for i in range(5)] for j in range(5)]
>>> r
[[None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None]]
>>> id(r[0][0]) == id(r[2][0])
True

इसलिए इस दृष्टिकोण का उपयोग करके अपने डिफ़ॉल्ट मान को ठीक से सेट करें।

पूर्ण सही:

डबल लूप के माइक के उत्तर का पालन करें ।

Answer 13

Matrix={}
for i in range(0,3):
  for j in range(0,3):
    Matrix[i,j] = raw_input("Enter the matrix:")

Comments

हालांकि यह कोड प्रश्न का उत्तर दे सकता है, लेकिन यह कोड क्यों और / या इस प्रश्न के उत्तर के बारे में अतिरिक्त संदर्भ प्रदान करता है, इसके दीर्घकालिक मूल्य में सुधार करता है।

— अजीन

Answer 14

2-आयामी सरणी का उपयोग आरंभ करने के लिए: arr = [[]*m for i in range(n)]

वास्तव में, arr = [[]*m]*nएक 2 डी सरणी बनाएगा जिसमें सभी एन सरणियां एक ही सरणी को इंगित करेंगी, इसलिए किसी भी तत्व में मूल्य में कोई भी परिवर्तन सभी n सूचियों में परिलक्षित होगा

और अधिक स्पष्टीकरण यात्रा के लिए: https://www.geeksforgeeks.org/python-using-2d-arrays-lists-the-right-way/

Answer 15

इसे बनाने के लिए सबसे सरल सोच का उपयोग करें।

wtod_list = []

और आकार जोड़ें:

wtod_list = [[0 for x in xrange(10)] for x in xrange(10)]

या यदि हम आकार को पहले घोषित करना चाहते हैं। हम केवल उपयोग करते हैं:

   wtod_list = [[0 for x in xrange(10)] for x in xrange(10)]

Answer 16

जैसा @Arnab और @ माइक ने बताया, एक सरणी एक सूची नहीं है। कुछ भिन्नताएं 1 हैं) आरंभीकरण के दौरान निश्चित आकार 2 हैं) सरणियाँ सामान्य रूप से एक सूची की तुलना में कम संचालन का समर्थन करती हैं।

हो सकता है कि ज्यादातर मामलों में ओवरकिल हो, लेकिन यहां एक बुनियादी 2d सरणी कार्यान्वयन है जो अजगर ctypes (c पुस्तकालयों) का उपयोग करके हार्डवेयर सरणी कार्यान्वयन का लाभ उठाता है

import ctypes
class Array:
    def __init__(self,size,foo): #foo is the initial value
        self._size = size
        ArrayType = ctypes.py_object * size
        self._array = ArrayType()
        for i in range(size):
            self._array[i] = foo
    def __getitem__(self,index):
        return self._array[index]
    def __setitem__(self,index,value):
        self._array[index] = value
    def __len__(self):
        return self._size

class TwoDArray:
    def __init__(self,columns,rows,foo):
        self._2dArray = Array(rows,foo)
        for i in range(rows):
            self._2dArray[i] = Array(columns,foo)

    def numRows(self):
        return len(self._2dArray)
    def numCols(self):
        return len((self._2dArray)[0])
    def __getitem__(self,indexTuple):
        row = indexTuple[0]
        col = indexTuple[1]
        assert row >= 0 and row < self.numRows() \
               and col >=0 and col < self.numCols(),\
               "Array script out of range"
        return ((self._2dArray)[row])[col]

if(__name__ == "__main__"):
    twodArray = TwoDArray(4,5,5)#sample input
    print(twodArray[2,3])

Answer 17

महत्वपूर्ण बात जो मुझे समझ में आई है वह यह है: किसी सरणी (किसी भी आयाम में) को प्रारंभ करते समय हमें सरणी के सभी पदों के लिए एक डिफ़ॉल्ट मान देना चाहिए। तब केवल आरंभीकरण पूरा होता है। उसके बाद, हम सरणी के किसी भी स्थान पर नए मान बदल सकते हैं या प्राप्त कर सकते हैं। नीचे दिए गए कोड ने मेरे लिए पूरी तरह से काम किया

N=7
F=2

#INITIALIZATION of 7 x 2 array with deafult value as 0
ar=[[0]*F for x in range(N)]

#RECEIVING NEW VALUES TO THE INITIALIZED ARRAY
for i in range(N):
    for j in range(F):
        ar[i][j]=int(input())
print(ar)

Answer 18

यदि आप numpy का उपयोग करते हैं , तो आप आसानी से 2d arrays बना सकते हैं:

import numpy as np

row = 3
col = 5
num = 10
x = np.full((row, col), num)

एक्स

array([[10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10]])

Answer 19

row=5
col=5
[[x]*col for x in [b for b in range(row)]]

ऊपर आपको 5x5 2D सरणी दी जाएगी

[[0, 0, 0, 0, 0],
 [1, 1, 1, 1, 1],
 [2, 2, 2, 2, 2],
 [3, 3, 3, 3, 3],
 [4, 4, 4, 4, 4]]

यह नेस्टेड सूची समझ का उपयोग कर रहा है। नीचे के रूप में ब्रेकडाउन:

[[x]*col for x in [b for b in range(row)]]

[x] * col -> अंतिम अभिव्यक्ति जो
x -> x के लिए मूल्यांकन की जाती है, जो इट्रेटर द्वारा प्रदान की जाने वाली वैल्यू होगी
(बी फॉर रेंज (पंक्ति)]] -> इटरेटर।

[ख में बी के लिए सीमा (पंक्ति)]] यह [०,१,२,३,४,४] का मूल्यांकन करेगा पंक्ति = ५ के बाद से
अब इसे सरल बनाना

[[x]*col for x in [0,1,2,3,4]]

यह x [0,1,2,3,4] में x के लिए [[0] * 5 का मूल्यांकन करेगा -> x = 0 1 पुनरावृत्ति के साथ
[[1] * 5 के लिए x में [0,1,2] 3,4]] -> x = 1 2 पुनरावृत्ति
[[2] * 5 के लिए x में [0,1,2,3,4]] -> x = 2 3 पुनरावृत्ति के साथ
[[3] * 5 x के लिए [0,1,2,3,4]] -> x = 3 4 वें पुनरावृत्ति के साथ
[[4] * 5 के लिए x में [0,1,2,3,4]] -> x के साथ = 4 5 वीं पुनरावृत्ति

Answer 20

यह सबसे अच्छा है जो मैंने नए प्रोग्रामर को पढ़ाने के लिए पाया है, और अतिरिक्त पुस्तकालयों का उपयोग किए बिना। मुझे हालांकि कुछ बेहतर चाहिए।

def initialize_twodlist(value):
    list=[]
    for row in range(10):
        list.append([value]*10)
    return list

Answer 21

यहाँ एक आसान तरीका है:

import numpy as np
twoD = np.array([[]*m]*n)

किसी भी 'x' मान के उपयोग से सभी कोशिकाओं को आरंभ करने के लिए:

twoD = np.array([[x]*m]*n

Answer 22

अक्सर मैं इस दृष्टिकोण का उपयोग 2-आयामी सरणी को शुरू करने के लिए करता हूं

n=[[int(x) for x in input().split()] for i in range(int(input())]

Answer 23

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

x = 0
mat1 = []
for i in range(3):
    mat1.append(x)
    x+=1
print(mat1)


x=0
mat2 = []
for i in range(3):
    tmp = []
    for j in range(4):
        tmp.append(x)
        x+=1
    mat2.append(tmp)

print(mat2)


x=0
mat3 = []
for i in range(3):
    tmp = []
    for j in range(4):
        tmp2 = []
        for k in range(5):
            tmp2.append(x)
            x+=1
        tmp.append(tmp2)
    mat3.append(tmp)

print(mat3)

Comments

एसओ में आपका स्वागत है। इस सवाल का पहले से ही बड़े पैमाने पर वोट-स्वीकृत जवाब है। पहली नजर में, यह पोस्ट वास्तव में सवाल का जवाब नहीं देता है। मार्गदर्शन के लिए stackoverflow.com/help/how-to-answer देखें ।

— निक

Answer 24

आप यह कोशिश कर सकते हैं [[०] * १०] * १०। यह प्रत्येक सेल के लिए 10 पंक्तियों के 2d सरणी और मान 0 के साथ 10 कॉलम लौटाएगा।

Comments

यह मूल रूप से stackoverflow.com/a/25601284/2413201 के रूप में एक ही उत्तर है ...

— 9

यह एक ही पंक्ति में 10 पॉइंटर्स की सरणी बनाता है। यदि आप करते हैं a = [[0]*10]*10और फिर a[0][0] = 1आप देखेंगे कि प्रत्येक पंक्ति में पहला तत्व अब 1 के बराबर है

— andnik

Answer 25

lst = [[0] * मी के लिए मैं रेंज में (n)]

सभी मैट्रिक्स n = पंक्तियों और m = कॉलम को इनिशियलाइज़ करें

Comments

क्या आप कृपया कोड के रूप में कोड को प्रारूपित कर सकते हैं? यह अधिक पठनीय होगा।

— थॉमस

Answer 26

एक और तरीका दो-आयामी सरणी रखने के लिए एक शब्दकोश का उपयोग करना है।

twoD = {}
twoD[0,0] = 0
print(twoD[0,0]) # ===> prints 0

यह सिर्फ किसी भी 1 डी, 2 डी मूल्यों को पकड़ सकता है और इसे 0या किसी अन्य इंट वैल्यू को इनिशियलाइज़ करने के लिए , संग्रह का उपयोग कर सकता है ।

import collections
twoD = collections.defaultdict(int)
print(twoD[0,0]) # ==> prints 0
twoD[1,1] = 1
print(twoD[1,1]) # ==> prints 1

Answer 27

कोड:

num_rows, num_cols = 4, 2
initial_val = 0
matrix = [[initial_val] * num_cols for _ in range(num_rows)]
print(matrix) 
# [[0, 0], [0, 0], [0, 0], [0, 0]]

initial_val अपरिवर्तनीय होना चाहिए।

Answer 28

from random import randint
l = []

for i in range(10):
    k=[]
    for j in range(10):
        a= randint(1,100)
        k.append(a)

    l.append(k)




print(l)
print(max(l[2]))

b = []
for i in range(10):
    a = l[i][5]
    b.append(a)

print(min(b))

Comments

कृपया अपने कोड का वर्णन करते हुए कुछ पाठ जोड़ें।

— वाचाडामडूड ३०००

आमतौर पर अनाम कोड की कुछ पंक्तियों को पोस्ट करने के बजाय किसी समाधान की व्याख्या करना बेहतर होता है। आप पढ़ सकते हैं कि मैं कैसे एक अच्छा उत्तर लिखूं , और पूरी तरह से कोड-आधारित उत्तरों की व्याख्या करना ।

— मैसिमिलियानो क्रूस