dictionary — চাবি দিয়ে খোঁজা

১ · dictionary কী — অবস্থান নয়, নাম দিয়ে খোঁজা

পর্ব ১৪-এ list আর পর্ব ১৫-এ tuple দেখেছেন। দুটোতেই জিনিস থাকে ক্রমিক অবস্থানে: প্রথম, দ্বিতীয়, তৃতীয়। কিছু চাইলে বলতে হয় “৩ নম্বর ঘরেরটা দাও”. কিন্তু বাস্তব জীবনে আমরা কদাচিৎ এভাবে খুঁজি। মোবাইলে কাউকে কল করতে চাইলে আপনি ভাবেন না “আমার কন্টাক্টের ২৪৭ নম্বর মানুষটা”; আপনি টাইপ করেন “সুমি”. দোকানে চালের দাম জানতে চাইলে দোকানি “তালিকার ৫ নম্বর জিনিস” খোঁজেন না, “চাল” খোঁজেন।

এই কাজের জন্য Python-এর dictionary (সংক্ষেপে dict). একটি dict হলো কয়েকটি key-value pair-এর সংগ্রহ: প্রতিটি চাবি (key)-র সাথে একটি মান (value) জোড়া। আপনি চাবি দেন, dict মান ফেরত দেয়।

contacts = {"সুমি": "01711-000001", "রহিম": "01811-000002"}
print(contacts["সুমি"])            # 01711-000001

bn_en = {"বই": "book", "কলম": "pen", "পানি": "water"}
print(bn_en["কলম"])                # pen

গঠনটি খেয়াল করুন: দ্বিতীয় বন্ধনী { }, প্রতিটি জোড়ায় চাবি: মান, জোড়াগুলোর মাঝে কমা। খোঁজার সময় list-এর মতোই তৃতীয় বন্ধনী [ ], কিন্তু ভেতরে index নয় — চাবি। দ্বিতীয় উদাহরণটি একটি ছোট বাংলা-ইংরেজি অভিধান; “dictionary” নামটাও এসেছে এই ছবি থেকে — শব্দ দিয়ে খুঁজলে মানে পাওয়া যায়।

dict সবখানে — Python-এর মেরুদণ্ড

dict শুধু একটি ডেটা স্ট্রাকচার নয়; Python ভাষাটিই এর ওপর দাঁড়িয়ে আছে। কয়েকটি উদাহরণ, যা পরের পর্বগুলোতে বারবার দেখবেন:

• ওয়েবের ডেটা: API থেকে যে JSON আসে (পর্ব ২৬, ৪৭), Python-এ পড়লে সেটি সাধারণত dict আর list-এর মিশ্রণ হয়ে যায় — {"name": "রিয়া", "marks": [78, 91]}.
• ফাংশনের keyword argument: f(name="রিয়া", age=20) — ফাংশনের ভেতরে **kwargs আসলে একটি dict (পর্ব ২০)।
• object-এর attribute: একটি সাধারণ object-এর ভেতরের মানগুলো সাধারণত একটি dict-এ থাকে, নাম __dict__ (পর্ব ২৯)।
• ভ্যারিয়েবলের নাম নিজেই: একটি module-এর global ভ্যারিয়েবলগুলো আসলে একটি dict-এ রাখা — নাম চাবি, object মান। globals() চালিয়ে দেখতে পারেন।

২ · dict তৈরির কয়েকটি উপায়

একই dict বানানোর একাধিক রাস্তা আছে। কোনটি কখন সুবিধাজনক, দেখে নিন:

dict(zip(...)) সবচেয়ে কাজের রূপগুলোর একটি। পর্ব ১২-এ দেখেছেন zip দুটি সারি থেকে জোড়া বানায়; dict() সেই জোড়াগুলোর প্রথমটিকে চাবি আর দ্বিতীয়টিকে মান বানায়। dict(zip([101, 102, 103], [78, 91, 65])) দেয় {101: 78, 102: 91, 103: 65}. শেষ লাইনের {r: 0 for r in rolls} ধাঁচটির নাম dict comprehension — এক লাইনে নিয়ম মেনে dict বানানো; পুরো আলোচনা পর্ব ১৮-এ।

