بتل کد Battle Codeدارد باز می‌شود…

آموزش پایتون

تابع در پایتون: آموزش def، پارامتر و return با مثال

۱۰ دقیقه مطالعه · ۳۰ مهر ۱۴۰۵

فهرست مطالب
  1. تابع چیست و چطور تعریف می‌شود؟
  2. پارامتر و آرگومان: دادن ورودی به تابع
  3. برگرداندن جواب با return
  4. آرگومان پیش‌فرض و آرگومان با نام
  5. حوزه‌ی متغیرها (scope): کدام متغیر کجا دیده می‌شود؟
  6. ساختن برنامه از تابع‌های کوچک
  7. اشتباه‌های رایج در تابع‌ها
  8. تابع را کجا تمرین کنیم؟
  9. سؤال‌های پرتکرار

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

در این مقاله از ساده‌ترین تابع شروع می‌کنیم و به پارامتر، return، آرگومان پیش‌فرض و آرگومان با نام، حوزه‌ی متغیرها (scope)، docstring، تابع‌هایی که تابع دیگری را صدا می‌زنند و lambda می‌رسیم. آخر هم اشتباه‌های رایج تازه‌کارها را با راه رفعشان می‌بینیم. همه‌ی مثال‌ها اجرا شده‌اند و خروجی هر کدام زیرش آمده است.

تابع چیست و چطور تعریف می‌شود؟

چرا به تابع نیاز داریم؟

شما از اولین روز پایتون با تابع کار کرده‌اید: print، len، input و int همه تابع‌اند. پایتون آن‌ها را از قبل ساخته و شما فقط صدایشان می‌زنید. حالا وقت آن است که تابع‌های خودتان را بسازید.

فرض کنید در یک بازی، بعد از هر مرحله باید سه خط پیام چاپ شود. اگر این سه خط را ده جای برنامه کپی کنید، برای عوض کردن یک کلمه باید ده جا را درست کنید و احتمالاً یکی را جا می‌اندازید. با تابع، آن سه خط را یک بار می‌نویسید، یک اسم رویش می‌گذارید و هر جا لازم بود صدایش می‌زنید. سه فایده‌ی اصلی تابع این‌هاست:

  • تکرار کمتر: کد یک بار نوشته می‌شود و بارها استفاده می‌شود.
  • خوانایی بیشتر: اسمی مثل calculate_total می‌گوید آن تکه کد چه می‌کند.
  • پیدا کردن راحت‌تر خطا: هر تابع را می‌شود جدا امتحان کرد.

تعریف و صدا زدن تابع با def

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

def greet():
    print("Hello!")
    print("Welcome to the game.")

greet()
greet()
Hello!
Welcome to the game.
Hello!
Welcome to the game.

تعریف کردن تابع به‌تنهایی چیزی چاپ نمی‌کند؛ فقط به پایتون می‌گوید «این دستور را یاد بگیر». کد داخل تابع وقتی اجرا می‌شود که آن را با اسم و پرانتز صدا بزنید: greet(). برای اسم تابع از حرف‌های کوچک انگلیسی و خط زیر استفاده کنید و اسمی بگذارید که کار تابع را بگوید، مثل show_menu یا draw_square.

پارامتر و آرگومان: دادن ورودی به تابع

تابعی که همیشه یک کار ثابت انجام دهد، کاربردش محدود است. با پارامتر می‌شود به تابع اطلاعات داد. پارامتر متغیری است که داخل پرانتزِ تعریف تابع می‌آید و مقدارش موقع صدا زدن تعیین می‌شود:

def greet(name):
    print(f"Hello, {name}!")

greet("Sara")
greet("Reza")
Hello, Sara!
Hello, Reza!

تابع می‌تواند چند پارامتر داشته باشد که با ویرگول از هم جدا می‌شوند. مقدارها به همان ترتیب به پارامترها می‌رسند:

def show_score(name, score):
    print(name, "has", score, "points")

show_score("Nika", 120)
Nika has 120 points

