Last modified: June 06, 2026
This article is written in: 🇵🇱
Funkcje lambda, zwane również funkcjami anonimowymi, są narzędziem szeroko stosowanym w programowaniu funkcyjnym. Są to krótkie, jedno-wierszowe funkcje, które nie posiadają przypisanej nazwy i są używane tam, gdzie zdefiniowanie pełnoprawnej funkcji byłoby nadmiarowe lub zbędne. W Pythonie i wielu innych językach programowania funkcje lambda odgrywają istotną rolę, zwłaszcza przy manipulacji danymi i implementacji algorytmów funkcyjnych.
Funkcje lambda są przykładami funkcji wyższego rzędu, co oznacza, że funkcje te mogą być traktowane jak obiekty – mogą być przekazywane jako argumenty do innych funkcji, zwracane jako wynik innych funkcji lub przechowywane w strukturach danych, takich jak listy. Lambda funkcje pozwalają na zapisanie funkcji w sposób zwięzły i syntaktycznie uproszczony.
Funkcje lambda mają następujące zalety:
map(), filter(), reduce().W Pythonie składnia funkcji lambda wygląda następująco:
lambda argumenty: wyrażenielambda: Słowo kluczowe do zdefiniowania funkcji anonimowej.argumenty: Lista argumentów funkcji. Możliwe jest przekazanie dowolnej liczby argumentów oddzielonych przecinkami.wyrażenie: Wyrażenie, które zostanie obliczone i zwrócone jako wynik funkcji.Przykład składni w porównaniu do tradycyjnej funkcji:
def zwykla_funkcja(x):
return x ** 2
# Odpowiednik lambda
lambda_funkcja = lambda x: x ** 2Funkcja lambda pełni rolę uproszczonej wersji zwykłej funkcji. Różnice między nimi można wyrazić następująco:
def. Jest bardziej elastyczna i może zawierać złożoną logikę.Poniżej przedstawiamy porównanie między funkcją tradycyjną a funkcją lambda, obie podnoszą liczbę do kwadratu.
def zwykla_funkcja(liczba: int) -> int:
return liczba ** 2
przyklad_lambdy = lambda liczba: liczba ** 2
wartosc = 2
print(zwykla_funkcja(wartosc)) # Wynik: 4
print(przyklad_lambdy(wartosc)) # Wynik: 4
print((lambda liczba: liczba ** 2)(wartosc)) # Wynik: 4Funkcje wyższego rzędu to funkcje, które przyjmują inne funkcje jako argumenty lub zwracają funkcje jako wynik. Przykładowo, funkcje takie jak map(), filter() i reduce() wykorzystują lambdy do przetwarzania kolekcji danych.
map()Funkcja map() stosuje daną funkcję do każdego elementu iterowalnego obiektu (np. listy).
lista = [1, 2, 3, 4]
kwadraty = list(map(lambda x: x ** 2, lista))
print(kwadraty) # Wynik: [1, 4, 9, 16]filter()Funkcja filter() zwraca te elementy iterowalnego obiektu, które spełniają warunek podany w funkcji lambda.
lista = [1, 2, 3, 4, 5, 6]
parzyste = list(filter(lambda x: x % 2 == 0, lista))
print(parzyste) # Wynik: [2, 4, 6]reduce()Funkcja reduce() (dostępna w module functools) redukuje iterowalny obiekt do jednej wartości, stosując funkcję do kolejnych elementów.
from functools import reduce
suma = reduce(lambda a, b: a + b, [1, 2, 3, 4])
print(suma) # Wynik: 10Mimo swojej zwięzłości, funkcje lambda mają pewne ograniczenia w porównaniu do tradycyjnych funkcji:
if-elif-else, pętle for czy while.ifChociaż lambdy nie mogą bezpośrednio zawierać pełnej instrukcji if, mogą korzystać z operatora warunkowego (ternary operator).
czy_parzysta = lambda x: 'parzysta' if x % 2 == 0 else 'nieparzysta'
print(czy_parzysta(4)) # Wynik: 'parzysta'
print(czy_parzysta(5)) # Wynik: 'nieparzysta'forFunkcje lambda nie obsługują bezpośrednio pętli for. Jednak można symulować iteracje za pomocą funkcji takich jak map(), która stosuje lambdę do każdego elementu iterowalnego obiektu.
lista = [1, 2, 3, 4]
kwadraty = list(map(lambda x: x ** 2, lista))
print(kwadraty) # Wynik: [1, 4, 9, 16]Mimo że lambdy nie obsługują pętli, możliwe jest definiowanie prostych rekursji, chociaż nie jest to zalecane z powodu ograniczeń głębokości stosu w Pythonie.
faktorial = lambda n: 1 if n == 0 else n * faktorial(n - 1)
print(faktorial(5)) # Wynik: 120Lambdy są używane do definiowania kryteriów sortowania, zwłaszcza przy pracy z bardziej złożonymi strukturami danych, jak listy słowników.
studenci = [
{'imie': 'Jan', 'wiek': 23},
{'imie': 'Anna', 'wiek': 22},
{'imie': 'Piotr', 'wiek': 24}
]
sortowani_po_wieku = sorted(studenci, key=lambda x: x['wiek'])
print(sortowani_po_wieku)
# Wynik: [{'imie': 'Anna', 'wiek': 22}, {'imie': 'Jan', 'wiek': 23}, {'imie': 'Piotr', 'wiek': 24}]Lambdy są powszechnie używane w analizie danych, szczególnie gdy przetwarzamy dane w ramach takich narzędzi jak pandas. Mogą być używane w operacjach typu apply().
import pandas as pd
df = pd.DataFrame({
'A': [1, 2, 3],
'B': [10, 20, 30]
})
df['C'] = df.apply(lambda row: row.A + row.B, axis=1)
print(df)Wynik:
A B C
0 1 10 11
1 2 20 22
2 3 30 33operator jako alternatywa dla prostych lambdDla podstawowych operacji arytmetycznych i logicznych moduł operator dostarcza gotowych funkcji, które są czytelniejsze i szybsze niż lambdy:
from operator import add, mul, itemgetter, attrgetter
# Zamiast: lambda a, b: a + b
print(add(3, 4)) # 7
# Zamiast: lambda a, b: a * b
print(mul(3, 4)) # 12
# Sortowanie list słowników
studenci = [
{"imie": "Jan", "wiek": 23},
{"imie": "Anna", "wiek": 21},
{"imie": "Piotr", "wiek": 25},
]
# Zamiast: sorted(studenci, key=lambda x: x["wiek"])
posortowani = sorted(studenci, key=itemgetter("wiek"))
print(posortowani)
# [{'imie': 'Anna', 'wiek': 21}, {'imie': 'Jan', 'wiek': 23}, ...]
# Sortowanie obiektów po atrybucie
from collections import namedtuple
Osoba = namedtuple("Osoba", ["imie", "wiek"])
osoby = [Osoba("Jan", 23), Osoba("Anna", 21)]
# Zamiast: sorted(osoby, key=lambda x: x.wiek)
posortowani2 = sorted(osoby, key=attrgetter("wiek"))functools.partial — częściowe zastosowanie funkcjifunctools.partial pozwala "zamrozić" niektóre argumenty funkcji, tworząc nową funkcję z mniejszą liczbą parametrów. Jest to elegancka alternatywa dla lambdy, gdy chcemy utrwalić jeden z argumentów:
from functools import partial
def potega(podstawa, wykladnik):
return podstawa ** wykladnik
# Zamiast: lambda x: potega(x, 2)
kwadrat = partial(potega, wykladnik=2)
szescian = partial(potega, wykladnik=3)
print(kwadrat(5)) # 25
print(szescian(3)) # 27
# Przykład z print
print_sep = partial(print, sep=" | ")
print_sep("A", "B", "C") # A | B | C
# Przykład z mnożeniem
from operator import mul
podwoj = partial(mul, 2)
print(list(map(podwoj, range(5)))) # [0, 2, 4, 6, 8]def — kiedy co stosować?
| Sytuacja | Zalecane podejście |
| Prosta jednorazowa funkcja jako argument | lambda |
| Funkcja wielokrotnego użytku | def |
| Funkcja z wieloma operacjami / warunkami | def |
| Potrzebne docstringi lub adnotacje typów | def |
| Sortowanie po prostym kluczu | lambda lub operator |
Przekazanie do map(), filter() |
lambda lub wyrażenie listowe |
# Kiedy lambda jest czytelna
liczby = [1, -3, 5, -2, 4]
posortowane = sorted(liczby, key=lambda x: abs(x))
print(posortowane) # [1, -2, -3, 4, 5]
# Kiedy def jest czytelniejsze
def kryterium_sortowania(x):
"""Sortuje po wartości bezwzględnej, a przy remisie — malejąco."""
return (abs(x), -x)
posortowane2 = sorted(liczby, key=kryterium_sortowania)Lambda może być zwracana z funkcji, tworząc tzw. fabrykę funkcji:
def mnoznik(n):
return lambda x: x * n
podwoj = mnoznik(2)
potroil = mnoznik(3)
print(list(map(podwoj, [1, 2, 3, 4]))) # [2, 4, 6, 8]
print(list(map(potroil, [1, 2, 3, 4]))) # [3, 6, 9, 12]
# Fabryka walidatorów
def zakres(minimum, maksimum):
return lambda x: minimum <= x <= maksimum
czy_dorosly = zakres(18, 120)
czy_dziecko = zakres(0, 17)
print(czy_dorosly(25)) # True
print(czy_dziecko(10)) # True
print(czy_dorosly(15)) # False