চাবি আর মানের ধরন নিয়ে নিয়ম অসমান। মান যেকোনো কিছু হতে পারে — সংখ্যা, string, list, আরেকটি dict, এমনকি একটি ফাংশন। চাবির ক্ষেত্রে একটি শর্ত আছে, যার কারণ বুঝতে হলে dict-এর ভেতরে উঁকি দিতে হবে। চলুন সেটাই করি।

৩ · ভেতরের রহস্য — hashing আর গড়ে O(1) খোঁজা

একটি list-এ “রহিম” আছে কি না জানতে Python-কে প্রথম থেকে একটি একটি করে তুলনা করতে হয় — এটা linear search. দশ লাখ নামের list-এ সবচেয়ে খারাপ ক্ষেত্রে দশ লাখ তুলনা। dict এই সমস্যার সমাধান করে একটি পুরোনো, চমৎকার কৌশলে: hash table.

কৌশলটি তিন ধাপের। প্রথমে একটি hash function চাবিটিকে একটি পূর্ণসংখ্যায় বদলায় — Python-এ এটাই hash(key). একই চাবি থেকে সবসময় একই সংখ্যা আসে। দ্বিতীয়ত, dict-এর ভেতরে একটি নির্দিষ্ট সংখ্যক ঘর (slot) থাকে; সংখ্যাটিকে ঘরের সংখ্যা দিয়ে ভাগ করে ভাগশেষ নিলে পাওয়া যায় কোন ঘরে যেতে হবে। তৃতীয়ত, সেই ঘরে গিয়ে দেখা হয় চাবিটি সত্যিই এটাই কি না — মিললে মান ফেরত। পুরো কাজে চাবির সংখ্যা যত বড়ই হোক, ধাপ মোটামুটি একই। নিচের ছবিতে সংখ্যাগুলো বোঝানোর জন্য বানানো — আসল hash মান অনেক বড়, আর প্রতিবার Python চালালে string-এর hash বদলে যায় (প্রশ্ন ০২-এ কারণ)।

prices = {"চাল": 75, "তেল": 190, "ডাল": 140}
# খুঁজছি: prices["ডাল"]
# list হলে: "চাল"? না। "তেল"? না। "ডাল"? হ্যাঁ — ৩টি তুলনা
# dict কি সবকটি দেখবে? দেখা যাক…

hash("ডাল")   → …4813   (উদাহরণ; আসল সংখ্যা ১৯ অঙ্কের মতো লম্বা)
hash("ডাল")   → …4813   একই রানে আবার — একই সংখ্যা
hash("ডাব")   → …0272   একটি অক্ষর বদলালেই সম্পূর্ণ আলাদা

4813 % 8 = 5

ঘর:  0     1      2     3     4     5       6     7
     —   "চাল"    —     —     —   "তেল"     —     —
বাকি ৭টি ঘরের দিকে তাকানোই হলো না

ঘর 5-এ আছে "তেল" — চাবি মেলে না!
"তেল" ঢোকানোর সময় তার ঘরও 5 হয়েছিল, সে আগে এসেছিল।
"ডাল" ঢোকানোর সময় ঘর 5 ভরা পেয়ে পরের ঘর খোঁজা হয়েছিল।
খোঁজার সময়ও একই পথ ধরা হয় → ঘর 6

ঘর 6: hash মেলে? হ্যাঁ। চাবি == "ডাল"? হ্যাঁ
prices["ডাল"] → 140
মোট দেখা হলো ২টি ঘর — dict-এ ৩টি চাবি থাকুক বা ৩০ লাখ

“গড়ে” শব্দটি কেন গুরুত্বপূর্ণ

dict-এর খোঁজা average case-এ O(1), সবসময় নয়। যদি দুর্ভাগ্যক্রমে (বা কেউ ইচ্ছে করে) অনেকগুলো চাবি একই ঘরের দিকে যায়, তবে প্রতিটি খোঁজায় লম্বা পথ হাঁটতে হয় — সবচেয়ে খারাপ ক্ষেত্রে O(n), ঠিক list-এর মতো। ভালো hash function আর টেবিল সময়মতো বড় করার কারণে বাস্তবে এটা প্রায় ঘটে না। তবে আক্রমণকারীরা ইচ্ছে করে এমন চাবি বানাতে পারে কি না — সেই গল্প প্রশ্ন ০২-এ।

