آموزش تابع در پایتون — تعریف، آرگومان، مقدار بازگشتی

🚀 نقشه راه یادگیری تابع در پایتون

💡 تعریف تابع

چرا و چطور تابع بسازیم؟ بلوک‌های سازنده کد.

⚙️ آرگومان‌ها

داده‌ها رو چطور به تابع بدیم؟ انواع آرگومان‌ها.

↩️ مقدار بازگشتی

تابع چطور نتیجه رو برگردونه؟ استفاده از `return`.

📊 دامنه متغیرها

متغیرها کجان؟ Local و Global.

🛠️ عیب‌یابی

حل مشکلات رایج در استفاده از توابع.

مقدمه‌ای بر توابع در پایتون: چرا اصلاً بهش نیاز داریم؟

ببین رفیق، فرض کن داری یه ساختمان بزرگ می‌سازی. آیا برای هر طبقه، آجر و سیمان رو از اول می‌سازی؟ مسلماً نه! از بلوک‌های آماده استفاده می‌کنی. توی برنامه‌نویسی هم توابع دقیقاً همین نقش رو دارن.

تابع (Function) توی پایتون یه بلوک از کده که فقط وقتی صداش بزنی، اجرا میشه. این بلوک کدی می‌تونه یه کار خاص رو برات انجام بده. هدف اصلی توابع اینه که جلوی تکرار کد (Don’t Repeat Yourself – DRY) رو بگیرن و کدت رو خواناتر و سازمان‌یافته‌تر کنن. همینطور، اگه یه مشکلی پیش اومد، به جای اینکه کل کد رو زیر و رو کنی، مستقیم می‌ری سراغ تابعی که اون مشکل رو ایجاد کرده.

تعریف تابع در پایتون (The `def` Keyword)

برای تعریف یه تابع تو پایتون، از کلمه کلیدی def استفاده می‌کنیم. بعد از def اسم تابع رو می‌نویسی، یه پرانتز باز و بسته () که جای آرگومان‌هاست، و در آخر یه دو نقطه :. تمام کدهایی که داخل تابع هستن، باید با یک ایندنت (تورفتگی) مشخص بشن.

def سلام_گفتن():
    print("سلام رفیق! خوش اومدی به دنیای پایتون.")

# فراخوانی تابع
سلام_گفتن()
    

function copyCode(button) {
const codeBlock = button.nextElementSibling.querySelector(‘code’);
const textToCopy = codeBlock.innerText;
navigator.clipboard.writeText(textToCopy).then(() => {
const originalText = button.innerText;
button.innerText = ‘کپی شد!’;
setTimeout(() => {
button.innerText = originalText;
}, 2000);
}).catch(err => {
console.error(‘Failed to copy text: ‘, err);
});
}

تو مثال بالا، تابعی به اسم سلام_گفتن تعریف کردیم که فقط یه جمله رو چاپ می‌کنه. برای اینکه این تابع اجرا بشه، باید اون رو با اسمش و پرانتز خالی فراخوانی (Call) کنیم.

آرگومان‌ها (Arguments): چطور به توابع داده بدیم؟

توابع معمولاً برای اینکه مفید باشن، نیاز دارن که داده‌ای رو از بیرون دریافت کنن. این داده‌ها به عنوان “آرگومان” یا “پارامتر” شناخته میشن. آرگومان‌ها رو داخل پرانتزهای تابع تعریف می‌کنیم.

1. آرگومان‌های موقعیتی (Positional Arguments)

اینا ساده‌ترین نوع آرگومان‌ها هستن. ترتیبشون مهمه و باید به همون ترتیبی که تعریف شدن، موقع فراخوانی تابع هم داده بشن.

def خوش_آمد_گویی(نام, شهر):
    print(f"سلام {نام} عزیز! از {شهر} خوش اومدی.")

خوش_آمد_گویی("علی", "تهران") # خروجی: سلام علی عزیز! از تهران خوش اومدی.
خوش_آمد_گویی("اصفهان", "فاطمه") # اشتباه! ترتیب رعایت نشده.
    

