Lambda w Pythonie: funkcje anonimowe, klucz sortowania i map/filter

Funkcja, której nie chce ci się nazywać

Większość funkcji w Pythonie definiuje się przez def, mają nazwy i leżą w pliku, gdzie można ich używać wielokrotnie. lambda to mniejsza, bezimienna alternatywa, przydatna w tych kilku przypadkach, w których pełna definicja funkcji byłaby większą ceremonią, niż jest warta.

Oto obie formy obok siebie:

def double(x):
    return x * 2

double_lambda = lambda x: x * 2

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

Dwie funkcje, które robią dokładnie to samo. Wersja z lambdą mieści się w jednej linii, bo to w zasadzie jej zadanie: jednorazowa funkcja na jednorazową chwilę.

Składnia

lambda <params>: <expression>

• <params> to ta sama lista parametrów, której użyłby def: obsługuje wartości domyślne, *args i **kwargs.
• <expression> to jedno wyrażenie, którego wartość staje się wartością zwracaną.

Przykłady:

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"))

Nie ma słowa kluczowego return. Wartość wyrażenia jest zwracana automatycznie.

Jedyne ograniczenie

Lambda może zawierać tylko jedno wyrażenie. Nie da się w niej umieścić instrukcji:

# Te nie działają:
# bad = lambda x: x = x + 1         # nie można przypisywać
# worse = lambda x:                 # nie można mieć if/elif/else jako instrukcji
#     if x > 0:
#         return x
#     else:
#         return -x

Możesz za to użyć wyrażenia warunkowego:

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

Jeśli potrzebujesz więcej niż jednego wyrażenia, to sygnał, żeby przejść na def.

Gdzie lambdy naprawdę się opłacają

Lambda przypisana do zmiennej prawie zawsze jest gorsza niż nazwany def:

# Nie rób tak.
double = lambda x: x * 2

To zdecydowanie gorsze niż def double(x): return x * 2: czytelność ta sama, a do tego wersja z lambdą pokazuje w śladzie stosu mało pomocną nazwę <lambda>.

Lambdy błyszczą dokładnie w jednym miejscu: jako argumenty wpisane bezpośrednio w wywołanie funkcji wyższego rzędu.

Własne klucze sortowania

Klasyczny przypadek:

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)

Argument key funkcji sorted oczekuje funkcji, która przyjmuje element i zwraca wartość, według której sortujemy. Jednolinijkowa lambda pasuje tu idealnie, a pełny def byłby zbyt ciężki na coś tak małego.

Możesz sortować po kilku polach, używając krotki:

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

Podobna historia: wszystkie przyjmują opcjonalny argument w postaci funkcji:

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

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

# map: stosuje funkcję do każdego elementu
numbers = [1, 2, 3, 4]
doubled = list(map(lambda n: n * 2, numbers))
print(doubled)

# filter: zostawia elementy, dla których funkcja zwraca true
evens = list(filter(lambda n: n % 2 == 0, numbers))
print(evens)

Zamiast map i filter zwykle jeszcze czytelniejsza jest 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)

Z tego powodu większość programistów Pythona wybiera comprehensions zamiast map/filter. lambda pozostaje naturalnym wyborem dla sorted, min i max, gdzie comprehension nie daje skrótu.

Lambdy i moduł operator

Gdy twoja lambda tylko "wyciąga klucz" albo "wyciąga atrybut", moduł operator w Pythonie ma szybsze i czytelniejsze alternatywy:

from operator import itemgetter, attrgetter

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

# Te dwa zapisy są równoważne:
a = sorted(users, key=lambda u: u["name"])
b = sorted(users, key=itemgetter("name"))

print(a)
print(b)

To niewielki zysk, ale w kodzie, który już importuje operator, czyta się to nieco bardziej deklaratywnie.

Kiedy wrócić do def

Jeśli spełniony jest którykolwiek z tych warunków, napisz def:

1. Logika nie mieści się zgrabnie w jednym wyrażeniu.
2. Chcesz nazwać funkcję, bo nazwa poprawi czytelność.
3. Używasz tej samej logiki w więcej niż jednym miejscu.
4. Funkcja potrzebuje docstringa (lambda nie może go mieć).

Pamiętaj: w Pythonie nikt nie przyznaje punktów za liczbę linii. Gdy logika przestaje być banalna, trzylinijkowa nazwana funkcja prawie zawsze czyta się lepiej niż jednolinijkowa lambda.

Dalej: dekoratory

Lambdy przekazują funkcje jako wartości. Dekoratory idą o krok dalej: pozwalają opakować dowolną funkcję w zachowanie wielokrotnego użytku (logowanie, pomiar czasu, cache, autoryzację) za pomocą jednego @ w linii nad nią. O tym jest następna strona.