অর্থাৎ dict গতি কেনে মেমরি দিয়ে। একটি বাস্তব হিসাব ভাবুন: ১০,০০০ গ্রাহকের প্রত্যেকের জন্য ১০,০০০ লেনদেনের তালিকায় খোঁজা। list দিয়ে প্রতিটি খোঁজা গড়ে কয়েক হাজার তুলনা — মোট কয়েক কোটি। গ্রাহকদের একটি dict-এ রাখলে প্রতিটি খোঁজা প্রায় এক ধাপ — মোট ১০,০০০-এর কাছাকাছি। অনেক “ধীর প্রোগ্রাম” শুধু একটি list-কে dict (বা পরের পর্বের set) দিয়ে বদলালেই দ্রুত হয়ে যায়।

৪ · পড়া — d[key], get() আর in

dict থেকে মান পড়ার দুটি প্রধান উপায়, আর তাদের পার্থক্য শুধু একটি জায়গায় — চাবি না থাকলে কী হবে.

চাবি না থাকলে d[key] যে traceback দেয়, সেটি দেখতে এমন:

>>> prices = {"চাল": 75, "ডাল": 140}
>>> prices["চিনি"]
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    prices["চিনি"]
    ~~~~~~^^^^^^^^
KeyError: 'চিনি'

শেষ লাইনটি পড়ুন: KeyError-এর পরে সেই চাবিটি, যা পাওয়া যায়নি। প্রায়ই এখানেই ভুলটি ধরা পড়ে — বানান ভুল, শেষে বাড়তি ফাঁকা জায়গা ("চিনি "), বা সংখ্যা আর string গুলিয়ে ফেলা (101 বনাম "101" — dict-এর কাছে এরা সম্পূর্ণ আলাদা চাবি)।

in — চাবি আছে কি?

পর্ব ০৮-এর membership operator in dict-এ শুধু চাবি দেখে, মান নয়। "ডাল" in prices → True, কিন্তু 140 in prices → False, যদিও 140 একটি মান হিসেবে আছে। মানের মধ্যে খুঁজতে চাইলে লিখতে হয় 140 in prices.values() — কিন্তু সেটি আবার list-এর মতো একে একে দেখা, O(n). চাবিতে in hash table ব্যবহার করে, তাই গড়ে O(1).

“চাবি আছে কি দেখি, থাকলে পড়ি” — এই দুই ধাপ প্রায়ই একটি get()-এ মিলিয়ে ফেলা যায়:

# দুই ধাপে: চাবি দুবার খোঁজা হয়
if "চিনি" in prices:
    price = prices["চিনি"]
else:
    price = 0

# এক ধাপে: একই কাজ
price = prices.get("চিনি", 0)

৫ · যোগ, হালনাগাদ, মিলানো আর মোছা

dict একটি mutable object — তৈরির পরেও বদলানো যায়। বদলানোর উপায়গুলো একসাথে:

সবচেয়ে বেশি ব্যবহৃত হলো প্রথমটি — d[k] = v. লক্ষ করুন, যোগ আর হালনাগাদের জন্য আলাদা কোনো লেখা নেই। এর সুবিধাও আছে, অসুবিধাও: একটি বানান ভুলে আপনি পুরোনো মান বদলানোর বদলে চুপচাপ একটি নতুন চাবি যোগ করে ফেলতে পারেন (stock["চাল "] = 50 — শেষে ফাঁকা জায়গা)।

দুটি dict মিলানো — | আর |=

Python 3.9 থেকে dict-এ merge operator আছে (PEP 584). দোকানের পুরোনো দামের তালিকা আর আজকের নতুন দামের তালিকা মিলাতে চান:

old = {"চাল": 75, "ডাল": 140, "তেল": 190}
today = {"তেল": 185, "চিনি": 135}

print(old | today)   # {'চাল': 75, 'ডাল': 140, 'তেল': 185, 'চিনি': 135}
print(today | old)   # {'তেল': 190, 'চিনি': 135, 'চাল': 75, 'ডাল': 140}

নিয়ম: একই চাবি দুই দিকে থাকলে ডান দিকেরটি জেতে. তাই old | today-তে তেলের নতুন দাম 185, আর today | old-তে পুরোনো 190 ফিরে এসেছে। চাবির ক্রম আসে বাঁ দিকের dict থেকে, নতুন চাবিগুলো শেষে যুক্ত হয়। | কোনোটিকেই বদলায় না, নতুন dict বানায়; |= বাঁ দিকেরটিকে জায়গায় বদলায়। এই কাজটি আগে লেখা হতো {**old, **today} দিয়ে, যা পুরোনো কোডে এখনো দেখবেন — ফল একই।

