পাইথনে দ্বি-মাত্রিক অ্যারে কীভাবে শুরু করবেন?

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

কেবলমাত্র একটি ছোট (বা তাৎপর্যপূর্ণ, কে দেখছে তার উপর নির্ভর করে) নটপিক: তালিকাগুলি অ্যারে নয়। আপনি যদি অ্যারে চান, অল্প ব্যবহার করুন।

— অর্ণব দত্ত

এই প্রশ্নটি অনুরূপ : এটি পাইথনের বহুমাত্রিক অ্যারেগুলির সূচনা নিয়ে আলোচনা করে।

— অ্যান্ডারসন গ্রিন

@ অর্ণবদত্ত আপনি কীভাবে নালায় একটি বহুমাত্রিক অ্যারে শুরু করবেন?

— অ্যান্ডারসন সবুজ

@ অ্যান্ডারসগ্রিন

— অর্ণব দত্ত

আপনি ডিফল্ট পাইথনে কাঠামোর মতো অ্যারেতে ডেটা সাজিয়ে নিতে পারেন তবে এটি কোনও NumPy অ্যারের মতো দক্ষ বা কার্যকর নয় not বিশেষত যদি আপনি বড় ডেটা সেটগুলি ব্যবহার করতে চান। এখানে কিছু ডকুমেন্টেশন ডক্স.স্কিপি.অর্গ

— নম্পি

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] * 10 x x x x (10)] এর জন্য একটি উপলব্ধি থেকে মুক্তি পেতে ব্যবহার করা যেতে পারে। সমস্যাটি হ'ল গুণটি অগভীর অনুলিপি করে, তাই নতুন = [foo] * 10 নতুন = [নতুন] * 10 আপনাকে দশবার একই তালিকাযুক্ত একটি তালিকা পাবেন।

— স্কট ওলচোক

একইভাবে, [foo] * 10একই একই foo10 বারের সাথে একটি তালিকা রয়েছে যা গুরুত্বপূর্ণ বা নাও হতে পারে।

— মাইক গ্রাহাম

আমরা সবচেয়ে সহজ জিনিসটি ব্যবহার করতে পারি: wtod_list = [[0 x x x x (10))] x x x x x (10)]

— indi60

যদিও কোনও মাছ দেখতে কেমন লাগে তা কাউকে দেখাতে কখনই ব্যাথা লাগে না।

— Csteele5

মাইক গ্রাহামের সম্পর্কে মন্তব্যটির জন্য [foo] * 10: এর অর্থ এই যে আপনি এলোমেলো সংখ্যার সাথে একটি অ্যারে পূরণ করছেন তবে এটি কাজ করবে না (মূল্যায়ন [random.randint(1,2)] * 10করে [1] * 10বা [2] * 10যার অর্থ আপনি একটি এলোমেলো অ্যারের পরিবর্তে সমস্ত 1 বা 2 এর অ্যারে পেয়েছেন

— 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) এটির সমান, তবে নেস্টেড লুপটি প্রথমে আসতে হবে [আমি রেঞ্জের জন্য রেঞ্জ (রেঞ্জ_ওফ_জে)]

— আসতে হবে

এই উত্তরটি যেহেতু আমরা বারবার জরিমানা কিন্তু আমি কাজ করে iসারি এবং jকলামের জন্য, আমি মনে করি এটা swap 'র ভাল হওয়া উচিত 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) তবে এটি আরও বেশি কার্যকর কারণ এটি নামের সন্ধানকে এড়িয়ে চলে। যে কোনও উপায়ে, এটি প্রতিটি সারির অগভীর অনুলিপি তৈরি করে, তাই এখন সমস্ত উপাদান স্বাধীন are

সমস্ত উপাদান 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। আপনার যদি একটি স্বেচ্ছাসেবী পরিবর্তনযোগ্য বস্তু থাকে তবে আপনার ডেটা নির্দিষ্ট করার জন্য আপনার একটি পরিকল্পনা দরকার।

— মাইক গ্রাহাম

আপনার যদি কোনও লুপে খারাপভাবে গতির প্রয়োজন হয় তবে সিথন, বুনা বা অনুরূপ ব্যবহার করার সময় হতে পারে ...

— james.haggerty

@ জনলআরউয়ি আপনি ভাবেন আপনি বদলে গেছেন xএবং y। এটি হওয়া উচিত নয়[[copy.deepcopy(foo) for y in range(10)] for x in range(10)]

— ব্যবহারকারীর 3085931

@ নিলগুলি [foo]*1010 টি পৃথক অবজেক্ট তৈরি করে না - তবে foo যেমন 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।

— চিনিয়

উত্সাহিত, যেহেতু এটি আমাকে পেয়েছে। পরিষ্কার হতে হবে [[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)]।

— জেডএক্স 9

