List comprehension w Pythonie: składnia, filtrowanie i dict comprehension

Jedna linia, jedna myśl

Ten wzorzec na pewno już znasz: zaczynasz od pustej listy, przechodzisz pętlą po czymś, czasem filtrujesz i dopisujesz do wyniku.

numbers = [1, 2, 3, 4, 5]

doubled = []
for n in numbers:
    doubled.append(n * 2)

print(doubled)

List comprehension mówi to samo w jednej linii:

numbers = [1, 2, 3, 4, 5]

doubled = [n * 2 for n in numbers]
print(doubled)

Czytaj od lewej do prawej: "nowa lista złożona z n * 2 dla każdego n w numbers". Struktura to [expression for item in iterable].

To nie jest sztuczka tylko z Pythona. Nazywa się to comprehension, bo deklaratywnie opisujesz, co trafia do nowej listy, zamiast rozpisywać mechanikę jej budowania.

Dodawanie filtra

Dopisz klauzulę if po części z pętlą, żeby filtrować:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

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

squares_of_odds = [n * n for n in numbers if n % 2 == 1]
print(squares_of_odds)

Drugą linię czytaj tak: "n * n dla każdego n w numbers, ale tylko jeśli n jest nieparzyste".

Równoważna pętla:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

squares_of_odds = []
for n in numbers:
    if n % 2 == 1:
        squares_of_odds.append(n * n)

print(squares_of_odds)

Obie wersje są w porządku. Comprehension jest krótsza, a gdy przeczytasz kilka, łatwiej się ją przegląda, bo cały zamiar widać w jednej linii.

Mapowanie i filtrowanie naraz

Możesz przepuszczać wartości przez funkcję i jednocześnie filtrować:

words = ["python", "is", "great", "fun"]

long_upper = [w.upper() for w in words if len(w) > 3]
print(long_upper)

Dla każdego słowa dłuższego niż 3 litery dodaj jego wersję pisaną wielkimi literami.

Zagnieżdżone pętle w comprehension

Dwa for dają pary w stylu iloczynu kartezjańskiego:

suits = ["♠", "♥", "♦", "♣"]
ranks = ["J", "Q", "K", "A"]

deck = [rank + suit for suit in suits for rank in ranks]
print(deck)

Kolejność jest taka sama jak przy zagnieżdżonych pętlach: pierwszy for jest zewnętrzny, drugi wewnętrzny. Czyta się to od lewej do prawej, tak jak odpowiadającą temu pętlę z wcięciami.

Dwa poziomy to mniej więcej granica, za którą zwykła pętla czyta się lepiej. Jeśli dochodzisz do trzech, wróć do pętli.

Dict comprehension i set comprehension

Ten sam pomysł, inne nawiasy:

numbers = [1, 2, 3, 4, 5]

# Dict comprehension: tworzy słownik
squares = {n: n * n for n in numbers}
print(squares)

# Set comprehension: tworzy zbiór
unique_squares = {n * n for n in [1, -1, 2, -2, 3]}
print(unique_squares)

Na pierwszy rzut oka set comprehension wygląda identycznie jak dict comprehension. Różnica to key: value zamiast pojedynczego wyrażenia. Klamry z : to słownik; klamry bez : to zbiór.

Wyrażenia generatorowe

To niemal bliźniak list comprehension, tylko z nawiasami okrągłymi zamiast kwadratowych i, co najważniejsze, nie buduje listy:

numbers = [1, 2, 3, 4, 5]

total = sum(n * n for n in numbers)
print(total)

any_negative = any(n < 0 for n in numbers)
print(any_negative)

Zauważ, że generator trafił bezpośrednio do sum() i any(), bez dodatkowych nawiasów. Wyrażenia generatorowe to właściwe narzędzie, gdy wywołujący musi przejść po wynikach tylko raz. Przy dużych kolekcjach oszczędzają pamięć w porównaniu z pełną listą.

Kiedy lepiej użyć zwykłej pętli

Comprehensions kuszą. Technicznie da się w nie wcisnąć mnóstwo rzeczy. Nie warto.

Sięgnij po zwykłą pętlę, gdy:

• Przekształcenie ma więcej niż jeden krok. Jeśli potrzebujesz zmiennych pośrednich, rozpisz to.
• Jest w nim złożona obsługa błędów albo rozgałęzienia.
• Każdy, kto czyta tę linię, musi zatrzymać się więcej niż raz, żeby ją zrozumieć.

Zasada, którą stosuję: jeśli potrafię przeczytać comprehension jednym tchem i zrozumieć, co robi, zostaje. Jeśli się potykam, przepisuję ją na pętlę.

Niektóre comprehensions wyglądają sprytnie, ale szkodzą:

# Sprytne, ale męczące:
data = [(x, y) for x in range(5) for y in range(5) if (x + y) % 2 == 0 and x != y]

# Jaśniejsze jako pętla:
data = []
for x in range(5):
    for y in range(5):
        if (x + y) % 2 == 0 and x != y:
            data.append((x, y))

print(data)

Ten sam wynik. Wersja z pętlą ma pięć linii zamiast jednej, ale "dłuższe" nie znaczy "gorsze".

Kilka wzorców, które będziesz powtarzać

users = [
    {"name": "Ada", "active": True},
    {"name": "Boris", "active": False},
    {"name": "Ciara", "active": True},
]

# Wyciągnij jeden atrybut z każdego elementu.
names = [u["name"] for u in users]
print(names)

# Przefiltruj i wybierz pole za jednym zamachem.
active_names = [u["name"] for u in users if u["active"]]
print(active_names)

# Zbuduj słownik do wyszukiwania z kluczem z jednego pola.
by_name = {u["name"]: u for u in users}
print(by_name["Ada"])

# Policz, ile elementów spełnia warunek.
active_count = sum(1 for u in users if u["active"])
print(active_count)

Te wzorce pokrywają zaskakująco dużo codziennej pracy z danymi.

Co dalej

Znasz już główne typy kolekcji i comprehension, które je łączy. Następny rozdział: funkcje, czyli zamykanie zachowania w nazwanych jednostkach wielokrotnego użytku.