lambda, functools আর itertools — ফাংশন দিয়ে ডেটার পাইপলাইন

১ · ফাংশনও একটি মান — হাতে হাতে পাঠানো যায়

পর্ব ১৩-এ আপনি ফাংশন লিখতে শিখেছেন, আর পর্ব ২০ ও ৩৫-এ দেখেছেন ফাংশন অন্য ফাংশন ফেরত দিতে পারে। এই পর্বের সবকিছু একটি সরল সত্যের ওপর দাঁড়িয়ে: Python-এ ফাংশন একটি সাধারণ object, ঠিক একটি সংখ্যা বা string-এর মতো। def লেখা মানে একটি function object তৈরি করে একটি নামের সাথে জুড়ে দেওয়া। তাই ফাংশনকে আরেকটি নামে রাখা যায়, list-এ রাখা যায়, আর argument হিসেবে অন্য ফাংশনে পাঠানো যায়। এই গুণের নাম first-class function.

যে ফাংশন অন্য ফাংশনকে argument হিসেবে নেয় (বা ফেরত দেয়), তাকে বলে higher-order function. আপনি এদের আগেই ব্যবহার করেছেন: sorted(names, key=len)-এ len ফাংশনটিকে ডাকা হয়নি, শুধু পাঠানো হয়েছে — বন্ধনী নেই, লক্ষ করুন। sorted নিজে প্রতিটি নামের ওপর সেটা ডাকে।

এই পর্বের পুরো ধারণা এক বাক্যে: লুপের ভেতরে “কীভাবে” করতে হবে তা ধাপে ধাপে না লিখে, ডেটার ওপর “কী” রূপান্তর হবে তা ছোট ছোট ফাংশন দিয়ে বর্ণনা করা। এই ধাঁচকে বলে functional programming. এর উল্টো দিক, যেখানে আপনি ভ্যারিয়েবল বদলে বদলে ধাপে ধাপে নির্দেশ দেন, তাকে বলে imperative programming. Python দুই ধাঁচই সমর্থন করে, আর দুটির মিশ্রণই এখানে স্বাভাবিক।

২ · lambda — এক expression-এর নামহীন ফাংশন

lambda দিয়ে একটি ছোট anonymous function বানানো যায়, অর্থাৎ নাম ছাড়া ফাংশন। গঠন:

কোলনের বাঁয়ে parameter, ডানে একটিমাত্র expression, যার মান স্বয়ংক্রিয়ভাবে ফেরত যায় — return লিখতে হয় না, লেখা যায়ও না। কয়েকটি উদাহরণ:

square = lambda x: x * x          # চলে, কিন্তু PEP 8 এটা নিষেধ করে (নিচে দেখুন)
print((lambda a, b: a + b)(3, 4))  # 7 — তৈরি করেই সাথে সাথে ডাকা
print((lambda: "হ্যালো")())         # parameter ছাড়া lambda
grade = lambda m: "পাস" if m >= 33 else "ফেল"   # conditional expression চলে

lambda-র সীমা — কেন শুধু একটি expression

lambda-র body-তে কোনো statement থাকতে পারে না। তাই সেখানে if/else ব্লক, for লুপ, try, return, সাধারণ assignment (x = 5) বা একাধিক লাইন চলে না। শর্ত লাগলে a if cond else b ধরনের conditional expression ব্যবহার করতে হয়। এই সীমা ইচ্ছাকৃত: lambda বড় হতে শুরু করলে Python চায় আপনি def লিখে তাকে একটি নাম আর docstring দিন।

আরও একটি ছোট সমস্যা: lambda-র নাম সবসময় <lambda>. ভেতরে error হলে traceback-এ লেখা থাকে File "...", line 4, in <lambda> — কোন lambda, তা বোঝার উপায় নেই। দশটি lambda থাকলে ডিবাগ করা কঠিন।

সবচেয়ে ভালো ব্যবহার — key= দিয়ে সাজানো

পর্ব ১৪-এ দেখেছেন sorted একটি key function নেয়; min আর max-ও একই রকম key নেয়। ধরুন একটি দোকানের পণ্যের তালিকা দামের ক্রমে সাজাতে হবে, আর সমান দামের পণ্যগুলো নামের ক্রমে। কৌশল হলো key থেকে একটি tuple ফেরত দেওয়া: (p.price, p.name). Python tuple তুলনা করে বাঁ দিক থেকে, ঘরে ঘরে — অভিধানের মতো (lexicographic order). প্রথম ঘর সমান হলে তবেই দ্বিতীয় ঘর দেখা হয়। ধাপে ধাপে দেখুন, ভেতরে আসলে কী হয়:

