سلام دوستان...
با آموزش پایتون همراه ما باشید :
آموزش توابع در پایتون
تابع یک قطعه کد سازمان دهی شده است که می توان آن را بارها فراخوانی کرده و مورد استفاده قرار داد. تابع به منظور اجرای یک عملیات خاص بکار می رود. توابع modularity (قابلیت تفکیک مولفه های سیستم و ادغام مجدد آن ها؛ در واقع modularity معماری نرم افزار را به کامپوننت هایی تقسیم می کند که پیاده سازی و نگهداشت آن را آسان می سازد) برنامه و قابلیت استفاده ی مجدد آن را بالا می برد. همان طور که می دانید، پایتون توابع درون ساخته ی متعددی همچون print() ارائه می دهد، با این حال کاربر می تواند توابع خود را تعریف کند که به آن توابع user-defined یا توابع کاربر می گویند.
تعریف تابع
می توانید توابعی تعریف کنید که عملیات دلخواه را انجام دهد. برای تعریف توابع کاربر، بایستی از قوانین زیر پیروی کرد:
قطعه کد تابع باید با کلیدواژه ی def آغاز شود. به دنبال آن اسم تابع و پرانتز درج می شود ( () ).
پارامترهای ورودی یا آرگومان ها باید داخل پرانتز قرار داده شوند.
اولین دستور تابع می تواند یک دستور اختیاری باشد - function_docstring.
قطعه کد داخل ساختمان یا بدنه ی تابع با دو نقطه آغاز می شود، سپس دستوراتی که زیر آن قرار می گیرند، همگی توگذاشته می شوند.
دستور return اجرای تابع را متوقف کرده نتیجه را برمی گرداند (جمع بندی یک سری عملیات و یا کارهایی رو نمایش می دهد) و در صورت نیاز یک عبارت را به فراخواننده پاس می دهد. دستور return None نیز یعنی هیچ مقداری را به عنوان خروجی برنگرداند.
نحوه ی نگارش (syntax):
def functionname( parameters ):
"function_docstring"
function_suite
return [expression]
پارامترها به ترتیبی که تعریف شده اند، عمل می کنند و بایستی آن ها را به همان ترتیبی که تعریف شده اند، مقداردهی کرد.
مثال
تابع زیر یک رشته به عنوان ورودی پذیرفته و آن را چاپ می کند.
def printme( str ):
"This prints a passed string into this function"
print str
return
آموزش پایتون : فراخوانی تابع
با تعریف تابع فقط یک اسم به آن تخصیص می یابد، سپس پارامترهای آن مشخص شده و ساختمان کد ایجاد می شود. پس از اینکه ساختمان تابع ایجاد می شود، می توانید آن را از تابع دیگر صدا بزنید یا آن را مسقیم از پنجره ی prompt پایتون فراخوانی کنید. مثال زیر تابع printme() را صدا می زند:
#!/usr/bin/python
# 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
ارسال پارامتر با reference در برابر ارسال با مقدار
تمامی پارامترها (آرگومان ها) در زبان پایتون با reference پاس داده می شوند، بدین معنی که اگر آنچه یک پارامتر به آن اشاره دارد را در تابع تغییر دهید، تغییر در تابع فراخواننده نیز منعکس می شود.
#!/usr/bin/python
# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
mylist.append([1,2,3,4]);
print "Values inside the function: ", mylist
return
# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist
در اینجا reference به شی ارسالی حفظ شده و مقادیر جدید را به همان شی الصاق می کنیم. نتیجه:
Values inside the function: [10, 20, 30, [1, 2, 3, 4]]
Values outside the function: [10, 20, 30, [1, 2, 3, 4]]
یک مثال دیگر را در زیر مشاهده می کنید که آرگومان با reference ارسال شده و reference مورد نظر در تابع فراخوانده شده، بازنویسی (overwrite) شده است.
#!/usr/bin/python
# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
mylist = [1,2,3,4]; # This would assig new reference in mylist
print "Values inside the function: ", mylist
return
# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist
پارامتر mylist، نسبت به تابع changeme محلی (local) می باشد. ویرایش پارامتر مزبور در تابع موردنظر هیچ تاثیری بر روی mylist نمی گذارد. درواقع تابع هیچ کار خاصی انجام نمی دهد، نتیجه ای که از آن حاصل می گردد به شرح زیر می باشد:
Values inside the function: [1, 2, 3, 4]
Values outside the function: [10, 20, 30]
آرگومان های تابع
می توان یک تابع را به وسیله ی نوع آرگومان های لیست شده در زیر، فراخوانی کنید:
آرگومان های الزامی
آرگومان های Keyword
آرگومان های پیش فرض
آرگومان های با طول متغیر (Variable-length)
آرگومان های الزامی
آرگومان های الزامی، آرگومان هایی هستند که به ترتیب (تعریف شده) به تابع مورد نظر پاس داده می شوند. در اینجا، تعداد آرگومان هایی که در فراخوانی تابع مشخص می شود باید با تعریف تابع منطبق باشد. برای فراخوانی تابع printme()، می بایست یک آرگومان به آن ارسال کنید، در غیر این صورت خطای نحوی (syntax error) می دهد:
#!/usr/bin/python
# 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()
آرگومان های keyword
آرگومان های keyword در فراخوانی توابع مورد استفاده قرار می گیرد. هنگامی که از آرگومان های keyword در فراخوانی تابع استفاده می کنید، فراخواننده آرگومان ها را به وسیله ی اسم آن (پارامتر) شناسایی می کند. این کار به شما اجازه می دهد ترتیب آرگومان ها را تغییر دهید، زیرا که مفسر پایتون قادر است با استفاده از کلیدواژه ای ارائه شده، مقادیر را به پارامترها match (وصل) کند. می توانید تابع printme() را به ترتیب زیر فراخوانی کنید:
#!/usr/bin/python
# 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
مثال زیر تصویر روشن تری از آن ارائه می دهد. توجه داشته باشید که ترتیب پارامترها اهمیتی ندارد.
#!/usr/bin/python
# 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
آرگومان پیش فرض آرگومانی است که در صورت مشخص نکردن مقداری در فراخوانی تابع برای آن، به صورت خودکار مقدار پیش فرض می پذیرد. نمونه ی زیر نشان می دهد که مقداری برای آرگومان age (در فراخوانی تابع) تعریف نشده، با این وجود تابع دوم مقدار 50 را برای آن چاپ می کند:
#!/usr/bin/python
# 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
دوره آموزش پایتون: آرگومان های با طول متغیر (Variable-length arguments)
گاهی لازم است یک تابع را با آرگومان های بیشتری نسبت به آنچه در زمان تعریف تابع مشخص کردید، پردازش و فراخوانی کنید. این دست از آرگومان ها در اصطلاح آرگومان های با طول متغیر (variable length) خوانده می شوند و برخلاف آرگومان های الزامی و پیش فرض، در تعریف تابع ذکر نمی شوند. نحوه ی نگارش:
def functionname([formal_args,] *var_args_tuple ):
"function_docstring"
function_suite
return [expression]
علامت (*) پیش از اسم متغیر (vartuple) که دارنده ی آرگومان های متغیر nonkeyword است، درج می شود. لازم به ذکر است که این tuple، چنانچه به هنگام فراخوانی تابع (function call) هیچ آرگومان اضافی مشخص نشود، تهی باقی می ماند. مثال:
#!/usr/bin/python
# 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 functions)
توابعی که به شیوه ی معمول و با درج کلیدواژه ی def تعریف نشده اند، توابع anonymous نام دارند. برای ایجاد توابع anonymous، بایستی از کلیدواژه ی lambda استفاده نمود.
توابعی که به شکل lambda تعریف شده اند، قادراند چندین آرگومان به عنوان ورودی بپذیرند، اما فقط یک مقدار را در قالب عبارت به عنوان خروجی برمی گرداند. همچنین نمی توانند چندین دستور یا عبارت درخود داشته باشند.
یک تابع anonymous نمی تواند به صورت مستقیم برای چاپ (print) فراخوانی شود، زیرا lambda به یک عبارت نیاز دارد.
توابع lambda دارای فضای نامی محلی (local namespace) خود هستند و نمی توانند به متغیرهایی که در لیست پارامتر خود آورده نشده و نیز متغیرهایی که در فضای نامی سراسری هستند، دسترسی داشته باشند.
اگرچه بنظر می رسد که lambda ها، نسخه ی تک خطی از یک تابع هستند، با این وجود معادل دستورات درون برنامه ای (in-line statement) در زبان های C و C++ محسوب نمی شوند که هدف از آن افزایش کارایی تابع به وسیله ی ارسال پشته ی تخصیص تابع هنگام فراخوانی است.
ساختار نگارشی
سینتکس توابع lambda همان طور که در نمونه ی زیر مشاهده می کنید، شامل تنها یک خط می باشد:
lambda [arg1 [,arg2,.....argn]]:expression
در زیر نحوه ی عملکرد تابعی که به صورت lambda تعریف شده باشد، را مشاهده می کنید:
#!/usr/bin/python
# 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
دستور [expression] return عملیات تابع را به پایان می رساند و خروجی آن را برمی گرداند و در صورت لزوم یک عبارت را به فراخواننده ارسال می نماید. دستور return ای که جلوی آن هیچ آرگومانی درج نشده باشد برابر با return none می باشد. مثال های بالا هیچ مقداری را برنمی گردانند. مثال زیر یک مقدار را از تابع به صورت زیر برمی گرداند:
#!/usr/bin/python
# 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
حوزه ی دسترسی متغیر (variable scope)
امکان دسترسی به تمامی متغیرهایی که در مکان های مختلف یک برنامه قرار دارند، وجود ندارد. قابلیت دسترسی به یک متغیر درواقع به مکان تعریف متغیر بستگی دارد. حوزه ی دسترسی یا scope تعیین می کند که در چه قسمت هایی از برنامه می توانید به شناسه ی مورد نظر دسترسی داشته باشید. در کل دو نوع حوزه ی دسترسی در پایتون وجود دارد:
متغیرهای سراسری (global)
متغیرهای محلی (local)
مقایسه ی متغیر سراسری با محلی
متغیرهایی که داخل بدنه ی تابع تعریف می شوند، حوزه ی دسترسی آن ها محلی محسوب می شود. متغیرهایی که بیرون بدنه یا ساختمان تابع تعریف می شوند، متغیرهای سراسری نامیده می شوند. متغیرهای محلی را فقط می توان درون تابعی که در آن (متغیر) تعریف شده، مورد دسترسی قرار داد، در حالی که متغیرهای سراسری از تمام بخش های برنامه (توسط تابع) قابل دستیابی می باشد. به هنگام فراخوانی تابع، متغیرهای تعریف شده داخل آن همگی قابل دسترسی می باشند (در حوزه ی دسترسی قرار می گیرند). مثال:
#!/usr/bin/python
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
آموزش پایتون ادامه دارد
