استفادهٔ مجدد از کد

چرا استفادهٔ مجدد از کد مهم است؟

وقتی توابع را یاد می‌گیرید، یکی از مهم‌ترین هدف‌ها این است که بتوانید «یک بار کد بنویسید و بارها استفاده کنید».
منظور از استفادهٔ مجدد از کد این است که:

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

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

نشانهٔ این‌که به یک تابع نیاز دارید

در عمل، چه زمانی باید یک تابع بسازید تا بعداً دوباره از آن استفاده کنید؟ چند نشانهٔ متداول:

1. کد تکراری
   اگر یک قطعه کد را در چند جای برنامه نوشته‌اید یا کپی می‌کنید، معمولاً وقت تعریف یک تابع است.
2. کدی که یک کار مشخص انجام می‌دهد
   اگر چند خط کد همراه هم یک کار «معنی‌دار» انجام می‌دهند (مثلاً «نمایش خوش‌آمدگویی»، «محاسبهٔ میانگین نمرات»، «چاپ منوی برنامه»)، بهتر است در قالب تابع دربیاید.
3. کدی که احتمالاً بعداً به آن نیاز خواهید داشت
   اگر حس می‌کنید این منطق در برنامه‌های آینده هم کاربرد دارد، به شکل تابع بنویسید تا بعداً راحت آن را کپی یا حتی در یک ماژول جدا ذخیره کنید.

مثال ساده؛ فرض کنید چند جای برنامه به کاربر خوش‌آمد می‌گویید:

print("سلام! به برنامهٔ ما خوش آمدید.")
print("سلام! به برنامهٔ ما خوش آمدید.")
print("سلام! به برنامهٔ ما خوش آمدید.")

این تکرار است. بهتر است یک تابع بسازیم:

def say_welcome():
    print("سلام! به برنامهٔ ما خوش آمدید.")
# هر جا لازم بود:
say_welcome()
say_welcome()

جایگزین کردن کد تکراری با یک تابع

فرض کنید یک برنامهٔ ساده دارید که در چند جا مساحت دایره را حساب می‌کند:

pi = 3.14159
r1 = 5
area1 = pi * r1 * r1
print("مساحت دایره ۱:", area1)
r2 = 10
area2 = pi * r2 * r2
print("مساحت دایره ۲:", area2)

این‌جا فرمول محاسبه $ \pi r^2 $ تکرار شده است. آن را در قالب تابع می‌نویسیم:

pi = 3.14159
def circle_area(r):
    return pi * r * r
print("مساحت دایره ۱:", circle_area(5))
print("مساحت دایره ۲:", circle_area(10))

مزیت‌ها:

• اگر بعداً مقدار pi را عوض کنید یا فرمول را اصلاح کنید، لازم نیست همه‌جا به‌دنبال کد بگردید.
• کد اصلی (قسمت print) خواناتر می‌شود؛ فقط می‌گوید «مساحت دایره» را حساب کن، بدون درگیر شدن با جزئیات فرمول.

---

انتزاع (پنهان کردن جزئیات)

وقتی از تابع استفاده می‌کنید، در واقع «جزئیات پیاده‌سازی» را درون تابع پنهان می‌کنید و در بقیهٔ برنامه فقط به اسم تابع و کاری که انجام می‌دهد توجه می‌کنید. این کار را «انتزاع» (Abstraction) می‌گویند.

مثال:

def calculate_tax(amount):
    # یک منطق فرضی برای محاسبهٔ مالیات
    tax = amount * 0.09
    return tax
price = 500_000
tax = calculate_tax(price)
print("قیمت:", price)
print("مالیات:", tax)
print("قیمت نهایی:", price + tax)

وقتی بعداً کد را می‌خوانید، لازم نیست درگیر این شوید که مالیات چطور دقیقاً حساب می‌شود؛ فقط می‌دانید calculate_tax مالیات را برمی‌گرداند.

این نوع استفادهٔ مجدد از کد باعث می‌شود برنامه را در «سطح بالاتر» تفکر کنید:
به‌جای فکر کردن به جزئیات هر خط، در مورد «کارهای» اصلی فکر می‌کنید:
«هزینه را بگیر، مالیاتش را حساب کن، نمایش بده.»

توابع کوچک و یک‌کارِه برای استفادهٔ مجدد بهتر

یک نکتهٔ مهم برای استفادهٔ مجدد مؤثر از کد این است که تابع‌ها را تا حد ممکن:

• کوچک بنویسید.
• یک کار مشخص انجام دهند (Single Responsibility).

مثال بد (تابعی که چند کار مختلف انجام می‌دهد):