মোছা — del, pop, popitem

del prices["তেল"] শুধু মুছে দেয়। prices.pop("তেল") মুছে দিয়ে মানটি হাতে দেয় — “দোকান থেকে তেল সরাও, আর বলো দাম কত ছিল”. চাবি না থাকার সম্ভাবনা থাকলে default দিন: prices.pop("লবণ", None) কখনো error দেয় না। popitem() সবশেষে যোগ হওয়া জোড়াটি সরায় — Python 3.7 থেকে এই ক্রম নিশ্চিত, তাই dict-কে একটি স্ট্যাকের মতোও ব্যবহার করা যায় (শেষে ঢুকেছে, আগে বেরোবে)।

৬ · লুপ, view আর চাবির ক্রম

পর্ব ১২-এ দেখেছেন, dict-এর ওপর সরাসরি for লুপ চালালে প্রতি ঘোরায় একটি চাবি আসে। মান বা দুটিই চাইলে তিনটি method আছে:

সবচেয়ে প্রচলিত রূপ for roll, mark in marks.items(): — প্রতিটি জোড়াকে পর্ব ১৫-এর unpacking দিয়ে দুটি নামে ভাগ করা। for roll in marks: লিখে ভেতরে marks[roll] পড়াও কাজ করে, কিন্তু প্রতিবার একটি বাড়তি খোঁজা হয়, আর পড়তেও কম পরিষ্কার।

View — কপি নয়, জীবন্ত জানালা

keys(), values(), items() কোনো নতুন list বানায় না। এরা দেয় একটি view — dict-এর দিকে খোলা একটি জানালা। dict বদলালে জানালা দিয়ে তাকালে বদলটাও দেখা যায়। কোনো কপি হয় না বলে লাখো চাবির dict-এও items() তৈরি হয় সঙ্গে সঙ্গে। নিচের প্রথম কোডে এটি নিজে দেখবেন। একটি স্থির তালিকা দরকার হলে স্পষ্ট করে বানিয়ে নিন: list(d.keys()) বা সংক্ষেপে list(d).

চাবির ক্রম — ঢোকানোর ক্রমই থাকে

dict-এ লুপ চালালে চাবিগুলো কোন ক্রমে আসবে? উত্তর: যে ক্রমে ঢোকানো হয়েছিল — একে বলে insertion order. আগে থেকে থাকা চাবির মান বদলালে তার জায়গা বদলায় না; মুছে আবার যোগ করলে সে শেষে যায়। এই নিশ্চয়তার একটি ইতিহাস আছে:

• Python 3.5 পর্যন্ত: ক্রম ছিল কার্যত এলোমেলো — hash অনুযায়ী। নির্দিষ্ট ক্রম চাইলে collections.OrderedDict লাগত।
• CPython 3.6: নতুন “compact dict” নকশায় ক্রম রক্ষা হতে লাগল, কিন্তু সেটি ছিল বাস্তবায়নের খুঁটিনাটি (implementation detail) — ভাষার প্রতিশ্রুতি নয়।
• Python 3.7 থেকে: insertion order ভাষার নিয়ম। যেকোনো Python বাস্তবায়নকে এটি মানতে হবে।

তাই আজকের Python-এ print(d)-এর আউটপুট নির্ধারিত — একই কোড প্রতিবার একই ক্রমে ছাপে। (পরের পর্বের set-এর ক্ষেত্রে কিন্তু এই নিশ্চয়তা নেই।)

লুপ চলার সময় dict বদলাবেন না

পর্ব ১২-এ দেখেছেন, list-এর ওপর লুপ চালাতে চালাতে তাকে বদলালে একটি জিনিস চুপচাপ বাদ পড়ে। dict এখানে আরও কড়া — লুপ চলার সময় চাবি যোগ বা মুছলে Python সরাসরি থামিয়ে দেয়:

>>> stock = {"চাল": 50, "চিনি": 0, "ডাল": 0}
>>> for item in stock:
...     if stock[item] == 0:
...         del stock[item]
...
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    for item in stock:
                ^^^^^
