Listy składane i słowniki składane – jak pisać krótszy i czytelniejszy kod w Pythonie?

Wprowadzenie do składni list comprehensions i dictionary comprehensions

Python oferuje zwięzły i czytelny sposób tworzenia nowych kolekcji danych — tzw. comprehensions. Są to specjalne konstrukcje językowe umożliwiające tworzenie list, słowników oraz zbiorów w sposób deklaratywny, przypominający bardziej opis tego, co chcemy uzyskać, niż jak to zrobić krok po kroku.

List comprehensions pozwalają na tworzenie list poprzez przekształcanie lub filtrowanie elementów z innych kolekcji (np. list, zakresów, zbiorów, itp.). Zamiast stosować pętle i instrukcje warunkowe w kilku liniach kodu, można zapisać to samo w jednej, bardziej kompaktowej formie.

Dictionary comprehensions są podobne w działaniu, ale służą do tworzenia słowników. Umożliwiają szybkie budowanie par klucz-wartość na podstawie istniejących danych, często z przekształceniem lub filtrowaniem, co pozwala uzyskać czysty i uporządkowany kod.

Obie formy comprehensions zwiększają czytelność i skracają kod, eliminując potrzebę stosowania wieloliniowych konstrukcji z użyciem pętli i instrukcji warunkowych. Ich składnia jest przejrzysta i intuicyjna, co czyni je jednymi z ulubionych narzędzi w arsenale programisty Pythona.

Warto jednak pamiętać, że mimo podobieństw list comprehensions i dictionary comprehensions różnią się zastosowaniem — pierwsze generują sekwencje, drugie zaś struktury asocjacyjne. Znajomość obu rodzajów comprehensions znacząco wpływa na jakość i efektywność pisanego kodu.

Zalety stosowania comprehensions w Pythonie

List comprehensions i dictionary comprehensions to zwięzłe konstrukcje języka Python, które umożliwiają szybkie tworzenie list i słowników na podstawie istniejących danych. Ich stosowanie niesie ze sobą wiele korzyści, które sprawiają, że są one preferowaną formą pisania kodu w wielu przypadkach, zwłaszcza tam, gdzie liczy się czytelność i efektywność. Z doświadczenia szkoleniowego Cognity wiemy, że ten temat budzi duże zainteresowanie – również wśród osób zaawansowanych.

• Krótszy kod: Comprehensions pozwalają wyrazić operacje przekształcania danych w jednej, zwartej linii, co znacząco ogranicza liczbę linii kodu w porównaniu z klasycznymi pętlami.
• Lepsza czytelność: Dobrze napisane comprehensions są łatwe do zrozumienia i jasno pokazują intencję programisty bez konieczności analizowania całej struktury pętli.
• Wydajność: W wielu przypadkach comprehensions działają szybciej niż ich odpowiedniki oparte na pętlach, ponieważ są zoptymalizowane wewnętrznie przez interpreter Pythona.
• Przejrzysta składnia: Użycie składni comprehensions sprawia, że kod wygląda bardziej „pythonicznie”, co jest zgodne z filozofią języka zakładającą pisanie prostego i przejrzystego kodu.
• Łatwe filtrowanie danych: Dzięki możliwości dodawania warunków w comprehensions, łatwo ograniczyć wynik do elementów spełniających określone kryteria.

Comprehensions są szczególnie użyteczne przy pracy z kolekcjami danych, takich jak listy, słowniki czy zbiory, i stanowią praktyczne narzędzie w codziennym programowaniu w Pythonie. Choć ich składnia może wydawać się na początku mniej intuicyjna, nabierają sensu wraz z praktyką i znacząco przyspieszają proces tworzenia kodu.

Zamiana tradycyjnych pętli for na list comprehensions – przykłady

List comprehensions to zwięzła i często bardziej czytelna alternatywa dla klasycznych pętli for używanych do tworzenia nowych list na podstawie istniejących danych. Pozwalają one połączyć iterację, filtrację i przekształcanie elementów w jednej, skondensowanej konstrukcji.

Podstawowa różnica między tradycyjnym podejściem a list comprehension polega na tym, że zamiast tworzyć pustą listę i dodawać do niej elementy wewnątrz pętli, w składanej liście cały ten proces zamykany jest w jednej linii kodu.

numbers = [1, 2, 3, 4, 5]
squares = []
for n in numbers:
    squares.append(n ** 2)

numbers = [1, 2, 3, 4, 5]
squares = [n ** 2 for n in numbers]

words = ["Python", "is", "fun"]
lengths = []
for word in words:
    lengths.append(len(word))

words = ["Python", "is", "fun"]
lengths = [len(word) for word in words]

Jak widać, składane listy pozwalają znacząco skrócić kod, eliminując potrzebę inicjalizacji pustej listy i jawnego wywoływania append(). Dzięki temu kod staje się bardziej deklaratywny – od razu widać, że jego celem jest utworzenie nowej listy na podstawie przekształcenia istniejącej sekwencji.

