mutability, alias আর copy — দুই নাম, এক list-এর রহস্য

১ · একটি রহস্যময় বাগ — যে কপি আসলে কপি নয়

খুলনার একটি স্কুলের এক শিক্ষক Python দিয়ে নিজের ক্লাসের নম্বরপত্র রাখেন। প্রতিটি শিক্ষার্থীর জন্য একটি ছোট list: নাম আর বিষয়ভিত্তিক নম্বর। পুরো শ্রেণির নম্বর একটি বড় list-এ। পরীক্ষার পর তিনি একটি “যদি” হিসাব করতে চাইলেন — যদি সবাইকে ৫ নম্বর গ্রেস দিই, তাহলে কতজন পাস করবে? আসল নম্বর যেন না বদলায়, তাই তিনি সাবধানে লিখলেন trial = marks, তারপর trial-এ ৫ যোগ করলেন।

হিসাব ঠিকঠাক এল। কিন্তু পরদিন ছাপানো ফলাফলে দেখা গেল — সবার নম্বরে ৫ বেশি! আসল নম্বরপত্রও বদলে গেছে। তিনি ভাবলেন trial = marks লিখেই তো কপি করেছিলাম, তাহলে আসলটা বদলাল কীভাবে?

পর্ব ০৫-এ আপনি এর উত্তরের বীজ দেখেছেন: Python-এ নাম হলো লেবেল, বাক্স নয়। এই পর্বে সেই বীজ থেকে পুরো গাছ জন্মাবে। কারণ “দুটি নাম একই object দেখাচ্ছে” — এই একটি তথ্য না জানার কারণে Python-এর সবচেয়ে বেশি “রহস্যময়” বাগ তৈরি হয়। নতুনদের কোডে, অভিজ্ঞদের কোডে, আর AI-এর লেখা কোডেও।

২ · Mutable আর immutable — কোন object বদলানো যায়

Python-এর প্রতিটি object তৈরির মুহূর্তেই একটি স্থায়ী বৈশিষ্ট্য নিয়ে জন্মায়: তার ভেতরের মান পরে বদলানো যাবে কি না। যে object বদলানো যায় তাকে বলে mutable, যে যায় না তাকে immutable. এটা object-এর type ঠিক করে, আপনি নন।

একটি ভুল ধারণা শুরুতেই ভেঙে দিই। “String immutable” মানে এই নয় যে name নামটি আর অন্য কিছুতে লাগানো যাবে না। name = "রহিম", তারপর name = "করিম" — সম্পূর্ণ বৈধ। এখানে “রহিম” object বদলায়নি; লেবেলটি খুলে “করিম” নামের নতুন object-এ লাগানো হয়েছে। Immutability হলো object-এর বৈশিষ্ট্য, নামের নয়। নাম সবসময় সরানো যায়।

এখন বুঝুন কেন এই পার্থক্য এত গুরুত্বপূর্ণ। ধরুন a = 10 আর b = a. দুটি নাম একই 10-কে দেখাচ্ছে। এবার b += 1. যেহেতু 10 নিজে বদলাতে পারে না, Python একটি নতুন 11 বানিয়ে শুধু b-কে সেখানে সরায়। a তখনো 10. তাই সংখ্যা বা string নিয়ে কাজ করার সময় কেউ কখনো “alias বাগ” টের পায় না — immutable object ভাগ করা সম্পূর্ণ নিরাপদ, যেন ছাপানো বইয়ের একই পাতা দুজন পড়ছে; কেউ পাতা বদলাতে পারে না।

৩ · নাম সরানো, নাকি object বদলানো — দুই ধরনের কাজ

Python-এ ডেটার ওপর যত কাজ করেন, সবই দুই দলের কোনো একটিতে পড়ে। এই দুটি আলাদা করে চিনতে পারলে এই পর্বের প্রায় সব রহস্য খুলে যায়।