این دو کلمه زیاد با هم قاطی می‌شوند، پس یک بار برای همیشه:

اصطلاحکجاست؟در مثال بالا
پارامتر (parameter)در تعریف تابع، داخل پرانتزname و score
آرگومان (argument)در صدا زدن تابع، مقدار واقعی"Nika" و 120
بدنه‌ی تابعخط‌های تورفته زیر defخط print

برگرداندن جواب با return

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

def square(n):
    return n * n

result = square(7)
print(result)
print(square(3) + square(4))
49
25

جوابی که return برمی‌گرداند جای صدا زدن تابع می‌نشیند. یعنی square(3) + square(4) اول به 9 + 16 تبدیل می‌شود و بعد به ۲۵.

فرق print و return

این مهم‌ترین نکته‌ی این مقاله است. print چیزی را روی صفحه نشان می‌دهد، اما return مقدار را به برنامه برمی‌گرداند. تابعی که return ندارد، در واقع None برمی‌گرداند، یعنی «هیچ»:

def add_print(a, b):
    print(a + b)

def add_return(a, b):
    return a + b

x = add_print(2, 3)
y = add_return(2, 3)
print("x =", x)
print("y =", y)
5
x = None
y = 5

add_print عدد ۵ را چاپ کرد، اما چیزی در x نریخت. add_return چیزی چاپ نکرد، ولی جواب را در y گذاشت. قانون ساده: اگر قرار است با جواب تابع کار دیگری بکنید، از return استفاده کنید.

return کار تابع را تمام می‌کند

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

def check_age(age):
    if age < 0:
        return "Invalid age"
    if age < 13:
        return "Child"
    return "Teen or adult"

print(check_age(-2))
print(check_age(9))
print(check_age(15))
Invalid age
Child
Teen or adult

تابع می‌تواند چند مقدار را هم با هم برگرداند. پایتون آن‌ها را در یک تاپل می‌گذارد و می‌شود همان‌جا در چند متغیر بازشان کرد:

def min_max(numbers):
    return min(numbers), max(numbers)

low, high = min_max([7, 2, 9, 4])
print(low, high)
2 9

آرگومان پیش‌فرض و آرگومان با نام

گاهی یک پارامتر بیشتر وقت‌ها مقدار یکسانی دارد. می‌شود برایش مقدار پیش‌فرض گذاشت تا اگر موقع صدا زدن چیزی برایش فرستاده نشد، همان مقدار استفاده شود:

def power(base, exponent=2):
    return base ** exponent

print(power(5))
print(power(2, 10))
print(power(exponent=3, base=4))
25
1024
64

در خط آخر، آرگومان‌ها با نام فرستاده شده‌اند (keyword arguments). وقتی اسم پارامتر را می‌نویسید، ترتیب دیگر مهم نیست و کد هم خواناتر می‌شود. این روش وقتی تابع چند پارامتر پیش‌فرض دارد و فقط می‌خواهید یکی را عوض کنید، خیلی به کار می‌آید:

def order(drink, size="medium", sugar=1):
    print(f"{size} {drink}, sugar: {sugar}")

order("tea")
order("cocoa", sugar=0)
order("milk", "large")
medium tea, sugar: 1
medium cocoa, sugar: 0
large milk, sugar: 1

خود print هم آرگومان با نام دارد؛ مثلاً print("a", "b", sep="-") بین دو کلمه خط تیره می‌گذارد. یک قانون را هم به خاطر بسپارید: پارامترهای پیش‌فرض باید بعد از پارامترهای معمولی بیایند. نوشتن def order(size="medium", drink): خطای SyntaxError می‌دهد.

حوزه‌ی متغیرها (scope): کدام متغیر کجا دیده می‌شود؟

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

def make_bonus():
    bonus = 50
    print("inside:", bonus)

make_bonus()
print(bonus)
inside: 50
Traceback (most recent call last):
  File "main.py", line 6, in <module>
    print(bonus)
          ^^^^^
NameError: name 'bonus' is not defined

