ফাংশন — def, return, default আর keyword argument

১ · ফাংশন কী — নাম দেওয়া, বারবার ব্যবহারযোগ্য রেসিপি

আগের পর্বগুলোতে আপনি অনেক ফাংশন ব্যবহার করেছেন: print(), len(), input(), round(). কেউ একজন এগুলো আগেই লিখে রেখেছেন, আপনি শুধু নাম ধরে ডেকেছেন। এই পর্বে আপনি নিজেই ফাংশন বানাবেন। মডিউল ২-এর এটাই শেষ পর্ব, আর সম্ভবত সবচেয়ে গুরুত্বপূর্ণ — কারণ বড় প্রোগ্রাম আসলে অনেকগুলো ছোট ফাংশনের সমষ্টি।

একটি function হলো নাম দেওয়া, বারবার ব্যবহারযোগ্য একটি রেসিপি. রেসিপিতে উপকরণ ঢোকে, নির্দিষ্ট ধাপে কাজ হয়, শেষে একটি পদ বের হয়। ফাংশনেও তাই: ইনপুট ঢোকে (parameter), ভেতরে কাজ হয়, ফল বের হয় (return value). রেসিপি একবার ঠিকঠাক লিখে রাখলে প্রতিবার নতুন করে ভাবতে হয় না — শুধু বলেন “ওই রেসিপিটা বানাও”।

ফাংশন কেন দরকার? তিনটি বড় কারণ:

• নাম দেওয়া: price * 1.15 দেখে বোঝা কঠিন এটা কী। add_vat(price) পড়লেই বোঝা যায়। ভালো নাম একটি ধারণাকে এক শব্দে বেঁধে ফেলে।
• একবার পরীক্ষা, বহুবার ব্যবহার: VAT-এর হিসাব যদি প্রোগ্রামের ২০ জায়গায় কপি করা থাকে, হার বদলালে ২০ জায়গায় বদলাতে হবে — আর একটা বাদ পড়বেই। ফাংশনে থাকলে বদল এক জায়গায়।
• ভাগ করে ভাবা: “বিল তৈরি” একটি বড় কাজ। একে ভাঙুন — “দাম যোগ”, “ছাড় বাদ”, “VAT যোগ”, “রসিদ ছাপা”। প্রতিটি আলাদা ফাংশন, প্রতিটি আলাদাভাবে বোঝা ও পরীক্ষা করা যায়।

প্রথম ফাংশনের গঠন

def add_vat(price, rate):          # def + নাম + (parameter) + কোলন
    total = price * (1 + rate)     # body — চার space ভেতরে
    return total                   # ফল ফেরত

bill = add_vat(500, 0.15)          # ডাকা: argument 500 আর 0.15
print(bill)                        # 575.0

লাইন ধরে দেখুন। def একটি keyword, যা বলে “এখানে একটি ফাংশন সংজ্ঞায়িত হচ্ছে”। এরপর নাম (add_vat — PEP 8 অনুযায়ী ছোট হাতের অক্ষর আর আন্ডারস্কোর), বন্ধনীর ভেতরে parameter-এর নাম, শেষে কোলন। এর নিচে indentation দিয়ে লেখা অংশটুকুই ফাংশনের body — if বা for-এর মতোই। Indentation যেখানে শেষ, ফাংশনও সেখানে শেষ।

আরেকটি গুরুত্বপূর্ণ বিষয়: def লাইনটি চলার সময় ফাংশনের ভেতরের কোড চলে না. def শুধু একটি function object তৈরি করে আর add_vat নামটি তার গায়ে লাগায়। ভেতরের কোড চলে তখনই, যখন আপনি বন্ধনী দিয়ে ডাকেন — add_vat(500, 0.15). রেসিপি লিখে রাখা আর রান্না করা আলাদা কাজ। এজন্যই ফাংশনের ভেতরে বানান-ভুল থাকলেও ডাকার আগ পর্যন্ত NameError দেখা দেয় না।

২ · return — ফল ফেরত দেওয়া, একাধিক মান আর None

