در این ویدیو با تابع در پایتون آشنا خواهید شد. در این ویدیو میفهمید که تابع در پایتون چیست، نحو ایجاد کردن تابع در پایتون به چه شکل است، اجزا و انواع تابع در پایتون چیست. هر تابع در پایتون قطعه کدی است که فقط در زمان فراخوانی، اجرا میشود. مثلا زمانی که از print برای چاپ کردن چیزی استفاده میکردید، در واقع داشتید یک تابع پایتون را فراخوانی میکردید. فراخوانی تابع میتواند به هر تعداد انجام شود و محدودیتی برای اینکار وجود ندارد.
توابع میتوانند در زمان فراخوانی مقادیری را دریافت کرده و در صورت نیاز نتیجه خاصی را برگشت(return) دهند. به مقادیری که به تابع ارسال میشود پارامتر(parameter) گفته میشود.
هر تابع(Function) یک وظیفه مشخص دارد که در زمان فراخوانی آن را انجام میدهد مثلا از تابع len پایتون برای گرفتن تعداد آیتم های یک آبجکت استفاده میشود. استفاده از توابع باعث میشود کدتان ماژولارتر و تکرار کد کمتر شود و بتوانید از یک قطعه کد چندین بار استفاده کنید.
پایتون دارای 71 تابع داخلی است که لیست آنها را میتوانید از اینجا مشاهده کنید. توابع پایتون به همین تعداد محدود نمیشوند و تعداد خیلی بیشتری وجود دارند اما بقیه توابع پایتون در ماژول های دیگر قرار دارند که برای استفاده از آنها باید import شوند.
تعریف تابع با کلمه کلیدی def پایتون
شما می توانید با دستور def یک تابع در پایتون را برای انجام کار مورد نیاز خود تعریف کنید. در اینجا قوانین ساده ای برای تعریف تابع در پایتون وجود دارد:
- بلوک های تابع با کلمه کلیدی def و سپس نام تابع و پرانتز ( ) شروع می شوند.
- هر پارامتر یا آرگومان ورودی باید در داخل این پرانتز قرار گیرد.
- اولین دستور یک تابع می تواند یک docstring اختیاری باشد.
- بلوک کد در هر تابع با دونقطه (:) شروع می شود و تورفتگی دارد.
- عبارت return [expression] از یک تابع خارج می شود و به صورت اختیاری یک عبارت را به اجرا کننده پس می دهد.
برای نامگذاری توابع در پایتون، PEP8 توصیه میکند از حروف کوچک استفاده کرده و کلمات را با underscore جدا کنید. مثلا hello_user. البته این قاعده فقط یک پیشنهاد است و میتوانید از آن تبعیت نکنید.
نحو تابع در پایتون
ساختار کلی تابع در پایتون به شکل زیر است:
به‌طور پیشفرض، پارامترها به موقعیت خود حساس هستند و باید به همان ترتیبی که تعریف شده‌اند، مقداردهی شوند.
مثال از تابع
به طور مثال در کد زیر یک تابع به نام greeting ساختیم که در صورت فراخوانی مقدار Hello را چاپ خواهد کرد:
def greeting():
print('Hello')
در پایتون نام تمام توابع باید منحصر به فرد باشد و نمیتوانید نام تکراری برای توابعتان انتخاب کنید.
در پایتون همه چیز یک آبجکت است. در کد بالا شما یک آبجکت function به نام greeting ایجاد کردید. برای اثبات این موضوع میتوانید از تابع type استفاده کنید:
>>> type(greeting)
<class 'function'>
در پایتون میتوانید توابعی ایجاد کنید که بدنه نداشته باشند. برای اینکار میتوانید از کلمه کلیدی pass پایتون یا یک docstring استفاده کنید:
def greeting():
pass
def greeting():
"""This is a empty function"""
در کد بالا هر دو توابع بدون بدنه هستند و در صورت فراخوانی هیچ اتفاقی نخواهد افتاد.
فراخوانی تابع در پایتون
کلمه کلیدی def پایتون فقط یک تابع را تعریف کرده و پارامترهای آن را مشخص میکند و تاثیری در اجرای آن ندارد. بدنه تابع تا زمانی که نام تابع فراخوانی(call) نشود، اجرا نخواهد شد. مثلا در قطعه کد پایین، درست است که تابع greeting را ساخته ایم اما هرگز اجرا نخواهد شد:
def greeting():
print('Hello')
برای اجرای یک تابع باید نام آن را همراه یک جفت پرانتز استفاده کنید:
>>> greeting()
Hello
دقت کنید که در زمان فراخوانی تابع اگر پرانتز را قرار ندهید، آبجکت تابع را برگشت خواهد داد:
>>> greeting
<class 'function'>
دستور return پایتون
در قطعه کدی که بالا دیدید، تابع greeting در صورت فراخوانی یک مقدار را چاپ میکرد. اما توابع پایتون قرار نیست همیشه یک مقدار را چاپ کنند. در اکثر مواقع نیاز داریم که تابع بعد از انجام عملیات، نتیجه نهایی را برگشت دهد. مثلا در تابع greeting میخواهیم به جای چاپ کردن مقدار Hello، آن را برگشت دهد. در اینصورت میتوانیم از دستور return استفاده کنیم:
def greeting():
return 'Hello'
greeting()
همانطور که در کد بالا میبینید بعد از فراخوانی تابع greeting چیزی چاپ نمیشود، به خاطر اینکه نتیجه را به جای چاپ، برگشت دادیم. دستور return پایتون یکی از اجزای کلیدی توابع و متدها است. با دستور return میتوانید مطمئن شوید که نتیجه نهایی به صدا زننده تابع، برگشت داده خواهد شد. به نتیجه ای که برگشت داده میشود مقدار بازگشتی یا return value گفته میشود.
در کد بالا به صورت صریح یک مقدار را به دستور return دادیم اما اگر دستور return را بدون مقدار استفاده کنید به طور پیشفرض مقدار None برگشت داده خواهد شد:
>>> def greeting():
>>> return
>>> greeting()
None
دقت کنید که return اجرای تابع را متوقف خواهد کرد و دستورات بعد از return هرگز اجرا نخواهند شد:
def greeting():
return 'Hello'
print('How are you?')
در کد بالا، از آنجایی که دستور print بعد از return قرار گرفته است، هرگز اجرا نخواهد شد.
در پایتون نمیتوانید در یک تابع دو بار از return استفاده کنید و اینکار باعث میشود که فقط دستور return اول اجرا شود و بقیه دستورات return توسط مفسر پایتون نادیده گرفته شوند:
def greeting():
return 'Hello'
return 'Hi'
در کد بالا، فقط دستور return اول اجرا خواهد شد و دستور return دوم هرگز اجرا نخواهد شد. اما اگر نیاز داشتید که در یک تابع پایتون چند مقدار را برگشت دهید میتوانید از دستور return به همراه کاما استفاده کنید:
def greeting():
return 'Hello', 'Hi', 'Hey'
در کد بالا، سه مقدار را همزمان برگشت میدهیم.
انواع تابع در پایتون
تابع در پایتون به سه نوع تقسیم می شود:
- توابع داخلی که به آنها Built-in Functions گفته میشود.
- توابع ساخته شده توسط کاربر که User-Defined Functions نامیده میشوند.
- توابع ناشناس که با نام Anonymous functions نیز شناخته میشوند.
در این قسمت انواع تابع در پایتون توضیح میدهیم.
توابع داخلی پایتون
توابع داخلی یا built-in functions به توابعی گفته میشود که عملکرد آنها به صورت پیشفرض در مفسر پایتون قرار گرفته است و برای استفاده از آنها فقط کافیست نام آن تابع را فراخوانی کنید. در لیست زیر چند مورد از مهم ترین توابع داخلی پایتون را برایتان آورده ایم:
- تابع print که برای چاپ مقدار در خروجی استفاده میشود.
- تابع input که برای گرفتن ورودی از کاربر استفاده میشود.
- تابع sorted که برای مرتب کردن آبجکت ها استفاده میشود.
- تابع round که برای گرد کردن اعداد استفاده میشود.
- تابع type که برای مشخص کردن نوع یک آبجکت استفاده میشود.
- تابع max که برای مشخص کردن بیشترین مقدار استفاده میشود.
- تابع sum که برای جمع کردن چند عدد استفاده میشود.
در این بخش فقط تعداد کمی از توابع داخلی پایتون را دیدید. پایتون دارای 71 تابع داخلی است.
توابع ساخته توسط کاربر در پایتون
پایتون دارای توابع داخلی مفید بسیاری است. این توابع یک کار از پیش تعریف شده را انجام می دهند و می توانند در هر برنامه ای بنا به نیاز فراخوانی شوند. با این حال، اگر یک تابع داخلی مناسب برای هدف خود پیدا نکردید، می توانید یک تابع را ایجاد کنید. به این نوع توابع که توسط شخص برنامه نویس ایجاد میشوند User defined functions گفته میشود.
همانطور که در قسمت قبل دیدید برای ساخت یک تابع باید از کلمه کلیدی def استفاده کنید:
def show():
pass
در قطعه کد بالا یک تابع به نام show ایجاد کردیم.
توابع ناشناس در پایتون
در پایتون، توابع ناشناس به توابعی گفته میشود که بدون نام باشند. در حالی که توابع معمولی با کلمه کلیدی def ساخته میشوند، برای ساخت توابع ناشناس باید از کلمه کلیدی lambda استفاده کنید. به همین دلیل توابع ناشناس، توابع لامبدا نیز نامیده میشوند.
ساختار توابع لامبدا به شکل زیر است:
double = lambda x: x * 2
print(double(5))
در کد بالا با استفاده از توابع ناشناس تابعی نوشتیم که یک عدد گرفته و آن را ضربدر دو میکند.
کار با آرگومان های توابع پایتون
در بخش های قبل در رابطه با اطلاعاتی که میتوانید به توابع پایتون ارسال کنید صحبت شد. تابع در پایتون میتواند دارای ورودی باشند. این ورودی ها اطلاعاتی هستند که یک تابع پایتون ممکن است به آن ها نیاز داشته باشد. به این ورودی ها آرگومان یا پارامتر گفته میشود. وجود آرگومان اجباری نبوده و فقط در صورت نیاز میتوانید آنها را مشخص کنید.
آرگومان های توابع بعد از نام تابع و در داخل پرانتز مشخص میشوند. محدودیتی در تعداد آرگومان وجود ندارد و هر تعداد که بخواهید میتوانید آرگومان مشخص کنید، فقط کافیست آنها را با علامت کاما از هم جدا کنید.
تفاوت پارامتر و آرگومان
بسیاری از برنامه نویسان کلمات پارامتر و آرگومان را به جای هم استفاده میکنند و گمان میکنند که این دو با هم تفاوتی ندارند. کلمات آرگومان و پارامتر هر دو به اطلاعات ورودی به تابع اشاره میکنند اما با جهتی متفاوت.
یک پارامتر(parameter) به ورودی هایی گفته میشود که در تعریف تابع مشخص شده اند. مثلا در کد زیر، تابع greeting دارای یک پارامتر به نام name است.
def greeting(name):
pass
اما آرگومان(argument) که به صورت مختصر args هم خوانده میشود، به اطلاعاتی گفته میشود که در زمان فراخوانی تابع به آن ارسال میشود. مثلا در کد زیر مقدار amir را به عنوان آرگومان به تابع greeting ارسال کردیم:
greeting('amir')
میتوانید از کلمات آرگومان و پارامتر به جای یکدیگر استفاده کنید و اشکالی ندارد اما دانستن تفاوت بین این دو مهم است.
انواع آرگومان در پایتون
در توابع پایتون 5 نوع آرگومان وجود دارد میتوانید با استفاده از آنها، یک تابع را فراخوانی کنید:
- آرگومان های اجباری
- آرگومان های کلید واژه
- آرگومان هایی با مقدار پیشفرض
- آرگومان هایی با تعداد نامشخص
- آرگومان های کلید واژه با تعداد نامشخص
آرگومان‌های اجباری در توابع پایتون
آرگومان های اجباری(positional arguments) به آرگومان هایی گفته میشود که در زمان فراخوانی تابع، به همان ترتیبی که مشخص شده اند باید ارسال شوند. در این حالت، تعداد آرگومان هایی که به فراخوانی تابع ارسال شده اند باید با آرگومان های مشخص شده در تابع برابر باشند.
در کد زیر، تابعی به نام greeting داریم که یک آرگومان به نام name را میگیرد:
def greeting(name):
print(name)
از آنجایی که آرگومان name اجباری است، در زمان فراخوانی تابع حتما باید ارسال شود، در غیر اینصورت با خطا مواجه خواهید شد:
>>> greeting()
TypeError: greeting() missing 1 required positional argument: 'name'
>>> greeting('amir')
amir
آرگومان‌های کلید واژه در توابع پایتون
آرگومان های کلیدواژه(keyword arguments) به فراخوانی تابع مربوط می شوند. هنگامی که از آرگومان های کلیدواژه در فراخوانی تابع استفاده می کنید باید نام پارامترها را نیز مشخص کنید. با این روش میتوانید ترتیب آرگومان ها را تغییر دهید زیرا مفسر پایتون میتواند از کلمات کلیدی رائه شده برای تطبیق مقادیر پارامترها استفاده کند.
به کد زیر دقت کنید:
def greeting(name, age):
pass
در کد بالا، تابع greeting به دو آرگومان name و age نیاز دارد. در فراخوانی عادی باید برای ارسال آرگومان ها ترتیب را رعایت کنید اما میتوانید با مشخص کردن نام پارامتر، بدون ترتیب اطلاعات را ارسال کنید:
greeting(age=12, name='amir')
آرگومان‌های با مقدار پیشفرض در توابع پایتون
در توابع پایتون میتوانید به آرگومان ها مقدار پیشفرض اختصاص دهید تا اگر در زمان فراخوانی آرگومانی ارسال نشد از مقدار پیشفرض استفاده شود. آرگومان های با مقدار پیشفرض(default arguments) اختیاری هستند و در زمان فراخوانی تابع اجباری در مقداردهی آنها وجود ندارد اما اگر مقداردهی شوند، مقدار پیشفرض خود را نادیده خواهند گرفت. دقت کنید که آرگومان های با مقدار پیشفرض حتما باید بعد از آرگومان های اجباری قرار داشته باشند:
def greeting(name, age=0):
pass
تابع greeting بالا دارای دو آرگومان است که آرگومان name اجباری و آرگومان age دارای مقدار پیشفرض است. در زمان فراخوانی تابع بالا میتوانید مقدار age را ارسال نکنید اما آرگومان name اجباری است:
greeting('amir')
همچنین میتوانید بدون رعایت ترتیب، آرگومان ها را ارسال کنید اما باید حتما از آرگومان های کلید واژه استفاده کنید:
greeting(name='amir', age=12)
آرگومان های با تعداد نامشخص در توابع پایتون
اگر تعداد آرگومان هایی که قرار است به تابع ارسال شوند مشخص نیست میتوانید از علامت ستاره(*) استفاده کنید. دقت کنید که علامت ستاره فقط برای آرگومان های عادی است و برای آرگومان های کلید واژه کار نخواهد کرد. آرگومان هایی که از طریق ستاره جذب میشوند در یک تاپل ذخیره شده و در دسترس هستند. آرگومان های با تعداد نامشخص(arbitrary positional argument) باید آخرین آرگومان در تعریف تابع باشد.
به کد زیر دقت کنید:
def greeting(name, *args):
pass
در تابع بالا، آرگومان name اجباری بوده و باید ارسال شود و بقیه آرگومان های ارسال در args ذخیره میشوند. تابع بالا را میتوانید به حالت های زیر فراخوانی کنید:
greeting('amir')
greeting('amir', 'jack')
greeting('amir', 'kevin', 12, ['a', 'b'])
آرگومان های کلید واژه با تعداد نامشخص در توابع پایتون
اگر قرار است تابع شما تعداد آرگومان نامشخصی را به شکل کلید واژه دریافت کند، میتوانید از دو ستاره(**) استفاده کنید. در این روش که arbitrary keyword argument نامیده میشود، آرگومان ها در یک دیکشنری ذخیره شده و در دسترس هستند. آرگومان دو ستاره باید در آخرین مکان باشد، حتی بعد از آرگومان های یک ستاره.
به کد زیر دقت کنید:
def greeting(name, *args, **kwargs):
pass
در تابع بالا، آرگومان name اجباری است و حتما باید ارسال شود. آرگومان هایی که به شکل عادی ارسال میشوند در args و آرگومان هایی که به شکل کلید مقدار ارسال میشوند نیز در kwargs ذخیره میشوند. تابع بالا را میتوانید به حالت های زیر فراخوانی کنید:
greeting('amir')
greeting('amir', 'jack')
greeting('amir', 'kevin', 12, city='Tehran', code='+98')
ارسال نظر