comprehension — এক লাইনে list, dict আর set

১ · comprehension কী — একটি বাক্যে নতুন সংগ্রহ

আগের কয়েকটি পর্বে আপনি list, tuple, dict আর set চিনেছেন। বাস্তব কাজে এদের নিয়ে সবচেয়ে বেশি যা করা হয়, তা হলো একটি সংগ্রহ থেকে আরেকটি নতুন সংগ্রহ বানানো: দামের তালিকা থেকে ভ্যাটসহ দাম, সব শিক্ষার্থী থেকে শুধু পাস করা শিক্ষার্থী, নামের তালিকা থেকে নামের প্রথম অক্ষরগুলো।

পর্ব ১২-এর লুপ দিয়ে এটা আপনি এখনই পারেন। খালি list খুলুন, লুপ চালান, শর্ত মিললে append করুন:

nums = [3, 4, 5, 6]
evens_sq = []
for n in nums:
    if n % 2 == 0:
        evens_sq.append(n * n)
print(evens_sq)          # [16, 36]

চার লাইন কোড, কিন্তু উদ্দেশ্য একটাই — “জোড় সংখ্যাগুলোর বর্গের একটি list”. পাঠককে চারটি লাইন পড়ে, খালি list, লুপ, শর্ত আর append জোড়া দিয়ে সেই উদ্দেশ্যটি আবার বানাতে হয়। Comprehension উদ্দেশ্যটিকে সরাসরি লিখতে দেয়:

evens_sq = [n * n for n in nums if n % 2 == 0]

বাংলায় পড়ুন বাঁ থেকে: “n-এর বর্গ, nums-এর প্রতিটি n-এর জন্য, যদি n জোড় হয়”. এটাই একটি list comprehension. এখানে তিনটি অংশ আছে, যা প্রায় সব comprehension-এ ফিরে আসে:

গণিতের বইয়ে এই লেখার ধরন আপনি আগেই দেখেছেন। সেট গঠন পদ্ধতিতে লেখা হয় { x² | x ∈ N, x জোড় } — “x-এর বর্গ, যেখানে x স্বাভাবিক সংখ্যা এবং জোড়”. একে বলে set-builder notation. Python-এর comprehension প্রায় হুবহু এই গণিতের বাক্য: {x * x for x in range(1, 11) if x % 2 == 0}. শুধু “|” আর “∈”-এর জায়গায় ইংরেজি শব্দ for আর in.

২ · list comprehension — লুপের পাশাপাশি রেখে পড়া

Comprehension নতুন কোনো জাদু নয়। প্রতিটি comprehension-কে একটি নির্দিষ্ট নিয়মে সাধারণ for লুপে খুলে লেখা যায়, আর Python ভেতরে মোটামুটি সেটাই করে। নিয়মটা এই: for আর if অংশগুলো একই ক্রমে ওপর থেকে নিচে বসান, আর রূপান্তরটি সবচেয়ে ভেতরে append-এর মধ্যে রাখুন। নিচের ধাপগুলোতে দেখুন, ছোট একটি comprehension আসলে কীভাবে চলে:

1nums = [3, 4, 5, 6]2# evens_sq = [n * n for n in nums if n % 2 == 0]3result = []                  # Python-এর গোপন খালি list4for n in nums:               # উৎস5    if n % 2 == 0:           # ছাঁকনি6        result.append(n * n) # রূপান্তর7evens_sq = result

রূপান্তর আর ছাঁকনি — দুটিই ঐচ্ছিক। তাই comprehension চার রকম চেহারায় দেখা যায়:

একটি বাস্তব উদাহরণ। একটি অনলাইন দোকানের ওয়েবসাইট থেকে দামগুলো এসেছে লেখা (string) হিসেবে: ["৳120", "৳45", "৳300"]. হিসাব করতে হলে এগুলো সংখ্যা চাই। কাজটি হলো “প্রত্যেকটি থেকে টাকার চিহ্ন বাদ দিয়ে int বানাও” — শুধু রূপান্তর:

taka = [int(p.removeprefix("৳")) for p in prices]    # [120, 45, 300]

removeprefix (Python 3.9 থেকে) শুরুর “৳” সরায়, int() বাকি লেখাকে সংখ্যা বানায়। রূপান্তর অংশে আপনি যেকোনো expression লিখতে পারেন — ফাংশন ডাকা, method ডাকা, গণনা, এমনকি একটি tuple বা আরেকটি list.