return দুটি কাজ একসাথে করে: ফাংশন সেখানেই থামায়, আর একটি মান ডাকা জায়গায় পাঠায়. return-এর পরের লাইন আর চলে না। ডাকা জায়গায় add_vat(500, 0.15) পুরো লেখাটি যেন সেই মান দিয়ে বদলে যায় — তাই একে ভ্যারিয়েবলে রাখা যায়, অন্য হিসাবে বসানো যায়, এমনকি অন্য ফাংশনের argument হিসেবেও পাঠানো যায়: print(add_vat(500, 0.15)).

একাধিক মান ফেরত — আসলে একটি tuple

অনেক সময় একটি হিসাব থেকে দুটি ফল দরকার — যেমন BMI-র সংখ্যা আর তার শ্রেণি। Python-এ লেখা যায় return bmi, "স্বাভাবিক". দেখে মনে হয় দুটি মান ফেরত যাচ্ছে, কিন্তু আসলে কমা দিয়ে একটি tuple তৈরি হয় — দুটি মানের একটি প্যাকেট — আর সেই একটি tuple-ই ফেরত যায়। ডাকার জায়গায় value, category = bmi_report(...) লিখলে প্যাকেটটি খুলে দুটি নামে বসে যায়। একে বলে unpacking. Tuple আর unpacking-এর পুরো গল্প পর্ব ১৫-এ।

যে ফাংশন কিছু return করে না — None

যদি ফাংশনে return না-ই থাকে, অথবা শুধু return লেখা থাকে কোনো মান ছাড়া? তখন Python নিজে থেকেই একটি বিশেষ object ফেরত দেয়: None. এর মানে “কোনো মান নেই”। None নিজেও একটি object (type NoneType), আর পুরো প্রোগ্রামে এর একটিই কপি থাকে — তাই None পরীক্ষা করা হয় is দিয়ে: if result is None:. অর্থাৎ Python-এ প্রতিটি ফাংশন ডাক কিছু না কিছু ফেরত দেয় — কখনো আপনার দেওয়া মান, কখনো None.

নিচের প্রোগ্রামে তিনটি বাস্তব ফাংশন একসাথে দেখুন — VAT-এর হিসাব (ডিফল্ট হারসহ), BMI-র মান ও শ্রেণি, আর একটি অভিবাদন যা শুধু ছাপে। চালানোর আগে অনুমান করুন শেষ লাইন কী ছাপবে:

def add_vat(price, rate=0.15):
    """দাম আর VAT-এর হার নিয়ে VAT-সহ মোট দাম ফেরত দেয়।"""
    return round(price * (1 + rate), 2)

def bmi_report(weight_kg, height_m):
    bmi = round(weight_kg / height_m ** 2, 1)
    if bmi < 18.5:
        return bmi, "কম ওজন"
    if bmi < 25:
        return bmi, "স্বাভাবিক"
    return bmi, "বেশি ওজন"

def greet(name):
    print(f"স্বাগতম, {name}!")

print(add_vat(1000))
print(add_vat(1000, rate=0.05))
value, category = bmi_report(68, 1.70)
print(value, category)
result = greet("রিনা")
print(result)

৩ · print বনাম return — নতুনদের সবচেয়ে সাধারণ গোলমাল

পর্দায় দুটোই একই রকম দেখায় বলে নতুন প্রোগ্রামাররা প্রায়ই print আর return গুলিয়ে ফেলেন। কিন্তু দুটির গন্তব্য সম্পূর্ণ আলাদা। print-এর গন্তব্য মানুষের চোখ — লেখাটি টার্মিনালে যায়, প্রোগ্রাম আর সেটি ফেরত পায় না। return-এর গন্তব্য প্রোগ্রামের বাকি অংশ — মানটি ডাকা জায়গায় ফেরত আসে, যেখানে আরও হিসাব হতে পারে। নিচে দুটি প্রায় একই রকম ফাংশন দেখুন, আর ধাপে ধাপে লক্ষ করুন কে কী পায়:

1def show_total(a, b):2    print(a + b)34def get_total(a, b):5    return a + b67x = show_total(2, 3)8y = get_total(2, 3)9print(x, y)