RuntimeError: dictionary changed size during iteration

RuntimeError-এর বার্তাটি স্পষ্ট: “লুপের মাঝে dictionary-র আকার বদলেছে”. কারণ চাবি যোগ বা মোছায় ভেতরের টেবিল নতুন করে সাজানো হতে পারে, তখন লুপ কোথায় ছিল তার হিসাব আর অর্থবহ থাকে না। Python ভুল উত্তর দেওয়ার চেয়ে থামিয়ে দেওয়া ভালো মনে করে। দুটি সমাধান:

• চাবিগুলোর কপির ওপর লুপ: for item in list(stock): — list(stock) লুপ শুরুর আগেই চাবিগুলোর একটি আলাদা list বানায়, তাই আসল dict থেকে মোছা নিরাপদ।
• নতুন dict বানানো: stock = {k: v for k, v in stock.items() if v > 0} — যা রাখতে চান শুধু তা দিয়ে (comprehension, পর্ব ১৮)।

একটি সূক্ষ্ম বিষয়: লুপের মাঝে আগে থেকে থাকা চাবির মান বদলানো (stock[item] = 0) নিষেধ নয়, কারণ তাতে আকার বা কাঠামো বদলায় না। নিষেধ শুধু চাবি যোগ আর মোছা। এবার এখন পর্যন্ত শেখা সব একসাথে চালিয়ে দেখুন:

prices = {"চাল": 75, "ডাল": 140, "তেল": 190}
print(prices["ডাল"], prices.get("চিনি"), prices.get("চিনি", 0))

prices |= {"চিনি": 135, "তেল": 185}   # নতুন চাবি যোগ, পুরোনোটি হালনাগাদ
print(prices)
print("লবণ" in prices, 140 in prices)  # in শুধু চাবি দেখে

names = prices.keys()                  # view — জীবন্ত জানালা
prices["ডিম"] = 150
print(len(names), list(names)[-1])

for item in list(prices):              # কপির ওপর লুপ, তাই মোছা নিরাপদ
    if prices[item] >= 150:
        del prices[item]
print(prices)
print(prices.pop("লবণ", "নেই"), prices.popitem())

৭ · চাবির শর্ত — কেন hashable হতে হয়

অংশ ৩-এর ছবিটি মনে করুন: চাবি ঢোকানোর সময় তার hash দেখে ঘর ঠিক হয়েছিল। এখন ভাবুন, চাবিটি যদি পরে বদলে যায়? তার নতুন hash অন্য ঘর দেখাবে, অথচ সে বসে আছে পুরোনো ঘরে। খুঁজতে গেলে Python ভুল ঘরে যাবে — চাবিটি dict-এর ভেতরে থেকেও “হারিয়ে” যাবে। এই বিপদ এড়াতে Python-এর নিয়ম: dict-এর চাবি হতে হবে hashable — অর্থাৎ এমন object, যার hash তার জীবনকালে বদলায় না, আর যাকে অন্যের সাথে == দিয়ে তুলনা করা যায়।

বাস্তবে এর মানে: Python-এর built-in immutable ধরনগুলো চাবি হতে পারে, বদলানো যায় এমন ধরনগুলো পারে না।

list-কে চাবি বানাতে গেলে কী হয়, Python 3.14-এ দেখুন:

>>> seats = {}
>>> seats[[3, 4]] = "রিয়া"
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    seats[[3, 4]] = "রিয়া"
    ~~~~~^^^^^^^^
TypeError: cannot use 'list' as a dict key (unhashable type: 'list')

এটি একটি TypeError. পুরোনো Python version-গুলোতে বার্তাটি ছিল ছোট — শুধু TypeError: unhashable type: 'list'; সাম্প্রতিক version বার্তাটিকে আরও ব্যাখ্যামূলক করেছে। দুটিরই মানে এক। সমাধান সহজ: সারি-কলামের মতো জোড়া চাবি হিসেবে চাইলে list নয়, tuple ব্যবহার করুন — seats[(3, 4)] = "রিয়া", বা বন্ধনী ছাড়া seats[3, 4] = "রিয়া". পর্ব ১৫-এ দেখেছেন, tuple-এর এটাই একটি বড় কাজ।