1shop = [Product("tea", 20), Product("coffee", 60),2        Product("biscuit", 20), Product("cake", 60)]3ordered = sorted(shop,4    key=lambda p: (p.price, p.name))5print([p.name for p in ordered])

দুটি কাজের কথা। এক, min আর max-ও একই key নেয়: max(shop, key=lambda p: p.price) সবচেয়ে দামি পণ্য দেয় (সমান হলে প্রথমটি)। দুই, Python-এর sort stable — সমান key-র জিনিস আগের ক্রম বজায় রাখে। তাই tuple-এর বদলে দুবার sort করেও কাজ হয়: আগে নাম দিয়ে, তারপর দাম দিয়ে। যখন একটি key ঊর্ধ্বক্রমে আর অন্যটি নিম্নক্রমে, অথচ সেটা string (যার চিহ্ন উল্টানো যায় না), তখন এই দুই-ধাপের কৌশলই সহজ।

lambda না def — PEP 8 কী বলে

উপরের কোডের প্রথম লাইন square = lambda x: x * x চলে ঠিকই, কিন্তু Python-এর style guide PEP 8 স্পষ্ট বলে: lambda-কে সরাসরি একটি নামে বসাবেন না, def লিখুন। কারণ সহজ — নাম দিতেই যদি চান, তাহলে def square(x): return x * x লিখলে ফাংশনের আসল নাম হয় square (traceback-এ সেটাই দেখাবে), docstring আর type hint যোগ করা যায়, আর একই লাইন-সংখ্যাতেই হয়। lambda-র একমাত্র সুবিধা হলো নামহীনতা; নাম দিলে সেই সুবিধাটাই চলে যায়।

৩ · map আর filter বনাম comprehension

map(f, items) প্রতিটি জিনিসের ওপর f চালায়। filter(pred, items) শুধু সেই জিনিসগুলো রাখে, যাদের ওপর pred সত্য দেয়। Python 3-এ দুটিই list নয়, একটি iterator ফেরত দেয় — অলস, আর একবারই হাঁটা যায় (পর্ব ৩৪-এর exhaustion ফাঁদ এখানেও)। ফল দেখতে list(...) দিয়ে মোড়াতে হয়।

prices = ["120", "45", "300", "80"]
nums = list(map(int, prices))                  # [120, 45, 300, 80]
cheap = list(filter(lambda p: p < 100, nums))  # [45, 80]

# একই কাজ comprehension দিয়ে:
nums = [int(p) for p in prices]
cheap = [p for p in nums if p < 100]

# map একাধিক iterable নিতে পারে — zip-এর মতো জোড়ায় জোড়ায়
print(list(map(pow, [2, 3, 10], [3, 2, 2])))   # [8, 9, 100]

কোনটি লিখবেন? পর্ব ১৮-এর ভাবনার প্রশ্নে Guido van Rossum-এর যুক্তি দেখেছেন। বাস্তব নির্দেশনা একটি টেবিলে:

গতির দিক থেকে পার্থক্য সাধারণত ছোট। map একটি built-in ফাংশনের (যেমন int) সাথে সামান্য দ্রুত হতে পারে, কারণ প্রতিটি জিনিসের জন্য Python-স্তরের কোনো ফাংশন ডাকতে হয় না। কিন্তু lambda থাকলে প্রতিবার একটি Python ফাংশন ডাকা হয়, আর তখন comprehension প্রায়ই সমান বা দ্রুত। গতি নিয়ে ভাবার আগে মাপুন — পর্ব ৪৩-এ এর পদ্ধতি দেখবেন।

৪ · functools আর operator — reduce, partial আর তৈরি key

standard library-র functools module হলো “ফাংশন নিয়ে কাজ করার ফাংশন”-এর সংগ্রহ। পর্ব ৩৫-এ এর দুটি সদস্য দেখেছেন: wraps আর lru_cache/cache — আগের ফল মনে রেখে একই ডাক বারবার না চালানো। এখানে আরও তিনটি।

reduce — বাঁ থেকে ডানে ভাঁজ করা