এই পার্থক্যের নাম দিই: প্রথমটি rebinding, দ্বিতীয়টি mutation. নিচের stepper-এ দুটোই একসাথে দেখুন। প্রতিটি ধাপে প্রশ্ন করুন: “লেবেল সরল, নাকি বাক্সের ভেতরটা বদলাল?”

1a = [1, 2, 3]2b = a3b.append(4)4b += [5]5b = b + [6]6print(a, b)

+=-এর দ্বৈত চরিত্র

x += y একটি augmented assignment. Python এটি চালানোর সময় প্রথমে জিজ্ঞেস করে: “x-এর type কি জায়গাতেই যোগ করতে জানে?” এই প্রশ্নের উত্তর দেয় __iadd__ নামের একটি বিশেষ method (দুই পাশে দুটি আন্ডারস্কোর থাকে বলে এদের বলে dunder method; বিস্তারিত পর্ব ৩০-এ)। List-এর এই method আছে, তাই list জায়গাতেই বাড়ে — একে বলে in-place বদল। Int, str, tuple-এর এই method নেই, কারণ তারা বদলাতেই পারে না। তখন Python সাধারণ + দিয়ে নতুন object বানায় আর নামটি সরায়।

শেষ সারির আগের সারিটি খেয়াল করুন। t = (1, 2), u = t, তারপর t += (3,) — এখন t হলো (1, 2, 3) কিন্তু u এখনো (1, 2). Tuple বদলায়নি, t নামটি নতুন tuple-এ সরে গেছে। আরেকটি ছোট পার্থক্য: list-এর += যেকোনো iterable নেয়, + নেয় না। x += "ab" লিখলে list-এ 'a' আর 'b' আলাদা উপাদান হয়ে যোগ হয়, কিন্তু x + "ab" দেয় TypeError.

যে method বদলায়, সে None ফেরত দেয়

Python-এর built-in type-গুলো একটি সুন্দর নিয়ম মানে: যে method object-কে জায়গাতেই বদলায় (list.sort, list.append, list.reverse, dict.update), সে কিছু ফেরত দেয় না — অর্থাৎ None. আর যে কাজ নতুন object বানায়, সে সেটি ফেরত দেয় (sorted(x), reversed(x), s.upper()). নিয়মটি ইচ্ছাকৃত, যাতে কোডে দেখেই বোঝা যায় কোনটি বদলাচ্ছে। এ কারণেই marks = marks.sort() একটি বিখ্যাত ভুল — marks হয়ে যায় None. হয় marks.sort() (জায়গায় সাজাও), নয়তো ranked = sorted(marks) (নতুন সাজানো list নাও, আসলটি অক্ষত রাখো)।

৪ · ফাংশনে list পাঠালে — call by sharing

পর্ব ১৩-এ আপনি ফাংশনে argument পাঠাতে শিখেছেন। এখন সেই কাজটির ভেতরটা দেখুন। ফাংশন ডাকার সময় Python যা করে, তা আসলে একটি assignment: ফাংশনের parameter-এর নামটি সেই একই object-এ লাগিয়ে দেয়, যা আপনি পাঠিয়েছেন। কোনো কপি হয় না। ফলে ফাংশনের ভেতরের নাম আর বাইরের নাম একই object-এর দুটি alias.

1def add_bonus(scores):2    scores.append(5)3    scores = [0]4    return scores5mine = [10, 20]6out = add_bonus(mine)7print(mine, out)

এই আচরণের একটি নাম আছে: call by sharing. Python-এর অফিসিয়াল টিউটোরিয়াল (পাদটীকায়) বলে, একে “call by object reference” বলাই বেশি ঠিক — argument হিসেবে যায় object-এর reference, object-এর কপি নয়। এটা C-র মতো “call by value” নয় (তাহলে ফাংশন একটি কপি পেত, আসলটি বদলাতেই পারত না), আবার C++-এর int&-এর মতো “call by reference”-ও নয় (তাহলে ভেতরের scores = [0] বাইরের mine-কেও সরিয়ে দিত)। দুটির মাঝামাঝি একটি তৃতীয় ব্যবস্থা — ভাবনার প্রশ্ন ১-এ এর ইতিহাস দেখবেন।