৮ · বাস্তব প্যাটার্ন — গণনা, দলে ভাগ, উল্টানো, lookup

প্যাটার্ন ১: গণনা — কোন শব্দ কতবার

একটি SMS-এ কোন শব্দ কতবার এসেছে? এটি dict-এর সবচেয়ে ক্লাসিক কাজ — চাবি শব্দ, মান গণনা। কৌশলের মূলে একটি লাইন: counts[word] = counts.get(word, 0) + 1. শব্দটি আগে না এলে get দেয় 0, তার সাথে 1 — প্রথমবার গণনা 1. আগে এলে পুরোনো গণনার সাথে 1. ধাপে ধাপে দেখুন:

1words = ["কাল", "ক্লাস", "কাল", "পরীক্ষা"]2counts = {}3for word in words:4    counts[word] = counts.get(word, 0) + 15print(counts)

এই কাজটি এত প্রচলিত যে standard library-তে এর জন্য একটি তৈরি জিনিস আছে — collections.Counter. Counter(words) একাই পুরো লুপের কাজ করে, আর .most_common(3) সবচেয়ে বেশি আসা তিনটি দেয়। Counter আসলে dict-এরই একটি উপশ্রেণি (subclass), তাই dict-এর সব কিছুই এতে চলে; বাড়তি সুবিধা হলো, না থাকা চাবি পড়লে KeyError নয়, 0 দেয়।

প্যাটার্ন ২: দলে ভাগ — কোন জেলায় কে

শিক্ষার্থীদের জেলা অনুযায়ী দলে ভাগ করতে চান: চাবি জেলা, মান সেই জেলার শিক্ষার্থীদের list. সমস্যা হলো, একটি জেলার প্রথম শিক্ষার্থী এলে তার জন্য খালি list আগে বানাতে হয়। তিনটি উপায়:

• হাতে: if district not in groups: groups[district] = [], তারপর groups[district].append(name) — লম্বা, কিন্তু সবাই বোঝে।
• setdefault: groups.setdefault(district, []).append(name) — “চাবি না থাকলে খালি list বসাও, তারপর যেটা আছে সেটা দাও”. এক লাইন, তবে নামটি অনেকের কাছে বিভ্রান্তিকর।
• defaultdict: groups = defaultdict(list) — না থাকা চাবি পড়লেই সে নিজে list() ডেকে একটি খালি list বসিয়ে দেয়। সবচেয়ে পরিষ্কার।

1by_district = defaultdict(list)2for name, district in students:3    by_district[district].append(name)

প্যাটার্ন ৩: উল্টে দেওয়া, nested dict আর মান অনুযায়ী সাজানো

উল্টে দেওয়া: রোল → নম্বর থেকে নম্বর → রোল চাই। {mark: roll for roll, mark in marks.items()}. সাবধান: দুজন একই নম্বর পেলে উল্টানো dict-এ একজন হারিয়ে যাবে — চাবি অনন্য হতে হয়, শেষেরটি জেতে। একাধিক থাকতে পারলে উল্টানোর সময় defaultdict(list) দিয়ে দলে ভাগ করুন।

Nested dict: মান নিজেই একটি dict হতে পারে — একটি কন্টাক্ট বুকে প্রত্যেকের নম্বর, জেলা, ইমেইল। ঠিক JSON-এর মতো রেকর্ড:

contacts = {
    "সুমি": {"phone": "01711-000001", "district": "রাজশাহী"},
    "রহিম": {"phone": "01811-000002", "district": "খুলনা", "email": "rahim@example.com"},
}
print(contacts["রহিম"]["district"])               # খুলনা
print(contacts["সুমি"].get("email", "ইমেইল নেই"))  # ইমেইল নেই

দুই স্তরে খুঁজতে দুটি তৃতীয় বন্ধনী। ভেতরের কোনো চাবি সবার না থাকলে সেখানে get. অনেক স্তরের nested dict পড়া কঠিন হয়ে যায়; তখন পর্ব ৩২-এর dataclass ভালো বিকল্প।

মান অনুযায়ী সাজানো: dict চাবি ঢোকানোর ক্রমে থাকে, নিজে সাজায় না। সবচেয়ে বেশি আসা শব্দগুলো আগে চাইলে sorted(counts, key=counts.get, reverse=True) — চাবিগুলো সাজাও, প্রতিটির তুলনার মাপকাঠি তার মান। জোড়াসহ চাইলে sorted(counts.items(), key=lambda pair: pair[1], reverse=True) — lambda হলো এক লাইনের ছোট ফাংশন, পর্ব ৩৮-এ শিখবেন।

