*args ו-**kwargs ב-Python: ארגומנטים פוזיציונליים וארגומנטים בעלי שם

כשלא יודעים כמה ארגומנטים יגיעו

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

Python פותרת את זה בעזרת שני סימנים מיוחדים ברשימת הפרמטרים: *args ו-**kwargs.

*args אוסף ארגומנטים פוזיציונליים

כוכבית אחת אומרת "ארזו את כל הארגומנטים הפוזיציונליים העודפים לתוך tuple":

def log_all(*args):
    for message in args:
        print("LOG:", message)

log_all("starting")
log_all("ready", "set", "go")
log_all()    # גם אפס ארגומנטים זה בסדר

בתוך הפונקציה, args הוא tuple רגיל. אפשר לעבור עליו בלולאה, לגשת אליו לפי אינדקס, להעביר אותו ל-len() או לחתוך אותו.

*args מופיע בדרך כלל לצד פרמטרים בעלי שם:

def first_then_rest(first, *rest):
    print("first:", first)
    print("rest:", rest)

first_then_rest("a")
first_then_rest("a", "b", "c", "d")

first תופס את הארגומנט הראשון; *rest אורז את כל מה שבא אחריו לתוך tuple.

**kwargs אוסף ארגומנטים בעלי שם

שתי כוכביות עושות את אותו הדבר עבור ארגומנטים בעלי שם, ואורזות אותם לתוך dict:

def describe(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

describe(name="Rosa", age=30, city="Lisbon")

בתוך describe, kwargs הוא dict רגיל. המפתחות הם שמות הארגומנטים, בתור מחרוזות.

שימוש בשניהם יחד

אפשר להשתמש בשניהם באותה פונקציה. המוסכמה היא *args לפני **kwargs:

def show(**kwargs):
    print(kwargs)

def logger(*args, **kwargs):
    print("positional:", args)
    print("keyword:", kwargs)

logger(1, 2, 3, level="warn", tag="api")

הסדר המלא של הפרמטרים, מההתחלה ועד הסוף, הוא:

1. פרמטרים פוזיציונליים רגילים (חובה או עם ערכי ברירת מחדל).
2. *args.
3. פרמטרים שמקבלים ערך רק לפי שם (כל מה שבא אחרי *args חייב לעבור לפי שם).
4. **kwargs.

def post(title, *tags, draft=False, **metadata):
    print(title, tags, draft, metadata)

post("Hello", "python", "docs", draft=True, author="Rosa")

title תופס את הארגומנט הפוזיציונלי הראשון. שאר הפוזיציונליים נכנסים ל-tags. את draft חייבים להעביר לפי שם (הוא מופיע אחרי *tags). כל ארגומנט בעל שם אחר נוחת ב-metadata.

פריסה עם * ו-** בנקודת הקריאה

הכוכביות עובדות גם בכיוון ההפוך: הן פורסות רצף או dict לתוך הארגומנטים של קריאה:

def area(width, height):
    return width * height

dimensions = (4, 5)
print(area(*dimensions))       # פורס את ה-tuple לשני ארגומנטים

options = {"width": 4, "height": 5}
print(area(**options))         # פורס את ה-dict לארגומנטים בעלי שם

זה שימושי מאוד להעברת ארגומנטים הלאה:

def log(level, message):
    print(f"[{level}] {message}")

def wrapped(*args, **kwargs):
    print("before")
    result = log(*args, **kwargs)
    print("after")
    return result

wrapped("info", "starting up")
wrapped(level="warn", message="retrying")

wrapped לא צריכה לדעת אילו ארגומנטים log מצפה לקבל. היא פשוט אוספת הכל ומעבירה הלאה. הדפוס הזה מופיע כל הזמן בדקורטורים (נושא מתקדם יותר) ובפונקציות עוטפות.

מתי *args ו-**kwargs הם בחירה לא נכונה

קל להתלהב ולהשתמש בהם בכל מקום. שתי אזהרות:

הם מסתירים מה הפונקציה מצפה לקבל

אם כל פונקציה בקוד שלכם היא def f(*args, **kwargs), לקוד שקורא לה אין מושג אילו ארגומנטים תקינים. השתמשו בפרמטרים בעלי שם בכל פעם שאפשר, ותנו ל-*args/**kwargs לשאת רק קלט שבאמת משתנה במספרו, או העברה נקייה הלאה.

הודעות השגיאה נעשות מעורפלות

שם ארגומנט עם שגיאת כתיב הופך ל-None שקט או ל-KeyError עמוק בתוך הפונקציה, במקום הודעת "unexpected keyword argument" מיידית בנקודת הקריאה. פרמטרים בעלי שם נותנים משוב טוב בהרבה.

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

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

פונקציית עזר בסגנון שרטוט שעוטפת פונקציה חיצונית עם כמה ערכי ברירת מחדל:

def styled_print(*values, sep=" | ", end="\n", **style):
    prefix = style.get("prefix", "")
    suffix = style.get("suffix", "")
    message = sep.join(str(v) for v in values)
    print(prefix + message + suffix, end=end)

styled_print("user", "action", "timestamp")
styled_print("a", "b", "c", sep=" > ", prefix="[info] ")
styled_print(42, True, None, prefix=">>> ", suffix=" <<<")

*values מאפשר לקורא להעביר כל מספר של פריטים; **style בולע הגדרות נוספות בלי לחייב שכל אפשרות תהיה פרמטר בעל שם. זה גמיש בלי להיות אטום, כי הלוגיקה הפנימית מראה בדיוק אילו מפתחות היא קוראת מתוך style.

סיכום

• *args אורז ארגומנטים פוזיציונליים עודפים לתוך tuple.
• **kwargs אורז ארגומנטים בעלי שם עודפים לתוך dict.
• בנקודת הקריאה, *seq ו-**dict פורסים בכיוון ההפוך.
• הפרמטרים חייבים להופיע בסדר הזה: רגילים → *args → רק לפי שם → **kwargs.
• אל תגזימו: פרמטרים בעלי שם ברורים יותר כשאפשר להשתמש בהם.

בהמשך: lambda, דרך לכתוב פונקציות קטנות וחד-פעמיות בשורה אחת.