যে ফাংশন বাজারের তালিকা “পরিষ্কার” করতে গিয়ে চমকে দেয়

বাস্তবে এটি কেমন দেখায়, নিচের কোডে দেখুন। শেষ অংশে একটি ফাংশন বাজারের তালিকা থেকে খালি ঘর সরিয়ে “পরিষ্কার” তালিকা ফেরত দেয়। যিনি ফাংশনটি ডাকছেন, তিনি ভাবছেন তাঁর আসল তালিকা অক্ষত থাকবে। চালিয়ে দেখুন:

marks = [72, 38, 55]
copy_name = marks            # কপি নয় — দ্বিতীয় নাম
copy_name.append(90)
print(marks, copy_name is marks)

nums = [1, 2]
before = nums
nums += [3]                  # একই object বদলায়
print(before, nums is before)
nums = nums + [4]            # নতুন object, নাম সরে যায়
print(before, nums is before)

def clean(items):
    while "" in items:
        items.remove("")     # caller-এর list-ই বদলাচ্ছে
    return items

bazar = ["চাল", "", "ডাল", ""]
result = clean(bazar)
print(bazar, result is bazar)

ঠিক করার দুটি পরিষ্কার পথ আছে, আর একটি বেছে নিয়ে ফাংশনের নাম ও docstring-এ তা স্পষ্ট করা উচিত। পথ এক — নতুন list ফেরত দিন: return [x for x in items if x != ""]. আসলটি অক্ষত থাকে; comprehension (পর্ব ১৮) এখানে স্বাভাবিক পছন্দ। পথ দুই — জায়গায় বদলান, কিন্তু কিছু ফেরত দেবেন না: ফাংশনটি None ফেরত দিক আর নাম হোক remove_blanks_inplace. Built-in-এর sorted বনাম list.sort-এর মতোই। সবচেয়ে খারাপ হলো দুটোর মিশ্রণ — বদলাও এবং ফেরতও দাও — কারণ তখন caller ধরে নেয় সে একটি নতুন জিনিস পেয়েছে। ফাংশনের বাইরের ডেটা বদলানো একটি side effect, আর লুকানো side effect-ই সবচেয়ে বেশি সময় নষ্ট করে।

ভেতরের list ফেরত দেওয়ার বিপদ

উল্টো দিকেও একই বিপদ। ধরুন একটি module-এ ভর্তি হওয়া শিক্ষার্থীদের একটি list আছে, _students, আর একটি ফাংশন get_students() সেটি ফেরত দেয়। কেউ ফেরত পাওয়া list নিয়ে .sort() করল বা একটি নাম .remove() করল — আপনার module-এর ভেতরের তালিকাও বদলে গেল, কারণ আপনি ভেতরের object-টিরই reference দিয়েছেন। ভেতরের অবস্থা বাইরে দিতে হলে কপি (list(_students)) বা tuple (tuple(_students)) দিন। অংশ ৮-এ এই কৌশলের পুরো নাম দেখবেন — defensive copy.

৫ · Shallow copy — বাইরের বাক্স নতুন, ভেতরের জিনিস পুরোনো

তাহলে কপি চাইলে কী লিখবেন? Python-এ কপি বানানোর অনেক পথ আছে, আর এদের বেশিরভাগই একই জিনিস করে: shallow copy. অর্থাৎ বাইরের container (list, dict, set) নতুন তৈরি হয়, কিন্তু তার ঘরগুলোতে পুরোনো container-এর একই object-গুলোর reference বসে।

সমতল (flat) list-এর জন্য shallow copy-ই পুরো কপি। prices = [40, 25, 60]-এর কপিতে একটি দাম বদলালে আসলটি বদলায় না, কারণ copy[0] = 45 হলো কপি-list-এর একটি ঘরে rebinding, আর ভেতরের সংখ্যাগুলো immutable. সমস্যা শুরু হয় যখন ভেতরের জিনিসগুলো নিজেরাই mutable — অর্থাৎ nested list, list-এর ভেতরে dict, dict-এর ভেতরে list.

