معرفی و ساخت تابع در پایتون

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

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

تابع در پایتون چیست و چه کاربردی دارد؟

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

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

مفهوم تابع در ریاضیات مشابه است. در ریاضی، یک تابع معمولاً ورودی‌ را می‌گیرد و بر اساس آن ورودی، خروجی‌ تولید می‌کند. اما در برنامه‌نویسی، توابع می‌توانند ویژگی‌های متفاوتی داشته باشند. به طور مثال:

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

توابع داخلی پایتون (Built-in Functions)

زمانی که مفسر پایتون را نصب می‌کنیم، مجموعه‌ای از توابع آماده نیز به همراه آن نصب می‌شوند که به آن‌ها توابع داخلی یا Built-in Functions گفته می‌شود. این توابع بدون نیاز به تعریف قبلی، در دسترس ما هستند و می‌توانیم به‌راحتی از آن‌ها در کدنویسی استفاده کنیم.من در این فصل، توابع داخلی پایتون را بر اساس مستندات رسمی پایتون (نسخه 3.13) معرفی خواهم کرد. این مستندات از وب‌سایت رسمی قابل دسترسی هستند و شامل توضیحات کامل و مثال‌هایی برای هر تابع می‌باشند.

برخی از توابع داخلی که احتمالاً تاکنون با آن‌ها آشنا شده‌اید یا در آینده بیشتر با آن‌ها کار خواهید کرد، عبارت‌اند از:

• ()print: برای چاپ اطلاعات در خروجی
• ()range: برای تولید دنباله‌ای از اعداد
• ()abs: برای محاسبه قدر مطلق یک عدد

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

مزایای استفاده از توابع در برنامه‌نویسی

شاید بپرسید فایده استفاده از توابع در برنامه‌نویسی چیست؟

 اولین سودی که استفاده از توابع به ما می‌رساند، به اصطلاح (Abstrction and Reusability) نامیده می‌شود.
فرض کنید در پروژه خود چند خط کد دارید که می‌خواهید در چندین بخش از برنامه تکرار کنید. اگر این کدها را مستقیماً در هر بخش کپی و پیست کنید، نه‌تنها باعث شلوغی و افزایش حجم کد می‌شود، بلکه در صورت نیاز به ایجاد تغییر، باید همه نسخه‌های کپی‌شده را اصلاح کنید که بسیار زمان‌بر و پرخطر است.
در عوض، اگر همان قطعه کد را در قالب یک تابع بنویسید، کافی است تنها یک بار آن را تعریف کرده و در هر جایی که نیاز دارید آن را فراخوانی کنید. این کار باعث:

• کاهش تکرار کد
• افزایش خوانایی
• سهولت در نگهداری و ویرایش
• کاهش احتمال بروز خطا در آینده

می‌شود.

