توابع در پایتون
بهنام نوبخت · ۱۴۰۵/۸/۲۲
توابع (Functions) یکی از مهمترین مفاهیم برنامهنویسی در پایتون هستند که به ما کمک میکنند کدهای خود را به بخشهای کوچک، منظم و قابل استفاده مجدد تقسیم کنیم. بهجای اینکه یک قطعه کد را چندین بار بنویسیم، میتوانیم آن را داخل یک تابع قرار دهیم و هر زمان که نیاز داشتیم، تابع را فراخوانی کنیم. توابع باعث خوانایی بیشتر برنامه، کاهش تکرار کد و سادهتر شدن نگهداری و توسعه پروژهها میشوند. در این آموزش، با نحوه تعریف تابع در پایتون، پارامترها، آرگومانها، دستور return، مقادیر پیشفرض، توابع چندپارامتری و چند قابلیت کاربردی دیگر آشنا میشویم.
تابع در پایتون چیست؟
تابع مجموعهای از دستورها است که برای انجام یک کار مشخص تعریف میشود. پس از تعریف تابع، میتوانیم با فراخوانی آن، دستورهای داخل تابع را اجرا کنیم.
برای تعریف تابع در پایتون از کلمه کلیدی def استفاده میکنیم.
ساختار کلی تابع:
def function_name():
# Function body
statementsدر این ساختار:
defبرای تعریف تابع استفاده میشود.function_nameنام تابع است.پرانتزها محل تعریف پارامترهای تابع هستند.
علامت
:پایان خط تعریف تابع را مشخص میکند.دستورهای داخل تابع باید با تورفتگی مناسب نوشته شوند.
تعریف و فراخوانی تابع
بیایید یک تابع ساده بسازیم که پیامی را نمایش دهد.
def say_hello():
print("Hello, Python!")
say_hello()خروجی:
Hello, Python!در این مثال، ابتدا تابع say_hello() تعریف شده است. سپس با نوشتن نام تابع و پرانتز، آن را فراخوانی کردهایم.
نکته مهم این است که تعریف تابع بهتنهایی باعث اجرای دستورهای داخل آن نمیشود؛ برای اجرای تابع باید آن را فراخوانی کنیم.
میتوانیم یک تابع را چند بار فراخوانی کنیم:
def say_hello():
print("Hello!")
say_hello()
say_hello()
say_hello()خروجی:
Hello!
Hello!
Hello!این یکی از مهمترین مزیتهای توابع است؛ یک بار کد را تعریف میکنیم و هر چند بار که لازم باشد، از آن استفاده میکنیم.
تابع دارای پارامتر در پایتون
گاهی میخواهیم تابع هنگام اجرا اطلاعاتی دریافت کند. برای این کار از پارامترها استفاده میکنیم.
مثال:
def greet(name):
print(f"Hello, {name}!")
greet("Ali")
greet("Sara")خروجی:
Hello, Ali!
Hello, Sara!در این مثال، name یک پارامتر است و مقادیر "Ali" و "Sara" هنگام فراخوانی به تابع داده شدهاند.
تفاوت دو اصطلاح مهم:
پارامتر (Parameter): متغیری که هنگام تعریف تابع داخل پرانتز قرار میگیرد.
آرگومان (Argument): مقداری که هنگام فراخوانی تابع به آن ارسال میکنیم.
تابع با چند پارامتر
یک تابع میتواند چند پارامتر دریافت کند.
برای مثال، تابعی میسازیم که نام و سن یک شخص را دریافت کند.
def introduce(name, age):
print(f"My name is {name} and I am {age} years old.")
introduce("Ali", 25)
introduce("Sara", 22)خروجی:
My name is Ali and I am 25 years old.
My name is Sara and I am 22 years old.مقادیر در این مثال بر اساس ترتیب پارامترها اختصاص داده میشوند. بنابراین، هنگام استفاده از آرگومانهای موقعیتی باید ترتیب آنها را رعایت کنیم.
دستور return در پایتون
یکی از مهمترین بخشهای توابع، دستور return است. این دستور نتیجه اجرای تابع را به محل فراخوانی برمیگرداند.
مثال:
def add(a, b):
return a + b
result = add(10, 20)
print(result)خروجی:
30در این مثال، تابع مجموع دو عدد را محاسبه کرده و نتیجه را برگردانده است. سپس نتیجه در متغیر result ذخیره شده است.
تفاوت print() و return
این دو دستور کاربرد متفاوتی دارند.
print() برای نمایش اطلاعات در خروجی استفاده میشود، اما return نتیجه را از تابع برمیگرداند تا بتوانیم آن را در بخش دیگری از برنامه استفاده کنیم.
مثال با print():
def add(a, b):
print(a + b)
result = add(10, 20)
print(result)خروجی:
30
Noneچرا مقدار None نمایش داده میشود؟ چون تابع نتیجهای را با return برنگردانده است. تابعی که به انتهای خود برسد و دستور return نداشته باشد، بهصورت خودکار None برمیگرداند.
مثال با return:
def add(a, b):
return a + b
result = add(10, 20)
print(result)
print(result * 2)خروجی:
30
60در این حالت، نتیجه تابع را میتوانیم در محاسبات دیگر نیز استفاده کنیم.
تابع با مقدار بازگشتی شرطی
تابع میتواند بر اساس شرایط مختلف، نتایج متفاوتی برگرداند.
مثال: بررسی زوج یا فرد بودن عدد.
def check_number(number):
if number % 2 == 0:
return "Even"
return "Odd"
print(check_number(10))
print(check_number(7))خروجی:
Even
Oddدر این تابع، اگر باقیمانده تقسیم عدد بر ۲ برابر صفر باشد، عبارت Even برگردانده میشود؛ در غیر این صورت، نتیجه Odd است.
پس از اجرای return، اجرای همان فراخوانی تابع به پایان میرسد.
پارامترهای دارای مقدار پیشفرض
در پایتون میتوانیم برای پارامترهای تابع مقدار پیشفرض تعیین کنیم. اگر هنگام فراخوانی مقداری برای آنها ارسال نشود، مقدار پیشفرض استفاده خواهد شد.
def greet(name, message="Hello"):
print(f"{message}, {name}!")
greet("Ali")
greet("Sara", "Welcome")خروجی:
Hello, Ali!
Welcome, Sara!در این مثال، پارامتر message دارای مقدار پیشفرض "Hello" است.
بنابراین، در فراخوانی اول فقط نام ارسال شده و در فراخوانی دوم، مقدار پیام نیز مشخص شده است.
نکته: پارامترهای دارای مقدار پیشفرض باید بعد از پارامترهای بدون مقدار پیشفرض قرار بگیرند.
مثال صحیح:
def introduce(name, city="Tehran"):
print(f"{name} lives in {city}.")اما تعریف زیر معتبر نیست:
def introduce(city="Tehran", name):
print(name, city)زیرا پارامتر بدون مقدار پیشفرض بعد از پارامتر دارای مقدار پیشفرض قرار گرفته است.
فراخوانی تابع با آرگومانهای نامدار
تا اینجا بیشتر آرگومانها را بر اساس ترتیب ارسال کردهایم. اما پایتون اجازه میدهد نام پارامتر را هنگام فراخوانی مشخص کنیم. به این روش Keyword Arguments یا آرگومانهای نامدار گفته میشود.
def introduce(name, age, city):
print(f"{name} is {age} years old and lives in {city}.")
introduce(name="Ali", age=25, city="Tehran")خروجی:
Ali is 25 years old and lives in Tehran.مزیت این روش، خوانایی بیشتر کد است.
همچنین میتوانیم ترتیب آرگومانهای نامدار را تغییر دهیم:
def introduce(name, age, city):
print(f"{name} is {age} years old and lives in {city}.")
introduce(city="Tehran", name="Sara", age=22)خروجی:
Sara is 22 years old and lives in Tehran.هنگام ترکیب آرگومانهای موقعیتی و نامدار، آرگومانهای موقعیتی باید قبل از آرگومانهای نامدار قرار بگیرند.
دریافت تعداد نامشخصی از آرگومانها با *args
گاهی نمیدانیم تابع چند آرگومان دریافت خواهد کرد. در این شرایط میتوانیم از *args استفاده کنیم.
def calculate_sum(*args):
total = 0
for number in args:
total += number
return total
print(calculate_sum(10, 20))
print(calculate_sum(10, 20, 30, 40))خروجی:
30
100در این مثال، args داخل تابع یک تاپل شامل آرگومانهای موقعیتی دریافتشده است.
نام args قراردادی رایج است؛ علامت * ویژگی اصلی این روش را مشخص میکند.
دریافت آرگومانهای نامدار با **kwargs
برای دریافت تعداد نامشخصی از آرگومانهای نامدار میتوانیم از **kwargs استفاده کنیم.
def show_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
show_info(name="Ali", age=25, city="Tehran")خروجی:
name: Ali
age: 25
city: Tehranدر این مثال، kwargs یک دیکشنری از آرگومانهای نامدار دریافت میکند.
این قابلیت برای زمانی مفید است که تابع باید اطلاعاتی با کلیدهای مختلف دریافت کند.
استفاده همزمان از پارامترهای معمولی، *args و **kwargs
میتوانیم هر سه نوع پارامتر را در یک تابع استفاده کنیم.
def show_profile(name, *skills, **details):
print(f"Name: {name}")
print(f"Skills: {skills}")
print(f"Details: {details}")
show_profile(
"Ali",
"Python",
"SQL",
age=25,
city="Tehran"
)خروجی:
Name: Ali
Skills: ('Python', 'SQL')
Details: {'age': 25, 'city': 'Tehran'}در این مثال:
nameیک پارامتر معمولی است.skillsآرگومانهای موقعیتی اضافی را در قالب تاپل دریافت میکند.detailsآرگومانهای نامدار اضافی را در قالب دیکشنری دریافت میکند.
این روش انعطافپذیر است، اما بهتر است فقط زمانی استفاده شود که واقعاً به چنین انعطافی نیاز داریم.
محدوده متغیرها در توابع (Scope)
متغیرها در پایتون محدوده دسترسی دارند. متغیری که داخل یک تابع تعریف میشود، معمولاً متغیر محلی (Local Variable) است.
def calculate():
result = 10 + 20
print(result)
calculate()خروجی:
30اما اگر بخواهیم خارج از تابع به متغیر result دسترسی پیدا کنیم، خطا دریافت میکنیم:
def calculate():
result = 10 + 20
calculate()
print(result)در این مثال، متغیر result خارج از تابع تعریف نشده است؛ بنابراین قابل دسترسی نیست.
متغیرهای سراسری
متغیری که خارج از تابع تعریف شود، میتواند در داخل تابع خوانده شود.
tax_rate = 0.1
def calculate_tax(price):
return price * tax_rate
print(calculate_tax(1000))خروجی:
100.0در این مثال، تابع از متغیر سراسری tax_rate استفاده میکند.
برای برنامههای کوچک این کار ممکن است مناسب باشد، اما در برنامههای بزرگ بهتر است وابستگیهای تابع تا حد امکان از طریق پارامترها مشخص شوند.
تفاوت return و print() در طراحی توابع
برای درک بهتر این تفاوت، دو تابع را مقایسه کنیم.
تابع اول فقط نتیجه را نمایش میدهد:
def calculate_area(width, height):
print(width * height)
calculate_area(5, 4)خروجی:
20تابع دوم نتیجه را برمیگرداند:
def calculate_area(width, height):
return width * height
area = calculate_area(5, 4)
print(f"Area: {area}")
print(f"Double area: {area * 2}")خروجی:
Area: 20
Double area: 40تابع دوم انعطافپذیرتر است؛ زیرا میتوانیم نتیجه آن را ذخیره کنیم، در محاسبات دیگر به کار ببریم یا در بخشهای مختلف برنامه استفاده کنیم.
بهطور کلی، بهتر است توابعی که مسئول محاسبه هستند، نتیجه را با return برگردانند. نمایش خروجی را میتوان به بخشی از برنامه سپرد که مسئول تعامل با کاربر است.
توابع بازگشتی (Recursive Functions)
تابع بازگشتی تابعی است که خودش را فراخوانی میکند. از این روش میتوان برای حل برخی مسائل استفاده کرد.
مثال: محاسبه فاکتوریل یک عدد صحیح نامنفی.
فاکتوریل عدد (n) برابر حاصلضرب اعداد ۱ تا (n) است. برای مثال:
(5! = 5 \times 4 \times 3 \times 2 \times 1 = 120)
کد پایتون:
def factorial(n):
if n < 0:
raise ValueError("n must be non-negative")
if n == 0 or n == 1:
return 1
return n * factorial(n - 1)
print(factorial(5))خروجی:
120در این تابع:
شرط
n == 0 or n == 1حالت پایه است.در حالتهای دیگر، تابع خودش را با مقدار کوچکتر فراخوانی میکند.
با رسیدن به حالت پایه، فراخوانیها بهتدریج نتیجه را محاسبه میکنند.
نکته: بازگشت برای تمام مسائل بهترین انتخاب نیست. در پایتون، بازگشتهای بسیار عمیق ممکن است به محدودیت عمق بازگشت برسند؛ برای بسیاری از تکرارهای ساده، حلقه انتخاب مناسبتری است.
مستندسازی تابع با Docstring
برای توضیح هدف، پارامترها و نتیجه یک تابع میتوانیم از Docstring استفاده کنیم. این توضیح معمولاً بلافاصله بعد از خط تعریف تابع و داخل سه کوتیشن قرار میگیرد.
def calculate_area(width, height):
"""Calculate the area of a rectangle."""
return width * height
print(calculate_area(5, 4))
print(calculate_area.__doc__)خروجی:
20
Calculate the area of a rectangle.Docstring به برنامهنویسان کمک میکند تا کاربرد تابع را راحتتر بفهمند. در پروژههای بزرگ، مستندسازی مناسب توابع اهمیت زیادی دارد.
مثال عملی؛ ساخت ماشینحساب ساده با توابع
در این مثال، یک ماشینحساب ساده میسازیم که چهار عمل اصلی ریاضی را انجام میدهد.
def add(a, b):
return a + b
def subtract(a, b):
return a - b
def multiply(a, b):
return a * b
def divide(a, b):
if b == 0:
return None
return a / b
print("Addition:", add(10, 5))
print("Subtraction:", subtract(10, 5))
print("Multiplication:", multiply(10, 5))
result = divide(10, 5)
if result is not None:
print("Division:", result)
else:
print("Cannot divide by zero.")خروجی:
Addition: 15
Subtraction: 5
Multiplication: 50
Division: 2.0در این برنامه، هر عملیات در تابع جداگانهای قرار گرفته است. این کار باعث میشود کد منظمتر شود و هر تابع را بتوانیم مستقل آزمایش یا در بخشهای دیگر برنامه استفاده کنیم.
تمرینهای توابع در پایتون
برای تسلط بر توابع، تمرینهای زیر را حل کنید.
تمرین ۱: تابع خوشامدگویی
تابعی به نام greet بنویسید که نام یک شخص را دریافت کند و پیام خوشامدگویی نمایش دهد.
نمونه فراخوانی:
greet("Sara")خروجی مورد انتظار:
Hello, Sara!تمرین ۲: جمع دو عدد
تابعی به نام add تعریف کنید که دو عدد دریافت کند و مجموع آنها را با return برگرداند.
سپس نتیجه را در یک متغیر ذخیره و چاپ کنید.
تمرین ۳: بررسی زوج یا فرد بودن
تابعی بنویسید که یک عدد دریافت کند و عبارت Even یا Odd را برگرداند.
تمرین ۴: محاسبه مساحت مستطیل
تابعی به نام calculate_area بنویسید که طول و عرض مستطیل را دریافت کند و مساحت آن را برگرداند.
فرمول:
(Area = width \times height)
تمرین ۵: مقدار پیشفرض
تابعی به نام introduce بنویسید که نام و شهر را دریافت کند. مقدار پیشفرض شهر را "Tehran" در نظر بگیرید.
تابع را یک بار بدون تعیین شهر و بار دیگر با تعیین شهر دلخواه فراخوانی کنید.
تمرین ۶: محاسبه میانگین با *args
تابعی بنویسید که هر تعداد عدد دریافت کند و میانگین آنها را برگرداند.
اگر هیچ عددی دریافت نشد، باید از تقسیم بر صفر جلوگیری کنید و نتیجه مناسبی برگردانید یا خطای قابل فهمی ایجاد کنید.
تمرین ۷: پیدا کردن بزرگترین عدد
تابعی بنویسید که چند عدد دریافت کند و بزرگترین مقدار را برگرداند. میتوانید از *args استفاده کنید.
برای حالت ورودی خالی نیز تصمیم مشخصی بگیرید؛ مثلاً خطای ValueError ایجاد کنید.
تمرین ۸: تابع بازگشتی فاکتوریل
تابعی بازگشتی بنویسید که فاکتوریل یک عدد صحیح نامنفی را محاسبه کند. برای مقادیر منفی نیز خطای مناسبی در نظر بگیرید.
جمعبندی
در این مقاله با توابع در پایتون آشنا شدیم و یاد گرفتیم چگونه با def تابع تعریف کنیم، با پارامترها و آرگومانها اطلاعات دریافت کنیم و با return نتیجه را برگردانیم. همچنین پارامترهای دارای مقدار پیشفرض، آرگومانهای نامدار، *args، **kwargs، محدوده متغیرها، توابع بازگشتی و مستندسازی با Docstring را بررسی کردیم.
مهمترین نکته این است که توابع به ما کمک میکنند کدهای تکراری را کاهش دهیم، مسئولیتهای مختلف برنامه را از هم جدا کنیم و برنامههایی خواناتر و قابل نگهداریتر بنویسیم.
نظرات
هنوز نظری ثبت نشده است.