is আর == দিয়ে ভাগাভাগি পরীক্ষা

পর্ব ০৮-এ শিখেছেন — == জিজ্ঞেস করে “মান কি সমান?”, আর is জিজ্ঞেস করে “একই object কি?” কপির গভীরতা মাপতে এই দুটি একসাথে ব্যবহার করুন। b = a.copy()-এর পর b == a হবে True (মান এক), b is a হবে False (বাইরের বাক্স আলাদা)। কিন্তু a যদি list-এর list হয়, তাহলে b[0] is a[0] হবে True — ভেতরের বাক্স একই। এই একটি লাইন দিয়েই যেকোনো কপি কত গভীর, নিজে পরীক্ষা করতে পারবেন।

এবার শুরুর নম্বরপত্রে ফিরি। এবার শিক্ষক সাবধান — trial = sheet.copy() লিখেছেন। তবু কেন আসলটা বদলায়, আর deepcopy কীভাবে সমাধান দেয়, দেখুন:

1sheet = [[45, 38], [70, 66]]2trial = sheet.copy()3trial[0][1] += 54trial.append([50, 50])5deep = copy.deepcopy(sheet)6deep[1][0] = 0

৬ · [[0]*3]*3 — সিট-প্ল্যানের ফাঁদ

পরীক্ষার হলে সিট-প্ল্যান বানানোর একটি প্রোগ্রাম লিখছেন। ৩টি সারি, প্রতি সারিতে ৩টি বেঞ্চ, শুরুতে সব খালি। পর্ব ১৪-এ শিখেছেন [0] * 3 দেয় [0, 0, 0]. তাহলে [[0] * 3] * 3 নিশ্চয়ই তিনটি শূন্যের সারি দেবে? ছাপালে তা-ই দেখায়: [[0, 0, 0], [0, 0, 0], [0, 0, 0]]. কিন্তু প্রথম সারির প্রথম বেঞ্চে রাফিকে বসালেই তিন সারির প্রথম বেঞ্চে রাফি!

কারণ * দিয়ে list পুনরাবৃত্তি (list repetition) উপাদানগুলোর কপি করে না — reference-গুলোর পুনরাবৃত্তি করে। [0] * 3-এ তিনটি ঘরই একই 0-কে দেখায়, কিন্তু 0 immutable, তাই কোনো সমস্যা নেই: কোনো ঘরে নতুন মান বসানো মানে সেই ঘরে rebinding. কিন্তু বাইরের * 3-এ তিনটি ঘরই একই সারি-list-কে দেখায়, আর সেটি mutable. ধাপে ধাপে দেখুন:

1grid = [[0] * 3] * 32grid[0][0] = 13print(grid)4ok = [[0] * 3 for _ in range(3)]5ok[0][0] = 1

একই পরিবারের আরও দুটি ফাঁদ চিনে রাখুন। [[]] * 4 চারটি খালি list নয়, একটি খালি list চারবার। আর dict.fromkeys(names, []) প্রতিটি নামের জন্য একই একটি list বসায় — কোনো একজনের তালিকায় কিছু যোগ করলে সবার তালিকায় যোগ হয়। সমাধান একই: comprehension দিয়ে প্রতিবার নতুন object — {name: [] for name in names}.

গেম বোর্ডের কপি

টিক-ট্যাক-টো বা লুডোর মতো খেলায় কম্পিউটার-চালিত খেলোয়াড় সাধারণত প্রতিটি সম্ভাব্য চাল একটি কপি-বোর্ডে খেলে দেখে, তারপর সবচেয়ে ভালোটি বেছে নেয়। বোর্ড যদি list-এর list হয় আর কপি হয় board.copy() দিয়ে, তাহলে “পরীক্ষামূলক” চালগুলো আসল বোর্ডেই বসে যায় — খেলা শুরুর আগেই বোর্ড ভরে যায়। এখানে দুই স্তরের কপিই যথেষ্ট: [row[:] for row in board] — প্রতিটি সারির shallow copy, ফলে বাইরে-ভেতরে দুটোই নতুন। বোর্ডের ঘরে যদি আরও গভীর mutable জিনিস (যেমন প্রতিটি ঘরে গুটির list) থাকে, তখন deepcopy.

