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

سلام دوستان…

با آموزش پایتون همراه ما باشید :

قسمت اول آموزش Python

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

تابع یک قطعه کد سازمان دهی شده است که می توان آن را بارها فراخوانی کرده و مورد استفاده قرار داد. تابع به منظور اجرای یک عملیات خاص بکار می رود. توابع modularity (قابلیت تفکیک مولفه های سیستم و ادغام مجدد آن ها؛ در واقع modularity معماری نرم افزار را به کامپوننت هایی تقسیم می کند که پیاده سازی و نگهداشت آن را آسان می سازد) برنامه و قابلیت استفاده ی مجدد آن را بالا می برد.
همان طور که می دانید، پایتون توابع درون ساخته ی متعددی همچون print() ارائه می دهد، با این حال کاربر می تواند توابع خود را تعریف کند که به آن توابع user-defined یا توابع کاربر می گویند.

تعریف تابع

می توانید توابعی تعریف کنید که عملیات دلخواه را انجام دهد. برای تعریف توابع کاربر، بایستی از قوانین زیر پیروی کرد:

  1. قطعه کد تابع باید با کلیدواژه ی def آغاز شود. به دنبال آن اسم تابع و پرانتز درج می شود ( () ).
  2. پارامترهای ورودی یا آرگومان ها باید داخل پرانتز قرار داده شوند.
  3. اولین دستور تابع می تواند یک دستور اختیاری باشد – function_docstring.
  4. قطعه کد داخل ساختمان یا بدنه ی تابع با دو نقطه آغاز می شود، سپس دستوراتی که زیر آن قرار می گیرند، همگی توگذاشته می شوند.
  5. دستور return اجرای تابع را متوقف کرده نتیجه را برمی گرداند (جمع بندی یک سری عملیات و یا کارهایی رو نمایش می دهد) و در صورت نیاز یک عبارت را به فراخواننده پاس می دهد. دستور return None نیز یعنی هیچ مقداری را به عنوان خروجی برنگرداند.

نحوه ی نگارش (syntax):

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

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

مثال

تابع زیر یک رشته به عنوان ورودی پذیرفته و آن را چاپ می کند.

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

آموزش پایتون : فراخوانی تابع

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

123456789#!/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")

نتیجه ی زیر حاصل می گردد:

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

ارسال پارامتر با reference در برابر ارسال با مقدار

تمامی پارامترها (آرگومان ها) در زبان پایتون با reference پاس داده می شوند، بدین معنی که اگر آنچه یک پارامتر به آن اشاره دارد را در تابع تغییر دهید، تغییر در تابع فراخواننده نیز منعکس می شود.

1234567891011#!/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 به شی ارسالی حفظ شده و مقادیر جدید را به همان شی الصاق می کنیم. نتیجه:

12Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]
Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

یک مثال دیگر را در زیر مشاهده می کنید که آرگومان با reference ارسال شده و reference مورد نظر در تابع فراخوانده شده، بازنویسی (overwrite) شده است.

1234567891011#!/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 نمی گذارد. درواقع تابع هیچ کار خاصی انجام نمی دهد، نتیجه ای که از آن حاصل می گردد به شرح زیر می باشد:

12Values inside the function:  [1, 2, 3, 4]
Values outside the function:  [10, 20, 30]

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

می توان یک تابع را به وسیله ی نوع آرگومان های لیست شده در زیر، فراخوانی کنید:

  1. آرگومان های الزامی
  2. آرگومان های Keyword
  3. آرگومان های پیش فرض
  4. آرگومان های با طول متغیر (Variable-length)

آرگومان های الزامی

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

12345678#!/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() را به ترتیب زیر فراخوانی کنید:

12345678#!/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")

کد بالا پس از اجرا، نتیجه ی زیر را بدست می دهد:

1My string

مثال زیر تصویر روشن تری از آن ارائه می دهد. توجه داشته باشید که ترتیب پارامترها اهمیتی ندارد.

123456789#!/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" )

خروجی:

12Name:  miki
Age  50

