آموزش پایتون - توابع

تابع در برنامه‌نویسی به معنای یک بلوک کد است که یک وظیفه خاص را انجام می‌دهد. توابع در برنامه‌نویسی به منظور تقسیم کد به بخش‌های کوچکتر و قابل مدیریت تر به کار می‌روند و به برنامه‌نویسان اجازه می‌دهند تا قطعات کد را مجددا استفاده کنند و بهبود پذیری کد را افزایش دهند. 

توابع، به شما امکان می‌دهند که برنامه‌ی خود را به صورت ماژولار تر طراحی کرده و بتوانید از یک سری کدها چندین بار در جاهای مختلف برنامه استفاده کنید بدون آن که نیاز داشته باشید آن‌ها را از اول کدنویسی کنید.

همانطور که از قبل می‌دانید، پایتون توابع داخلی بسیاری مانند print() را در اختیار شما قرار می‌دهد.

اما شما می‌توانید توابع خودتان را تعریف و ایجاد کنید و سپس در برنامه خود از آن ها استفاده نمایید. این توابع به عنوان توابع تعریف شده توسط کاربر شناخته می‌شوند.

تعریف یک تابع در پایتون

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

• بلاک‌های تابع با کلمه کلیدی def شروع شده و سپس به آن نام تابع و بعد از آن پرانتزها ( ( ) ) پیوست می‌شود.

• هر پارامتر ورودی یا آرگومان باید در این پرانتزها قرار گیرد.همچنین شما می توانید هیچ پارامتر ورودی را برای تابع خود تعریف نکنید

• نحوه نوشتن ساختار تابع

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

مثال

تابع زیر یک رشته را به عنوان پارامتر ورودی می‌گیرد و آن را روی صفحه چاپ می‌کند.

def printme( str ):
   "This prints a passed string into this function"
   print str
   return

فراخوانی یک تابع

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

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

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme("I'm first call to user defined function!")
printme("Again second call to the same function")

هنگامی که کد بالا اجرا می‌شود، نتیجه زیر را تولید می‌کند −

I'm first call to user defined function!
Again second call to the same function

آرگومان‌های تابع

می‌توانید تابع را با استفاده از انواع زیر از آرگومان‌ها فراخوانی کنید −

• آرگومان‌های اجباری
• آرگومان‌های کلیدواژه‌ای
• آرگومان‌های پیش‌فرض
• آرگومان‌های طول متغیر 

آرگومان‌های اجباری

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

برای فراخوانی تابع printme()، حتماً باید یک آرگومان را پاس دهید، در غیر این صورت خطای نحوی را نشان می‌دهد −

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print(str)
   return;

# Now you can call printme function
printme()

هنگام اجرای کد بالا، نتیجه زیر تولید می‌شود −

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)

آرگومان‌های کلیدواژه‌ای

آرگومان‌های کلیدواژه‌ای با فراخوانی‌های تابع مرتبط هستند. هنگام استفاده از آرگومان‌های کلیدواژه‌ای در فراخوانی یک تابع، فراخواننده آرگومان‌ها را با نام پارامترها شناسایی می‌کند.

این به شما این امکان را می‌دهد تا آرگومان‌ها را به ترتیب دلخواه خود قرار دهید، زیرا مفسر پایتون قادر است از کلمات کلیدی ارائه شده برای هم‌خوانی مقادیر با پارامترها استفاده کند. می‌توانید تابع printme() را به روش‌های زیر با استفاده از آرگومان‌های کلیدواژه‌ای فراخوانی کنید −

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print(str)
   return;

# Now you can call printme function
printme( str = "My string")

هنگام اجرای کد بالا، نتیجه زیر تولید می‌شود −

My string

مثال زیر تصویری دقیق‌تر از این موضوع ارائه می‌دهد. توجه کنید که دیگر در این حالت ترتیب پارامترها مهم نیست.

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print("Name: ", name)
   print("Age ", age)
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )

هنگام اجرای کد بالا، نتیجه زیر تولید می‌شود −

Name:  miki
Age  50

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

آرگومان پیش‌فرض یک آرگومان است که در صورت عدم ارائه مقدار در هنگام فراخوانی آن تابع ، برای آن آرگومان یک مقدار پیش‌فرض را در نظر می گیرد. مثال زیر تصویری از آرگومان‌های پیش‌فرض ارائه می‌دهد، اگر مقدار سن در فراخوانی تعیین نشود، سن پیش‌فرض را چاپ می‌کند −

# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print("Name: ", name)
   print("Age ", age)
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )
printinfo( name="miki" )

وقتی کد بالا اجرا می‌شود، نتیجه زیر تولید می‌شود −

Name:  miki
Age  50
Name:  miki
Age  35