Answer 6

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

Comments

এক্সরেঞ্জ () পাইথন 3.5-এ সরানো হয়েছে

— মিয়াকিম

কেন এটি কাজ করে না: [0 * করল] * সারি। আমি যখন কিছু উপাদান সংশোধন করি তখন এটি অন্য জায়গায় প্রতিলিপি করে দেয়। তবে কেন বুঝতে পারছি না?

— কোড মুনচার

কারণ এটি প্রশ্নের মতো কোডের মতো একই কাজ করে।

— Ignacio Vazquez-Abram

@ কোডডেমুনচার [[0] * col] * rowআপনি যা চান তা না করার কারণ কারণ আপনি যখন 2 ডি তালিকা শুরু করবেন তখন পাইথন প্রতিটি সারিটির আলাদা কপি তৈরি করবে না। পরিবর্তে এটি একই অনুলিপিটিতে পয়েন্টার সহ বাইরের তালিকাটি সূচনা করবে [0]*col। সারিগুলির একটিতে আপনি যে কোনও সম্পাদনা করেন তারপরে অবশিষ্ট সারিগুলিতে প্রতিফলিত হবে যেহেতু এগুলি আসলে মেমরিতে একই ডেটারে নির্দেশ করছে।

— অ্যাডি

কেবল একটি চিন্তাভাবনা কিন্তু এই সমস্ত তালিকা কি সংযোজনের পক্ষে ভাল নয়? অর্থাৎ। যদি আমি 3 * 6 মাত্রার একটি খালি 2D তালিকা চাই এবং সূচক [0] [0], [1] [0], [2] [0] এবং আরও 18 টি উপাদান পূরণ করতে চাই তবে এর মধ্যে কোনওটিই নয় এই উত্তরগুলি ঠিক কাজ করবে?

— mLstudent33

Answer 7

সাধারণত যখন আপনি বহুমাত্রিক অ্যারে চান আপনি তালিকার একটি তালিকা চান না, বরং একটি অদ্ভুত অ্যারে বা সম্ভবত একটি ডিক চান।

উদাহরণস্বরূপ, নপি দিয়ে আপনি এমন কিছু করবেন

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

Comments

যদিও numpyদুর্দান্ত, আমি মনে করি এটি কোনও শিক্ষানবিসের জন্য কিছুটা ওভারকিল হতে পারে।

— এস্তেবান কাবার

নম্পি একটি বহুমাত্রিক অ্যারে প্রকার সরবরাহ করে। তালিকার বাইরে একটি ভাল বহুমাত্রিক অ্যারে তৈরি করা অসম্ভব ব্যবহারের চেয়ে শুরুর পক্ষে কম দরকারী এবং কঠিন। নেস্টেড তালিকাগুলি কিছু অ্যাপ্লিকেশনের জন্য দুর্দান্ত তবে সাধারণত 2 ডি অ্যারে চায় এমন ব্যক্তিরা সেরা হন না।

— মাইক গ্রাহাম

কয়েক বছর পরে মাঝে মাঝে মারাত্মক অজগর অ্যাপস করার পরে স্ট্যান্ডার্ড পাইথন অ্যারেগুলির স্পর্শগুলি কেবল এগিয়ে যাওয়ার পরোয়ানা বলে মনে হচ্ছে numpy। +1

— জাভাদ্ব্বা

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

আমার অভিজ্ঞতায়, এই "অনাকাঙ্ক্ষিত" প্রভাবটি প্রায়শই কিছু খুব খারাপ যৌক্তিক ত্রুটির উত্স হয়। আমার মতে, এই পদ্ধতির এড়ানো উচিত, পরিবর্তে @ বিপুলের উত্তরটি আরও ভাল।

— অ্যালান টুরিং

এই পদ্ধতিটি ভাল কাজ করে, কেন মন্তব্যে কিছু লোক এটিকে খারাপ হিসাবে উল্লেখ করেন?

— ব্র্যাভো

নিম্নতর পার্শ্ব প্রতিক্রিয়াটির কারণে, আপনি সত্যই এটিকে ম্যাট্রিক্স হিসাবে ধরে নিতে পারবেন না। আপনি যদি বিষয়বস্তু পরিবর্তন করতে না চান তবে তা ঠিক হয়ে যাবে।

— hithwen

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 ডি অ্যারে তৈরি করবে যাতে সমস্ত এন অ্যারে একই অ্যারেতে নির্দেশ করবে, সুতরাং যে কোনও উপাদানের মানের পরিবর্তনটি সমস্ত এন তালিকায় প্রতিফলিত হবে

আরও বিশদ ব্যাখ্যার জন্য এখানে যান: 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