তাহলে কোনটি কখন? নিয়মটি সহজ: হিসাবের ফাংশন return করবে; ছাপানোর কাজ করবে একেবারে বাইরের অংশ. একটি GPA ফাংশন যদি নিজেই ছাপিয়ে দেয়, তাহলে সেই GPA দিয়ে মেধাতালিকা সাজানো, সার্টিফিকেটে বসানো বা ওয়েবসাইটে দেখানো — কোনোটিই করা যাবে না। মান return করলে ছাপাতে চাইলে বাইরে print(gpa(...)) লিখলেই হয়; উল্টোটা সম্ভব নয়।

৪ · ফাংশন ডাকলে ভেতরে কী ঘটে — call stack আর frame

একটি ফাংশন আরেকটি ফাংশনকে ডাকতে পারে, সেটি আবার আরেকটিকে। Python কীভাবে মনে রাখে কে কাকে ডেকেছে, আর কাজ শেষে কোথায় ফিরতে হবে? উত্তর: call stack. প্রতিবার কোনো ফাংশন ডাকা হলে Python একটি নতুন frame তৈরি করে — একটি ছোট খাতা, যেখানে লেখা থাকে সেই ডাকের parameter, local variable, আর কোন লাইনে কাজ চলছে। নতুন frame রাখা হয় আগেরগুলোর ওপরে, প্লেটের স্তূপের মতো। return হলে ওপরের frame তুলে ফেলা হয়, আর কাজ চলে নিচের frame-এ, ঠিক যেখানে থেমেছিল।

নিচের প্রোগ্রামে add_vat নিজের কাজের মাঝে round_taka-কে ডাকে। “পরে” চাপুন আর stack-এর ওঠানামা দেখুন:

1def round_taka(amount):2    return round(amount)34def add_vat(price, rate=0.15):5    with_vat = price * (1 + rate)6    return round_taka(with_vat)78total = add_vat(200)9print(total)

Local variable সত্যিই local

ধাপ ৬ থেকে একটি গুরুত্বপূর্ণ নিয়ম বেরিয়ে আসে: ফাংশনের ভেতরে তৈরি নাম — parameter আর ভেতরে assign করা ভ্যারিয়েবল — হলো local variable. এরা থাকে শুধু সেই ডাকের frame-এ, আর frame মুছলে এরাও মুছে যায়। তাই ফাংশনের বাইরে print(with_vat) লিখলে NameError আসবে। একইভাবে, বাইরে price নামে কোনো ভ্যারিয়েবল থাকলেও ভেতরের price তার সাথে ধাক্কা খায় না — দুটি আলাদা খাতায় দুটি আলাদা লেবেল। প্রতিটি ডাক নতুন frame পায়, তাই একই ফাংশন দুবার ডাকলেও আগের ডাকের local variable পরের ডাকে থাকে না। ভেতর থেকে বাইরের নাম পড়া যায় কি না, বদলানো যায় কি না, global ও nonlocal কী — এই পুরো scope-এর নিয়ম (LEGB) পর্ব ২০-এ।

৫ · Argument পাঠানোর নিয়ম — positional, keyword আর default

এ পর্যন্ত আমরা argument পাঠিয়েছি ক্রম ধরে: প্রথম মান প্রথম parameter-এ, দ্বিতীয় মান দ্বিতীয়তে। একে বলে positional argument. কিন্তু parameter বেশি হলে ক্রম মনে রাখা কঠিন। convert(500, 120, 1) দেখে কে বলবে কোনটি টাকা, কোনটি হার, কোনটি দশমিকের ঘর? তাই Python নাম ধরেও পাঠাতে দেয়: convert(500, rate=120, digits=1) — এটি keyword argument, যা আপনি পর্ব ০৪-এ print(..., sep="-")-তে দেখেছিলেন।