Warto jednak pamiętać, że chociaż list comprehensions poprawiają zwięzłość, nie zawsze będą najlepszym wyborem w przypadku bardzo złożonej logiki – o tym więcej w dalszych częściach artykułu. Jeśli chcesz nauczyć się praktycznego wykorzystania takich technik w pracy z danymi, sprawdź Kurs Python - praktyczne wykorzystanie Pythona do analizy danych i automatyzacji.

Tworzenie słowników za pomocą dictionary comprehensions

Dictionary comprehensions to zwięzła składnia w Pythonie pozwalająca tworzyć słowniki w sposób deklaratywny i przejrzysty. Podobnie jak list comprehensions, umożliwiają one budowanie struktur danych w jednej linii kodu, eliminując konieczność stosowania wielokrotnych pętli i przypisań.

Podstawowa składnia dictionary comprehension wygląda następująco:

{klucz: wartość for element in iterable}

Taka konstrukcja pozwala dynamicznie generować pary klucz–wartość na podstawie zewnętrznego źródła danych, np. listy, zakresu liczb czy innego słownika. Przykład:

kwadraty = {x: x**2 for x in range(5)}

Rezultat:

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Dictionary comprehensions są szczególnie przydatne, gdy chcemy:

• przekształcić lub przefiltrować dane wejściowe do formatu słownikowego,
• usuwać duplikaty i przypisywać nowe wartości do istniejących kluczy,
• tworzyć nowe słowniki na podstawie już istniejących z modyfikacją kluczy lub wartości.

W czasie szkoleń Cognity ten temat bardzo często budzi ożywione dyskusje między uczestnikami.

Poniżej porównanie tworzenia słownika przy użyciu tradycyjnej pętli oraz dictionary comprehension:

numbers = [1, 2, 3]
squares = {}
for n in numbers:
    squares[n] = n ** 2

numbers = [1, 2, 3]
squares = {n: n ** 2 for n in numbers}

Jak widać, dictionary comprehensions pozwalają na znaczne skrócenie kodu bez utraty jego przejrzystości. W kolejnych częściach artykułu omówimy bardziej zaawansowane zastosowania, takie jak filtrowanie danych lub zagnieżdżanie struktur comprehensions.

Zaawansowane techniki – warunki i zagnieżdżenia w comprehensions

Składane listy (list comprehensions) i składane słowniki (dictionary comprehensions) to nie tylko sposób na skrócenie kodu – oferują również możliwość stosowania warunków oraz zagnieżdżonych struktur, które znacznie zwiększają ich funkcjonalność. Jeśli chcesz pogłębić swoją wiedzę i praktykę w pracy z danymi w Pythonie, sprawdź nasze szkolenie Kurs Python - kompleksowa analiza danych w Pythonie z wykorzystaniem bibliotek Pandas, NumPy, Matplotlib i Scikit-Learn.

Warunki w comprehensions

Jedną z głównych zalet comprehensions jest możliwość wbudowania logiki warunkowej bez konieczności pisania rozbudowanych instrukcji if. Warunki mogą pojawiać się:

• po pętli – filtrując elementy, które zostaną dodane (warunek końcowy)
• przed pętlą – w formie wyrażeń warunkowych (np. value_if_true if condition else value_if_false)

Przykład filtrowania wartości parzystych:

# Lista tylko z parzystych liczb
numbers = [1, 2, 3, 4, 5, 6]
even = [n for n in numbers if n % 2 == 0]

Przykład prostego wyrażenia warunkowego w list comprehension:

# Zwraca "parzysta" lub "nieparzysta" dla każdej liczby
labels = ["parzysta" if n % 2 == 0 else "nieparzysta" for n in numbers]

Zagnieżdżone comprehensions

Comprehensions mogą również zawierać zagnieżdżone pętle, co pozwala na ich użycie np. przy przekształcaniu struktur dwuwymiarowych czy generowaniu permutacji.

Przykład spłaszczania macierzy (listy list):

# Macierz 2x2
matrix = [[1, 2], [3, 4]]
flattened = [element for row in matrix for element in row]

Zagnieżdżenia działają identycznie jak w pętlach for, ale wymagają zachowania kolejności – najpierw pojawia się pierwsza pętla, potem kolejna itd.

Porównanie: warunki i zagnieżdżenia

Umiejętność korzystania z warunków i zagnieżdżeń w comprehensions pozwala na znaczną oszczędność kodu i zwiększenie jego przejrzystości, pod warunkiem zachowania umiaru i dbałości o czytelność.

Porównanie czytelności: comprehensions vs tradycyjne pętle

Jednym z głównych powodów, dla których Python zyskał popularność, jest jego czytelna i zwięzła składnia. W tym kontekście list comprehensions i dictionary comprehensions stanowią potężną alternatywę dla tradycyjnych pętli for, umożliwiając tworzenie list i słowników w sposób bardziej deklaratywny.

Porównajmy podstawowe różnice między tymi podejściami:

Oto przykład prostego przekształcenia listy liczb na ich kwadraty:

# Tradycyjna pętla
numbers = [1, 2, 3, 4, 5]
squares = []
for n in numbers:
    squares.append(n * n)

# List comprehension
squares = [n * n for n in numbers]