آرگومان‌های طول متغیر

ممکن است نیاز داشته باشید تا یک تابع را برای بیشتر از تعداد آرگومان‌هایی که در تعریف تابع مشخص کرده‌اید، پردازش کنید. این آرگومان‌ها به عنوان آرگومان‌هایی با طول متغیر شناخته می‌شوند و برخلاف آرگومان‌های ضروری و پیش‌فرض در هنگام تعریف تابع با نام مشخص نمی‌شوند.

دستورات برای یک تابع با آرگومان‌های غیر-کلیدواژه‌ای با طول متغیر به شکل زیر است −

def functionname([formal_args,] *var_args_tuple ):
   "function_docstring"
   function_suite
   return [expression]

یک علامت ستاره (*) قبل از نام متغیر قرار داده می‌شود که مقادیر تمام آرگومان‌های غیر-کلیدواژه را نگه می‌دارد. در صورتی که هیچ آرگومان اضافی در هنگام فراخوانی تابع مشخص نشود، این تاپل خالی می‌ماند. مثال زیر را بررسی کنید −

# Function definition is here
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print("Output is: ")
   print(arg1)
   for var in vartuple:
      print(var)
   return;

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

هنگام اجرای کد فوق، نتیجه زیر تولید می‌شود −

Output is:
10
Output is:
70
60
50

توابع ناشناس (Anonymous)

این توابع به دلیل اینکه به طور استاندارد با استفاده از کلمه کلیدی def اعلام نمی‌شوند، به عنوان توابع ناشناس شناخته می‌شوند. می‌توانید از کلمه کلیدی lambda برای ایجاد توابع ناشناس کوچک استفاده کنید.

• فرم‌های لامبدا می‌توانند هر تعداد آرگومان را دریافت کنند اما فقط یک مقدار را به صورت یک عبارت برگردانند. آن‌ها نمی‌توانند شامل دستورات یا چند عبارت باشند.

• یک تابع ناشناس نمی‌تواند به صورت مستقیم به print فراخوانی شود زیرا lambda نیاز به یک عبارت دارد.

• توابع لامبدا فضای نام محلی خود را دارند و قادر به دسترسی به متغیرهایی که در فهرست پارامترهایشان و فضای نام عمومی قرار ندارند نیستند.

• اگرچه به نظر می‌رسد لامبداها ، نسخه‌ی یک خطی از یک تابع باشند، اما معادل دستورات یک خطی در C یا C++ برابر نیستند. هدف آن‌ها عبور از تخصیص پشته‌ی تابع در هنگام فراخوانی برای بهبود عملکرد است.

نحوه نوشتن

نحوه نوشتن توابع لامبدا فقط شامل یک عبارت است، که به صورت زیر است −

lambda [arg1 [,arg2,.....argn]]:expression

مثال زیر نحوی را نشان می‌دهد که چگونه شکل لامبدا تابع کار می‌کند −

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;

# Now you can call sum as a function
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )

وقتی کد بالا اجرا می‌شود، نتیجه زیر را تولید می‌کند −

Value of total :  30
Value of total :  40

دستور return

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

مثال‌های بالا هیچ مقداری برنگشت نمی‌دهند. می‌توانید از یک تابع مقداری را با استفاده از روش زیر برگردانید −

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print "Inside the function : ", total
   return total;

# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total 

هنگام اجرای کد بالا، نتیجه زیر تولید می‌شود −

Inside the function :  30
Outside the function :  30

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

همهٔ متغیرها در یک برنامه در تمام نقاط آن برنامه قابل دسترسی نیستند. این دسترسی وابسته به جایی است که شما یک متغیر تعریف کرده‌اید.

دامنهٔ یک متغیر ، بخشی از برنامه را مشخص می‌کند که شما می‌توانید به آن متغیر در آن بخش دسترسی داشته باشد. دو نوع اصلی دامنهٔ متغیرها در پایتون وجود دارد −

• متغیرهای سراسری (Global variables)
• متغیرهای محلی (Local variables)

متغیرهای سراسری در مقابل متغیرهای محلی

متغیرهایی که در بدنهٔ یک تابع تعریف می‌شوند، دامنهٔ محلی دارند و متغیرهایی که در خارج از توابع تعریف می‌شوند، دامنهٔ سراسری دارند.

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

مثال ساده‌ای را در زیر می‌بینید −

total = 0; # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print("Inside the function local total : ", total)
   return total;

# Now you can call sum function
sum( 10, 20 );
print("Outside the function global total : ", total)

زمانی که کد بالا اجرا می‌شود، نتیجهٔ زیر تولید می‌شود −

Inside the function local total :  30
Outside the function global total :  0