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

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

به کمک این تابع، دستورات مربوط به چاپ یک رشته متنی پایتون فراخوانی شده و در خروجی چاپ می‌شود. فرض کنید بخواهید برای هر بار چاپ متن، تمام دستورات مرتبط با چاپ را هم بنویسید!

در این صورت دو مشکل عمده برایمان به وجود می‌آید:

• کدهای طولانی و شلوغی خواهیم داشت.
• اگر نیاز به تغییر یک بخش از کد (در این مثال در فرآیند چاپ متن) باشد، مجبوریم تمام بخش‌هایی که این قطعه کد را نوشته‌ایم تغییر دهیم.

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

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

توابع در پایتون (Python Functions) دارای ساختار مشخصی هستند. برای این که هر قطعه کد را شناسایی کنیم، باید برای آن‌ها یک اسم در نظر بگیریم. پس تمام توابع دارای یک اسم یکتا هستند.

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

فرض کنید می‌خواهیم یک تابع با نام myprint() بنویسیم. این تابع یک رشته متنی را در خروجی پایتون چاپ می‌کند. برای چاپ از print() استفاده می‌کنیم.

در جلود نام تابع علامت دو نقطه قرار داده و بدنه تابع را با یک فرورفتگی می‌نویسیم:

def myprint():    print("Some Text from winlearn")

تبریک! شما اولین تابع خود را با زبان پایتون نوشتید! حالا بیایید و یک تابع حرفه‌ای ایجاد کنیم…

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