در واقع، منظور از استفاده از توابع این است که شما برای جلوگیری از تکرار مداوم کدها، کارهای مشابه را در قالب یک تابع تعریف می‌کنید. این کار باعث می‌شود که کد شما کوتاه‌تر و سازمان‌دهی‌شده‌تر شود. ما در برنامه‌نویسی یک قانون داریم که به DRY (Don't Repeat Yourself) معروف است، که به این معنی است که از تکرار مداوم کدها خودداری کنید و به جای آن، راهی خلاقانه برای حل مشکل پیدا کنید. این قانون به شما کمک می‌کند تا کدهای خود را به گونه‌ای بنویسید که بتوانید بارها و بارها از آن‌ها استفاده کنید، بدون اینکه نیاز باشد همان کد را دوباره و دوباره بنویسید. یکی از مزایای اصلی این روش، کاهش پیچیدگی در برنامه است.

تقسیم وظایف پیچیده به بخش‌های کوچک‌تر با استفاده از توابع (Modularity)

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

• خواندن اطلاعات از فایل
• انجام محاسبات
• نوشتن نتایج به فایل

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

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

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

در پایان، اگر علاقه‌مند هستید درباره تعریف و کاربرد توابع در پایتون بیشتر بدانید، پیشنهاد می‌کنم مقاله‌ای بسیار مفید از وب‌سایت رسمی پایتون را مطالعه کنید. این مقاله با عنوان "Defining Functions" در سایت منتشر شده و در آن به‌صورت کامل، اصول تعریف، استفاده و مزایای توابع توضیح داده شده است. در بخش‌های ابتدایی این مقاله، دقیقاً موضوعاتی که در این فصل مطرح شد (مثل DRY، ساختار ماژولار و مزایای توابع) با مثال‌های کاربردی مورد بررسی قرار گرفته است.

آموزش تعریف تابع در پایتون (Python Function)

برای تعریف تابع در زبان برنامه‌نویسی پایتون، از کلمه کلیدی  def  استفاده می‌کنیم. این کلمه مخفف define به معنی "تعریف کردن" است. پس از آن، باید یک نام مناسب برای تابع خود انتخاب کنیم؛ همان‌طور که توابع آماده‌ای مثل ()print یا ()len در پایتون نام دارند. 

• بلوک کد با تورفتگی (indentation): مثل حلقه‌ها و شرط‌ها، بدنه‌ی تابع باید با تورفتگی مشخص شود.
• pass: زمانی استفاده می‌شود که فعلاً نمی‌خواهیم داخل تابع چیزی بنویسیم، ولی ساختار آن را نگه می‌داریم.

نحوه‌ی استفاده از تابع تعریف‌شده

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

def my_function():
    pass

my_function()

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

• نباید با عدد شروع شود
• نباید از کلمات رزروشده‌ی پایتون (مثل if, for, def و...) استفاده شود.
• بهتر است از حروف کوچک استفاده شود.
• باید معنی‌دار و توصیفی باشد (مثلاً calculate_salary بهتر از cs است).

استاندارد PEP 8 برای نام‌گذاری توابع

پایتون دارای یک راهنمای رسمی برای نگارش کد به نام PEP 8 است. این راهنما توسط سازنده‌ی پایتون، Guido van Rossum، نوشته شده و در آن درباره‌ی نگارش استاندارد کد پایتون صحبت شده است.

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

برای مطالعه‌ی بیشتر می‌توانید به صفحه PEP 8 در وب‌سایت رسمی پایتون مراجعه کنید.

تابع بدون ورودی و خروجی

یکی از ویژگی‌های مهم توابع در پایتون این است که می‌توانند بدون ورودی و خروجی باشند. این بدان معناست که تابع تنها وظیفه‌ای خاص را انجام می‌دهد (مثل چاپ یک پیغام در کنسول) و هیچ داده‌ای از بیرون دریافت نمی‌کند و هیچ داده‌ای هم به بیرون ارسال نمی‌کند.

در این مثال، تابعی تعریف می‌کنیم که فقط یک پیغام مشخص را در کنسول چاپ می‌کند:

def print_hello():
    print("Hello world!!!")

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

هر بار که این تابع را صدا بزنیم، همان پیغام چاپ می‌شود.

خلاصه و جمع بندی:

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

• انتزاع (Abstraction): توابع با پنهان‌سازی جزئیات پیاده‌سازی، سطح بالاتری از انتزاع را در برنامه ایجاد می‌کنند. این امر موجب می‌شود که برنامه‌نویس بتواند به جای تمرکز بر جزئیات اجرایی، بر منطق کلی برنامه تمرکز کند.
• ماژولاریتی (Modularity): توابع برنامه را به بخش‌های کوچکتر و مستقل تقسیم می‌کنند که هر کدام وظیفه مشخصی را انجام می‌دهند. این امر باعث می‌شود که برنامه قابل فهم‌تر و قابل نگهداری‌تر شود.
• تکرارپذیری (Reusability): با تعریف یک تابع، می‌توان از آن در بخش‌های مختلف برنامه استفاده کرد و از نوشتن کد تکراری جلوگیری کرد. این اصل به عنوان اصل DRY (Don't Repeat Yourself) شناخته می‌شود.درباره این موارد می‌توانید از این آدرس بیشتر مطالعه کنید.

ساختار یک تابع در پایتون:

1. def function_name(parameters):
2.     """docstring: توضیح مختصری درباره عملکرد تابع"""
3.     # بدنه تابع: مجموعه دستورات که توسط تابع اجرا می‌شود
4.     return value  # مقدار بازگشتی تابع (اختیاری)
5.  

• def: کلمه کلیدی برای تعریف یک تابع
• function_name: نامی که برای شناسایی تابع استفاده می‌شود. این نام باید ویژگی‌هایی داشته باشد که در این جلسه توضیح می‌دهیم.
• parameters: لیستی از متغیرها که به عنوان ورودی به تابع داده می‌شوند (اختیاری)
• docstring: یک رشته چند خطی که توضیح مختصری درباره عملکرد تابع ارائه می‌دهد. این رشته با سه کوتیشن تکراری (""" یا ''' ) محصور می‌شود.
• return: کلمه کلیدی برای بازگرداندن یک مقدار از تابع (اختیاری)

سه مورد آخر را در قسمت‌های بعدی توضیح می دهیم.

مثال:

1. def greet():
2.     print("Hello")
3.  
4. greet()  # خروجی: Hello
5.  

در این مثال، تابعی به نام greet تعریف شده است که یک پیام سلام را چاپ می‌کند.
مفاهیم پیشرفته‌تر:

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

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