এবার সব একসাথে চালিয়ে দেখুন — নম্বরপত্রের shallow কপি, deepcopy দিয়ে নিরাপদ কপি, আর সিট-প্ল্যানের ফাঁদ ও তার সমাধান:

import copy

sheet = [["রহিম", [45, 38]], ["সুমি", [70, 66]]]
what_if = sheet.copy()             # shallow copy
what_if[0][1][1] += 5              # রহিমকে ৫ গ্রেস নম্বর
print(sheet[0][1])                 # আসলটাও বদলে গেছে!
print(what_if is sheet, what_if[0] is sheet[0])

safe = copy.deepcopy(sheet)        # পুরো গভীর কপি
safe[1][1][0] += 5
print(sheet[1][1], safe[1][1], safe[1] is sheet[1])

seats = [["খালি"] * 3] * 2        # একই সারি দুবার!
seats[0][0] = "রাফি"
print(seats, seats[0] is seats[1])

seats = [["খালি"] * 3 for _ in range(2)]
seats[0][0] = "রাফি"
print(seats)

৭ · deepcopy — ভেতরে কী করে, কত খরচ, কখন দরকার

copy.deepcopy(x) একটি recursive কাজ: x-এর প্রতিটি উপাদানের জন্য আবার deepcopy ডাকে, তার উপাদানের জন্য আবার — যতক্ষণ না শুধু immutable জিনিস পায়। তিনটি সূক্ষ্ম বিষয় একে “সব কিছু কপি করো” থেকে বুদ্ধিমান করে তোলে।

• Immutable জিনিস কপি হয় না। সংখ্যা, string, None-এর মতো object হুবহু ফেরত আসে — নতুন বানানোর কোনো মানে নেই, কারণ এরা বদলাতে পারে না। ভেতরে শুধু immutable জিনিস থাকা tuple-ও একই tuple হিসেবে ফেরত আসে; copy.deepcopy((1, "ক")) is মূল tuple — True.
• Memo — “এটা আগে কপি করেছি কি?” কাজ শুরুর সময় deepcopy একটি dict বানায়, যার নাম memo: মূল object-এর identity থেকে তার কপি পর্যন্ত। প্রতিটি object কপি করার আগে memo দেখে নেয়। ফলে মূল ডেটায় একই list দুই জায়গায় থাকলে কপিতেও একটিই নতুন list দুই জায়গায় থাকে — ভাগাভাগির গঠন অটুট থাকে।
• Cycle-এ আটকে যায় না। পর্ব ০৫-এর reference cycle মনে আছে? x = [], x.append(x) — list নিজেই নিজের ভেতরে। সাধারণ recursion এখানে অনন্ত লুপে পড়ত। deepcopy নতুন খালি list বানিয়েই memo-তে লিখে রাখে, তারপর ভেতরে ঢোকে; আবার x-এর দেখা পেলে memo থেকে সেই নতুন list ফেরত দেয়। ফল: কপিটিও নিজের ভেতরে নিজেকে রাখে, মূলটিকে নয়।

খরচ

Deep copy-র সময় আর মেমরি দুটোই পুরো ডেটার আকারের সমানুপাতিক। এক লাখ শিক্ষার্থীর প্রত্যেকের নম্বরের list থাকলে deepcopy এক লাখের বেশি নতুন object বানাবে, প্রতিটির জন্য memo-তে খোঁজ নেবে, প্রতিটির type দেখে কপির নিয়ম বের করবে। বিশুদ্ধ Python-এ লেখা এই কাজ সাধারণ shallow copy-র চেয়ে অনেক গুণ ধীর। একবারের কাজে এটা কিছুই না; কিন্তু লুপের ভেতরে, প্রতিটি ধাপে বড় ডেটার deepcopy — একটি পরিচিত পারফরম্যান্স সমস্যা (পর্ব ৪৩-এ মাপতে শিখবেন)।

