scope, *args/**kwargs, closure আর default-এর ফাঁদ

১ · প্রতিটি নামের একটি ঠিকানা — scope আর LEGB নিয়ম

পর্ব ১৩-এ দেখেছিলেন, ফাংশনের ভেতরে তৈরি নাম local variable — সেই ডাকের frame-এ থাকে, ডাক শেষে মুছে যায়। কিন্তু তখন একটি প্রশ্ন খোলা রেখেছিলাম: ফাংশনের ভেতরে যদি এমন নাম লেখেন যা ভেতরে তৈরি হয়নি — যেমন বাইরের rate, বা round, বা print — Python সেটি কোথায় পায়? এই পর্ব সেই প্রশ্নের উত্তর দিয়ে শুরু।

পর্ব ০৫ থেকে আপনি জানেন, Python-এ ভ্যারিয়েবল মানে একটি name, যা কোনো object-এর গায়ে লেবেলের মতো লাগানো। প্রতিটি লেবেল লেখা থাকে কোনো একটি “খাতায়”। Python-এর ভাষায় এই খাতাকে বলে namespace, আর কোডের কোন অংশ থেকে কোন খাতা দেখা যায়, সেটাই scope. সহজ কথায়: scope বলে দেয় একটি নাম কোথায় থাকে, আর কোথা থেকে তাকে দেখা যায়.

চারটি স্তর একে একে দেখি:

• L — Local: এখন যে ফাংশন চলছে, তার নিজের নাম — parameter আর ভেতরে assign করা ভ্যারিয়েবল।
• E — Enclosing: ফাংশনের ভেতরে ফাংশন থাকলে, বাইরের (ঘিরে রাখা) ফাংশনের local নাম। একে বলে enclosing scope. শুধু nested ফাংশনেই এই স্তরটি থাকে।
• G — Global: ফাইলের (module-এর) একেবারে বাইরের স্তরে তৈরি নাম — যেমন ফাইলের শুরুতে লেখা rate = 0.15, বা def দিয়ে বানানো ফাংশনের নাম। Python-এ “global” মানে আসলে এই module-এর global, পুরো প্রোগ্রামের নয়; অন্য ফাইলের global আলাদা (পর্ব ২২-এ module-এর গল্প)।
• B — Built-in: Python নিজে যে নামগুলো সব জায়গায় দিয়ে রাখে — print, len, round, sum, list, ValueError ইত্যাদি। এরা থাকে builtins নামের একটি module-এ।

এবার একটি বাস্তব উদাহরণে চারটি স্তর একসাথে দেখুন। একটি দোকানের বিল-ফাংশন, যার ভেতরে আরেকটি ফাংশন। ভেতরের total ফাংশন চারটি নাম ব্যবহার করে — চারটিই চার আলাদা জায়গা থেকে আসে। “পরে” চাপুন:

1rate = 0.15                    # global2def make_bill(shop):3    discount = 0.10            # enclosing4    def total(price):          # local: price5        return round(price * (1 - discount) * (1 + rate))6    return total78bill = make_bill("Aarong")9print(bill(1000))

২ · ভেতর থেকে পড়া সহজ, বদলানো নয় — UnboundLocalError, global আর nonlocal

LEGB খোঁজা চলে পড়ার সময়। কিন্তু ফাংশনের ভেতরে কোনো নামে assign করলে (=, +=, for x in, def x ইত্যাদি) নিয়ম আলাদা: Python ধরে নেয় নামটি এই ফাংশনেরই local. আর এই সিদ্ধান্ত হয় ফাংশন চালানোর আগে, পর্ব ০৫-এর সেই compile ধাপে — Python পুরো ফাংশনের body একবারে দেখে, আর যেখানেই একটি নামে assign পায়, পুরো ফাংশনে নামটিকে local ঘোষণা করে।

এর ফল একটি বিখ্যাত error. একটি ওয়েবসাইটের ভিজিট গোনার কথা ভাবুন:

count = 0                # global

def click():
    count += 1           # মানে: count = count + 1
    return count

click()

দেখে মনে হয় এটি বাইরের count এক বাড়াবে। কিন্তু চালালে traceback আসে, যার শেষ লাইন:

UnboundLocalError: cannot access local variable 'count' where it is not associated with a value

কেন? count += 1 একটি assignment, তাই compile-এর সময়েই Python ঠিক করে ফেলেছে: click-এর ভেতরে count একটি local নাম। চালানোর সময় count + 1 হিসাব করতে গিয়ে সে local count খোঁজে — কিন্তু সেটি এখনো কোনো object-এর সাথে জোড়া হয়নি (unbound). Global-এর count সে দেখতেই যায় না, কারণ নামটি আগেই local ঘোষিত। Error-এর নাম UnboundLocalError ঠিক এই কথাই বলে: “local নামটি আছে, কিন্তু এখনো কোনো মানের সাথে বাঁধা নয়”। (পুরোনো Python version-এ বার্তাটি ছিল একটু অন্য রকম — local variable 'count' referenced before assignment; Python 3.11 থেকে বর্তমান লেখা।)

global — “এই নামটি বাইরের, local বানিও না”

সমাধানের একটি উপায় হলো Python-কে আগেই জানিয়ে দেওয়া: global count. এই লাইনটিকে বলে global statement. এর পরে ফাংশনের ভেতরে count-এ যত assignment, সব যায় module-এর global count-এ:

count = 0

def click():
    global count         # count = module-এর global নাম
    count += 1
    return count

এটি কাজ করে। কিন্তু অভিজ্ঞ প্রোগ্রামাররা global দেখলেই সতর্ক হন। কারণ এখন click-এর ফল শুধু তার argument-এর ওপর নির্ভর করে না — নির্ভর করে একটি লুকানো বাইরের মানের ওপর, যা প্রোগ্রামের যেকোনো জায়গা থেকে যে কেউ বদলাতে পারে। এই ধরনের মানকে বলে global state. এর সমস্যাগুলো:

• লুকানো যোগাযোগ: ফাংশনের def লাইন দেখে বোঝা যায় না সে কী কী পড়ে বা বদলায়। বাগ খুঁজতে পুরো ফাইল ঘাঁটতে হয়।
• পরীক্ষা কঠিন: প্রতিটি টেস্টের আগে global মান “রিসেট” করতে হয়, নইলে আগের টেস্টের ফল পরেরটিতে চুঁইয়ে পড়ে।
• একসাথে একাধিক কাজ অসম্ভব: দুটি আলাদা ওয়েবসাইটের ভিজিট গুনতে চাইলে? একটিই count — দুটি counter রাখার উপায় নেই।
• Thread-এ ঝুঁকি: একাধিক thread একই global বদলালে ফল এলোমেলো হতে পারে (পর্ব ৪১)।

নিয়ম: global পড়া ঠিক আছে যদি সেটি ধ্রুবক হয় — যেমন VAT_RATE = 0.15 (PEP 8 অনুযায়ী ধ্রুবকের নাম বড় হাতের অক্ষরে)। কিন্তু ফাংশনের ভেতর থেকে global বদলানো প্রায় সবসময় এড়ানো যায়: মান parameter-এ নিন, ফল return করুন। অথবা অবস্থা ধরে রাখতে চাইলে closure বা class ব্যবহার করুন — দুটিই এই পর্বে আসছে।

nonlocal — ঘিরে রাখা ফাংশনের নাম বদলানো

একই সমস্যা nested ফাংশনেও হয়। ভেতরের ফাংশন বাইরের ফাংশনের একটি নাম বদলাতে চাইলে += লিখলেই নামটি ভেতরের local হয়ে যায়। এখানে global কাজে আসবে না, কারণ নামটি global নয় — Enclosing স্তরের। এর জন্য আছে nonlocal: “এই নামটি আমার নয়, আমাকে ঘিরে রাখা নিকটতম ফাংশনের; সেখানেই বদলাও”। nonlocal এসেছে Python 3.0-তে; অংশ ৬-এ এটি দিয়ে একটি পরিষ্কার counter বানাব।

শেষ সারিটি খেয়াল করুন। cart.append(x) নামটিকে নতুন object-এ লাগায় না, শুধু পুরোনো object-টিকে ভেতর থেকে বদলায় — পর্ব ১৯-এর mutability. তাই এখানে global লাগে না, আর ঠিক এই কারণেই বাইরের list চুপচাপ বদলে যাওয়া আরও বিপজ্জনক: কোনো ঘোষণা ছাড়াই side effect.

Built-in নাম ঢেকে ফেলা — shadowing

LEGB-র একটি পার্শ্বফল: যেহেতু Global খোঁজা হয় Built-in-এর আগে, আপনি যদি module-এ list, sum, max, input বা id নামে ভ্যারিয়েবল বানান, তাহলে Python-এর আসল built-in আর পাওয়া যায় না — আপনার নামটি তাকে ঢেকে দেয়। একে বলে shadowing, যা পর্ব ০৬-এ এক লাইনে দেখেছিলেন:

sum = 0
for price in [120, 80, 50]:
    sum += price         # “মোট” রাখতে sum নামটি নেওয়া হলো
print(sum([1, 2, 3]))    # TypeError: 'int' object is not callable

এখানে sum এখন একটি int (250), ফাংশন নয় — তাই তাকে ডাকা যায় না। দশ লাইন পরে কেউ sum(...) লিখলে error বার্তা মূল ভুলের জায়গা দেখায় না, দেখায় ব্যবহারের জায়গা। list = [...] লেখার পর list("abc") ডাকলেও একই TypeError. সমাধান সহজ: অর্থপূর্ণ নাম দিন — total, prices, items. REPL-এ ভুল করে ঢেকে ফেললে del sum লিখলে আপনার নামটি মুছে যায়, আর LEGB আবার built-in পর্যন্ত পৌঁছায়। VS Code-এর মতো editor আর ruff-এর মতো linter (পর্ব ৪৪) এই ভুলে সতর্ক করে।

৩ · *args আর **kwargs — যত খুশি argument

এবার প্রসঙ্গ বদলাই — নামের ঠিকানা থেকে argument-এর দিকে। পর্ব ১৩-এর সব ফাংশনে parameter-এর সংখ্যা ছিল নির্দিষ্ট। কিন্তু print-কে ভাবুন: print(1), print(1, 2, 3), print("a", "b", sep="-") — একটি argument হোক বা বিশটি, সব চলে। নিজের ফাংশনে এই সুবিধা পেতে Python দেয় দুটি বিশেষ parameter.

আসল জাদু তারা চিহ্নে, নামে নয়। args আর kwargs (keyword arguments-এর সংক্ষেপ) শুধু প্রচলিত নাম; *prices বা **options লিখলেও একই কাজ হয়, আর অর্থপূর্ণ নাম দিলে পড়তে আরও সুবিধা। একটি সহজ উদাহরণ — যতগুলো দাম দেবেন, সবগুলোর যোগফল:

def bill_total(*prices, vat=0.15):
    return round(sum(prices) * (1 + vat), 2)

bill_total(100, 250, 80)        # prices = (100, 250, 80)
bill_total(500, vat=0.05)       # prices = (500,)
bill_total()                    # prices = ()  →  0.0

লক্ষ করুন, *prices-এর পরে লেখা vat স্বয়ংক্রিয়ভাবে keyword-only হয়ে গেছে। কারণ সহজ: সব বাড়তি positional argument তো *prices-ই খেয়ে ফেলে, তাই vat-এ কিছু পৌঁছানোর একমাত্র উপায় নাম ধরে পাঠানো। পর্ব ১৩-এর একক * চিহ্ন আসলে এরই নামহীন রূপ — “এখানে বাড়তি positional নেব না, তবে এর পরেরগুলো keyword-only”.

Parameter-এর ক্রমের নিয়ম

সব ধরনের parameter একসাথে লিখতে চাইলে একটি নির্দিষ্ট ক্রম মানতে হয়। ভুল ক্রম লিখলে চালানোর আগেই SyntaxError:

এই ক্রমের যুক্তি আছে। Python argument বসায় বাঁ থেকে ডানে: আগে positional-গুলো সাধারণ parameter-এ (a, b), যা বাকি থাকে তা *args-এ। তারপর keyword-গুলো নাম মিলিয়ে বসে (c, d, এমনকি a বা b-ও নাম ধরে পাওয়া যায়), আর যেগুলোর নাম কোনো parameter-এর সাথে মেলে না, সেগুলো যায় **kwargs-এ। তাই **kwargs সবসময় শেষে — সে “বাকি সব”-এর ঝুড়ি। পর্ব ১৩-এর / (positional-only) থাকলে সেটি বসে একেবারে শুরুর দিকে — positional-only parameter-গুলোর ঠিক পরে, সাধারণ parameter-গুলোর আগে। উদাহরণ: f(10, 20, 30, 40, c=5, color="red") ডাকলে a=10, b=20, args=(30, 40), c=5, d=2 (default), kwargs={'color': 'red'}.

৪ · ডাকার সময় প্যাকেট খোলা — f(*lst, **dct) আর argument ফরোয়ার্ড করা

সংজ্ঞায় তারা চিহ্ন জমা করে (অনেক argument → একটি tuple বা dict). ডাকার সময় তারা চিহ্ন করে উল্টো কাজ — খুলে ছড়িয়ে দেয়. একে বলে argument unpacking:

• f(*[500, 120]) মানে f(500, 120) — list (বা যেকোনো iterable) খুলে প্রতিটি উপাদান আলাদা positional argument.
• f(**{"sep": " / ", "end": "!"}) মানে f(sep=" / ", end="!") — dict খুলে প্রতিটি চাবি-মান জোড়া একটি keyword argument.

বাস্তবে এটি খুব কাজের। ধরুন একটি CSV ফাইলের একটি সারি list হিসেবে পেলেন — row = ["রিনা", 85, "ঢাকা"] — আর একটি ফাংশন তিনটি আলাদা parameter চায়: register(*row). অথবা একটি settings dict থেকে argument পাঠানো: connect(**config). পর্ব ১৫-এর unpacking-এর মতোই ধারণা, শুধু এবার ফাংশন ডাকের ভেতরে।

Wrapper — argument হাতে নিয়ে অন্য ফাংশনে পাঠানো

দুটি দিক একসাথে মেলালে পাওয়া যায় Python-এর একটি অতি শক্তিশালী কৌশল: wrapper function. ফাংশনটি *args, **kwargs দিয়ে যা আসে সব জমা করে, নিজের কিছু কাজ যোগ করে, তারপর *args, **kwargs দিয়ে হুবহু আরেকটি ফাংশনে পাঠিয়ে দেয় — না জেনেই সেখানে কী কী argument ছিল। একে বলে argument “forward” করা।

একটি লগিং সহায়ক ভাবুন: প্রতিটি বার্তার সামনে স্তর (INFO, WARN) বসাবে, কিন্তু বাকি সব — যত মান, sep, end — print-এর কাছে হুবহু যাবে। print-এর প্রতিটি option আপনাকে আলাদা করে লিখতে হবে না। নিচের প্রথম runnable প্রোগ্রামে (অংশ ৫-এর শেষে) এটি চালিয়ে দেখবেন।

৫ · Default-এর ফাঁদ — একবার তৈরি হওয়া list

পর্ব ১৩-এ এক লাইনে সতর্ক করেছিলাম: default হিসেবে [] দেবেন না। পর্ব ১৯-এ শিখেছেন mutable object আর alias কী। এবার দুটি মিলিয়ে পুরো রহস্য খুলি। একটি অনলাইন দোকানের শপিং-কার্ট ফাংশন — নতুন ক্রেতার জন্য খালি কার্ট, আর পণ্য যোগ হবে:

def add_to_cart(item, cart=[]):
    cart.append(item)
    return cart

লেখক ভেবেছিলেন: “cart না দিলে প্রতিবার নতুন খালি list”. আসলে তা হয় না। মূল কথাটি একটি বাক্যে: default-এর expression হিসাব হয় একবারই — def লাইন চলার মুহূর্তে, প্রতিটি ডাকে নয়. সেই মুহূর্তে একটি খালি list তৈরি হয়, আর ফাংশন object সেটি নিজের ভেতরে (add_to_cart.__defaults__-এ) রেখে দেয়। এরপর যতবার cart ছাড়া ডাকবেন, ততবার cart নামটি সেই একই list-এর গায়ে লাগবে। ধাপে ধাপে দেখুন:

1def add_to_cart(item, cart=[]):2    cart.append(item)3    return cart45a = add_to_cart("চাল")6b = add_to_cart("ডাল")7c = add_to_cart("তেল")8print(a, a is c)

এখানে None একটি sentinel-এর কাজ করছে — একটি বিশেষ সংকেত-মান, যার মানে “কেউ কিছু পাঠায়নি”। if not cart: না লিখে if cart is None: লেখার কারণ আছে: কেউ ইচ্ছা করে নিজের খালি list পাঠালে not cart সত্য হবে, আর আপনি তাঁর list ফেলে নতুন একটি বানিয়ে ফেলবেন — তাঁর list-এ পণ্য যোগ হবে না। is None শুধু “কিছুই পাঠানো হয়নি” অবস্থাটি ধরে।

এবার প্রথম runnable প্রোগ্রাম। এতে আছে *args/**kwargs-এর ভেতরটা দেখা, print-এ সব ফরোয়ার্ড করা একটি লগ-সহায়ক, আর কার্টের বাগ ও সমাধান পাশাপাশি। চালানোর আগে শেষ তিন লাইনের আউটপুট অনুমান করুন:

def log(level, *args, **kwargs):
    print(f"[{level}]", args, kwargs)       # ভেতরে কী এল
    print(f"[{level}]", *args, **kwargs)    # হুবহু ফরোয়ার্ড

nums, opts = [500, 120], {"sep": " / "}
log("INFO", *nums, **opts)

def add_to_cart(item, cart=[]):
    cart.append(item)
    return cart

def add_to_cart_safe(item, cart=None):
    if cart is None:
        cart = []
    cart.append(item)
    return cart

print(add_to_cart("চাল"))
print(add_to_cart("ডাল"))
print(add_to_cart_safe("চাল"), add_to_cart_safe("ডাল"))

৬ · Closure — জন্মস্থানের কথা মনে রাখা ফাংশন

পর্ব ১৩-এ দেখেছিলেন, ফাংশনও একটি object (first-class function) — তাকে অন্য ফাংশনে পাঠানো যায়, আর ফাংশন থেকে ফেরতও দেওয়া যায়। আর এই পর্বের অংশ ১-এ দেখলেন, ফাংশনের ভেতরে আরেকটি ফাংশন লেখা যায় — একে বলে nested function. এবার দুটি মেলাই: একটি ফাংশন যদি ভেতরে আরেকটি ফাংশন বানিয়ে সেটিই ফেরত দেয়?

def make_multiplier(n):
    def multiply(x):
        return x * n      # n ভেতরে তৈরি হয়নি — এসেছে বাইরের ফাংশন থেকে
    return multiply       # বন্ধনী নেই: ফাংশন object নিজে ফেরত

triple = make_multiplier(3)
print(triple(10))         # 30

এখানে একটি ধাঁধা আছে। পর্ব ১৩ বলে, make_multiplier(3) return করলেই তার frame মুছে যায়, সঙ্গে local n-ও। তাহলে পরে triple(10) ডাকলে multiply n-এর মান 3 পায় কোথা থেকে? উত্তর: multiply জন্মের সময়েই বুঝে নিয়েছে যে সে n ব্যবহার করে, আর n-কে সঙ্গে করে নিয়ে গেছে। এমন ফাংশনকে বলে closure — যে ফাংশন তার জন্মস্থানের (Enclosing scope-এর) ভ্যারিয়েবল মনে রাখে, এমনকি সেই জায়গা শেষ হয়ে যাওয়ার পরেও.

এই “খাম”টি Python-এ সত্যিই আছে। একে বলে cell — একটি ছোট বাক্স, যেটি একটি ভ্যারিয়েবল ধরে রাখে। ভেতরের ফাংশন যে বাইরের নাম ব্যবহার করে (যাকে বলে free variable), Python সেই নামটিকে সাধারণ local হিসেবে না রেখে একটি cell-এ রাখে, আর ভেতরের ফাংশন object সেই cell-এর একটি reference নিজের __closure__-এ রেখে দেয়। ধাপে ধাপে দেখুন:

1def make_multiplier(n):2    def multiply(x):3        return x * n4    return multiply56triple = make_multiplier(3)7print(triple(10))

make_multiplier-এর মতো যে ফাংশনের কাজই হলো নতুন ফাংশন বানিয়ে ফেরত দেওয়া, তাকে বলে factory function. এর একটি বাস্তব প্রয়োগ: বিভিন্ন পণ্যে বিভিন্ন হারে VAT. বাংলাদেশে পণ্য বা সেবাভেদে VAT-এর হার আলাদা হতে পারে (এখানে ১৫% আর ৫% শুধু উদাহরণ)। প্রতিটি হারের জন্য আলাদা ফাংশন হাতে লেখার বদলে একটি factory: vat15 = make_vat(0.15), vat5 = make_vat(0.05). হার একবার ঠিক হয়ে closure-এ বন্দি থাকে, তারপর শুধু দাম দিয়ে ডাকলেই হয় — আর কেউ ভুল করে বাইরে থেকে হার বদলাতেও পারে না।

nonlocal দিয়ে অবস্থা ধরে রাখা — একটি counter

অংশ ২-এর ভিজিট counter মনে আছে? global দিয়ে চলত, কিন্তু একটির বেশি counter রাখা যেত না। Closure আর nonlocal দিয়ে এর পরিষ্কার সমাধান: make_counter()-এর ভেতরে count = 0, ভেতরের click() ফাংশন nonlocal count লিখে সেটি বাড়ায়। প্রতিবার make_counter() ডাকলে নতুন cell-এ নতুন count — হোমপেজের জন্য একটি counter, ব্লগের জন্য আরেকটি, কেউ কারও সাথে মেশে না। আর বাইরের কোনো কোড count-এ সরাসরি হাত দিতে পারে না; বাড়ানোর একমাত্র উপায় click() ডাকা। এভাবে তথ্য লুকিয়ে রাখাকে বলে encapsulation — class-এরও মূল উদ্দেশ্য এটাই।

দ্বিতীয় runnable প্রোগ্রামে VAT factory, counter আর পরের অংশের লুপ-ফাঁদ একসাথে:

def make_vat(rate):
    def add_vat(price):
        return round(price * (1 + rate), 2)
    return add_vat

vat15 = make_vat(0.15)
print(vat15(1000), make_vat(0.05)(1000), vat15.__closure__[0].cell_contents)

def make_counter():
    count = 0
    def click():
        nonlocal count
        count += 1
        return count
    return click

visit = make_counter()
print("ভিজিট:", visit(), visit(), visit())

late = [lambda: i for i in range(3)]
fixed = [lambda i=i: i for i in range(3)]
print([f() for f in late], [f() for f in fixed])

৭ · লুপে closure-এর ফাঁদ — late binding

খামের উপমায় একটি সূক্ষ্ম কথা লুকিয়ে ছিল। Closure খামে মানের ফটোকপি রাখে না, রাখে ভ্যারিয়েবলটিকেই (cell-টিকে)। ফাংশন যখন ডাকা হয়, তখন cell খুলে সেই মুহূর্তের মান পড়ে — বানানোর মুহূর্তের মান নয়। একে বলে late binding. make_multiplier-এ এটা টের পাওয়া যায়নি, কারণ n আর কখনো বদলায়নি। কিন্তু লুপে বানানো closure-এ ভ্যারিয়েবলটি প্রতিবার বদলায়:

1funcs = []2for i in range(3):3    funcs.append(lambda: i)4print([f() for f in funcs])56# সমাধান: lambda i=i: i

এই ফাঁদ শুধু lambda-তে নয়, লুপের ভেতরে def দিয়ে বানানো ফাংশনেও একই রকম। বাস্তবে এটি দেখা যায় GUI-তে বোতাম বানানোর সময় (দশটি বোতাম, সবগুলো চাপলে দশ নম্বরের কাজ হয়), বা লুপে callback নিবন্ধন করার সময়। i=i কৌশল ছাড়াও আরেকটি পরিষ্কার পথ হলো একটি factory function দিয়ে প্রতিবার নতুন scope বানানো — make_multiplier(i)-এর মতো — অথবা functools.partial (পর্ব ৩৮)। i=i-এর একটি ছোট অসুবিধা: কেউ ভুল করে f(5) ডাকলে আটকানো মানের বদলে 5 ফেরত আসে, কারণ i এখন একটি সাধারণ parameter.

৮ · Closure নাকি class? আর কোনটি কখন

Counter-এর উদাহরণে closure দুটি কাজ করল: কিছু অবস্থা (count) ধরে রাখল, আর সেটি বদলানোর একটি আচরণ (click) দিল। এই “অবস্থা + আচরণ” জুটিই আসলে object-oriented programming-এর মূল ভাবনা। একই counter class দিয়েও লেখা যায় — পর্ব ২৯-এ দেখবেন class Counter: আর self.count += 1. তাহলে কোনটি কখন?

একটি পুরোনো রসিকতা আছে প্রোগ্রামারদের মধ্যে: “closure হলো গরিবের object, আর object হলো গরিবের closure”. কথাটির মানে, দুটি একই সমস্যার দুটি সমাধান — ডেটা আর তার ওপর কাজকে একসাথে বেঁধে রাখা। ছোট আর এক-কাজের হলে closure হালকা ও সুন্দর; বড় হলে class পরিষ্কার।

৯ · AI-এর যুগে — scope আর default-এর ভুল ধরা

AI-এর লেখা কোড সাধারণত চলে — আর এই পর্বের ভুলগুলোর বিপদ ঠিক সেখানেই। Mutable default বা late binding প্রথম পরীক্ষায় ধরা পড়ে না; ধরা পড়ে দ্বিতীয় ডাকে, বা প্রোডাকশনে, যখন দুজন ক্রেতার কার্ট মিশে যায়। AI-এর প্রশিক্ষণের কোডে এই ধাঁচগুলো প্রচুর আছে, তাই AI-ও সেগুলো নকল করে:

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

• প্রতিটি def লাইনে default-গুলো দেখেছি — [], {}, set() বা অন্য mutable কিছু নেই
• global শব্দটি খুঁজেছি (Ctrl+F); থাকলে জিজ্ঞেস করেছি সেটি parameter/return দিয়ে বদলানো যায় কি না
• *args, **kwargs থাকলে নিশ্চিত হয়েছি যে সেগুলো আসলেই কোথাও ফরোয়ার্ড হচ্ছে; না হলে নাম দেওয়া parameter চেয়েছি
• লুপের ভেতরে lambda বা def থাকলে প্রতিটি ফাংশন আলাদা করে ডেকে ফল মিলিয়েছি
• একই ফাংশন অন্তত দুবার ডেকে দেখেছি — দ্বিতীয় ডাকে আগের ডাকের কিছু “চুঁইয়ে” আসছে কি না
• কোনো ভ্যারিয়েবলের নাম built-in-এর সাথে মেলে না (list, dict, str, id, sum, max, input)