2. آرگومان‌های کلیدواژه‌ای (Keyword Arguments)

تو این حالت، می‌تونی اسم آرگومان رو موقع فراخوانی تابع مشخص کنی. خوبی‌اش اینه که ترتیب مهم نیست و کدت خواناتر میشه.

def نمایش_محصول(نام_محصول, قیمت, موجودی):
    print(f"محصول: {نام_محصول}")
    print(f"قیمت: {قیمت} تومان")
    print(f"موجودی: {موجودی}")

نمایش_محصول(نام_محصول="لپ‌تاپ", موجودی=5, قیمت=25000000)
# ترتیب مهم نیست:
نمایش_محصول(موجودی=10, نام_محصول="موبایل", قیمت=12000000)
    

3. آرگومان‌های پیش‌فرض (Default Arguments)

گاهی وقتا یه آرگومان هست که بیشتر اوقات یه مقدار ثابت داره. می‌تونی براش یه مقدار پیش‌فرض تعیین کنی. اگه موقع فراخوانی اون آرگومان رو ندی، مقدار پیش‌فرض استفاده میشه. وگرنه مقداری که خودت دادی جایگزین میشه.

def ارسال_پیام(متن_پیام, نوع="اطلاع رسانی"):
    print(f"[{نوع}] {متن_پیام}")

ارسال_پیام("کلاس پایتون فردا برگزار نمی‌شود.") # خروجی: [اطلاع رسانی] کلاس پایتون فردا برگزار نمی‌شود.
ارسال_پیام("برنامه شما با موفقیت اجرا شد.", نوع="موفقیت") # خروجی: [موفقیت] برنامه شما با موفقیت اجرا شد.
    

4. آرگومان‌های متغیر (Arbitrary Arguments: `*args` و `**kwargs`)

تصور کن نمی‌دونی قراره چند تا آرگومان به تابع بدی. اینجا *args و **kwargs ناجی میشن.

*args (Arbitrary Positional Arguments)

با *args می‌تونی هر تعداد آرگومان موقعیتی رو به تابع پاس بدی. این آرگومان‌ها داخل تابع به صورت یک “تاپل” (tuple) جمع میشن.

def جمع_اعداد(*اعداد):
    مجموع = 0
    for عدد in اعداد:
        مجموع += عدد
    print(f"مجموع اعداد: {مجموع}")

جمع_اعداد(1, 2, 3) # خروجی: مجموع اعداد: 6
جمع_اعداد(10, 20, 30, 40, 50) # خروجی: مجموع اعداد: 150
    

**kwargs (Arbitrary Keyword Arguments)

وقتی می‌خوای یه تعداد نامحدود آرگومان کلیدواژه‌ای رو به تابع پاس بدی، از **kwargs استفاده می‌کنی. این آرگومان‌ها داخل تابع به صورت یک “دیکشنری” (dictionary) جمع میشن. اگه دوست داری در مورد دیکشنری‌ها بیشتر بدونی، می‌تونی به سایت اصلی ما سر بزنی و مقالات مربوط به ساختارهای داده پایتون رو بخونی.

def نمایش_اطلاعات(**اطلاعات):
    for کلید, مقدار in اطلاعات.items():
        print(f"{کلید}: {مقدار}")

نمایش_اطلاعات(نام="سارا", سن=30, شغل="مهندس")
# خروجی:
# نام: سارا
# سن: 30
# شغل: مهندس

نمایش_اطلاعات(کشور="ایران", زبان="فارسی")
    

مقدار بازگشتی (Return Value): تابع چطور نتیجه رو برگردونه؟

تا الان دیدیم که توابع می‌تونن یه سری کارها رو انجام بدن، مثلاً یه چیزی رو چاپ کنن. اما اگه بخوایم نتیجه اون کار رو برای استفاده‌های بعدی تو قسمت‌های دیگه برنماه (برنامه) دریافت کنیم، چی؟ اینجا return وارد عمل میشه.