def process_user():
    name = input("نام شما چیست؟ ")
    age = int(input("سن شما چند است؟ "))
    print("سلام", name)
    if age >= 18:
        print("شما بزرگسال هستید.")
    else:
        print("شما زیر ۱۸ سال هستید.")

این تابع:

• ورودی می‌گیرد،
• پردازش سن را انجام می‌دهد،
• و پیام چاپ می‌کند.

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

def get_user_info():
    name = input("نام شما چیست؟ ")
    age = int(input("سن شما چند است؟ "))
    return name, age
def classify_age(age):
    if age >= 18:
        return "بزرگسال"
    else:
        return "زیر ۱۸ سال"
def greet_user(name, status):
    print("سلام", name)
    print("شما", status, "هستید.")
# استفاده:
name, age = get_user_info()
status = classify_age(age)
greet_user(name, status)

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

مثال: تبدیل یک بخش تکراری از برنامه به تابع

فرض کنید یک برنامهٔ آزمون (Quiz) ساده نوشته‌اید و در آن چندین بار روند زیر را تکرار می‌کنید:

1. سؤال را نمایش بده.
2. پاسخ کاربر را بگیر.
3. بررسی کن درست است یا نه.
4. پیام مناسب را چاپ کن.

کدِ بدون استفادهٔ مجدد می‌تواند این‌طور باشد:

score = 0
print("سؤال ۱: پایتون چیست؟")
answer = input("جواب شما: ")
if answer == "زبان برنامه نویسی":
    print("آفرین! درست است.")
    score += 1
else:
    print("متاسفانه اشتباه است.")
print("سؤال ۲: 2 + 2 چند می‌شود؟")
answer = input("جواب شما: ")
if answer == "4":
    print("آفرین! درست است.")
    score += 1
else:
    print("متاسفانه اشتباه است.")
print("امتیاز نهایی شما:", score)

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

def ask_question(question, correct_answer):
    print(question)
    answer = input("جواب شما: ")
    if answer == correct_answer:
        print("آفرین! درست است.")
        return 1
    else:
        print("متاسفانه اشتباه است.")
        return 0
score = 0
score += ask_question("سؤال ۱: پایتون چیست؟", "زبان برنامه نویسی")
score += ask_question("سؤال ۲: 2 + 2 چند می‌شود؟", "4")
print("امتیاز نهایی شما:", score)

چیزی که به‌دست آوردیم:

• منطق تکراری در تابع ask_question جمع شده است.
• اگر بخواهیم نوع مقایسهٔ جواب (مثلاً حساس نبودن به حروف بزرگ/کوچک) را عوض کنیم، فقط در یک جا تغییر می‌دهیم.
• اضافه کردن سؤال جدید خیلی راحت است: فقط یک خط دیگر score += ask_question(...) می‌نویسیم.

---

استفادهٔ مجدد از توابع در چند فایل (نگاه مقدماتی)

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

ایدهٔ کلی این است:

1. توابع کلی و مفید را در یک فایل (ماژول) قرار می‌دهید، مثلاً helpers.py.
2. در برنامهٔ اصلی (مثلاً main.py) آن‌ها را import می‌کنید و استفاده می‌کنید.

ساختار ساده:

# فایل helpers.py
def circle_area(r):
    pi = 3.14159
    return pi * r * r

# فایل main.py
from helpers import circle_area
print(circle_area(10))

در فصل‌های بعدی، با جزئیات import و سازمان‌دهی کد در چند فایل بیشتر کار خواهید کرد؛ این‌جا فقط ایدهٔ کلی استفادهٔ مجدد از کد در چند برنامه را می‌بینید.

مزایای کلی استفادهٔ مجدد از کد با توابع

جمع‌بندی مزایا:

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

---

تمرین‌های پیشنهادی

برای تمرین استفادهٔ مجدد از کد:

1. یکی از برنامه‌های سادهٔ قبلی‌تان را بازنویسی کنید و هر بخش تکراری را به تابع تبدیل کنید.
2. برنامهٔ کوچکی بنویسید که:
• تابعی برای نمایش منو داشته باشد.
• تابعی برای دریافت یک عدد از کاربر (با تبدیل به int) داشته باشد.
• تابعی برای چاپ نتیجهٔ یک عملیات (مثلاً جمع دو عدد) داشته باشد.
  و این توابع را چند بار در برنامه صدا بزنید.
3. یک فایل جدید بسازید و توابعی که فکر می‌کنید در آینده به دردتان می‌خورند (مثلاً max_of_three(a, b, c)) در آن قرار دهید.
   سعی کنید در یک برنامهٔ دیگر از آن‌ها استفاده کنید (با کمک import که در فصل کتابخانه‌ها کامل خواهید دید).

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