Kurs Python · Moduł 2: Struktury danych

List Comprehensions - Efektywna eksploracja

13 min czytania ·
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 negowane

Zagnież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 kolei

Kiedy 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:

  1. squares - kwadraty liczb od 1 do 10
  2. evens - liczby parzyste od 1 do 20 (warunek if)
  3. upper_animals - nazwy zwierząt wielkimi literami
  4. late_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 if a if-else w 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. 1. Co zwraca: [x*2 for x in range(3)]?

  2. 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)]

  1. PytanieList Comprehension
  2. PytanieList comprehension z warunkiem
  3. Zadanie z kodemList Comprehension
  4. Kliknij w kolejnościList Comprehension

Przydatne artykuły