کلمه کلیدی return باعث میشه تابع یک مقدار خاص رو به جایی که فراخوانی شده، برگردونه. به محض اینکه پایتون به خط return می‌رسه، اجرای تابع متوقف میشه و مقدار رو برمی‌گردونه.

def جمع_دو_عدد(عدد1, عدد2):
    حاصل_جمع = عدد1 + عدد2
    return حاصل_جمع

نتیجه = جمع_دو_عدد(5, 7)
print(f"حاصل جمع: {نتیجه}") # خروجی: حاصل جمع: 12

عدد_جدید = نتیجه * 2
print(f"عدد جدید: {عدد_جدید}") # خروجی: عدد جدید: 24
    

یه نکته خیلی مهم: اگه یه تابع return نداشته باشه، به صورت پیش‌فرض None رو برمی‌گردونه. None یک نوع داده خاص تو پایتونه که به معنی “هیچی” یا “نداشتن مقدار” هست.

def تابعی_بدون_بازگشتی(نام):
    print(f"سلام {نام}")

خروجی_تابع = تابعی_بدون_بازگشتی("مهدی")
print(f"مقدار بازگشتی: {خروجی_تابع}") # خروجی: مقدار بازگشتی: None
    

بازگرداندن چندین مقدار

پایتون یه قابلیت باحال داره که می‌تونی چند تا مقدار رو همزمان از یه تابع برگردونی. این مقادیر به صورت یه تاپل (tuple) برگردونده میشن.

def محاسبات_ساده(عدد1, عدد2):
    جمع = عدد1 + عدد2
    تفریق = عدد1 - عدد2
    ضرب = عدد1 * عدد2
    تقسیم = عدد1 / عدد2
    return جمع, تفریق, ضرب, تقسیم

حاصل_جمع, حاصل_تفریق, حاصل_ضرب, حاصل_تقسیم = محاسبات_ساده(10, 5)
print(f"جمع: {حاصل_جمع}, تفریق: {حاصل_تفریق}, ضرب: {حاصل_ضرب}, تقسیم: {حاصل_تقسیم}")
# خروجی: جمع: 15, تفریق: 5, ضرب: 50, تقسیم: 2.0

# یا می‌تونی همه رو به یه متغیر اختصاص بدی و بعد از تاپل استفاده کنی:
نتایج = محاسبات_ساده(20, 4)
print(f"نتایج به صورت تاپل: {نتایج}") # خروجی: نتایج به صورت تاپل: (24, 16, 80, 5.0)
    

دامنه متغیرها (Variable Scope): Local و Global

یکی از مفاهیم مهم در توابع، “دامنه متغیرها”ست. هر متغیری که تعریف می‌کنی، یه جایی رو داره که توش معتبره. این دامنه می‌تونه محلی (Local) یا سراسری (Global) باشه.

متغیرهای Local (محلی)

متغیرهایی که داخل یک تابع تعریف میشن، “متغیرهای محلی” هستن. این متغیرها فقط داخل همون تابع قابل دسترسی‌ان و به محض اتمام اجرای تابع، از حافظه پاک میشن. از بیرون تابع نمی‌تونی بهشون دسترسی داشته باشی.

def تابع_محلی():
    x = 10 # x یک متغیر محلی است
    print(f"داخل تابع، x = {x}")

تابع_محلی()
# print(x) # اینجا خطا میده چون x خارج از تابع تعریف نشده
    

متغیرهای Global (سراسری)

متغیرهایی که در بالاترین سطح کد (خارج از هر تابعی) تعریف میشن، “متغیرهای سراسری” هستن. این متغیرها تو هر جای کد، حتی داخل توابع هم قابل دسترسی‌ان.

y = 20 # y یک متغیر سراسری است

def تابع_سراسری():
    print(f"داخل تابع، y = {y}")