আর default argument মানে সংজ্ঞাতেই একটি মান বসিয়ে রাখা, যেমন rate=0.15. ডাকার সময় সেই argument না দিলে default বসে যায়। এতে সাধারণ ক্ষেত্রে ডাকা সহজ হয়, আবার বিশেষ ক্ষেত্রে বদলানোও যায়। নিচে একটি টাকা-থেকে-ডলার ফাংশনে দেখুন Python কীভাবে argument আর parameter মেলায়:

1def to_dollar(taka, rate=122.0, symbol="$", *, digits=2):2    return f"{symbol}{round(taka / rate, digits)}"34print(to_dollar(500, digits=1, rate=120))

মেলানোর নিয়ম — যা ভাঙলে error

• Positional আগে, keyword পরে: to_dollar(rate=120, 500) লিখলে চালানোর আগেই SyntaxError — keyword-এর পরে positional বসানো যায় না।
• একই parameter দুবার নয়: to_dollar(500, taka=600) লিখলে TypeError: to_dollar() got multiple values for argument 'taka'.
• অচেনা নাম নয়: to_dollar(500, rat=120) — বানান ভুল — দিলে TypeError: to_dollar() got an unexpected keyword argument 'rat'. Did you mean 'rate'? ভালো দিক: ভুলটা চুপচাপ লুকিয়ে থাকে না, আর Python 3.14 সঠিক নামটিও সুপারিশ করে।
• সংজ্ঞায় default-ওয়ালা parameter পরে: def f(a=1, b): লেখা যায় না, কারণ তখন f(5)-এর 5 কোথায় বসবে বোঝা যায় না।

Default-এ বদলানো যায় না এমন মান রাখুন

Default মান তৈরি হয় একবারই — def লাইন চলার সময়, প্রতিটি ডাকে নতুন করে নয়। সংখ্যা, string বা None-এর মতো immutable মানে এতে কোনো সমস্যা নেই। কিন্তু default হিসেবে একটি খালি list (items=[]) দিলে সব ডাক একই list ভাগাভাগি করে, আর এক ডাকে যোগ করা জিনিস পরের ডাকেও থেকে যায়।

* আর / — কোন argument কীভাবে পাঠানো যাবে, তা ঠিক করা

কখনো আপনি চান কিছু argument অবশ্যই নাম ধরে পাঠাতে হবে। ধরুন transfer(5000, True, False) — True আর False এখানে কী বোঝায়, পড়ে বোঝার উপায় নেই। সংজ্ঞায় একটি একক * বসালে তার পরের সব parameter হয়ে যায় keyword-only: def transfer(amount, *, confirm=True, notify=False). এখন ডাকতে হবে transfer(5000, notify=True) — পড়লেই অর্থ পরিষ্কার। Python-এর নিজের sorted()-এ key আর reverse এভাবেই keyword-only.

উল্টোটাও আছে। সংজ্ঞায় / বসালে তার আগের parameter-গুলো হয়ে যায় positional-only — নাম ধরে পাঠানো যায় না: def bmi(weight, height, /). এতে ফাংশন-লেখক পরে parameter-এর নাম বদলালেও কারও কোড ভাঙে না। এটি এসেছে Python 3.8 থেকে (PEP 570). অনেক built-in ফাংশন আগে থেকেই এমন — len(obj=[1, 2]) লিখে দেখুন, TypeError পাবেন। নতুনদের এগুলো রোজ লিখতে হবে না, তবে ডকুমেন্টেশনে sorted(iterable, /, *, key=None, reverse=False) দেখলে এখন বুঝবেন কোন অংশ কী বলছে।

৬ · ভালো ফাংশনের গুণ — docstring, type hint, pure function আর assert

ফাংশন লেখা সহজ; ভালো ফাংশন লেখা একটি দক্ষতা। ভালো ফাংশন পড়লে বোঝা যায়, ব্যবহার করতে ভয় লাগে না, আর বদলালে কিছু ভাঙে না। চারটি অভ্যাস এই তিনটি গুণ এনে দেয়।

১. Docstring আর help()