آرگومان پیش فرض آرگومانی است که در صورت مشخص نکردن مقداری در فراخوانی تابع برای آن، به صورت خودکار مقدار پیش فرض می پذیرد. نمونه ی زیر نشان می دهد که مقداری برای آرگومان age (در فراخوانی تابع) تعریف نشده، با این وجود تابع دوم مقدار 50 را برای آن چاپ می کند:

12345678910#!/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" )

نتیجه:

1234Name:  miki
Age  50
Name:  miki
Age  35

دوره آموزش پایتون: آرگومان های با طول متغیر (Variable-length arguments)

گاهی لازم است یک تابع را با آرگومان های بیشتری نسبت به آنچه در زمان تعریف تابع مشخص کردید، پردازش و فراخوانی کنید. این دست از آرگومان ها در اصطلاح آرگومان های با طول متغیر (variable length) خوانده می شوند و برخلاف آرگومان های الزامی و پیش فرض، در تعریف تابع ذکر نمی شوند.
نحوه ی نگارش:

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

علامت (*) پیش از اسم متغیر (vartuple) که دارنده ی آرگومان های متغیر nonkeyword است، درج می شود. لازم به ذکر است که این tuple، چنانچه به هنگام فراخوانی تابع (function call) هیچ آرگومان اضافی مشخص نشود، تهی باقی می ماند. مثال:

123456789101112#!/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 استفاده نمود.

  1. توابعی که به شکل lambda تعریف شده اند، قادراند چندین آرگومان به عنوان ورودی بپذیرند، اما فقط یک مقدار را در قالب عبارت به عنوان خروجی برمی گرداند. همچنین نمی توانند چندین دستور یا عبارت درخود داشته باشند.
  2. یک تابع anonymous نمی تواند به صورت مستقیم برای چاپ (print) فراخوانی شود، زیرا lambda به یک عبارت نیاز دارد.
  3. توابع lambda دارای فضای نامی محلی (local namespace) خود هستند و نمی توانند به متغیرهایی که در لیست پارامتر خود آورده نشده و نیز متغیرهایی که در فضای نامی سراسری هستند، دسترسی داشته باشند.
  4. اگرچه بنظر می رسد که lambda ها، نسخه ی تک خطی از یک تابع هستند، با این وجود معادل دستورات درون برنامه ای (in-line statement) در زبان های C و C++ محسوب نمی شوند که هدف از آن افزایش کارایی تابع به وسیله ی ارسال پشته ی تخصیص تابع هنگام فراخوانی است.

ساختار نگارشی

سینتکس توابع lambda همان طور که در نمونه ی زیر مشاهده می کنید، شامل تنها یک خط می باشد:

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

در زیر نحوه ی عملکرد تابعی که به صورت lambda تعریف شده باشد، را مشاهده می کنید:

1234567#!/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 می باشد.
مثال های بالا هیچ مقداری را برنمی گردانند. مثال زیر یک مقدار را از تابع به صورت زیر برمی گرداند:

12345678910#!/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

نتیجه ی آن را در زیر مشاهده می کنید:

12Inside the function :  30
Outside the function :  30

حوزه ی دسترسی متغیر (variable scope)

امکان دسترسی به تمامی متغیرهایی که در مکان های مختلف یک برنامه قرار دارند، وجود ندارد. قابلیت دسترسی به یک متغیر درواقع به مکان تعریف متغیر بستگی دارد.
حوزه ی دسترسی یا scope تعیین می کند که در چه قسمت هایی از برنامه می توانید به شناسه ی مورد نظر دسترسی داشته باشید. در کل دو نوع حوزه ی دسترسی در پایتون وجود دارد:

  1. متغیرهای سراسری (global)
  2. متغیرهای محلی (local)

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

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

1234567891011#!/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

نتیجه:

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

آموزش پایتون ادامه دارد

نویسنده مطلب: Diamond

منبع مطلب

به فکر سرمایه‌گذاری هستی؟

با هر سطحی از دانش در سریع‌ترین زمان با آموزش گام به گام، سرمایه گذاری را تجربه کن. همین الان میتونی با لینک زیر ثبت نام کنی و ۱۰ درصد تخفیف در کارمزد معاملاتی داشته باشی

ثبت نام و دریافت جایزه
ممکن است شما بپسندید
نظر شما درباره این مطلب

آدرس ایمیل شما منتشر نخواهد شد.