reduce(f, items, initial) একটি দুই-argument ফাংশন নিয়ে পুরো ধারাকে একটি মানে নামিয়ে আনে: প্রথমে f(initial, প্রথম), তারপর সেই ফল আর দ্বিতীয় জিনিস দিয়ে আবার f, এভাবে শেষ পর্যন্ত। একে বলে fold — একটি লম্বা কাপড় বাঁ দিক থেকে ভাঁজ করতে করতে একটি ছোট বান্ডিল বানানোর মতো। একটি উদাহরণ, যেখানে ক্রমটা সত্যিই গুরুত্বপূর্ণ — অঙ্কের list থেকে একটি সংখ্যা বানানো:

1from functools import reduce2year = reduce(lambda acc, d: acc * 10 + d,3              [2, 0, 2, 6], 0)4print(year)

শেষ ধাপের কথাটাই reduce-এর মূল সমস্যা। Python-এ প্রায় প্রতিটি সাধারণ reduce-এর জন্য একটি নামওয়ালা, স্পষ্ট ফাংশন আছে:

এই বদলগুলো শুধু পড়তে সহজ নয়, প্রায়ই নিরাপদও: any প্রথম সত্য মান পেলেই থেমে যায় (short-circuit), reduce পুরো ধারা হাঁটে। reduce তখনই রাখুন, যখন ভাঁজের নিয়মটা সত্যিই নিজস্ব আর কোনো তৈরি ফাংশনে মেলে না — যেমন একসারি dict-কে একটির পর একটি merge করা: reduce(operator.or_, configs, {}). এমন ক্ষেত্রেও একটি সাধারণ for লুপ প্রায়ই সমান পরিষ্কার।

partial — কিছু argument আগেই বসিয়ে নতুন ফাংশন

ধরুন add_vat(price, rate) নামে একটি ফাংশন আছে, আর আপনার দোকানে হার সবসময় ১৫%. প্রতিবার rate=0.15 লেখা ক্লান্তিকর আর ভুলপ্রবণ। functools.partial একটি নতুন callable বানায়, যার কিছু argument আগে থেকেই বসানো:

from functools import partial
vat15 = partial(add_vat, rate=0.15)   # rate আটকানো
vat15(200)                            # = add_vat(200, rate=0.15)
to_int_bin = partial(int, base=2)
to_int_bin("1010")                    # 10

এটা পর্ব ২০-এর factory function (make_multiplier)-এর মতো একই কাজ করে, কিন্তু নতুন ফাংশন লিখতে হয় না। partial object-এর .func, .args, .keywords দেখে বোঝা যায় কী বসানো আছে — lambda-তে সেটা দেখা যায় না। আর লুপে callback বানানোর সময় partial সেই মুহূর্তের মান ধরে রাখে, তাই পর্ব ২০-এর late binding ফাঁদে পড়ে না (অংশ ৭)।

operator module — lambda ছাড়াই key

অনেক lambda শুধু একটি ঘর বা attribute বের করে, বা দুটি মান গুণ বা যোগ করে। এসবের জন্য operator module-এ তৈরি ফাংশন আছে, যা C-তে লেখা, তাই সাধারণত একটু দ্রুত, আর নাম দেখেই অর্থ বোঝা যায়:

• itemgetter(1) ≈ lambda row: row[1]; itemgetter(2, 0) একসাথে দুটি ঘরের tuple দেয় — একাধিক key-র সাজানোয় কাজের।
• attrgetter("price") ≈ lambda p: p.price; attrgetter("price", "name") tuple দেয়।
• operator.mul, add, or_ ইত্যাদি ≈ lambda a, b: a * b ইত্যাদি — reduce বা map-এ পাঠানোর জন্য।

cmp_to_key — পুরোনো ধাঁচের তুলনা ফাংশন

Python 2-তে sorted-এ একটি cmp ফাংশন দেওয়া যেত, যা দুটি জিনিস নিয়ে ঋণাত্মক, শূন্য বা ধনাত্মক ফেরত দিত (C-র qsort-এর মতো)। Python 3 এটা সরিয়ে শুধু key রেখেছে, কারণ key প্রতি জিনিসে একবার চলে, আর cmp চলত প্রতিটি তুলনায়। তবু কিছু নিয়ম স্বভাবতই “দুটিকে মিলিয়ে দেখো” ধাঁচের — যেমন সংখ্যাগুলো এমনভাবে সাজানো যাতে জোড়া লাগালে সবচেয়ে বড় সংখ্যা হয় ("9" আর "34": "934" > "349"). তখন cmp_to_key একটি পুরোনো ধাঁচের তুলনা ফাংশনকে key-তে রূপ দেয়: sorted(xs, key=cmp_to_key(compare)). কোডিং ইন্টারভিউতে এই সমস্যাটি বেশ পরিচিত।