در خط دوم و دقیقاً پس از تعریف تابع، با قرار دادن یک رشته‌ی متنی کامنت شده با '''، می‌توانیم توضیحاتی درباره تابع بنویسیم. این توضیحات دلخواه بوده و برای توسعه‌های بعدی یا هنگام کار با IDEهای برنامه‌نویسی کاربرد خواهد داشت.

در قطعه کد زیر، من یک توضیح ساده برای تابع خود نوشته‌ام.

def myprint():    ''' This Simple Function Will Print a Static Text '''    print("Some Text from SabzDanesh.com")

ورودی تابع

تابع myprint() که در اینجا تعریف کردیم، همیشه یک متن ثابت را چاپ می‌کند. اگر بخواهیم رشته‌ی مورد نظر را در زمان فراخوانی به تابع بدهیم، باید برای تابع خود ورودی تعریف کنیم.

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

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

def myFunction( arg1, arg2, arg3 ):    # Some Codes Here

وقتی یک تابع با ورودی‌هایش صدا زده می‌شود، مقادیر ورودی درون این متغیرها قرار می‌گیرند. در نتیجه برای خواندن آن مقادیر در بدنه اصلی تابع از این متغیرها (در این جا arg1 ، arg2 و arg3) کمک می‌گیریم. (بیشتر بدانید: انواع متغیر در پایتون)

خروجی تابع

برخی از توابع باید یک خروجی به ما بدهند. برای مثال فرض کنید تابع add() را برای جمع کردن دو عدد تعریف می‌کنیم. این تابع باید دو ورودی و یک خروجی داشته باشد.

ورودی‌ها همان اعداد مورد نظر برای عملیات جمع بوده و خروجی، حاصل جمع ما خواهد بود.

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

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

برای اینکه معنی دقیق خروجی تابع را متوجه شوید، به مثال زیر توجه کنید.

a = input("Enter First Number: ")
b = input("Enter Second Number: ")
result = add(a,b)
print(result)

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

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

تعریف و استفاده از توابع در پایتون به همین سادگی است! در ادامه ۲ ترفند و ۲ نکته برای حرفه‌ای‌تر شدن در هنگام کار با توابع با شما مطرح می‌کنم.

ارسال پارامتر با ارجاع (رفرنس)

تمام پارامترهایی که به صورت شئ هستند، در زبان پایتون با ارجاع (Reference) فراخوانی می‌شوند. برای درک بهتر موضوع، اجازه دهید با یک مثال ادامه دهیم.

فرض کنید تابعی دارید که یک لیست به عنوان ورودی می‌گیرد. سپس آن را مرتب کرده و در محیط برنامه چاپ می‌کند.

def list_sort( lst ):    lst.sort()    print( "Sorted List is: ", lst )

حال یک لیست با مقادیر بهم‌ریخته ایجاد کرده و آن را به تابع می‌دهیم تا نتیجه را به ما نمایش دهد.

mylist = [21, 15, 36, 18, 27]
list_sort( mylist )

خروجی کد بالا چیزی شبیه زیر را به ما خواهد داد:

Sorted List is:  [15, 18, 21, 27, 36]

حال اگر مقدار mylist را چاپ کنیم؛ با کمال تعجب می‌بینیم که لیست ما که بیرون از تابع بوده هم به صورت صعودی مرتب شده است!

print( mylist )
# [15, 18, 21, 27, 36]

اما چرا ؟

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

توابع ناشناس به صورت معمول و با کلمه کلیدی def تعریف نمی‌شوند. برای تعریف آن‌ها از کلمه کلیدی lambda استفاده می‌شود؛ به همین خاطر گاهی اوقات به آن‌ها تابع Lambda هم گفته می‌شود.

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

تعریف توابع ناشناس پایتون به صورت زیر است:

lambda arg1, arg2: arg1 + arg2

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

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

pw = lambda a, b: a**b
print( pw(2,3) )
# 8

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

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

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

1. آرگومان‌های ضروری
2. آرگومان‌های کلمه کلیدی
3. آرگومان با مقدار پیش‌فرض
4. آرگومان با تعداد نامشخص

تعریف آرگومان ضروری برای تابع پایتون

در مثال‌هایی که تا به اینجای آموزش زدیم، تماماً از آرگومان‌های ضروری استفاده شده است. آرگومان ضروری (Required Argument) آرگومانی است که باید در هنگام صدا زده شدن تابع، مقداردهی شود.

مثال تابع add() برای جمع دو عدد را به خاطر بیاورید.

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

اگر تابع را بدون آرگومان، با یک آرگومان یا با بیش از دو آرگومان صدا بزنیم، با خطای TypeError مواجه خواهیم شد.

add( 5 )
# Traceback (most recent call last):
#   File "run.py", line 7, in <module>
#     add( 5 )
# TypeError: add() missing 1 required positional argument: 'b'

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

تعریف آرگومان کلمه کلیدی

این نوع تعریف آرگومان هیچ فرقی با تعریف عادی ندارد. تفاوت آرگومان‌های کلمه کلیدی (Keyword Argument) بر روی نحوه صدا زدن آن‌هاست.

فرض کنید تابع pw() در زیر را برای به توان رساندن عدد در اختیار داریم.

def pw( base, power ):    print( base**power )

برای فراخوانی تابع می‌توانیم به صورت زیر عمل کنیم.

pw( 2, 3 )
# 8

حالت دیگر (فراخوانی به کمک کلمه کلیدی) همین تابع به صورت زیر است.

pw( base=2, power=3 )
# 8
pw( power=3, base=2 )
# 8

همانطور که در این مثال می‌بینید، در این نوع فراخوانی، ترتیب ورودی‌ها اهمیتی ندارد. هر ورودی با توجه به نام آن شناخته و مقداردهی خواهد شد.

تعریف آرگومان با مقدار پیش‌فرض در پایتون

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

در آخرین مثال، می‌خواهیم تابع را طوری تغییر دهیم که اگر ورودی توان (power) تعریف نشد، مقدارش برابر 1 شود. برای این کار به صورت زیر عمل می‌کنیم.

def pw( base, power=1 ):    print( base**power )

به همین سادگی! با قرار دادن علامت مساوی (=) و تعریف مقدار مورد نظر، یک مقدار پیش‌فرض برای آرگومان در نظر گرفته‌ایم.

به کمک این روش عملاً یک آرگومان دلخواه برای تابع پایتون تعریف شده است.

آرگومان ورودی نامحدود برای تابع

در معدود توابعی تعداد ورودی‌ها از قبل مشخص نیست یا به طور دقیق‌تر، می‌خواهیم تعداد آرگومان‌ها متغیر باشد. برای تعریف تعداد آرگومان متغیر برای تابع پایتون، از روش آرگومان طول متغیر (Variable-Length Arguments) استفاده می‌شود.

می‌خواهیم یک تابع برای محاسبه میانگین اعداد بنویسیم. برای گرفتن ورودی دو روش داریم:

روش اول استفاده از یک لیست برای گرفتن اعداد است و روش دوم استفاده از آرگومان با طول متغیر.

برای تعریف آرگومان با طول متغیر، کافی است قبل از اسم متغیر ورودی، علامت ستاره (*) قرار دهیم. با این کار تمام ورودی‌های بعد از آن متغیر، به صورت تاپل پایتون (tuple) درون آن متغیر قرار گرفته و در بدنه‌ی تابع در دسترس ما خواهند بود.

تابع average() را به کمک حلقه for پایتون برای محاسبه میانگین تعداد نامشخصی از اعداد را به صورت زیر می‌نویسیم.

def average( *vals ):    total = 0    for val in vals:        total += val    return total/len(vals)

حال این تابع را با هر تعداد آرگومان ورودی که می‌خواهیم می‌توان صدا زد!

average(5)
# 5.0
average(1, 2, 3, 4, 5)
# 3.0
average(1, 3, 5, 7, 9, 11, 13, 15)
# 8.0

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

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

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

• بخش نام و تعریف ورودی‌ها
• بخش بدنه اصلی
• بخش پایانی

در بخش پایانی تابع با کمک return می‌توانیم مقادیر محاسبه شده‌ی نهایی را به عنوان خروجی تابع برگردانیم.

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