بیرون تابع، bonus وجود ندارد. در عوض، متغیری که بیرون از همه‌ی تابع‌ها ساخته شده (سراسری یا global) داخل تابع قابل خواندن است. اما اگر بخواهید داخل تابع آن را عوض کنید، پایتون آن را یک متغیر محلی تازه حساب می‌کند و به مشکل می‌خورید:

score = 0

def add_point():
    score = score + 1

add_point()
Traceback (most recent call last):
  File "main.py", line 6, in <module>
    add_point()
  File "main.py", line 4, in add_point
    score = score + 1
            ^^^^^
UnboundLocalError: cannot access local variable 'score' where it is not associated with a value

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

def add_point(score):
    return score + 1

score = 0
score = add_point(score)
score = add_point(score)
print(score)
2

این‌طوری هر تابع فقط با ورودی‌هایش کار می‌کند و خروجی‌اش را برمی‌گرداند؛ چنین تابعی را راحت‌تر می‌شود فهمید، امتحان کرد و در برنامه‌ی دیگری دوباره به کار برد.

هر وقت خواستید از global استفاده کنید، اول از خودتان بپرسید: «نمی‌شود این مقدار را با پارامتر بدهم و با return پس بگیرم؟» تقریباً همیشه می‌شود.

ساختن برنامه از تابع‌های کوچک

توضیح نوشتن با docstring

اولین خط داخل تابع می‌تواند یک متن داخل سه علامت نقل‌قول باشد که توضیح می‌دهد تابع چه کار می‌کند. به آن docstring می‌گویند. پایتون آن را نگه می‌دارد و ابزارهایی مثل help(average) نشانش می‌دهند:

def average(numbers):
    """Return the average of a list of numbers."""
    return sum(numbers) / len(numbers)

print(average([12, 18, 15]))
print(average.__doc__)
15.0
Return the average of a list of numbers.

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

تابعی که تابع دیگر را صدا می‌زند

برنامه‌های واقعی از تابع‌های کوچکی ساخته می‌شوند که هر کدام یک کار انجام می‌دهند و همدیگر را صدا می‌زنند. این برنامه هزینه‌ی رنگ کردن اتاق‌ها را حساب می‌کند:

def area(width, height):
    return width * height

def paint_cost(width, height, price_per_meter):
    return area(width, height) * price_per_meter

def report(room, width, height):
    cost = paint_cost(width, height, 30)
    print(f"{room}: {area(width, height)} square meters, cost {cost}")

report("Kitchen", 4, 3)
report("Bedroom", 5, 4)
Kitchen: 12 square meters, cost 360
Bedroom: 20 square meters, cost 600

report تابع paint_cost را صدا می‌زند و paint_cost هم تابع area را. اگر روزی فرمول مساحت عوض شود، فقط یک جا را درست می‌کنید. وقتی تابعی خودش را صدا بزند، به آن بازگشت (recursion) می‌گویند که موضوع مقاله‌ی تابع بازگشتی در پایتون است.

lambda: تابع یک‌خطی بی‌اسم

lambda راهی برای ساختن تابع‌های خیلی کوتاه در یک خط است. بیشتر وقتی به کار می‌رود که یک تابع کوچک را باید به تابع دیگری بدهید، مثلاً به sorted برای تعیین معیار مرتب‌سازی:

double = lambda x: x * 2
print(double(6))

words = ["banana", "kiwi", "apple", "fig"]
print(sorted(words, key=lambda w: len(w)))
12
['fig', 'kiwi', 'apple', 'banana']

lambda w: len(w) یعنی «تابعی که w را می‌گیرد و طولش را برمی‌گرداند». در این مثال خاص، key=len هم همین کار را می‌کرد. برای هر چیزی بیشتر از یک عبارت کوتاه، همان def خواناتر است.

اشتباه‌های رایج در تابع‌ها

صدا زدن تابع قبل از تعریفش

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

say_hi()

def say_hi():
    print("Hi")
Traceback (most recent call last):
  File "main.py", line 1, in <module>
    say_hi()
    ^^^^^^