from collections import Counter, defaultdict

sms = "কাল ক্লাস নেই কাল পরীক্ষা আছে পরীক্ষা কাল সকালে"
counts = {}
for word in sms.split():
    counts[word] = counts.get(word, 0) + 1
print(counts)
print(sorted(counts, key=counts.get, reverse=True)[:2])
print(Counter(sms.split()).most_common(2))

students = [("রিয়া", "রাজশাহী"), ("জয়", "সিলেট"), ("সুমি", "রাজশাহী")]
by_district = defaultdict(list)
for name, district in students:
    by_district[district].append(name)
print(dict(by_district))

marks = {101: 78, 102: 91, 103: 65}
roll_of = {mark: roll for roll, mark in marks.items()}   # উল্টে দেওয়া
print(roll_of[91], roll_of)

প্যাটার্ন ৪: লম্বা if/elif-এর বদলে lookup table

পর্ব ১১-এ if/elif দিয়ে সিদ্ধান্ত নিয়েছেন। কিন্তু কিছু if/elif আসলে সিদ্ধান্ত নয় — শুধু “এই চাবির জন্য এই মান” খোঁজা:

# if/elif দিয়ে — প্রতিটি নতুন জেলায় দুই লাইন বাড়ে
if district == "ঢাকা":
    charge = 60
elif district == "গাজীপুর":
    charge = 80
elif district == "চট্টগ্রাম":
    charge = 120
else:
    charge = 150

# lookup table দিয়ে — ডেটা এক জায়গায়, যুক্তি এক লাইনে
DELIVERY_CHARGE = {"ঢাকা": 60, "গাজীপুর": 80, "চট্টগ্রাম": 120}
charge = DELIVERY_CHARGE.get(district, 150)

দ্বিতীয় রূপটি একটি lookup table. সুবিধা অনেক: নতুন জেলা মানে শুধু একটি জোড়া; তালিকাটি পরে একটি ফাইল বা ডেটাবেস থেকে আনা যায় (পর্ব ২৬); আর if/elif-এ ৬৪টি জেলার জন্য গড়ে কয়েক ডজন তুলনা লাগত, dict-এ একটি hash খোঁজা। মান হিসেবে ফাংশনও রাখা যায় — {"add": add, "sub": sub}[op](a, b) — যা একটি ছোট ক্যালকুলেটর বা মেনু-চালিত প্রোগ্রামের ভিত্তি। তবে যেখানে শর্তগুলো সত্যিকারের তুলনা (mark >= 80), সেখানে if/elif বা match-ই স্বাভাবিক; dict কাজ করে শুধু “ঠিক এই মান” খোঁজায়।

৯ · AI-এর যুগে — AI-এর লেখা dict কোড যাচাই

dict-এর কোড AI খুব দ্রুত লেখে, আর বেশিরভাগ সময় চলে। কিন্তু চারটি ভুল বারবার দেখা যায় — কোনোটি প্রোগ্রাম থামিয়ে দেয়, কোনোটি চুপচাপ ভুল ফল দেয়, কোনোটি শুধু কোডকে অকারণে লম্বা করে।

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

• প্রতিটি d[key]-এর জন্য নিজেকে জিজ্ঞেস করেছি: এই চাবি কি সত্যিই সবসময় থাকবে?
• প্রতিটি .get()-এর default অর্থপূর্ণ কি না, আর None এলে পরের লাইন ভাঙবে কি না দেখেছি
• শুধু মান বাছাইয়ের জন্য লম্বা if/elif থাকলে তা একটি dict দিয়ে বদলানো যায় কি না ভেবেছি
• কোনো dict-এর লুপের ভেতরে সেই dict-এই del, pop বা নতুন চাবি আছে কি না খুঁজেছি
• হাতে লেখা গণনা বা গ্রুপিং Counter/defaultdict দিয়ে ছোট করা যায় কি না দেখেছি
• চাবি না থাকা, খালি dict আর একই মানের দুটি চাবি (উল্টানোর সময়) দিয়ে কোডটি নিজে চালিয়ে দেখেছি