Kurs Python · Moduł 2: Struktury danych
List Comprehensions - Efektywna eksploracja
W tej lekcji15
Witaj ponownie! Darwin tutaj z kolejnym potężnym narzędziem eksploracyjnym.
W poprzednich lekcjach nauczyłeś/aś się list i słowników. Widziałeś/aś już też zapowiedzi comprehensions - sposobu tworzenia kolekcji w jednej zwięzłej linii. Teraz czas zagłębić się w ten temat!
Comprehensions to jak mapa skarbów - zamiast opisywać krok po kroku jak dotrzeć do celu (tradycyjne pętle), wyrażasz wprost czego szukasz (comprehension). To jedna z najbardziej "pythonowych" cech języka - kod staje się czytelniejszy, krótszy i często szybszy.
Czym są comprehensions?
Comprehension to składnia Pythona pozwalająca tworzyć kolekcje (listy, słowniki, zbiory) w jednej linii, zamiast używać pętli.
# Tradycyjny sposób (4 linie)
squares = []
for x in range(1, 6):
squares.append(x ** 2)
# [1, 4, 9, 16, 25]
# List comprehension (1 linia!)
squares = [x ** 2 for x in range(1, 6)]
# [1, 4, 9, 16, 25]Zalety comprehensions:
- Krótsze - 1 linia zamiast 3-4
- Czytelniejsze - wyrażają intencję wprost
- Szybsze - optymalizowane wewnętrznie przez Python
- Pythonowe - idiomatyczny styl kodu
List comprehensions - podstawy
Składnia: [wyrażenie for element in iterable]
# Przykład 1: Liczby od 0 do 9
numbers = [x for x in range(10)]
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Przykład 2: Kwadraty liczb
squares = [x ** 2 for x in range(1, 11)]
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# Przykład 3: Konwersja temperatur
fahrenheit_temps = [32, 68, 104, 212]
celsius_temps = [(f - 32) * 5/9 for f in fahrenheit_temps]
# [0.0, 20.0, 40.0, 100.0]
# Przykład 4: Wielkie litery
animals = ["tygrys", "słoń", "papuga"]
animals_upper = [animal.upper() for animal in animals]
# ["TYGRYS", "SŁOŃ", "PAPUGA"]
# Przykład 5: Długości słów
species = ["Python", "Elephas", "Leo"]
lengths = [len(s) for s in species]
# [6, 7, 3]Safari przykład - Nazwy odkrytych gatunków
# Mamy listę gatunków (nazwa naukowa)
discovered = ["python regius", "panthera leo", "loxodonta africana"]
# Chcemy je sformatować: Wielkie litery + zamiana spacji na _
formatted = [name.upper().replace(" ", "_") for name in discovered]
# ['PYTHON_REGIUS', 'PANTHERA_LEO', 'LOXODONTA_AFRICANA']
# Lub dodać prefix "SPECIES_"
prefixed = [f"SPECIES_{name.upper()}" for name in discovered]
# ['SPECIES_PYTHON REGIUS', 'SPECIES_PANTHERA LEO', 'SPECIES_LOXODONTA AFRICANA']List comprehensions z warunkami
Składnia: [wyrażenie for element in iterable if warunek]
# Przykład 1: Tylko liczby parzyste
numbers = [x for x in range(1, 11) if x % 2 == 0]
# [2, 4, 6, 8, 10]
# Przykład 2: Tylko liczby nieparzyste
odd_numbers = [x for x in range(1, 11) if x % 2 != 0]
# [1, 3, 5, 7, 9]
# Przykład 3: Tylko dodatnie liczby
temperatures = [-5, 3, -2, 10, 15, -1, 8]
positive = [t for t in temperatures if t > 0]
# [3, 10, 15, 8]
# Przykład 4: Tylko długie słowa (>5 znaków)
animals = ["Tygrys", "Słoń", "Papuga", "Pyton", "Lew"]
long_names = [a for a in animals if len(a) > 5]
# ['Tygrys', 'Papuga']
# Przykład 5: Tylko słowa zaczynające się na 'P'
p_animals = [a for a in animals if a.startswith('P')]
# ['Papuga', 'Pyton']Safari przykład - Filtrowanie odkryć
# Lista odkrytych gatunków z niebezpiecznością
species_data = [
{"name": "Python regius", "dangerous": False, "size": 1.5},
{"name": "Panthera leo", "dangerous": True, "size": 2.5},
{"name": "Elephas maximus", "dangerous": False, "size": 3.0},
{"name": "Crocodylus niloticus", "dangerous": True, "size": 4.5}
]
# Tylko niebezpieczne gatunki
dangerous = [s["name"] for s in species_data if s["dangerous"]]
# ['Panthera leo', 'Crocodylus niloticus']
# Tylko duże gatunki (>2.5m)
large = [s["name"] for s in species_data if s["size"] > 2.5]
# ['Elephas maximus', 'Crocodylus niloticus']
# Tylko bezpieczne i małe (<2m)
safe_small = [s["name"] for s in species_data
if not s["dangerous"] and s["size"] < 2.0]
# ['Python regius']If-else w list comprehensions
Składnia: [wyrażenie_if if warunek else wyrażenie_else for element in iterable]
# Przykład 1: Parzyste/Nieparzyste etykiety
numbers = [1, 2, 3, 4, 5]
labels = ["parzysta" if x % 2 == 0 else "nieparzysta" for x in numbers]
# ['nieparzysta', 'parzysta', 'nieparzysta', 'parzysta', 'nieparzysta']
# Przykład 2: Klasyfikacja temperatur
temps = [15, 25, 35, 10, 30]
classification = ["gorąco" if t > 30 else "normalnie" if t > 20 else "zimno"
for t in temps]
# ['zimno', 'normalnie', 'gorąco', 'zimno', 'normalnie']
# Przykład 3: Konwersja wartości
raw_data = [5, 0, 10, -1, 15, 0, 20]
cleaned = [x if x > 0 else 0 for x in raw_data]
# [5, 0, 10, 0, 15, 0, 20]UWAGA: Składnia if-else jest inna niż samego if!
- Filtrowanie:
[x for x in lista if warunek]- if na końcu - Transformacja:
[x if warunek else y for x in lista]- if-else przed for
# Filtrowanie (pomija elementy)
result = [x for x in range(10) if x % 2 == 0]
# [0, 2, 4, 6, 8] - tylko parzyste
# Transformacja (zmienia elementy)
result = [x if x % 2 == 0 else -x for x in range(10)]
# [0, -1, 2, -3, 4, -5, 6, -7, 8, -9] - parzyste bez zmian, nieparzyste negowaneZagnieżdżone list comprehensions
Możesz zagnieżdżać comprehensions dla złożonych transformacji:
# Przykład 1: Spłaszczanie listy 2D
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
# Przykład 2: Kombinacje
colors = ["red", "green"]
sizes = ["S", "M", "L"]
combinations = [f"{color}_{size}" for color in colors for size in sizes]
# ['red_S', 'red_M', 'red_L', 'green_S', 'green_M', 'green_L']
# Przykład 3: Mnożenie macierzy (uproszczone)
matrix_2d = [[1, 2], [3, 4], [5, 6]]
doubled = [[num * 2 for num in row] for row in matrix_2d]
# [[2, 4], [6, 8], [10, 12]]Safari przykład - Kombinacje ekspedycji
# Zespoły i lokacje
teams = ["Alfa", "Beta", "Gamma"]
locations = ["Dżungla", "Sawanna", "Rzeka"]
# Wszystkie możliwe przydziały
assignments = [f"Zespół {team} → {location}"
for team in teams for location in locations]
# Wynik:
# ['Zespół Alfa → Dżungla', 'Zespół Alfa → Sawanna', 'Zespół Alfa → Rzeka',
# 'Zespół Beta → Dżungla', 'Zespół Beta → Sawanna', 'Zespół Beta → Rzeka',
# 'Zespół Gamma → Dżungla', 'Zespół Gamma → Sawanna', 'Zespół Gamma → Rzeka']Dictionary comprehensions
Składnia: {klucz: wartość for element in iterable}
# Przykład 1: Kwadraty jako słownik
squares = {x: x ** 2 for x in range(1, 6)}
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# Przykład 2: Długości słów
animals = ["Tygrys", "Słoń", "Papuga"]
lengths_dict = {animal: len(animal) for animal in animals}
# {'Tygrys': 6, 'Słoń': 4, 'Papuga': 6}
# Przykład 3: Z dwóch list (zip)
keys = ["Python", "Leo", "Elephas"]
values = ["Pyton", "Lew", "Słoń"]
translation = {k: v for k, v in zip(keys, values)}
# {'Python': 'Pyton', 'Leo': 'Lew', 'Elephas': 'Słoń'}
# Przykład 4: Odwracanie słownika
original = {"a": 1, "b": 2, "c": 3}
reversed_dict = {v: k for k, v in original.items()}
# {1: 'a', 2: 'b', 3: 'c'}Dict comprehension z warunkiem
# Tylko gatunki o nazwie dłuższej niż 5 znaków
animals = ["Tygrys", "Lew", "Słoń", "Papuga", "Pyton"]
long_animals = {a: len(a) for a in animals if len(a) > 5}
# {'Tygrys': 6, 'Papuga': 6}
# Tylko dodatnie wartości
data = {"a": 5, "b": -3, "c": 10, "d": -1, "e": 7}
positive_only = {k: v for k, v in data.items() if v > 0}
# {'a': 5, 'c': 10, 'e': 7}Safari przykład - Katalog gatunków
# Lista krotek (nazwa naukowa, nazwa polska, długość)
species_list = [
("Python regius", "Pyton królewski", 1.5),
("Panthera leo", "Lew", 2.5),
("Elephas maximus", "Słoń azjatycki", 3.0),
("Loxodonta africana", "Słoń afrykański", 3.5)
]
# Stwórz słownik: nazwa_naukowa → {dane}
catalog = {
name: {"pl": pl_name, "length": length}
for name, pl_name, length in species_list
}
print(catalog["Python regius"])
# {'pl': 'Pyton królewski', 'length': 1.5}
# Tylko duże gatunki (>2m)
large_catalog = {
name: {"pl": pl_name, "length": length}
for name, pl_name, length in species_list
if length > 2.0
}
# {'Panthera leo': {...}, 'Elephas maximus': {...}, 'Loxodonta africana': {...}}Set comprehensions
Składnia: {wyrażenie for element in iterable}
# Przykład 1: Unikalne długości
animals = ["Tygrys", "Słoń", "Papuga", "Pyton", "Lew"]
unique_lengths = {len(a) for a in animals}
# {3, 4, 5, 6} - zbiór (bez kolejności, bez powtórzeń)
# Przykład 2: Pierwsze litery
first_letters = {a[0] for a in animals}
# {'T', 'S', 'P', 'L'}
# Przykład 3: Parzyste kwadraty
even_squares = {x ** 2 for x in range(1, 11) if x % 2 == 0}
# {4, 16, 36, 64, 100}Set comprehension automatycznie usuwa duplikaty:
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique = {x for x in numbers}
# {1, 2, 3, 4}
# Można też: set(numbers)
# Ale set comprehension pozwala na transformacje:
unique_doubled = {x * 2 for x in numbers}
# {2, 4, 6, 8}Generator expressions
Składnia: (wyrażenie for element in iterable)
Generator expression wygląda jak list comprehension, ale używa () zamiast []. Różnica: Generator nie tworzy całej listy w pamięci od razu, tylko generuje elementy "na żądanie".
# List comprehension - tworzy całą listę
squares_list = [x ** 2 for x in range(1000000)] # Zajmuje dużo pamięci!
# Generator expression - generuje po kolei
squares_gen = (x ** 2 for x in range(1000000)) # Zajmuje mało pamięci!
# Generator możesz iterować tylko raz
for square in squares_gen:
print(square) # Generuje wartości po koleiKiedy używać generatorów:
- Gdy przetwarzasz duże zbiory danych
- Gdy nie potrzebujesz całej listy od razu
- Gdy iterujesz tylko raz
- Gdy chcesz oszczędzić pamięć
# Sumowanie kwadratów (efektywnie z generatorem)
total = sum(x ** 2 for x in range(1000000))
# Maksimum (efektywnie z generatorem)
max_val = max(x ** 2 for x in range(1000))
# Filtrowanie z generatorem
large_numbers = (x for x in range(1000000) if x > 999990)
for num in large_numbers:
print(num) # Drukuje tylko 9 ostatnich liczb (999991-999999)Safari przykład - Przetwarzanie dużych danych
# Mamy miliony odkryć w bazie
def get_all_species():
"""Symulacja pobierania milionów wpisów"""
for i in range(1000000):
yield {"id": i, "name": f"Species_{i}", "size": i % 100}
# Źle - tworzy całą listę (pamięciożerne!)
# large_species = [s["name"] for s in get_all_species() if s["size"] > 90]
# Dobrze - używa generatora (oszczędne!)
large_species = (s["name"] for s in get_all_species() if s["size"] > 90)
# Możemy iterować bez ładowania wszystkiego do pamięci
for species in large_species:
print(species)Comprehensions vs tradycyjne pętle
Kiedy używać comprehensions?
Użyj comprehension gdy:
- Transformujesz prostą kolekcję
- Filtrujesz elementy po prostym warunku
- Kod mieści się w 1 linii (max 80-100 znaków)
- Logika jest prosta i czytelna
Użyj tradycyjnej pętli gdy:
- Logika jest złożona (wiele if/else)
- Potrzebujesz wielu operacji na każdym elemencie
- Kod staje się nieczytelny
- Potrzebujesz obsługi wyjątków (try/except)
Porównanie
# Dobre zastosowanie comprehension
squares = [x ** 2 for x in range(10)]
even = [x for x in range(20) if x % 2 == 0]
names = [s.upper() for s in species]
# Źle - za skomplikowane dla comprehension
result = [
process_complex_logic(x, y, z)
if check_condition_1(x) and check_condition_2(y)
else alternative_processing(x)
if check_condition_3(z)
else default_value
for x, y, z in complicated_data
if validate(x) and validate(y) and validate(z)
] # NIE RÓB TAK!
# Lepiej - tradycyjna pętla
result = []
for x, y, z in complicated_data:
if not (validate(x) and validate(y) and validate(z)):
continue
if check_condition_1(x) and check_condition_2(y):
result.append(process_complex_logic(x, y, z))
elif check_condition_3(z):
result.append(alternative_processing(x))
else:
result.append(default_value)Wydajność comprehensions
Comprehensions są zazwyczaj szybsze niż tradycyjne pętle!
import time
# Tradycyjna pętla
start = time.time()
result = []
for x in range(1000000):
result.append(x ** 2)
time_loop = time.time() - start
# List comprehension
start = time.time()
result = [x ** 2 for x in range(1000000)]
time_comp = time.time() - start
print(f"Pętla: {time_loop:.4f}s")
print(f"Comprehension: {time_comp:.4f}s")
print(f"Comprehension jest {time_loop/time_comp:.2f}x szybsze!")
# Typowe wyniki:
# Pętla: 0.1234s
# Comprehension: 0.0987s
# Comprehension jest 1.25x szybsze!Dlaczego comprehensions są szybsze?
- Python optymalizuje je wewnętrznie
- Mniej wywołań funkcji (np. append())
- Interpreter "wie" co robisz i może zoptymalizować
Praktyczny przykład - Analiza ekspedycji
# Dane ekspedycji (dzień, dystans km, odkryte gatunki, temperatura °C)
expedition_log = [
(1, 15, 3, 32),
(2, 12, 5, 31),
(3, 8, 2, 35),
(4, 20, 7, 33),
(5, 10, 4, 30),
(6, 18, 6, 34),
(7, 14, 3, 32)
]
# 1. Całkowity dystans
total_distance = sum(day[1] for day in expedition_log)
print(f"Całkowity dystans: {total_distance} km") # 97 km
# 2. Średnia temperatura
avg_temp = sum(day[3] for day in expedition_log) / len(expedition_log)
print(f"Średnia temperatura: {avg_temp:.1f}°C") # 32.4°C
# 3. Dni z dużą liczbą odkryć (>4)
productive_days = [day[0] for day in expedition_log if day[2] > 4]
print(f"Produktywne dni: {productive_days}") # [2, 4, 6]
# 4. Słownik: dzień → dane
daily_stats = {
day: {"distance": dist, "species": spec, "temp": temp}
for day, dist, spec, temp in expedition_log
}
print(daily_stats[1]) # {'distance': 15, 'species': 3, 'temp': 32}
# 5. Klasyfikacja dni
day_types = {
day: "produktywny" if spec > 5 else "normalny" if spec > 3 else "słaby"
for day, dist, spec, temp in expedition_log
}
print(day_types)
# {1: 'słaby', 2: 'normalny', 3: 'słaby', 4: 'produktywny',
# 5: 'normalny', 6: 'produktywny', 7: 'słaby'}
# 6. Tylko gorące dni (>33°C)
hot_days = [(day, temp) for day, dist, spec, temp in expedition_log if temp > 33]
print(f"Gorące dni: {hot_days}") # [(3, 35), (6, 34)]Zagnieżdżone comprehensions - zaawansowane
# Przykład: Macierz odległości między lokacjami
locations = ["Obóz", "Rzeka", "Wodospad", "Szczyt"]
# Stwórz macierz odległości (losowe wartości)
import random
distance_matrix = {
loc1: {
loc2: random.randint(5, 50) if loc1 != loc2 else 0
for loc2 in locations
}
for loc1 in locations
}
print(distance_matrix["Obóz"])
# {'Obóz': 0, 'Rzeka': 23, 'Wodospad': 41, 'Szczyt': 37}
# Znajdź wszystkie pary lokacji z odległością <20km
close_pairs = [
f"{loc1} ↔ {loc2}"
for loc1, distances in distance_matrix.items()
for loc2, dist in distances.items()
if 0 < dist < 20
]
print(close_pairs)Zadanie praktyczne
W edytorze uzupełnij cztery listy, każdą jedną linijką z list comprehension:
squares- kwadraty liczb od 1 do 10evens- liczby parzyste od 1 do 20 (warunekif)upper_animals- nazwy zwierząt wielkimi literamilate_alphabet- zwierzęta, których nazwa w alfabecie wypada po "l"
Kod do tej lekcji: main.py
# List comprehension - eleganckie tworzenie list
# Składnia: [wyrażenie for element in iterable if warunek]
# Zwykłe tworzenie listy
animal_names = ["lew", "słoń", "zebra", "gepard", "hipopotam", "żyrafa"]
# Długości nazw - sposób tradycyjny
lengths = []
for name in animal_names:
lengths.append(len(name))
print(f"Długości (pętla): {lengths}")
# To samo z list comprehension!
lengths_comp = [len(name) for name in animal_names]
print(f"Długości (comprehension): {lengths_comp}")
# Z warunkiem (filtrowanie)
long_names = [name for name in animal_names if len(name) > 4]
print(f"Długie nazwy (>4 znaki): {long_names}")
# Transformacja + filtrowanie
upper_short = [name.upper() for name in animal_names if len(name) <= 4]
print(f"Krótkie WIELKIMI: {upper_short}")
# TODO: Stwórz listę kwadratów liczb od 1 do 10
# squares = [? for ? in range(1, 11)]
squares = []
print(f"\nKwadraty: {squares}")
# TODO: Stwórz listę parzystych liczb od 1 do 20
# evens = [? for ? in range(1, 21) if ?]
evens = []
print(f"Parzyste: {evens}")
# TODO: Stwórz listę nazw zwierząt zapisanych wielkimi literami
# upper_animals = [? for ? in animal_names]
upper_animals = []
print(f"Wielkie litery: {upper_animals}")
# TODO: Stwórz listę zwierząt zaczynających się na literę > "l" (alfabetycznie)
# late_alphabet = [? for ? in animal_names if ?]
late_alphabet = []
print(f"Po 'l' w alfabecie: {late_alphabet}")
Podsumowanie
W tej lekcji nauczyłeś/aś się:
- Czym są comprehensions i dlaczego są potężne
- List comprehensions (podstawowe i z warunkami)
- Dictionary comprehensions
- Set comprehensions
- Generator expressions (oszczędność pamięci)
- Zagnieżdżone comprehensions
- Kiedy używać comprehensions vs pętle
- Wydajność comprehensions
Checkpoint
Przed przejściem dalej:
- Rozumiesz składnię list comprehension
- Potrafisz używać warunków (if) w comprehensions
- Rozumiesz różnicę między
ifaif-elsew comprehension - Potrafisz tworzyć dict comprehensions
- Znasz różnicę między listą a generatorem
- Wiesz kiedy używać comprehension, a kiedy pętlę
Pythonowa zasada: "Proste jest lepsze niż skomplikowane" - jeśli comprehension robi kod nieczytelnym, użyj tradycyjnej pętli!
W następnej lekcji Darwin pokaże Ci algorytmy sortowania - jak porządkować katalog gatunków!
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Co zwraca: [x*2 for x in range(3)]?
2. Co zwraca: [x for x in range(5) if x % 2 == 0]?
Zadania praktyczne w grze
- Edytor kodu
Utwórz listę squares z kwadratami liczb od 1 do 5, używając list comprehension
- Klikanie w kolejności
Kliknij w kolejności: [x**2 for x in range(5)]