פונקציות ב-Python: def, return, ארגומנטים עם ברירת מחדל וארגומנטים בעלי שם

פונקציה היא בלוק של צעדים עם שם

בכל פעם שאתם מוצאים את עצמכם כותבים את אותן כמה שורות יותר מפעם אחת, או רוצים לתת שם לחתיכה קטנה של לוגיקה, אתם מוכנים לכתוב פונקציה. פונקציות הן הכלי האמיתי הראשון לניהול מורכבות בתוכנית Python.

הצורה הבסיסית:

def greet(name):
    print(f"Hello, {name}")

greet("Ada")
greet("Boris")

נפרק את זה:

• def היא המילה השמורה שפותחת הגדרת פונקציה.
• greet הוא שם הפונקציה.
• (name) היא רשימת הפרמטרים: הקלטים שהפונקציה מקבלת.
• הנקודתיים מסיימות את הכותרת; הבלוק המוזח שמתחת הוא הגוף.
• greet("Ada") היא קריאה. Python מריצה את הגוף כש-name קשור ל-"Ada".

פונקציות רדומות עד שקוראים להן. הגדרה של פונקציה לא מריצה אותה. קריאה לה עם greet("Ada") כן.

פרמטרים וארגומנטים

המילה פרמטר היא השם בתוך הגדרת הפונקציה. המילה ארגומנט היא הערך שמועבר כשקוראים לה. בשיחה יומיומית זה לא עניין גדול, אבל ההבחנה עוזרת כשקוראים הודעות שגיאה.

def power(base, exponent):
    return base ** exponent

print(power(2, 10))
print(power(5, 3))

כאן base ו-exponent הם פרמטרים. 2 ו-10 הם ארגומנטים. Python קושרת אותם לפי הסדר: הארגומנט הראשון לפרמטר הראשון, וכן הלאה.

return: שליחת ערך בחזרה

print כותבת למסך. return מחזירה ערך לקורא כדי שיוכל להשתמש בו:

def power(base, exponent):
    return base ** exponent

result = power(2, 10)
print(result + 1)

בלי return, פונקציה מחזירה None כברירת מחדל:

def greet(name):
    print(f"Hello, {name}")

value = greet("Ada")
print("got back:", value)   # got back: None

return גם יוצאת מהפונקציה מיד. תראו הרבה פעמים החזרות מוקדמות שמשמשות כדי לצאת ממקרי קצה לפני הלוגיקה המרכזית:

def discount(price, percent):
    if percent < 0 or percent > 100:
        return None
    return price * (1 - percent / 100)

print(discount(50, 20))
print(discount(50, 150))

החזרות מוקדמות מונעות מהגוף המרכזי להיות מקונן עמוק בתוך if/else.

ארגומנטים עם ברירת מחדל

לפרמטר יכול להיות ערך ברירת מחדל, שמשמש כשהקורא לא מספק ערך:

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Ada")
greet("Boris", "Good morning")

כל הפרמטרים עם ברירת מחדל חייבים לבוא אחרי הפרמטרים בלי ברירת מחדל. def f(a, b=1, c): היא שגיאת תחביר.

מלכודת ברירת המחדל המשתנה

זו המלכודת המפורסמת ביותר ב-Python. תסתכלו:

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item("apple"))
print(add_item("banana"))

הייתם מצפים שכל קריאה תתחיל עם רשימה ריקה. במקום זה, רשימת ברירת המחדל משותפת לכל הקריאות, והפריטים מצטברים. Python מחשבת את ברירת המחדל פעם אחת, כשהפונקציה מוגדרת, ומשתמשת שוב באותה רשימה יחידה לתמיד.

הדפוס הבטוח הוא להשתמש ב-None כברירת מחדל וליצור את הרשימה בתוך הפונקציה:

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item("apple"))
print(add_item("banana"))

עכשיו כל קריאה שלא מעבירה items מקבלת רשימה חדשה. הכלל הזה חל על רשימות, dicts, sets: כל דבר שניתן לשינוי.

ארגומנטים בעלי שם

אפשר להעביר ארגומנטים לפי שם במקום לפי מיקום. זה מאפשר לדלג על פרמטרים באמצע ולהפוך קריאות ארוכות לקריאות יותר:

def post(title, body, draft=False, tags=None):
    status = "draft" if draft else "published"
    print(f"[{status}] {title}")
    print(body)
    print("tags:", tags or [])

post("Python functions", "How to write them", draft=True, tags=["python", "tutorial"])

אפשר לערבב ארגומנטים פוזיציונליים וארגומנטים בעלי שם, אבל הפוזיציונליים חייבים לבוא קודם:

post("Title", body="Body text", draft=True)    # בסדר
# post(body="Body", "Title")                    # SyntaxError

ברגע שלפונקציה יש יותר משלושה או ארבעה פרמטרים, העדפה של ארגומנטים בעלי שם הופכת את הקריאות להרבה יותר קלות לקריאה.

פרמטרים רק לפי מיקום ורק לפי שם

Python מאפשרת לסמן חלק מהפרמטרים כאלה שמעבירים רק לפי מיקום (עם /) או רק לפי שם (עם *):

def configure(env, /, *, debug=False, log_level="info"):
    print(env, debug, log_level)

configure("prod")                          # בסדר: env פוזיציונלי
configure("prod", debug=True)              # בסדר
# configure(env="prod")                    # שגיאה: את env מעבירים רק לפי מיקום
# configure("prod", True, "info")          # שגיאה: את debug ו-log_level מעבירים רק לפי שם

לא צריך את אלה ביום הראשון. הם הופכים לשימושיים כשמעצבים APIs ורוצים לנעול את הדרך שבה קוראים משתמשים בפונקציה שלכם.

Docstrings ושמות

השורה הראשונה בתוך פונקציה יכולה להיות docstring: מחרוזת במירכאות משולשות ש-Python מתייחסת אליה כתיעוד:

def discount(price, percent):
    """Return the final price after applying a percentage discount."""
    return price * (1 - percent / 100)

help(discount)

כלים כמו help(), חלוניות רמז ב-IDE ומחוללי תיעוד קוראים את ה-docstring אוטומטית. שורה אחת עדיפה בהרבה על כלום.

ובבקשה, תחשבו על שמות:

• שמות של פונקציות צריכים להיות פעלים: fetch_profile, compute_total, is_valid.
• השתמשו ב-lower_snake_case.
• פונקציות שמחזירות בוליאני מתחילות הרבה פעמים ב-is_, has_ או can_.

שם טוב הופך את נקודת הקריאה למובנת מאליה בלי צורך בהערה.

קל יותר לחשוב על פונקציות טהורות

פונקציה טהורה (pure) מחזירה את אותו פלט עבור אותו קלט ואין לה תופעות לוואי: היא לא משנה מצב גלובלי, לא מדפיסה ל-stdout (חוץ מלצורכי דיבוג) ולא כותבת לקבצים.

# טהורה: קל לבדוק אותה, קל לחשוב עליה.
def total(price, tax_rate):
    return price * (1 + tax_rate)

# לא טהורה: משנה משתנה חיצוני.
cart = []
def add_to_cart(item):
    cart.append(item)

print(total(100, 0.08))
add_to_cart("apple")
print(cart)

לשתיהן יש מקום, אבל בקוד שרוצים לעשות בו שימוש חוזר ולבדוק אותו, שאפו לפונקציות טהורות ככל האפשר.

דוגמה קטנה שעובדת

פונקציה קצרה שמשלבת ברירות מחדל, ארגומנטים בעלי שם ו-return:

def format_address(street, city, country="US", zip_code=None):
    parts = [street, city]
    if zip_code:
        parts.append(zip_code)
    parts.append(country)
    return ", ".join(parts)

print(format_address("1 Main St", "Boston"))
print(format_address("1 Main St", "Boston", zip_code="02108"))
print(format_address("Place Vendôme 1", "Paris", country="France"))

הבא בתור: רשימות ארגומנטים גמישות

לפעמים לא יודעים עם כמה ארגומנטים יקראו לפונקציה, או שרוצים להעביר את כל הארגומנטים שמגיעים לפונקציה אחרת. *args ו-**kwargs מטפלים בזה. זה העמוד הבא.