এবার সব একসাথে চালিয়ে দেখুন — একাধিক key-তে সাজানো, attrgetter আর itemgetter, partial দিয়ে VAT, আর reduce বনাম sum:

from dataclasses import dataclass
from functools import partial, reduce
from operator import attrgetter, itemgetter, mul

@dataclass
class Product:
    name: str
    price: int

shop = [Product("tea", 20), Product("coffee", 60),
        Product("biscuit", 20), Product("cake", 60)]
ordered = sorted(shop, key=lambda p: (p.price, p.name))
print([p.name for p in ordered])
print(max(shop, key=attrgetter("price")).name)
def add_vat(price, rate):
    return round(price * (1 + rate), 2)
vat15 = partial(add_vat, rate=0.15)
print(vat15(200), vat15(1000), list(map(vat15, [40, 60])))
marks = [("Rahim", 85), ("Karim", 92), ("Mina", 78)]
print(max(marks, key=itemgetter(1)), sorted(marks, key=itemgetter(1))[0])
print(reduce(mul, [1, 2, 3, 4, 5]), sum(p.price for p in shop))

৫ · itertools ভ্রমণ — লুপ ছাড়া ডেটার রূপান্তর

পর্ব ৩৪-এ itertools থেকে count আর islice দেখেছেন। পুরো module-টি হলো iterator নিয়ে কাজ করার একটি টুলবক্স। প্রায় সব টুল একটি বা একাধিক iterable নেয় আর একটি অলস iterator দেয় — তাই এদের একটির আউটপুট আরেকটির ইনপুটে জুড়ে দেওয়া যায়, ঠিক লেগো ব্লকের মতো। কিছুই আগেভাগে list হয় না, যতক্ষণ না আপনি list(), for বা sum দিয়ে টানেন।

অসীম iterator — count, cycle, repeat

তিনটি টুল কখনো নিজে থেকে থামে না। এদের বলে infinite iterator, আর এদের সাথে সবসময় একটি সীমা লাগে — islice, zip (সবচেয়ে ছোটটিতে থামে) বা break:

from itertools import count, cycle, repeat, islice
list(islice(count(1001), 3))           # [1001, 1002, 1003] — টোকেন নম্বর
list(zip(["রাফি", "নীলা", "তানিম"], cycle(["লাল", "নীল"])))
# [('রাফি', 'লাল'), ('নীলা', 'নীল'), ('তানিম', 'লাল')] — পালা করে দল ভাগ
list(repeat("—", 3))                   # ['—', '—', '—'] (সংখ্যা দিলে সসীম)

জোড়া লাগানো — chain আর zip_longest

• chain(a, b, c) কয়েকটি iterable পরপর জুড়ে একটি ধারা বানায় — নতুন list না বানিয়ে। chain.from_iterable(list_of_lists) একটি nested list-কে এক স্তরে চ্যাপ্টা করে: [[1, 2], [3]] থেকে 1, 2, 3.
• zip_longest(a, b, fillvalue="-") হলো zip-এর ভাই, যে লম্বাটির শেষ পর্যন্ত চলে আর ফাঁকা জায়গা fillvalue দিয়ে ভরে। দুই শাখার বিক্রির তালিকা পাশাপাশি দেখাতে, যেখানে একটির দিন কম — zip চুপচাপ শেষ দিনগুলো ফেলে দিত।

accumulate — চলতি যোগফল আর ব্যাংক ব্যালান্স

accumulate হলো reduce-এর এমন রূপ, যা শুধু শেষ ফল নয়, প্রতিটি ধাপের ফল দেয় — একে বলে running total. ব্যাংকের স্টেটমেন্টের “ব্যালান্স” কলাম ঠিক এটাই। initial= (Python 3.8 থেকে) দিয়ে শুরুর ব্যালান্স দেওয়া যায়। ধাপে ধাপে দেখুন:

1tx = [5000, -1200, -800, 3000, -500]2for bal in accumulate(tx, initial=10000):3    print(bal)

আরও কয়েকটি দরকারি টুল