যা deepcopy করা যায় না

কিছু object “কপি” করার কোনো অর্থ নেই — খোলা ফাইল, নেটওয়ার্ক সংযোগ, thread-এর lock. দুটি কপি একই ফাইল-হ্যান্ডেল নিয়ে কী করবে? তাই এমন object-এর deepcopy চাইলে সাধারণত TypeError আসে (যেমন cannot pickle 'TextIOWrapper' instances). নিজের class-এ কপির নিয়ম ঠিক করে দিতে চাইলে __copy__ আর __deepcopy__ method লেখা যায়; আর Python 3.13 থেকে copy.replace() দিয়ে কিছু field বদলে একটি নতুন object বানানো যায় — dataclass-এর (পর্ব ৩২) সাথে এটি বিশেষ কাজের।

৮ · Immutability নকশার হাতিয়ার — defensive copy আর tuple-এর অদ্ভুত ঘটনা

এতক্ষণ কপি দিয়ে বাগ সারানো দেখলেন। অভিজ্ঞ প্রোগ্রামাররা আরেক ধাপ এগিয়ে ভাবেন: এমনভাবে কোড লিখি, যেন এই বাগ জন্মাতেই না পারে। দুটি কৌশল আছে।

কৌশল এক — সীমানায় কপি (defensive copy)

আপনার ফাংশন বা class যেখানে বাইরের দুনিয়ার সাথে ডেটা আদান-প্রদান করে, সেই সীমানায় কপি করুন। একে বলে defensive copy.

• ভেতরে নেওয়ার সময়: কেউ আপনাকে একটি list দিল আর আপনি সেটি পরে ব্যবহারের জন্য জমিয়ে রাখবেন? self.items = list(items) লিখুন, self.items = items নয়। নইলে caller পরে তাঁর list বদলালে আপনার ভেতরের অবস্থাও বদলে যাবে।
• বাইরে দেওয়ার সময়: ভেতরের list ফেরত দিতে হলে কপি বা tuple দিন — অংশ ৪-এর get_students()-এর সমাধান।
• কপির দাম মনে রাখুন: ছোট ডেটায় defensive copy প্রায় বিনামূল্যে; বিশাল ডেটায় প্রতিবার কপি ব্যয়বহুল। তখন দ্বিতীয় কৌশল ভালো।

কৌশল দুই — বদলাতেই না দেওয়া (immutability)

যে ডেটা বদলানোর কথা নয়, তাকে শুরু থেকেই immutable type-এ রাখুন। তাহলে যত খুশি ভাগ করুন, কপির দরকারই নেই।

• নির্দিষ্ট গঠনের রেকর্ড (একটি বিন্দুর স্থানাঙ্ক, একটি তারিখের অংশ) — tuple. পর্ব ১৫-এ দেখেছেন।
• অনুমোদিত মানের স্থির তালিকা (যেমন বিভাগের নাম) — frozenset({"ঢাকা", "চট্টগ্রাম", "রাজশাহী"}). কেউ ভুল করে .add() করতে পারবে না।
• dict শুধু পড়তে দিতে চাইলে — types.MappingProxyType(d) একটি read-only দৃশ্য দেয়; লেখার চেষ্টায় TypeError.
• নতুন মান দরকার হলে পুরোনোটি বদলানোর বদলে নতুন object বানান — sorted(), comprehension, s.replace()-এর মতো। এই ধাঁচে লেখা ফাংশনকে pure function বলে (পর্ব ১৩)।

সবচেয়ে অদ্ভুত ঘটনা — error-ও হয়, বদলও হয়