تابع_سراسری() # خروجی: داخل تابع، y = 20
print(f"خارج از تابع، y = {y}") # خروجی: خارج از تابع، y = 20
    

استفاده از global برای تغییر متغیرهای سراسری

اگه بخوای داخل یک تابع، مقدار یه متغیر سراسری رو تغییر بدی، باید از کلمه کلیدی global استفاده کنی. اگه این کار رو نکنی، پایتون فکر می‌کنه داری یه متغیر محلی جدید با همون اسم تعریف می‌کنی!

شمارنده = 0

def افزایش_شمارنده():
    global شمارنده
    شمارنده += 1
    print(f"شمارنده داخل تابع: {شمارنده}")

print(f"شمارنده قبل از فراخوانی: {شمارنده}") # خروجی: شمارنده قبل از فراخوانی: 0
افزایش_شمارنده() # خروجی: شمارنده داخل تابع: 1
افزایش_شمارنده() # خروجی: شمارنده داخل تابع: 2
print(f"شمارنده بعد از فراخوانی: {شمارنده}") # خروجی: شمارنده بعد از فراخوانی: 2
    

جدول مقایسه‌ای انواع آرگومان‌ها

برای اینکه دید بهتری نسبت به تفاوت انواع آرگومان‌ها پیدا کنی، این جدول مقایسه‌ای رو آماده کردم:

عیب‌یابی سریع: مشکلات رایج در توابع و راه حل‌ها

خب، تا اینجا کلی با توابع آشنا شدیم. اما مثل هر ابزار قدرتمند دیگه‌ای، توابع هم می‌تونن گاهی اوقات سر به سر آدم بذارن! بیا ببینیم چه مشکلاتی ممکنه پیش بیاد و چطور حلشون کنیم.

1. `TypeError: missing X required positional argument`

2. `NameError: name ‘X’ is not defined` برای متغیرهای محلی

3. مقادیر پیش‌فرض قابل تغییر (Mutable Default Arguments)

def اضافه_کردن_عنصر(عنصر, لیست_پیشفرض=None):
    اگر لیست_پیشفرض is None:
        لیست_پیشفرض = [] # اینجا هر بار یک لیست جدید ایجاد می‌شود
    لیست_پیشفرض.append(عنصر)
    return لیست_پیشفرض

print(اضافه_کردن_عنصر(1)) # خروجی: [1]
print(اضافه_کردن_عنصر(2)) # خروجی: [2] - لیست جدیدی ایجاد شد
        

4. فراموشی `return`

جمع‌بندی و نتیجه‌گیری

خب رفیق برنامه‌نویس، تا اینجا دیدیم که توابع چقدر می‌تونن کدنویسی رو برامون ساده‌تر و لذت‌بخش‌تر کنن. از تعریف ساده یه تابع با def شروع کردیم، انواع آرگومان‌ها رو شناختیم که چطور می‌تونیم داده‌ها رو به توابع پاس بدیم، و بعد هم با return یاد گرفتیم چطور نتیجه کار تابع رو پس بگیریم. همچنین با دامنه متغیرها و تفاوت بین متغیرهای محلی و سراسری آشنا شدیم.

استفاده درست از توابع، مهارت اصلی هر برنامه‌نویس حرفه‌ایه. کدت رو ماژولار می‌کنه، قابلیت استفاده مجددش رو بالا می‌بره و اشکال‌زدایی رو راحت‌تر از همیشه می‌کنه. پس هر وقت دیدی داری یه تیکه کد رو چند بار تکرار می‌کنی، یه لحظه مکث کن و از خودت بپرس: “آیا اینجا جای یه تابع نیست؟”

برای اینکه اطلاعات بیشتری در مورد برنامه‌نویسی و اسنیپت‌های مفید دیگه کسب کنی، حتماً به اسنیپت‌های CSS، اسنیپت‌های جاوااسکریپت، اسنیپت‌های HTML و اسنیپت‌های وردپرس هم سر بزن. دانش برنامه‌نویسی تو فراتر از پایتون هم مهمه!