ফাংশনের def লাইনের ঠিক নিচে তিন কোটে লেখা প্রথম string-টি হলো docstring. Comment-এর সাথে পার্থক্য: Python docstring ফেলে দেয় না, ফাংশনের __doc__-এ রেখে দেয়। তাই help(add_vat) লিখলে বা VS Code-এ ফাংশনের নামের ওপর মাউস রাখলে সেটি দেখায়। ভালো docstring বলে কী করে, কী নেয়, কী ফেরত দেয় — কীভাবে করে তা নয়, সেটা কোডই বলবে।

২. Type hint — নথি হিসেবে

def gpa(all_marks: list[int]) -> float: — এখানে : list[int] আর -> float হলো type hint. এরা পাঠককে (আর editor-কে) জানায় কী ধরনের মান আসবে, কী ফেরত যাবে। কিন্তু Python চলার সময় এগুলো যাচাই করে না — gpa("abc") ডাকলেও hint-এর কারণে কোনো error আসবে না; আসবে ভেতরের কোনো লাইনে গিয়ে। Hint যাচাই করে mypy বা pyright-এর মতো আলাদা টুল, পর্ব ৩৭-এ দেখবেন। আপাতত এগুলোকে ভাবুন জীবন্ত নথি হিসেবে, যা editor-এর auto-complete-কেও সাহায্য করে।

৩. ছোট, এক-কাজের, আর যতটা সম্ভব pure

একটি ফাংশন একটি কাজ করবে — যার নাম এক বাক্যে বলা যায়। “নম্বর থেকে grade point বের করে” ভালো। “নম্বর পড়ে, grade বের করে, ফাইলে লেখে, ইমেইল পাঠায়” — এটি আসলে চারটি ফাংশন। মোটামুটি একটি নিয়ম: ফাংশন যদি পুরো স্ক্রিনে না আঁটে, বা নাম দিতে গিয়ে “and” লাগে, ভাঙার কথা ভাবুন।

আরও ভালো হয় যদি ফাংশনটি pure function হয়: একই ইনপুটে সবসময় একই ফল দেয়, আর বাইরের কিছু বদলায় না। add_vat(1000) সবসময় 1150.0 — এটি pure. অন্যদিকে যে ফাংশন ছাপে, ফাইলে লেখে, ডেটাবেস বদলায় বা বাইরের list-এ যোগ করে, তার আছে side effect. Side effect খারাপ নয় — প্রোগ্রামের কাজই শেষ পর্যন্ত কিছু ছাপা বা সেভ করা। কৌশল হলো দুটিকে আলাদা রাখা: হিসাব pure ফাংশনে, side effect বাইরের পাতলা স্তরে. তাহলে হিসাবের অংশ পরীক্ষা করা অনেক সহজ হয়।

৪. assert দিয়ে এক লাইনে পরীক্ষা

assert একটি statement, যা বলে “এই কথাটি সত্য হতেই হবে”। সত্য হলে কিছু ঘটে না; মিথ্যা হলে AssertionError দিয়ে প্রোগ্রাম থামে। Pure ফাংশন পরীক্ষার জন্য এটি সবচেয়ে সহজ উপায়: assert add_vat(1000) == 1150.0. সীমার মানগুলো (৭৯ আর ৮০, ৩২ আর ৩৩) পরীক্ষা করুন — ভুল সাধারণত সেখানেই লুকায়। পেশাদার পরীক্ষার টুল pytest-ও ভেতরে এই assert-ই ব্যবহার করে; বিস্তারিত পর্ব ৩৯-এ। (সতর্কতা: python -O দিয়ে চালালে assert বাদ পড়ে যায়, তাই ব্যবহারকারীর ইনপুট যাচাইয়ে এটি ব্যবহার করবেন না — সেটা পর্ব ২৪-এর exception-এর কাজ।)

চারটি অভ্যাস একসাথে দেখুন — বাংলাদেশের প্রচলিত ৫-স্কেলে নম্বর থেকে grade point আর GPA. এখানে ফাংশনকে argument হিসেবে পাঠানোর একটি ঝলকও আছে:

def grade_point(marks: int) -> float:
    """নম্বর (0-100) থেকে ৫-স্কেলের grade point ফেরত দেয়।"""
    for cutoff, point in [(80, 5.0), (70, 4.0), (60, 3.5), (50, 3.0), (40, 2.0), (33, 1.0)]:
        if marks >= cutoff:
            return point          # পেলেই সঙ্গে সঙ্গে ফেরত
    return 0.0