NameError: name 'say_hi' is not defined

راه رفع: تعریف تابع‌ها را بالای برنامه بنویسید و صدا زدنشان را پایین‌تر.

تعداد آرگومان اشتباه

اگر تابع پارامتری دارد که مقدار پیش‌فرض ندارد، باید موقع صدا زدن برایش مقدار بفرستید:

def greet(name):
    print("Hello", name)

greet()
Traceback (most recent call last):
  File "main.py", line 4, in <module>
    greet()
TypeError: greet() missing 1 required positional argument: 'name'

return در جای اشتباه

تورفتگی return تعیین می‌کند کجا اجرا شود. این تابع قرار است جمع لیست را حساب کند، اما جواب غلط می‌دهد:

def total(numbers):
    s = 0
    for n in numbers:
        s += n
        return s

print(total([1, 2, 3]))
1

چون return داخل حلقه است، تابع بعد از اولین دور تمام می‌شود. اگر return s را یک تورفتگی عقب بیاورید (هم‌تراز با for)، جواب درست، یعنی ۶، چاپ می‌شود. این جدول بقیه‌ی اشتباه‌های رایج را خلاصه کرده است:

اشتباهچه می‌شود؟راه رفع
جا انداختن پرانتز: greetتابع اجرا نمی‌شودgreet()
print به‌جای returnجواب تابع None استجواب را return کنید
صدا زدن قبل از defNameErrorتعریف را بالاتر بیاورید
آرگومان کم یا زیادTypeErrorتعداد را با پارامترها یکی کنید
return داخل حلقهتابع زود تمام می‌شودتورفتگی return را درست کنید
جا انداختن دونقطه بعد از defSyntaxErrordef name():

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

تابع را کجا تمرین کنیم؟

بهترین تمرین، تبدیل کدهای تکراری خودتان به تابع است. چند ایده: تابعی که عددی را بگیرد و بگوید زوج است یا فرد؛ تابعی که دمای سلسیوس را به فارنهایت تبدیل کند؛ تابعی که لیستی از نمره‌ها را بگیرد و میانگین، کمترین و بیشترین را برگرداند؛ یا تابعی که با لاک‌پشت یک ستاره با اندازه‌ی دلخواه بکشد.

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

سؤال‌های پرتکرار

تابع در پایتون چیست؟

تابع یک تکه کد اسم‌دار است که یک کار مشخص انجام می‌دهد و با صدا زدن اسمش اجرا می‌شود. تابع را با def تعریف می‌کنند و می‌تواند ورودی بگیرد و با return جواب برگرداند. print و len هم تابع‌هایی هستند که پایتون از قبل ساخته است.

فرق print و return در تابع چیست؟

print فقط مقداری را روی صفحه نشان می‌دهد، اما return مقدار را به جایی که تابع صدا زده شده برمی‌گرداند تا بشود آن را در متغیر ریخت یا در حساب‌ها استفاده کرد. تابعی که return ندارد، None برمی‌گرداند.

فرق پارامتر و آرگومان چیست؟

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

آرگومان پیش‌فرض چیست؟

مقداری است که در تعریف تابع برای یک پارامتر می‌گذارید، مثل exponent=2. اگر موقع صدا زدن برای آن پارامتر چیزی نفرستید، همین مقدار استفاده می‌شود. پارامترهای پیش‌فرض باید بعد از پارامترهای معمولی بیایند.

lambda در پایتون چیست؟

lambda روشی برای ساختن یک تابع کوچک و بی‌اسم در یک خط است، مثل lambda x: x * 2. بیشتر برای دادن یک معیار کوتاه به تابع‌هایی مثل sorted، max یا min استفاده می‌شود. برای کارهای بزرگ‌تر از یک عبارت، def بهتر است.

چرا متغیری که داخل تابع ساختم بیرون تابع کار نمی‌کند؟

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

همین حالا روی Battle Code تمرین کن

مقاله‌های دیگر

همه‌ی مقاله‌ها