পাইথনে আমার তালিকার একটি তালিকা তৈরি করা দরকার, তাই আমি নিম্নলিখিতগুলি টাইপ করেছি:
myList = [[1] * 4] * 3তালিকাটি এমন দেখাচ্ছে:
[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]] তারপরে আমি অন্তর্নিহিত মানগুলির মধ্যে একটি পরিবর্তন করেছি:
myList[0][0] = 5এখন আমার তালিকাটি এমন দেখাচ্ছে:
[[5, 1, 1, 1], [5, 1, 1, 1], [5, 1, 1, 1]] যা আমি চেয়েছিলাম বা প্রত্যাশিত তা নয়। কেউ দয়া করে কী ঘটছে তা ব্যাখ্যা করতে পারেন এবং কীভাবে এটি ঘটাবেন?
উত্তর:
আপনি যখন লিখবেন তখন [x]*3মূলত তালিকাটি পাবেন [x, x, x]। অর্থাৎ একই সাথে 3 টি উল্লেখ সহ একটি তালিকা x। আপনি যখন এই এককটি সংশোধন করেন তখন xএটি এর তিনটি উল্লেখের মাধ্যমেই দৃশ্যমান হয়:
x = [1] * 4
l = [x] * 3
print(f"id(x): {id(x)}")
# id(x): 140560897920048
print(
f"id(l[0]): {id(l[0])}\n"
f"id(l[1]): {id(l[1])}\n"
f"id(l[2]): {id(l[2])}"
)
# id(l[0]): 140560897920048
# id(l[1]): 140560897920048
# id(l[2]): 140560897920048
x[0] = 42
print(f"x: {x}")
# x: [42, 1, 1, 1]
print(f"l: {l}")
# l: [[42, 1, 1, 1], [42, 1, 1, 1], [42, 1, 1, 1]]এটি ঠিক করার জন্য, আপনাকে অবশ্যই নিশ্চিত করতে হবে যে আপনি প্রতিটি পজিশনে একটি নতুন তালিকা তৈরি করেছেন। এটি করার একটি উপায়
[[1]*4 for _ in range(3)]যা [1]*4একবারে মূল্যায়নের পরিবর্তে এবং একবারে তালিকায় 3 টি উল্লেখ করার পরিবর্তে প্রতিটি সময় পুনরায় মূল্যায়ন করবে।
আপনি হয়ত ভাবতে *পারেন যে তালিকা বোধগম্যতা কেন স্বাধীন পদার্থ তৈরি করতে পারে না। এর কারণ কারণ গুণটি অপারেটর *এক্সপ্রেশন না দেখে অবজেক্টগুলিতে অপারেট করে। আপনি যখন 3 দ্বারা *গুণন করতে ব্যবহার করেন [[1] * 4], *কেবলমাত্র 1-উপাদান তালিকাটি এক্সপ্রেশন টেক্সটকে [[1] * 4]নয়, মূল্যায়নে দেখে [[1] * 4। *কীভাবে সেই উপাদানটির অনুলিপিগুলি তৈরি করবেন, কীভাবে পুনরায় মূল্যায়ন করবেন সে [[1] * 4]সম্পর্কে কোনও ধারণা নেই এবং আপনি এমনকি অনুলিপিগুলি চান এমন কোনও ধারণা নেই এবং সাধারণভাবে, উপাদানটির অনুলিপি করার উপায়ও নেই।
একমাত্র বিকল্পটি *হ'ল নতুন সাবলিস্ট তৈরির চেষ্টা না করে বিদ্যমান সাবলিস্টে নতুন উল্লেখ করা। অন্য যে কোনও কিছুই অসঙ্গত হতে পারে বা মৌলিক ভাষা নকশার সিদ্ধান্তগুলির প্রধান পুনর্নির্মাণের প্রয়োজন।
বিপরীতে, একটি তালিকা বোধগম্য প্রতিটি পুনরাবৃত্তিতে উপাদান এক্সপ্রেশন পুনর্মূল্যায়ন করে। [[1] * 4 for n in range(3)]reevaluates [1] * 4একই কারণে প্রত্যেক সময় [x**2 for x in range(3)]reevaluates x**2প্রত্যেক সময়। প্রতিটি মূল্যায়ন [1] * 4একটি নতুন তালিকা উত্পন্ন করে, সুতরাং তালিকা বোঝার আপনি যা চেয়েছিলেন তা করে does
ঘটনাচক্রে, [1] * 4উপাদানগুলির অনুলিপিও করে না [1], তবে এটি কোনও বিষয় নয়, যেহেতু পূর্ণসংখ্যার পরিবর্তনযোগ্য। আপনি এর মতো কিছু করতে 1.value = 2এবং একটি 1 কে 2 তে পরিণত করতে পারবেন না ।
[4]*3মূলত সমতুল্য x = 4; [x, x, x]। যদিও এটি সত্য, যেহেতু এটি পরিবর্তনযোগ্য না হওয়ার কারণে এটি কোনও সমস্যার কারণ হতে পারে না 4। এছাড়াও, আপনার অন্য উদাহরণটি সত্যিই আলাদা ঘটনা নয়। পরিবর্তনীয় a = [x]*3; a[0] = 5হলেও সমস্যা তৈরি করবে না x, যেহেতু আপনি পরিবর্তন করছেন না x, কেবল পরিবর্তন করছেন a। আমি আমার উত্তরকে বিভ্রান্তিমূলক বা ভুল হিসাবে বর্ণনা করব না - আপনি যদি অপরিবর্তনীয় কোনও জিনিস নিয়ে কাজ করেন তবে আপনি কেবল নিজেকে পায়ে গুলি করতে পারবেন না ।
x = 1000; lst = [x]*2; lst[0] is lst[1]-> True। পাইথন এখানে যা কিছু পরিবর্তনযোগ্য এবং অপরিবর্তনীয় বস্তুর মধ্যে পার্থক্য করে না।
size = 3
matrix_surprise = [[0] * size] * size
matrix = [[0]*size for i in range(size)]
xউল্লেখ করে। যদি আপনি একটি বিশ্বব্যাপী অনন্য বস্তুটি x = object()তৈরি matrix = [[x] * 2]করে থাকেন এবং সেগুলি সত্য করে দেন:matrix[0][0] is matrix[0][1]
list) সুতরাং যেখানে উভয় সারি হুবহু একই বস্তুর একের row = [x] * 2চেয়ে বেশি matrix = [row] * 2হয় এবং এখন এক সারিতে matrix[0][0] = yহঠাৎ করে অন্য একটিতে প্রতিফলিত হয়(matrix[0][0] is matrix[1][0]) == True
প্রকৃতপক্ষে, আপনি আশা করবেন ঠিক এটিই। আসুন এখানে কি ঘটছে তা পচিয়ে দিন:
তুমি লেখ
lst = [[1] * 4] * 3এটি সমান:
lst1 = [1]*4
lst = [lst1]*3এর অর্থ lstহল একটি তালিকা যা 3 টি উপাদানকে নির্দেশ করে lst1। এর অর্থ নিম্নলিখিত দুটি লাইন সমান:
lst[0][0] = 5
lst1[0] = 5হিসাবে lst[0]কিছুই কিন্তু lst1।
পছন্দসই আচরণটি পেতে, আপনি তালিকা বোঝার ব্যবহার করতে পারেন:
lst = [ [1]*4 for n in range(3) ] #python 3
lst = [ [1]*4 for n in xrange(3) ] #python 2এই ক্ষেত্রে, এক্সপ্রেশনটি প্রতিটি এন এর জন্য পুনরায় মূল্যায়ন করা হয়, যা একটি ভিন্ন তালিকার দিকে নিয়ে যায়।
id(lst[0][0])এবং id(lst[1][0])বা এমনকি id(lst[0])এবংid(lst[1])
[[1] * 4] * 3অথবা এমনকি:
[[1, 1, 1, 1]] * 3একটি তালিকা তৈরি করে যা অভ্যন্তরীণটিকে [1,1,1,1]3 বার উল্লেখ করে - অভ্যন্তরীণ তালিকার তিনটি অনুলিপি নয়, তাই আপনি যে কোনও সময় তালিকাটি (যে কোনও অবস্থানে) সংশোধন করবেন, আপনি তিনবার পরিবর্তনটি দেখতে পাবেন।
এটি এই উদাহরণ হিসাবে একই:
>>> inner = [1,1,1,1]
>>> outer = [inner]*3
>>> outer
[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
>>> inner[0] = 5
>>> outer
[[5, 1, 1, 1], [5, 1, 1, 1], [5, 1, 1, 1]]যেখানে এটি সম্ভবত খানিকটা অবাক হওয়ার মতো।
আপনার তালিকা উপলব্ধির মধ্যে, সমস্যাটি সঠিকভাবে ব্যাখ্যা করার মতো স্বীকৃত উত্তরের পাশাপাশি, আপনি যদি পাইথন -২.x ব্যবহার করে xrange()যা কোনও জেনারেটর ফেরত দেয় যা আরও কার্যকর ( range()পাইথন 3 তে একই কাজ করে) ফেলে _দেয় পরিবর্তনের পরিবর্তে n:
[[1]*4 for _ in xrange(3)] # and in python3 [[1]*4 for _ in range(3)]এছাড়াও, বারবার উপাদানগুলির একটি পুনরাবৃত্তি বস্তু তৈরি করতে আপনি আরও বেশি পাইথোনিক উপায় ব্যবহার করতে পারেন itertools.repeat():
>>> a=list(repeat(1,4))
[1, 1, 1, 1]
>>> a[0]=5
>>> a
[5, 1, 1, 1]দ্রষ্টব্য numpy ব্যবহার করে, আপনি শুধুমাত্র বেশী বা শূণ্যসমূহ আপনি ব্যবহার করতে পারেন একটি অ্যারের তৈরি করতে চান np.onesএবং np.zerosএবং / অথবা অন্যান্য সংখ্যা ব্যবহারের জন্য np.repeat():
In [1]: import numpy as np
In [2]:
In [2]: np.ones(4)
Out[2]: array([ 1., 1., 1., 1.])
In [3]: np.ones((4, 2))
Out[3]:
array([[ 1., 1.],
[ 1., 1.],
[ 1., 1.],
[ 1., 1.]])
In [4]: np.zeros((4, 2))
Out[4]:
array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.],
[ 0., 0.]])
In [5]: np.repeat([7], 10)
Out[5]: array([7, 7, 7, 7, 7, 7, 7, 7, 7, 7])পাইথন পাত্রে অন্যান্য বস্তুর উল্লেখ রয়েছে। এই উদাহরণটি দেখুন:
>>> a = []
>>> b = [a]
>>> b
[[]]
>>> a.append(1)
>>> b
[[1]]এই সালে bএকটি তালিকা যে একটি আইটেম যে তালিকায় একটি রেফারেন্স রয়েছে a। তালিকাটি aপরিবর্তনযোগ্য।
একটি পূর্ণসংখ্যার দ্বারা তালিকার গুণনটি তালিকাটিকে একাধিকবার যুক্ত করার সমতুল্য (দেখুন সাধারণ সিকোয়েন্স ক্রিয়াকলাপগুলি দেখুন )। উদাহরণ দিয়ে চালিয়ে যাচ্ছি:
>>> c = b + b
>>> c
[[1], [1]]
>>>
>>> a[0] = 2
>>> c
[[2], [2]]আমরা দেখতে পাচ্ছি যে তালিকার cএখন তালিকার দুটি উল্লেখ রয়েছে aযা সমান c = b * 2।
পাইথন এফএকিউতেও এই আচরণের ব্যাখ্যা রয়েছে: আমি কীভাবে একটি বহুমাত্রিক তালিকা তৈরি করব?
myList = [[1]*4] * 3[1,1,1,1]মেমরিতে একটি তালিকা অবজেক্ট তৈরি করে এবং তার রেফারেন্সটি 3 বারের বেশি অনুলিপি করে। এটি সমান obj = [1,1,1,1]; myList = [obj]*3। যে কোনও পরিবর্তনটি তালিকায় objযেখানেই objউল্লেখ করা হয়েছে সেখানে তিন জায়গায় প্রতিফলিত হবে । সঠিক বক্তব্যটি হ'ল:
myList = [[1]*4 for _ in range(3)]অথবা
myList = [[1 for __ in range(4)] for _ in range(3)]এখানে লক্ষণীয় গুরুত্বপূর্ণ বিষয় হ'ল *অপারেটর বেশিরভাগ আক্ষরিক তালিকা তৈরি করতে ব্যবহৃত হয় । যদিও 1তা অপরিবর্তনীয়, obj =[1]*4তবুও গঠন করতে 14 বার পুনরাবৃত্তি একটি তালিকা তৈরি করবে[1,1,1,1] । তবে যদি কোনও অপরিবর্তনীয় অবজেক্টের কোনও রেফারেন্স তৈরি করা হয় তবে অবজেক্টটি একটি নতুন দিয়ে ওভাররাইট করা হয়।
এই উপায়ে আমরা যদি না obj[1]=42হয়, তাহলে objহয়ে যাবে [1,42,1,1] না [42,42,42,42]
>>> myList = [1]*4
>>> myList
[1, 1, 1, 1]
>>> id(myList[0])
4522139440
>>> id(myList[1]) # Same as myList[0]
4522139440>>> myList[1] = 42 # Since myList[1] is immutable, this operation overwrites myList[1] with a new object changing its id.
>>> myList
[1, 42, 1, 1]
>>> id(myList[0])
4522139440
>>> id(myList[1]) # id changed
4522140752
>>> id(myList[2]) # id still same as myList[0], still referring to value `1`.
4522139440obj[2] = 42 রেফারেন্স প্রতিস্থাপন সূচিতে 2, যেমন বস্তু সূচক, যা কি দ্বারা সমর্থিত mutating বিরোধিতা myList[2][0] = ...করে ( myList[2]একটি তালিকা, এবং assigment গন্ধে পরিবর্তন Tha তালিকায় সূচক 0 এ রেফারেন্স)। অবশ্যই, পূর্ণসংখ্যার পরিবর্তনযোগ্য নয়, তবে প্রচুর পরিমাণে অবজেক্টের ধরণের হয় । এবং উল্লেখ্য যে [....]তালিকা প্রদর্শন স্বরলিপিটিও আক্ষরিক সিনট্যাক্সের একটি রূপ! পরিবর্তনীয় বনাম অপরিবর্তনীয় বস্তুগুলির সাথে যৌগিক (যেমন তালিকার মতো) এবং স্কেলার অবজেক্টগুলিকে (যেমন পূর্ণসংখ্যার) গুলিয়ে ফেলবেন না।
সাধারণ কথায় এটি ঘটছে কারণ অজগরটিতে সবকিছু রেফারেন্স অনুসারে কাজ করে , সুতরাং আপনি যখন তালিকাটির একটি তালিকা তৈরি করেন আপনি মূলত এই জাতীয় সমস্যাগুলি শেষ করেন।
আপনার সমস্যা সমাধানের জন্য আপনি এগুলির মধ্যে একটি করতে পারেন: ১. numpy.empty এর জন্য ন্যালি অ্যারে ডকুমেন্টেশন ব্যবহার করুন ২. আপনি একটি তালিকায় পৌঁছানোর সাথে সাথে তালিকা যুক্ত করুন। ৩. আপনি চাইলে অভিধানও ব্যবহার করতে পারেন
আসুন আপনার কোডটি নিম্নলিখিত উপায়ে আবার লিখুন:
x = 1
y = [x]
z = y * 4
myList = [z] * 3তারপরে এটি থাকার পরে, সমস্ত কিছু আরও স্পষ্ট করতে নিম্নলিখিত কোডটি চালান। কোডটি কী করে তা মূলত idপ্রাপ্ত বস্তুর গুলি প্রিন্ট করে
কোনও বস্তুর "পরিচয়" ফিরিয়ে দিন
এবং সেগুলি সনাক্ত করতে এবং কী ঘটে তা বিশ্লেষণে আমাদের সহায়তা করবে:
print("myList:")
for i, subList in enumerate(myList):
print("\t[{}]: {}".format(i, id(subList)))
for j, elem in enumerate(subList):
print("\t\t[{}]: {}".format(j, id(elem)))এবং আপনি নিম্নলিখিত আউটপুট পাবেন:
x: 1
y: [1]
z: [1, 1, 1, 1]
myList:
[0]: 4300763792
[0]: 4298171528
[1]: 4298171528
[2]: 4298171528
[3]: 4298171528
[1]: 4300763792
[0]: 4298171528
[1]: 4298171528
[2]: 4298171528
[3]: 4298171528
[2]: 4300763792
[0]: 4298171528
[1]: 4298171528
[2]: 4298171528
[3]: 4298171528সুতরাং এখন আমাদের ধাপে ধাপে যেতে দিন। আপনার কাছে xযা রয়েছে 1এবং একটি একক উপাদান তালিকা yরয়েছে x। আপনার প্রথম পদক্ষেপটি y * 4যা আপনাকে একটি নতুন তালিকা এনে দেবে, যা zমূলতঃ [x, x, x, x], তাই এটি একটি নতুন তালিকা তৈরি করে যার মধ্যে 4 টি উপাদান থাকবে, যা প্রাথমিক xঅবজেক্টের রেফারেন্স । নেট ধাপটি বেশ অনুরূপ। আপনি মূলত z * 3যা করেন [[x, x, x, x]] * 3এবং যা [[x, x, x, x], [x, x, x, x], [x, x, x, x]]প্রথম পদক্ষেপের জন্য একই কারণে হয় returns
এটি আরও বর্ণনামূলকভাবে ব্যাখ্যা করার চেষ্টা করছি,
অপারেশন 1:
x = [[0, 0], [0, 0]]
print(type(x)) # <class 'list'>
print(x) # [[0, 0], [0, 0]]
x[0][0] = 1
print(x) # [[1, 0], [0, 0]]অপারেশন 2:
y = [[0] * 2] * 2
print(type(y)) # <class 'list'>
print(y) # [[0, 0], [0, 0]]
y[0][0] = 1
print(y) # [[1, 0], [1, 0]]লক্ষ্য করা গেল কেন প্রথম তালিকার প্রথম উপাদানটি সংশোধন করে প্রতিটি তালিকার দ্বিতীয় উপাদানটি সংশোধন করে না? এটার কারন[0] * 2 সত্যই দুটি সংখ্যার একটি তালিকা, এবং 0 এর একটি রেফারেন্স পরিবর্তন করা যায় না।
আপনি যদি ক্লোন অনুলিপি তৈরি করতে চান তবে অপারেশন 3 চেষ্টা করুন:
import copy
y = [0] * 2
print(y) # [0, 0]
y = [y, copy.deepcopy(y)]
print(y) # [[0, 0], [0, 0]]
y[0][0] = 1
print(y) # [[1, 0], [0, 0]]ক্লোন অনুলিপি তৈরির আর একটি আকর্ষণীয় উপায়, অপারেশন 4:
import copy
y = [0] * 2
print(y) # [0, 0]
y = [copy.deepcopy(y) for num in range(1,5)]
print(y) # [[0, 0], [0, 0], [0, 0], [0, 0]]
y[0][0] = 5
print(y) # [[5, 0], [0, 0], [0, 0], [0, 0]]পাইথন তালিকার গুণাবলী থেকে @ স্পেলচেকার : [[...]] * 3 3 টি তালিকা তৈরি করে যা সংশোধিত হওয়ার পরে একে অপরকে মিরর করে এবং আমার সম্পর্কে একই প্রশ্ন ছিল "কেবলমাত্র বাহ্যিক * 3 কেন আরও রেফারেন্স তৈরি করে যখন অভ্যন্তরীণটি তা করে না কেন সব 1s হয় না? "
li = [0] * 3
print([id(v) for v in li]) # [140724141863728, 140724141863728, 140724141863728]
li[0] = 1
print([id(v) for v in li]) # [140724141863760, 140724141863728, 140724141863728]
print(id(0)) # 140724141863728
print(id(1)) # 140724141863760
print(li) # [1, 0, 0]
ma = [[0]*3] * 3 # mainly discuss inner & outer *3 here
print([id(li) for li in ma]) # [1987013355080, 1987013355080, 1987013355080]
ma[0][0] = 1
print([id(li) for li in ma]) # [1987013355080, 1987013355080, 1987013355080]
print(ma) # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]উপরের কোডটি চেষ্টা করার পরে এখানে আমার ব্যাখ্যা:
*3রেফারেন্স তৈরি করে, তবে এটি উল্লেখগুলি অপরিবর্তনীয়, এর মতো কিছু [&0, &0, &0], তারপর যখন পরিবর্তন করা যায় তবে li[0]আপনি কনস্টের কোনও অন্তর্নিহিত রেফারেন্স পরিবর্তন করতে পারবেন না 0, তাই আপনি কেবলমাত্র রেফারেন্সের ঠিকানাটি নতুনটিতে পরিবর্তন করতে পারবেন &1;ma=[&li, &li, &li]এবং liপরিবর্তনীয় হয়, সুতরাং যখন আপনি কল করবেন ma[0][0]=1, মা [0] [0] সমান &li[0], তাই সমস্ত &liদৃষ্টান্ত তার প্রথম ঠিকানাটিকে পরিবর্তিত করবে &1।ইনবিল্ট তালিকা ফাংশনটি ব্যবহার করে আপনি এটি করতে পারেন
a
out:[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
#Displaying the list
a.remove(a[0])
out:[[1, 1, 1, 1], [1, 1, 1, 1]]
# Removed the first element of the list in which you want altered number
a.append([5,1,1,1])
out:[[1, 1, 1, 1], [1, 1, 1, 1], [5, 1, 1, 1]]
# append the element in the list but the appended element as you can see is appended in last but you want that in starting
a.reverse()
out:[[5, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
#So at last reverse the whole list to get the desired lista.insert(0,[5,1,1,1])
[x]*33 টি রেফারেন্সের মতো স্টোর[x, x, x]কেবল তখনই ঠিক হয় যখনxপরিবর্তনযোগ্য হয়। যেমন এই does't কাজa=[4]*3, যেখানে পরেa[0]=5,a=[5,4,4].