takewhile আর filter-এর পার্থক্য খেয়াল করুন: filter পুরো ধারা হেঁটে সব মিল রাখে; takewhile প্রথম অমিলেই চিরতরে থামে — তাই সাজানো ডেটা বা অসীম ধারায় এটা কাজের। tee সম্পর্কে একটি সতর্কতা: দুটি কপি যদি অনেক দূরে সরে যায় (একটি শেষে, অন্যটি শুরুতে), tee মাঝের সব মান মেমরিতে জমা রাখে। সেক্ষেত্রে সরাসরি list() বানানোই সহজ আর সমান খরচের। batched-এর শেষ দলটি ছোট হতে পারে; Python 3.13 থেকে strict=True দিলে অসম্পূর্ণ শেষ দলে ValueError আসে।

৬ · groupby-এর ফাঁদ আর combinatorics

groupby — পাশাপাশি থাকা সমানদের দল

groupby(items, key) নাম শুনে মনে হয় SQL-এর GROUP BY বা pandas-এর মতো সব সমান key-কে এক দলে আনবে। আসলে না। groupby শুধু পাশাপাশি থাকা সমান key-গুলোকে এক দলে রাখে। key বদলালেই নতুন দল শুরু হয় — সেই key আগে এসে থাকলেও। এটা Unix-এর uniq কমান্ডের মতো, যা শুধু পরপর থাকা একই লাইন মেলায়। এ কারণে প্রায় সবসময় আগে একই key দিয়ে sort করতে হয়। মাসভিত্তিক বিক্রির উদাহরণে ভুল আর সমাধান দেখুন:

1sales = [("2026-01", 300), ("2026-02", 200),2         ("2026-01", 100), ("2026-02", 400)]3for m, g in groupby(sales, key=itemgetter(0)):4    print(m, sum(amt for _, amt in g))5sales.sort(key=itemgetter(0))   # সমাধান: আগে sort

combinatorics — product, permutations, combinations

“সব সম্ভাব্য জোড়া”, “সব সম্ভাব্য ক্রম” — এ ধরনের হিসাবে nested লুপ লিখলে সূচক নিয়ে ভুল (off-by-one) আর একই জোড়া দুবার গোনার ভয় থাকে। itertools-এর তিনটি টুল এগুলো নির্ভুলভাবে দেয়:

এবার পুরো ভ্রমণ এক জায়গায় চালিয়ে দেখুন — ব্যাংক ব্যালান্স, groupby-এর ভুল আর সমাধান, টুর্নামেন্টের জোড়া, মেনু-কম্বো, pagination আর দামের পরিবর্তন:

from itertools import (accumulate, batched, combinations, cycle,
                       groupby, islice, pairwise, product)
from operator import itemgetter

tx = [5000, -1200, -800, 3000, -500]
print(list(accumulate(tx, initial=10000)))
sales = [("2026-01", 300), ("2026-02", 200), ("2026-01", 100), ("2026-02", 400)]
month = itemgetter(0)
print([(m, sum(a for _, a in g)) for m, g in groupby(sales, key=month)])
sales.sort(key=month)
print({m: sum(a for _, a in g) for m, g in groupby(sales, key=month)})
players = ["Rafi", "Nila", "Tanim", "Sumi"]
matches = list(combinations(players, 2))
print(len(matches), matches[:2])
menu = list(product(["rice", "khichuri"], ["chicken", "fish"]))
print(len(menu), menu[-1])
print(list(batched(range(1, 8), 3)))
prices = [100, 120, 90]
print([b - a for a, b in pairwise(prices)], "".join(islice(cycle("AB"), 5)))

৭ · ফাংশনাল ধাঁচে ভাবা — pure function, closure আর কোথায় থামবেন

pure function আর side effect

এই পর্বের টুলগুলো সবচেয়ে ভালো কাজ করে pure function-এর সাথে — যে ফাংশন একই ইনপুটে সবসময় একই ফল দেয় আর বাইরের কিছু বদলায় না। lambda p: (p.price, p.name) pure. কিন্তু key ফাংশনের ভেতরে যদি একটি global counter বাড়ে, বা map-এর ফাংশন ফাইলে লেখে — সেটা side effect. সমস্যা হলো, এই টুলগুলো অলস: map(save_to_db, rows) লিখে কেউ না টানলে একটি সারিও সেভ হবে না, কোনো error-ও আসবে না। আর অর্ধেক টেনে থামলে অর্ধেক সেভ হবে।