এবার Python-এর বিখ্যাততম ধাঁধাগুলোর একটি। একটি tuple-এর ভেতরে একটি list. Tuple immutable, তাই t[0] += [1] লিখলে error আশা করেন — এবং error আসেও। কিন্তু তারপর t দেখুন:

>>> t = ([],)
>>> t[0] += [1]
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    t[0] += [1]
    ~^^^
TypeError: 'tuple' object does not support item assignment
>>> t
([1],)

Error এসেছে, তবু list-এ 1 ঢুকে গেছে! (উপরের আউটপুট CPython 3.14-এ যাচাই করা; traceback-এর ফাইলের নাম আর ~^^^ চিহ্ন আপনার পরিবেশে একটু ভিন্ন দেখাতে পারে।) ব্যাখ্যা অংশ ৩-এর +=-এর দুই ধাপে লুকিয়ে আছে। t[0] += [1] আসলে তিনটি কাজ:

1. t[0] পড়া — পাওয়া গেল ভেতরের list.
2. সেই list-এর __iadd__ ডাকা — list জায়গাতেই বাড়ল, এখন [1]. এই ধাপ সফল।
3. ফলটি আবার t[0] = ... দিয়ে বসানো — কারণ += সবসময় শেষে একটি assignment করে (int-এর মতো type-এর জন্য এটা দরকার)। কিন্তু tuple-এর ঘরে assignment নিষেধ, তাই TypeError. ততক্ষণে list বদলে গেছে।

সমাধান সহজ: ভেতরের list বদলাতে চাইলে সরাসরি তার method ডাকুন — t[0].append(1) বা t[0].extend([1]). এগুলোতে শেষের assignment নেই, তাই কোনো error নেই। আর এই ঘটনা আরেকবার মনে করায়: tuple-এর immutability অগভীর।

৯ · AI-এর যুগে — ভাগাভাগি করা ডেটার বাগ ধরা

AI-এর লেখা Python কোড সাধারণত দেখতে পরিষ্কার, চলেও। কিন্তু alias-জাতীয় বাগ ঠিক সেই ধরনের, যা “চলে” — কোনো error দেয় না, শুধু ভুল ফল দেয়, অনেক সময় অনেক পরে, অন্য কোনো জায়গায়। AI টেস্ট লেখার সময়ও প্রায়ই প্রতিটি ফাংশন একবার করে ডেকে দেখে, তাই “দ্বিতীয়বার ডাকলে” বা “caller পরে আসল list ব্যবহার করলে” যে বাগ বেরোয়, তা ধরা পড়ে না।

AI-এর কোডে mutability যাচাইয়ের চেকলিস্ট

• প্রতিটি ফাংশনের জন্য জানি — সে argument বদলায়, নাকি নতুন object ফেরত দেয়; দুটো একসাথে করে না
• Nested ডেটার প্রতিটি “কপি” লাইনে দেখেছি কত স্তর নতুন হচ্ছে, আর is দিয়ে ভেতরের স্তর পরীক্ষা করেছি
• গ্রিড বা ম্যাট্রিক্স বানানোর লাইনে * n দিয়ে list-এর list নেই
• কোনো ফাংশনের default মান mutable ([], {}, set()) নয়
• টেস্টে ফাংশন দুবার ডেকেছি, আর ডাকার পর আসল ইনপুট অক্ষত কি না যাচাই করেছি
• deepcopy যেখানে আছে, সেখানে সত্যিই দরকার কি না ভেবেছি — বড় ডেটার লুপে অপ্রয়োজনীয় deepcopy ধীরগতির কারণ

LOAD_NAME       t
LOAD_SMALL_INT  0
COPY / COPY            (t আর 0 পরে আবার লাগবে, তাই কপি রাখা)
BINARY_OP       26 ([])     → t[0] পড়া: ভেতরের list
LOAD_SMALL_INT  1
BUILD_LIST      1           → [1]
BINARY_OP       13 (+=)     → list.__iadd__: জায়গায় বাড়ে
SWAP / SWAP
STORE_SUBSCR                → t[0] = ফল  ← এখানে TypeError