@ অর্ণব এবং @ মাইক হিসাবে উল্লেখ করা হয়েছে, একটি অ্যারে তালিকা নয়। কয়েকটি পার্থক্য হ'ল 1) অ্যারেগুলি আরম্ভের সময় নির্দিষ্ট আকার হয় 2) অ্যারে সাধারণত কোনও তালিকার চেয়ে কম অপারেশনগুলিকে সমর্থন করে।

সম্ভবত বেশিরভাগ ক্ষেত্রেই ওভারকিল হতে পারে তবে পাইথন সিটিপস (সি লাইব্রেরি) ব্যবহার করে হার্ডওয়্যার অ্যারে বাস্তবায়নের জন্য এখানে একটি বেসিক 2 ডি অ্যারে বাস্তবায়ন রয়েছে verages

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

আপনি যদি ন্যালি ব্যবহার করেন তবে আপনি সহজেই 2 ডি অ্যারে তৈরি করতে পারেন:

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] * কল -> চূড়ান্ত এক্সপ্রেশন যা
এক্স ইন -> এক্স এর জন্য মূল্যায়ন করা হয় তা হবে পুনরাবৃত্তির দ্বারা সরবরাহ করা মান
[বি রেঞ্জের জন্য (সারি)]] -> আইট্রেটার।

[পরিসীমা (সারিতে) খ এর জন্য]] সারি = 5 থেকে এটি [0,1,2,3,4] এ মূল্যায়ন করবে
সুতরাং এখন এটি সরল করে তোলে

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

এটি x [0,1,2,3,4]] এ x এর জন্য [[0] * 5 এর মূল্যায়ন করবে -> x = 0 ম পুনরাবৃত্তির সাথে
[[1] * 5 x এর জন্য [0,1,2, 3,4]] -> x = 1 য় 2 য় পুনরাবৃত্তির সাথে
[[2] * 5 x এর জন্য [0,1,2,3,4]] -> x = 2 তৃতীয় পুনরাবৃত্তি সহ
[[3] * 5 x এর জন্য [0,1,2,3,4]] -> x = 3 4 র্থ পুনরাবৃত্তির সাথে
[[4] * 5 x এর জন্য [0,1,2,3,4]] -> x এর সাথে = 4 ম পুনরাবৃত্তি

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)

কোনও 'এক্স' মান ব্যবহারের সাথে সমস্ত কক্ষকে সূচনা করার জন্য:

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

এসও আপনাকে স্বাগতম। এই প্রশ্নের ইতিমধ্যে একটি ব্যাপক আপ-গ্রহণযোগ্য উত্তর রয়েছে has প্রথম দর্শনে, এই পোস্টটি আসলে প্রশ্নের উত্তর দেয় না। গাইডের জন্য stackoverflow.com/help/how-to-answer দেখুন ।

— নিক

Answer 24

আপনি এটি [[0] * 10] * 10 চেষ্টা করে দেখতে পারেন। এটি প্রতিটি কক্ষের মান 0 সহ 10 টি সারি এবং 10 কলামের 2d অ্যারে প্রদান করবে।

Comments

এই মূলত হিসাবে একই উত্তর stackoverflow.com/a/25601284/2413201 ...

— Armali

এটি একই সারিতে 10 পয়েন্টারের অ্যারে তৈরি করে। আপনি যদি করেন a = [[0]*10]*10এবং তারপরে a[0][0] = 1আপনি প্রতিটি সারিতে প্রথম উপাদানটি দেখতে পাবেন এখন সমান 1

— andnik

Answer 25

lst = [[0] * এম রেঞ্জে আমার জন্য (এন)]

সমস্ত ম্যাট্রিক্স এন = সারি এবং এম = কলাম শুরু করুন

Comments

আপনি কি কোড হিসাবে কোড ফর্ম্যাট করতে পারেন? এটি আরও বেশি পাঠযোগ্য।

— থমাস

Answer 26

আরেকটি উপায় হ'ল দ্বি-মাত্রিক অ্যারে ধরে রাখতে অভিধানকে ব্যবহার করা।

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

এটি কেবল যে কোনও 1 ডি, 2 ডি মান ধরে রাখতে পারে এবং এটি 0বা অন্য কোনও int মানকে আরম্ভ করতে , সংগ্রহগুলি ব্যবহার করতে পারে ।

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

আপনার কোডটি কী করে তা বর্ণনা করে কিছু পাঠ্য যুক্ত করুন।

— whackamadoodle3000

সাধারণত বেনাম কোডের কয়েকটি সারি পোস্ট করার পরিবর্তে কোনও সমাধান ব্যাখ্যা করা ভাল। আপনি কীভাবে আমি একটি ভাল উত্তর লিখতে পারি এবং পুরোপুরি কোড ভিত্তিক উত্তরগুলিও ব্যাখ্যা করতে পারি ।

— ম্যাসিমিলিয়ানো ক্রাউস