pure function-এর আরেক সুবিধা পরের পর্বে স্পষ্ট হবে: এদের পরীক্ষা করা সবচেয়ে সহজ — ইনপুট দিন, আউটপুট মিলিয়ে দেখুন, কোনো ফাইল বা ডেটাবেস সাজাতে হয় না। আর lru_cache শুধু pure function-এই নিরাপদ, কারণ সে ধরে নেয় একই argument-এ একই ফল।

closure আর late binding — পর্ব ২০-এর পুনরালোচনা

lambda-ও একটি পূর্ণ ফাংশন, তাই সে বাইরের ভ্যারিয়েবল মনে রাখতে পারে — closure. আর পর্ব ২০-এর late binding ফাঁদ এখানে সবচেয়ে বেশি দেখা যায়: [lambda x: x * r for r in (1.05, 1.10)] — দুটি lambda-ই ডাকার সময় r-এর শেষ মান (1.10) দেখে, তৈরির সময়ের মান নয়। তিনটি সমাধান: lambda x, r=r: x * r (default argument তৈরির সময় হিসাব হয়), একটি factory function, অথবা partial(mul, r) — partial তৈরির মুহূর্তের মানটিই রাখে।

কোথায় থামবেন — পড়ার যোগ্যতা আগে

ফাংশনাল টুল শেখার পর অনেকে সবকিছু এক লাইনে লিখতে চান। নিচের দুটি একই কাজ করে — কোনটি ছয় মাস পরে আপনি বা আপনার সহকর্মী বুঝবেন?

# এক লাইনের "চালাক" রূপ
total = reduce(lambda a, b: a + b, map(lambda o: o["qty"] * o["price"],
               filter(lambda o: o["status"] == "paid", orders)), 0)

# Pythonic রূপ
total = sum(o["qty"] * o["price"] for o in orders if o["status"] == "paid")

প্রথমটি পড়তে হয় ভেতর থেকে বাইরে, আর তিনটি lambda-র প্রতিটির parameter-এর নাম মনে রাখতে হয়। দ্বিতীয়টি বাঁ থেকে ডানে একটি বাক্যের মতো: “paid অর্ডারগুলোর qty × price-এর যোগফল”. Python-এর স্রষ্টা নিজেও ফাংশনাল ধাঁচ নিয়ে সংশয়ী ছিলেন (ভাবনার প্রশ্ন ২ ও ৫)। Python-এ নিয়মটা মোটামুটি এমন:

• একটি key, একটি তৈরি ফাংশন পাঠানো, বা একটি itertools টুল যা নামেই কাজ বলে দেয় (accumulate, pairwise, combinations) — ব্যবহার করুন।
• lambda-র ভেতরে lambda, তিন স্তরের nesting, বা কাগজে চালিয়ে দেখতে হয় এমন reduce — থামুন; comprehension, নামওয়ালা ছোট ফাংশন বা সাধারণ লুপে ভাঙুন।
• মাঝের ধাপগুলোকে নাম দিন: paid = (o for o in orders if ...), তারপর amounts = ... — নামই সবচেয়ে ভালো মন্তব্য।

৮ · AI-এর যুগে — AI-এর লেখা ফাংশনাল কোড যাচাই

AI কোড-সহকারীরা অনেক ভাষার কোড থেকে শিখেছে — JavaScript, Scala, Haskell, যেখানে map/filter/reduce-এর শিকল খুব স্বাভাবিক। তাই Python-এ চাইলেও তারা প্রায়ই সেই ধাঁচ আনে, যা চলে ঠিকই কিন্তু Pythonic নয়, আর কখনো কখনো নিঃশব্দে ভুল। বারবার দেখা যায় এমন ভুল:

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

• প্রতিটি map/filter-এর সাথে lambda থাকলে comprehension দিয়ে লিখে দেখেছি কোনটি পরিষ্কার
• প্রতিটি reduce-এর জন্য খুঁজেছি sum, max, min, any, all, math.prod বা "".join চলে কি না; খালি ইনপুটে কী হয় দেখেছি
• প্রতিটি groupby-এর আগে একই key-তে sort আছে কি না দেখেছি, আর অসাজানো ডেটা দিয়ে চালিয়েছি
• কোনো lambda নামে বসানো নেই, আর lambda x: f(x) ধরনের অকারণ মোড়ক নেই
• লুপে তৈরি lambda/callback আলাদা করে ডেকে দেখেছি (late binding), আর অলস map/filter-এ কোনো side effect লুকিয়ে নেই