৩ · শর্ত দুই জায়গায় — ছাঁকনি-if বনাম if-else

Comprehension নিয়ে নতুনদের সবচেয়ে বড় বিভ্রান্তি এটাই: if কখনো শেষে বসে, কখনো শুরুতে else-সহ বসে। দুটি সম্পূর্ণ আলাদা কাজ করে:

• শেষের if — ছাঁকনি: [x for x in nums if x > 0]. প্রশ্ন: “এই জিনিসটি কি নতুন list-এ ঢুকবে?” এখানে else লেখা যায় না, কারণ “না ঢুকলে কী ঢুকবে” প্রশ্নটার কোনো মানে নেই।
• শুরুর if-else — রূপান্তরের অংশ: [x if x > 0 else 0 for x in nums]. প্রশ্ন: “প্রতিটি জিনিসের জায়গায় কী বসবে?” এটা আসলে পর্ব ১১-এর conditional expression — ক if শর্ত else খ — যা রূপান্তর অংশে বসেছে। এখানে else বাধ্যতামূলক, কারণ প্রতিটি জিনিসের জন্য কিছু একটা মান তো লাগবেই।

ধাপে ধাপে দুটিকে পাশাপাশি চালিয়ে দেখুন — একই সংখ্যাগুলো, কিন্তু ফল দুই রকম:

1nums = [5, -2, 7, -4]2a = [x for x in nums if x > 0]           # ছাঁকনি3b = [x if x > 0 else 0 for x in nums]   # রূপান্তর

৪ · nested comprehension — একাধিক for-এর ক্রম

একটি comprehension-এ একাধিক for থাকতে পারে। তখন সেগুলো কাজ করে পর্ব ১২-এর nested loop-এর মতো। নিয়মটি একটিই, আর এটা জানলেই কোনো বিভ্রান্তি থাকে না: for-গুলো যে ক্রমে বাঁ থেকে ডানে লেখা, nested লুপে সেই ক্রমেই ওপর থেকে নিচে বসে। প্রথম for সবচেয়ে বাইরের লুপ, শেষ for সবচেয়ে ভেতরের। নিচে দেখুন:

1pairs = [(r, c)2         for r in range(2)     # বাইরের3         for c in range(3)]    # ভেতরের4# সমান লুপ:5for r in range(2):6    for c in range(3):7        pairs.append((r, c))

২D list চ্যাপ্টা করা

একটি স্কুলের তিনটি সেকশনের শিক্ষার্থীর নাম আলাদা আলাদা list-এ আছে: sections = [["রহিম", "সুমি"], ["করিম"], ["নাদিয়া", "তানভীর"]]. সবাইকে একটি সারিতে চাই। লুপে লিখলে: “প্রতিটি সেকশনের জন্য, সেকশনের প্রতিটি শিক্ষার্থীর জন্য, শিক্ষার্থীকে যোগ করো”. সেই ক্রমেই comprehension:

everyone = [s for sec in sections for s in sec]
# ['রহিম', 'সুমি', 'করিম', 'নাদিয়া', 'তানভীর']

একটি list-এর ভেতরের list খুলে এক সারি করাকে বলে flatten করা। প্রথম for sec in sections বাইরের, তাই সেটা আগে; দ্বিতীয় for s in sec প্রথমটির sec ব্যবহার করছে, তাই সেটাকে পরে আসতেই হবে। উল্টো লিখলে (for s in sec for sec in sections) Python বলবে sec এখনো সংজ্ঞায়িত নয় — বাস্তবে ঠিক এই ভুলটি অনেক হয়।

comprehension-এর ভেতরে comprehension — নামতার ছক

আরেক ধরনের nesting আছে, যা দেখতে একই রকম কিন্তু ফল আলাদা: রূপান্তর অংশেই আরেকটি comprehension. এতে একটি list-এর list তৈরি হয়, চ্যাপ্টা list নয়:

table = [[i * j for j in range(1, 4)] for i in range(1, 4)]
# [[1, 2, 3], [2, 4, 6], [3, 6, 9]]   — প্রতিটি সারি একটি list

এটা পড়ুন বাইরে থেকে: “1 থেকে 3-এর প্রতিটি i-এর জন্য একটি সারি; সেই সারি হলো প্রতিটি j-এর জন্য i × j”. বাইরের for i সারি ঠিক করে, ভেতরের comprehension প্রতি সারির ঘরগুলো। এখানে বাইরের for লেখা আছে শেষে, কারণ ভেতরের comprehension পুরোটা হলো রূপান্তর অংশ। দুই ধরনের nesting গুলিয়ে ফেলা খুব সহজ — তাই এখানে থেমে মিলিয়ে নিন:

৫ · dict আর set comprehension

বন্ধনী বদলালেই অন্য ধরনের সংগ্রহ। দ্বিতীয় বন্ধনী { }-এর ভেতরে চাবি: মান লিখলে তৈরি হয় dict — এর নাম dict comprehension. কোলন না থাকলে, শুধু একটি মান থাকলে তৈরি হয় set — set comprehension.

dict comprehension — তিনটি পরিচিত কাজ

• দুটি list থেকে dict: নামের list আর গ্রেডের list থেকে {নাম: গ্রেড}: {n: g for n, g in zip(names, grades, strict=True)}. (শুধু জোড়া লাগাতে চাইলে dict(zip(names, grades))-ও চলে; comprehension দরকার হয় যখন পথে কিছু বদলাতে বা ছাঁকতে হয়।)
• প্রতিটি মান বদলানো: চায়ের দোকানের মূল্যতালিকায় ১৫% ভ্যাট যোগ: {item: round(p * 1.15, 2) for item, p in price.items()}. চাবি একই, মান নতুন।
• dict উল্টে দেওয়া: {p: item for item, p in price.items()} — দাম থেকে জিনিস খোঁজার dict. সতর্কতা: দুটি জিনিসের দাম সমান হলে নতুন dict-এ একটিই থাকবে, কারণ চাবি অনন্য; শেষে যেটি আসে, সেটি আগেরটিকে মুছে দেয়।

ভেতরে .items() খেয়াল করুন। dict-এর ওপর সরাসরি লুপ চালালে শুধু চাবি আসে (পর্ব ১৬); চাবি আর মান দুটোই চাইলে .items(), আর for item, p in ...-এ unpacking দিয়ে জোড়াটি দুই নামে ভাগ হয়।

set comprehension — শুধু অনন্যগুলো

পাঁচজন শিক্ষার্থীর নামের প্রথম অক্ষরগুলো কী কী? {s[0] for s in students}. set নিজেই ডুপ্লিকেট বাদ দেয় (পর্ব ১৭), তাই “Rahim” আর “Rana”-র দুটি R মিলে একটি R. মনে রাখবেন, set-এর ক্রম নিশ্চিত নয় — ছাপানোর সময় নির্দিষ্ট ক্রম চাইলে sorted() দিন।

এবার এ পর্যন্ত যা দেখলেন সব একসাথে চালিয়ে দেখুন — দামের রূপান্তর, পাস করা শিক্ষার্থী, if-else, দুটি list থেকে dict, প্রথম অক্ষরের set আর সেকশন চ্যাপ্টা করা:

prices = ["৳120", "৳45", "৳300", "৳80"]
taka = [int(p.removeprefix("৳")) for p in prices]
print(taka, sum(taka))

marks = {"রহিম": 78, "সুমি": 91, "করিম": 29, "নাদিয়া": 65}
passed = [name for name, m in marks.items() if m >= 33]
print(passed)
print([m if m >= 33 else 0 for m in marks.values()])

names = ["রহিম", "সুমি", "করিম"]
grades = ["A", "A+", "F"]
print({n: g for n, g in zip(names, grades, strict=True)})

students = ["Rahim", "Sumi", "Rana", "Karim", "Sadia"]
print(sorted({s[0] for s in students}))

sections = [["রহিম", "সুমি"], ["করিম"], ["নাদিয়া", "তানভীর"]]
everyone = [s for sec in sections for s in sec]
print(everyone, len(everyone))

৬ · generator expression — দরকারমতো একটি একটি মান

ধরুন আপনার কাছে চারটি নম্বর আছে, আর শুধু মোট চাই। list comprehension দিয়ে লিখলে: sum([m for m in marks]). এখানে Python আগে পুরো একটি নতুন list বানায়, তারপর sum সেটা যোগ করে, তারপর list-টি ফেলে দেওয়া হয়। চারটি নম্বরে কিছু যায়-আসে না। কিন্তু এক কোটি লাইনের লগ ফাইলে? শুধু যোগ করার জন্য এক কোটি জিনিসের list মেমরিতে রাখা অপচয়।

সমাধান: তৃতীয় বন্ধনী বাদ দিন। sum(m for m in marks). প্রথম বন্ধনীর ভেতরের এই অংশটি একটি generator expression — সংক্ষেপে genexp. এটা কোনো সংগ্রহ বানায় না। এটা একটি generator object দেয়, যার কাছে “পরের মান দাও” বললে সে ঠিক একটি মান হিসাব করে দেয়, তারপর থেমে অপেক্ষা করে। পর্ব ১২-এর range-এর মতোই এটা lazy. ধাপে ধাপে দেখুন:

1marks = [70, 85, 60]2gen = (m for m in marks)      # কিছুই হিসাব হয়নি3total = sum(gen)

ফাংশনের একমাত্র argument হলে genexp-এর নিজের বন্ধনী বাদ দেওয়া যায় — তাই sum((m for m in marks)) না লিখে sum(m for m in marks). দুটি argument থাকলে বন্ধনী লাগবে: sorted((m for m in marks), reverse=True).

যেখানে genexp সবচেয়ে মানায়

• সংক্ষেপকারী ফাংশনে: sum, max, min, any, all, "".join — যারা পুরো ধারা একবার হেঁটে একটি উত্তর দেয়। যেমন বর্গের যোগফল: sum(x * x for x in nums); ফেল গোনা: sum(1 for m in marks if m < 33).
• আগেভাগে থামায় যেখানে: any(m < 33 for m in marks) প্রথম ফেল পেলেই True দিয়ে থামে (short-circuit). list comprehension দিলে আগে সবগুলো হিসাব হতো, তারপর any দেখত — অকারণ কাজ।
• বিশাল বা অসীম ধারায়: ফাইলের লাইন (পর্ব ২৫), নেটওয়ার্ক থেকে আসা ডেটা — যা পুরোটা মেমরিতে আঁটে না।

আর কখন list comprehension? যখন ফলটি একাধিকবার ব্যবহার করবেন, index দিয়ে ধরবেন, len() জানবেন বা ছাপাবেন। genexp একবার হাঁটার পরই শেষ। generator নিজে লেখা, yield আর ভেতরের যন্ত্রপাতি বিস্তারিত দেখবেন পর্ব ৩৪-এ (iterator, generator আর yield).

৭ · scope — comprehension-এর নিজের ঘর, আর walrus

পর্ব ১২-এ দেখেছেন, সাধারণ for লুপের loop variable লুপ শেষেও টিকে থাকে, শেষ মান নিয়ে। Comprehension-এ তা হয় না। Python 3-এ প্রতিটি comprehension-এর নিজস্ব scope আছে — একটি ছোট আলাদা ঘর। ভেতরের x বাইরের x-কে ছোঁয় না, আর comprehension শেষ হলে ভেতরের নামটি হারিয়ে যায়।

নিচের কোডে এটা আর generator expression, dict comprehension একসাথে দেখুন:

marks = [78, 91, 29, 65]
total = sum(m for m in marks)        # কোনো list তৈরি হয় না
print("মোট:", total)
print("বর্গের যোগফল:", sum(x * x for x in range(1, 5)))
print("কেউ ফেল?", any(m < 33 for m in marks))

price = {"চা": 10, "সিঙ্গারা": 15, "কেক": 40}
with_vat = {item: round(p * 1.15, 2) for item, p in price.items()}
print(with_vat)
by_price = {p: item for item, p in price.items()}
print(by_price[15])

x = "আগের মান"
squares = [x * x for x in range(4)]
print(squares, x)         # comprehension-এর x বাইরে আসেনি

for x in range(4):
    pass
print(x)                  # for লুপের x বাইরে রয়ে গেছে

কেন এই পার্থক্য? কারণ comprehension একটি expression — একটি মান তৈরির যন্ত্র। যন্ত্রের ভেতরের কাজের নাম বাইরে ছড়িয়ে পড়লে বিপদ: Python 2-এ list comprehension-এর variable সত্যিই বাইরে বেরিয়ে আসত, আর বাইরের একই নামের ভ্যারিয়েবলকে নিঃশব্দে বদলে দিত। Python 3 এটা বন্ধ করেছে (ভাবনার প্রশ্ন ৩-এ ইতিহাস)।

walrus দিয়ে একবার হিসাব, দুবার ব্যবহার

কখনো রূপান্তরের ফল দিয়েই ছাঁকতে হয়। ধরুন প্রতিটি দামের লেখা থেকে সংখ্যা বের করে শুধু ১০০-র বেশিগুলো রাখবেন। সাধারণভাবে লিখলে int(...) দুবার চলে — একবার ছাঁকনিতে, একবার রূপান্তরে। পর্ব ০৮-এর walrus operator := দিয়ে একবারেই:

big = [t for p in prices if (t := int(p.removeprefix("৳"))) > 100]
# [120, 300]

ছাঁকনিতে t হিসাব হয়ে নাম পায়, রূপান্তর অংশ সেটাই ব্যবহার করে। একটি অদ্ভুত নিয়ম জানা থাকা ভালো: comprehension-এর ভেতরে walrus দিয়ে বানানো নাম (t) loop variable-এর মতো ভেতরে আটকে থাকে না — বাইরের scope-এ চলে আসে (PEP 572 ইচ্ছা করেই এটা রেখেছে, যাতে “শেষ যেটা মিলেছিল” বাইরে থেকে দেখা যায়)। বেশি চতুরতা না করে walrus শুধু তখনই ব্যবহার করুন, যখন একই দামি হিসাব দুবার হচ্ছে। নইলে দুই ধাপে লিখুন: আগে taka = [...], তারপর [t for t in taka if t > 100].

৮ · কখন comprehension নয় — পড়ার যোগ্যতা আর গতি

Comprehension শেখার পর অনেকে সবকিছু এক লাইনে লিখতে চান। কিন্তু comprehension-এর একমাত্র উদ্দেশ্য কোডকে পড়তে সহজ করা। যেখানে সেটা হয় না, সেখানে সাধারণ লুপই ভালো। চারটি নিয়ম:

গতি — সত্যি, তবে মূল কারণ নয়

একটি append-লুপের প্রতি ঘোরায় Python-কে result.append নামটি খুঁজে বের করতে হয়, তারপর একটি method ডাকতে হয়। list comprehension-এর ভেতরে এর জন্য একটি বিশেষ bytecode নির্দেশ (LIST_APPEND) আছে, যা এই খোঁজা আর ডাকার খরচ বাঁচায়। তাই একই কাজে comprehension সাধারণত একটু দ্রুত — কত দ্রুত, তা Python-এর version, ডেটা আর কাজের ওপর নির্ভর করে। Python 3.12 থেকে list, dict আর set comprehension-এর আলাদা ফাংশন-কাঠামো সরিয়ে ফেলায় (ভাবনার প্রশ্ন ৪) পার্থক্যটা আরেকটু বেড়েছে।

কিন্তু রূপান্তর অংশে যদি একটি ভারী কাজ থাকে (ফাইল পড়া, জটিল হিসাব), তাহলে লুপের খরচ তার তুলনায় নগণ্য। গতির জন্য comprehension বেছে নেবেন না — পরিষ্কারের জন্য বেছে নিন, গতি বোনাস। সত্যিকারের গতির প্রশ্নে মেপে দেখুন (পর্ব ৪৩), আর লাখ লাখ সংখ্যার হিসাবে NumPy (পর্ব ৪৬)।

৯ · AI-এর যুগে — AI-এর লেখা comprehension যাচাই

AI comprehension খুব পছন্দ করে, কারণ এর প্রশিক্ষণের কোডে এগুলো প্রচুর আছে, আর এক লাইনের উত্তর “চতুর” দেখায়। সমস্যা হলো, AI প্রায়ই সংক্ষেপকে পরিষ্কারের ওপরে রাখে। তিনটি পরিচিত ধরন:

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

• প্রতিটি comprehension এক বাক্যে বাংলায় পড়তে পেরেছি (“প্রতিটি … -এর জন্য …, যদি …”); না পারলে লুপে ভেঙেছি
• কোনো comprehension-এর ফল ফেলে দেওয়া হচ্ছে কি না দেখেছি — হলে সেটা side effect, লুপ লাগবে
• sum([...]), max([...]), any([...])-এর তৃতীয় বন্ধনী সরিয়ে generator expression করেছি
• একাধিক for থাকলে তাদের ক্রম nested লুপে খুলে লিখে মিলিয়েছি
• set বা dict উল্টানোর ফল ছাপালে ক্রম আর হারানো চাবি নিয়ে নিশ্চিত হয়েছি; খালি ইনপুট দিয়ে একবার চালিয়েছি