Lambda ב-Python: פונקציות אנונימיות, sort key ו-map/filter

פונקציה שלא טורחים לתת לה שם

רוב הפונקציות ב-Python מוגדרות עם def, יש להן שם, והן יושבות בקובץ שבו אפשר להשתמש בהן שוב. lambda היא חלופה קטנה יותר וללא שם, שימושית במקרים המעטים שבהם הגדרת פונקציה מלאה הייתה יותר טקס ממה שהיא שווה.

הנה שתי הצורות זו לצד זו:

def double(x):
    return x * 2

double_lambda = lambda x: x * 2

print(double(5))
print(double_lambda(5))

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

תחביר

lambda <params>: <expression>

• <params> היא אותה רשימת פרמטרים ש-def הייתה משתמשת בה, כולל ערכי ברירת מחדל, *args ו-**kwargs.
• <expression> הוא ביטוי יחיד שהערך שלו הופך לערך המוחזר.

דוגמאות:

add = lambda a, b: a + b
print(add(3, 4))

square = lambda n: n * n
print(square(8))

greet = lambda name="world": f"Hello, {name}"
print(greet())
print(greet("Rosa"))

אין מילת מפתח return. הערך של הביטוי מוחזר באופן מרומז.

המגבלה היחידה

lambda יכולה להכיל רק ביטוי אחד. אי אפשר לשים בה פקודות:

# אלה לא עובדים:
# bad = lambda x: x = x + 1         # אי אפשר לבצע השמה
# worse = lambda x:                 # אי אפשר להשתמש ב-if/elif/else כפקודות
#     if x > 0:
#         return x
#     else:
#         return -x

אבל אפשר להשתמש בביטוי התנאי (ternary):

signed = lambda x: x if x > 0 else -x
print(signed(-5))
print(signed(5))

אם אתם צריכים יותר מביטוי אחד, זה הסימן לעבור ל-def.

איפה lambda באמת מצדיקה את עצמה

lambda שמושמת למשתנה כמעט תמיד גרועה יותר מ-def עם שם:

# אל תעשו את זה.
double = lambda x: x * 2

זה גרוע יותר באופן חד-משמעי מ-def double(x): return x * 2: אותה קריאוּת, ובנוסף גרסת ה-lambda נותנת לדיבאגרים את השם חסר התועלת <lambda> ב-stack traces.

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

מפתחות מיון מותאמים

המקרה הקלאסי:

users = [
    {"name": "Ada", "age": 36},
    {"name": "Boris", "age": 28},
    {"name": "Ciara", "age": 44},
]

by_age = sorted(users, key=lambda u: u["age"])
print(by_age)

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

אפשר למיין לפי כמה שדות בעזרת tuple:

records = [("Ada", 2), ("Boris", 1), ("Ada", 1), ("Boris", 3)]

by_name_then_version = sorted(records, key=lambda r: (r[0], r[1]))
print(by_name_then_version)

min, max, filter, map

אותו סיפור: כולן מקבלות ארגומנט אופציונלי של פונקציה:

prices = [{"item": "apple", "cost": 0.50}, {"item": "bread", "cost": 2.00}]

cheapest = min(prices, key=lambda p: p["cost"])
print(cheapest)

# map: מפעילה פונקציה על כל פריט
numbers = [1, 2, 3, 4]
doubled = list(map(lambda n: n * 2, numbers))
print(doubled)

# filter: משאירה את הפריטים שעבורם הפונקציה מחזירה true
evens = list(filter(lambda n: n % 2 == 0, numbers))
print(evens)

עבור map ו-filter, list comprehension בדרך כלל ברורה עוד יותר:

numbers = [1, 2, 3, 4]

doubled = [n * 2 for n in numbers]
evens = [n for n in numbers if n % 2 == 0]
print(doubled, evens)

רוב מתכנתי Python מעדיפים comprehensions על פני map/filter מהסיבה הזו. lambda נשארת בחירה טבעית עבור sorted, min ו-max, שבהן אין קיצור של comprehension.

lambda והמודול operator

כשה-lambda שלכם היא רק "קח מפתח" או "קח attribute", למודול operator של Python יש חלופות מהירות וברורות יותר:

from operator import itemgetter, attrgetter

users = [{"name": "Ada", "age": 36}, {"name": "Boris", "age": 28}]

# שתי השורות האלה שקולות:
a = sorted(users, key=lambda u: u["name"])
b = sorted(users, key=itemgetter("name"))

print(a)
print(b)

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

מתי לחזור ל-def

אם אחד מאלה נכון, כתבו def:

1. הלוגיקה לא נכנסת בצורה נקייה בביטוי אחד.
2. אתם רוצים לתת לפונקציה שם, כי השם ישפר את הקריאוּת.
3. הייתם משתמשים באותה לוגיקה ביותר ממקום אחד.
4. הפונקציה צריכה docstring (ל-lambda אי אפשר לצרף אחד).

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

הצעד הבא: Decorators

lambda מעבירה פונקציות כערכים. Decorators לוקחים את אותו רעיון צעד אחד קדימה: הם מאפשרים לעטוף כל פונקציה בהתנהגות שאפשר לעשות בה שימוש חוזר, כמו לוגים, מדידת זמן, caching או הרשאות, בעזרת @ אחד בשורה שמעליה. זה העמוד הבא.