Jak widać, list comprehension pozwala zapisać ten sam efekt w sposób bardziej zwarty. Jednak nie zawsze jest to korzystne — w przypadku bardziej złożonej logiki tradycyjna pętla może pozostać bardziej zrozumiała.

Wybór między tymi podejściami zależy więc głównie od balansu między zwięzłością a przejrzystością kodu. Dobrą praktyką jest stosowanie comprehensions tam, gdzie służą poprawie czytelności, a nie jej zaburzeniu.

Najczęstsze błędy i dobre praktyki

Listy składane (list comprehensions) i słowniki składane (dictionary comprehensions) to niezwykle użyteczne konstrukcje w Pythonie, które pozwalają na tworzenie nowych struktur danych w sposób bardziej zwięzły i często bardziej czytelny niż przy użyciu klasycznych pętli. Jednak niewłaściwe ich użycie może prowadzić do błędów lub obniżenia czytelności kodu. Poniżej przedstawiamy najczęstsze pułapki oraz dobre praktyki związane z ich stosowaniem.

• Nadmierna złożoność wyrażeń: jedną z najczęstszych pułapek jest umieszczanie zbyt wielu operacji w jednym wyrażeniu składanym. Takie konstrukcje są trudne do zrozumienia i utrzymania.
• Brak czytelności: chociaż składnie składane są krótsze, nie zawsze są bardziej czytelne. Jeśli kod staje się niejasny, lepiej zastosować tradycyjną pętlę.
• Nieużywanie warunków, gdy są potrzebne: często pomija się możliwość filtrowania danych w składni, co prowadzi do tworzenia niepotrzebnie rozbudowanych struktur lub późniejszej filtracji, co mogło zostać rozwiązane już na etapie składania.
• Tworzenie zbędnych kopii: niektórzy programiści używają list comprehensions do operacji, które nie wymagają tworzenia nowej listy (np. tylko dla efektów ubocznych), co powoduje niepotrzebne zużycie pamięci.
• Zła czytelność przy zagnieżdżeniach: stosowanie zagnieżdżonych składni składanych bez odpowiedniego komentarza lub formatowania może prowadzić do kodu trudnego do analizy.

Aby uniknąć tych problemów, warto stosować się do kilku sprawdzonych praktyk:

• Używaj składni składanych dla prostych operacji: najlepiej sprawdzają się tam, gdzie logika jest prosta i jednoznaczna.
• Stosuj warunki bezpośrednio w wyrażeniu: pozwala to ograniczyć wynikowe dane tylko do tych spełniających określone kryteria.
• Zachowaj umiar w długości: jeśli składnia składana zajmuje więcej niż jedną linię i trudno ją zrozumieć na pierwszy rzut oka, rozważ zastosowanie tradycyjnej pętli.
• Unikaj efektów ubocznych: składnie składane nie powinny być używane, jeśli głównym celem jest wykonanie działania, a nie stworzenie nowej kolekcji.
• Dąż do czytelności: pamiętaj, że kod piszesz nie tylko dla komputera, ale również dla innych programistów (i siebie w przyszłości).

Podsumowanie i rekomendacje

List comprehensions i dictionary comprehensions to potężne narzędzia w języku Python, które pozwalają na tworzenie list oraz słowników w sposób bardziej zwięzły i przejrzysty. Dzięki nim możliwe jest zapisanie wieloetapowych operacji w jednej, czytelnej konstrukcji, co znacząco poprawia efektywność pisania i czytania kodu.

Podstawowa różnica między tymi dwoma technikami polega na typie zwracanej struktury danych: list comprehensions generują listy, natomiast dictionary comprehensions tworzą słowniki. Obie formy umożliwiają zastosowanie wyrażeń warunkowych, filtrowanie danych oraz przekształcanie elementów w sposób bardziej deklaratywny niż tradycyjne pętle.

Stosowanie comprehensions jest szczególnie polecane tam, gdzie zależy nam na szybkim i eleganckim przekształceniu danych. Aby jednak w pełni wykorzystać ich potencjał, warto kierować się zasadą przejrzystości: jeśli wyrażenie staje się zbyt złożone, lepszym wyborem może być bardziej rozbudowana, ale czytelniejsza forma imperatywna.

Dobrą praktyką jest również umiejętne wykorzystywanie comprehensions tylko wtedy, gdy rzeczywiście poprawiają czytelność i strukturę kodu. Należy unikać ich nadużywania w przypadku skomplikowanej logiki lub wielu poziomów zagnieżdżeń.

Podsumowując, comprehensions to jedno z narzędzi, które znacząco wzbogacają składnię Pythona, czyniąc go bardziej eleganckim i wydajnym językiem do pracy z kolekcjami danych. Odpowiedzialne ich użycie może przełożyć się na lepszą jakość i klarowność kodu. Jeśli chcesz poznać więcej takich przykładów, zapraszamy na szkolenia Cognity, gdzie rozwijamy ten temat w praktyce.

Shadow AI – czym jest i dlaczego jest zagrożeniem dla organizacji? 05 lutego 2026

Operatory w Pythonie – arytmetyczne, logiczne i porównania z przykładami 03 lutego 2026