def gpa(all_marks: list[int]) -> float:
    total = 0.0
    for m in all_marks:
        total += grade_point(m)
    return round(total / len(all_marks), 2)

assert grade_point(80) == 5.0 and grade_point(79) == 4.0 and grade_point(32) == 0.0
print(grade_point.__doc__)

def by_gpa(student):
    return gpa(student[1])

students = [("রহিম", [85, 72, 64]), ("সুমি", [90, 88, 79]), ("জামিল", [55, 61, 47])]
for name, marks in sorted(students, key=by_gpa, reverse=True):
    print(name, gpa(marks))

৭ · ফাংশনও একটি object — অন্য ফাংশনে পাঠানো

পর্ব ০৫-এ দেখেছিলেন, Python-এ সবকিছুই object. ফাংশনও ব্যতিক্রম নয়। def by_gpa(...) লিখলে একটি function object তৈরি হয়, আর by_gpa নামটি তার লেবেল। তাই একটি সংখ্যা বা string দিয়ে যা করা যায়, ফাংশন দিয়েও তা করা যায়: অন্য নামে রাখা, list বা dict-এ রাখা, অন্য ফাংশনে argument হিসেবে পাঠানো, এমনকি ফাংশন থেকে ফেরত দেওয়া। একে বলে first-class function.

এর বাস্তব প্রয়োগ সর্বত্র। একটি bKash-ধাঁচের মেনু ভাবুন: actions = {"1": send_money, "2": cash_out, "3": check_balance}, তারপর actions[choice]() — লম্বা if/elif-এর বদলে একটি dict. max(products, key=get_price) দামি পণ্য খোঁজে, sorted(names, key=len) নামের দৈর্ঘ্য ধরে সাজায় — len-ও তো একটি ফাংশন। এই ধারণার ওপর দাঁড়িয়ে আছে দুটি বড় বিষয়, যা পরে আসবে: lambda (এক লাইনের নামহীন ফাংশন, পর্ব ৩৮) আর decorator (একটি ফাংশনকে মুড়িয়ে নতুন ফাংশন বানানো, @ চিহ্ন দিয়ে লেখা — পর্ব ৩৫)।

৮ · নিজেকে ডাকা ফাংশন — recursion-এর প্রথম ঝলক

একটি ফাংশন যদি অন্য ফাংশন ডাকতে পারে, তাহলে নিজেকে ডাকতে পারবে না কেন? পারে — একে বলে recursion. শর্ত একটাই: প্রতিটি ডাকে সমস্যা একটু ছোট হতে হবে, আর কোথাও এমন একটি সহজ অবস্থা থাকতে হবে যেখানে আর নিজেকে ডাকা হয় না — একে বলে base case. Factorial-এর সংজ্ঞাই recursive: ৩! = ৩ × ২!, ২! = ২ × ১!, আর ১! = ১ (এখানে থামা)। নিচে stack-এর ছবিতে দেখুন:

1def factorial(n):2    if n <= 1:3        return 14    return n * factorial(n - 1)56print(factorial(3))

৯ · AI-এর যুগে — AI-এর লেখা ফাংশন যাচাই

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

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

• ফাংশনের নাম এক বাক্যে তার কাজ বলে, আর পুরো ফাংশন এক স্ক্রিনে আঁটে
• হিসাবের ফাংশন return করে; ভেতরে কোনো অপ্রয়োজনীয় print নেই
• Docstring আছে, আর তা কোডের সাথে মেলে (একক, হার শতাংশ না দশমিক — স্পষ্ট)
• কোনো default-এ [], {} বা অন্য বদলানো যায় এমন object নেই
• সব শাখায় মান return হয় — কোনো if-শাখা চুপচাপ None ফেরত দেয় না
• সীমার মান (০, ঋণাত্মক, সর্বোচ্চ) দিয়ে নিজে assert লিখে চালিয়ে দেখেছি