Samouczek dotyczący rozumienia słownika Pythona

Język programowania Python oferuje unikalny zestaw narzędzi, dzięki którym kodowanie jest nie tylko zabawne, ale także przyspiesza Twoje postępy jako programisty. Ze względu na łatwość użycia Python stał się językiem podstawowym dla różnych branż, od tworzenia stron internetowych i nauki o danych po finanse i nie tylko.

Rozumienie słownika języka Python jest ważnym narzędziem, które umożliwia dynamiczne generowanie słowników poprzez iterację istniejących iterowalnych struktur danych lub słowników w celu tworzenia nowych. Rozumienie słownikowe można traktować jako podobne do rozumienia listy, ale z nieco innym przypadkiem użycia.

Gdy zapoznasz się ze zrozumieniem, odkryjesz, że mogą one znacznie poprawić kod, zwiększając przejrzystość i eliminując potrzebę długich, powtarzających się pętli.

Jeśli jesteś nowy w Pythonie , być może nie spotkałeś się ze zrozumieniem lub nie używałeś go w swoim kodzie. Zanim zagłębimy się w składnię, odpowiedzmy na podstawowe pytanie: Czym jest rozumienie ze słownika Pythona?

Spis treści

• Co to jest rozumienie słownika Pythona?
• Zrozumienie składni rozumienia słownika
• Przykłady rozumienia słownika
  • Odwzorowywanie liczb na ich kwadraty
  • Odwróć klucze i wartości
• 3 główne zalety rozumienia słownika
  • 1. Tworzenie jasnego i prostego kodu
  • 2. Lepsza wydajność w dobrym stylu
  • 3. Łatwe filtrowanie i transformacja danych
• 3 Przykłady, kiedy używać słownika ze zrozumieniem
  • 1. Podczas tworzenia słownika z dwóch list
  • 2. Podczas filtrowania słownika na podstawie wartości
  • 3. Podczas przekształcania kluczy lub wartości
• Pułapki rozumienia słownika
  • Równoważenie złożoności i czytelności
  • Wydajność z dużymi zestawami danych
• Porównanie z innymi metodami
  • Dla pętli
  • Funkcje lambdy
• Najlepsze praktyki dotyczące rozumienia słownika
• Nasze ostatnie zdanie

Co to jest rozumienie słownika Pythona?

Python Dictionary Comprehension to zwięzły sposób tworzenia słowników przy użyciu prostych wyrażeń. Pozwala generować nowe słowniki bez konieczności używania for-loops.e

Spójrzmy na przykład zrozumienia. Załóżmy, że masz dwie listy, jedną zawierającą klucze, a drugą wartości:

keys = ['a', 'b', 'c']
values = [1, 2, 3]

Korzystając ze słownikowego rozumienia, możesz utworzyć nowy słownik, przeglądając dwie listy i łącząc odpowiednie pary klucz-wartość:

my_dict = {k: v for k, v in zip(keys, values)}
print(my_dict)

Wyjście będzie:

{'a': 1, 'b': 2, 'c': 3}

Powyższy przykład powinien dać wyobrażenie o tym, czym są wyrażenia w Pythonie . Aby jeszcze bardziej pomóc Ci utrwalić tę koncepcję, przyjrzyjmy się składni pojęć słownikowych w Pythonie.

Zrozumienie składni rozumienia słownika

Składnia rozumienia ze słownika jest prosta, ale potężna. Oferują zwięzły sposób tworzenia nowego słownika w Pythonie . Ponadto stosują podobną składnię do rozumienia list, ale używają nawiasów klamrowych {} i pary klucz-wartość oddzielonych dwukropkiem.

Podstawowa struktura jest następująca:

{key: value for (key, value) in iterable}

W tej składni klucz i wartość reprezentują wyrażenia używane do generowania kluczy i wartości wynikowego słownika. Iterowalność zapewnia źródło danych używanych do tworzenia par klucz-wartość.

Ta składnia została wprowadzona w Pythonie 3 i przeniesiona aż do Pythona 2.7, zapewniając szeroką kompatybilność między wersjami Pythona.

Na przykład, aby utworzyć słownik, który odwzorowuje liczby od 0 do 4 na ich kwadraty przy użyciu rozumienia słownikowego, możesz użyć następującego kodu Pythona:

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

Spowoduje to powstanie następującego słownika:

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

Co zrobić, jeśli chcesz iterować po dwóch zmiennych w tym samym czasie? Możesz to osiągnąć za pomocą rozumienia słownika za pomocą funkcji zip() w celu utworzenia słownika z dwóch iteracji, jednej reprezentującej klucze, a drugiej reprezentującej wartości. Oto przykład:

keys = ['a', 'b', 'c', 'd', 'e']
values = [1, 2, 3, 4, 5]
my_dict = {k: v for k, v in zip(keys, values)}

Wynikowy słownik będzie:

{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

Rozumienie słownikowe umożliwia również dodanie opcjonalnej instrukcji if na końcu rozumienia, aby zastosować filtr warunkowy do uwzględnionych elementów.

Na przykład możesz utworzyć słownik zawierający tylko liczby parzyste i ich kwadraty, korzystając ze słownikowego rozumienia:

even_square_dict = {x: x**2 for x in range(10) if x % 2 == 0}

To skutkuje:

{0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

Teraz, gdy masz już pewną znajomość składni rozumienia, spójrzmy na kilka przykładów rozumienia.

Przykłady rozumienia słownika

Ze względu na potężną i elegancką składnię, rozumienie ze słownika znajduje szereg przypadków użycia. Mogą zaoszczędzić czas i sprawić, że Twój kod będzie bardziej czytelny.

Odwzorowywanie liczb na ich kwadraty

Rozważmy prosty przykład, w którym chcemy utworzyć słownik odwzorowujący liczby na ich kwadraty przy użyciu wyrażeń słownikowych Pythona:

squares = {x: x**2 for x in range(1, 6)}
print(squares)

Spowoduje to wyświetlenie:

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Powyższy kod wykonuje to samo zadanie, co sześciokrotne uruchomienie pętli i podniesienie każdej liczby do kwadratu. Poniższy kod ilustruje uruchomienie pętli w celu pobrania kwadratów liczb:

squares = {}
for x in range(1, 6):
    squares[x] = x ** 2

print(squares)

W tym momencie możesz się zastanawiać, po co używać rozumienia, skoro można używać pętli. Praktyczną zasadą w programowaniu jest pisanie zwięzłego i wydajnego kodu.

Możesz również zastosować warunki do zrozumienia. Na przykład możesz chcieć utworzyć słownik zawierający tylko liczby parzyste i ich kwadraty:

even_squares = {x: x**2 for x in range(1, 6) if x % 2 == 0}
print(even_squares)

Uruchomienie tego kodu spowoduje utworzenie nowego słownika, takiego jak następujący:

{2: 4, 4: 16}

Odwróć klucze i wartości

Możesz także z łatwością odwracać elementy słownika za pomocą rozumienia słownika w Pythonie.

Poniższy kod demonstruje, jak odwrócić klucze i wartości istniejącego słownika przy użyciu rozumienia słownika:

original_dict = {"one": 1, "two": 2, "three": 3, "four": 4}
reversed_dict = {v: k for k, v in original_dict.items()}
print(reversed_dict)

Powyższe rozumienie słownika (lub rozumienie dyktowane) wyświetli następujące informacje:

{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

Aby dobrze zrozumieć, czym są słowniki i jak można ich używać w różnych przypadkach, obejrzyj poniższy film:

Podane przykłady stanowią solidną podstawę do stosowania rozumienia ze słownika w projektach Pythona.

Ponadto rozumienie słownika można dalej optymalizować, dzięki czemu pojedynczy wiersz kodu może wykonywać złożone zadania, które mogą pochłaniać więcej czasu i pamięci dzięki pętlom.

3 główne zalety rozumienia słownika

Doświadczyłeś elegancji słownikowego rozumienia dzięki dostarczonym przykładom. Oprócz czytelności, rozumienie ma kilka zalet, w tym wydajność, podczas pracy z wydajną strukturą tablicy skrótów kluczy/wartości Pythona, zwaną rozumieniem dyktowanym .

1. Tworzenie jasnego i prostego kodu

Zrozumienia umożliwiają tworzenie nowych słowników bez wysiłku iw czytelny sposób. Sprawiają, że Twój kod wygląda i jest bardziej Pythoniczny w porównaniu z tradycyjnymi pętlami.

2. Lepsza wydajność w dobrym stylu

Rozumienie jest nie tylko eleganckie, ale także wydajne. Często działają szybciej niż pętle for, ponieważ używają jednego wyrażenia. Python optymalizuje ten rodzaj kodu, eliminując potrzebę wielokrotnego wywoływania konstruktora słownika lub używania metody update().

3. Łatwe filtrowanie i transformacja danych

Kolejną zaletą rozumienia słownikowego jest prostota filtrowania i przekształcania danych. Na przykład możesz utworzyć nowy słownik z istniejącego, stosując warunek lub modyfikując klucze lub wartości.

Bardzo ważne jest, aby zrozumieć, kiedy używać rozumienia ze słownika w Pythonie, ponieważ mogą one szybko stać się złożone i trudniejsze do czytania i pisania. Przyjrzyjmy się teraz niektórym przypadkom użycia rozumienia ze słownika w Pythonie.

3 Przykłady, kiedy używać słownika ze zrozumieniem

Rozumienie jest przydatne w następujących 3 scenariuszach:

1. Podczas tworzenia słownika z dwóch list

{key:value for key, value in zip(list1, list2)}

2. Podczas filtrowania słownika na podstawie wartości

{k: v for k, v in original_dict.items() if v > threshold}

3. Podczas przekształcania kluczy lub wartości

{k.upper(): v * 2 for k, v in original_dict.items()}

Należy pamiętać, że chociaż wyrażenia ze zrozumieniem mogą uczynić kod bardziej eleganckim i wydajnym, mogą również stać się trudne do odczytania, jeśli są zbyt złożone.

Przyjrzyjmy się niektórym z najczęstszych pułapek podczas korzystania ze słownikowych wyjaśnień.

Pułapki rozumienia słownika

Rozumienie słownikowe zapewnia elegancję i wydajność, ale wiąże się również z wyzwaniami. Omówimy typowe pułapki związane z czytelnością, złożonością i wydajnością w przypadku dużych zestawów danych.

Równoważenie złożoności i czytelności

Złożone wyrażenia słownikowe mogą być trudne do odczytania. Priorytetowo traktuj czytelność kodu, zwłaszcza podczas pracy z innymi. W niektórych przypadkach tradycyjne pętle for mogą być prostsze i łatwiejsze w utrzymaniu.

Wydajność z dużymi zestawami danych

W przypadku dużych zbiorów danych rozumienie słownikowe może nie zawsze być optymalne. Według Stack Overflow , wbudowany konstruktor dict() może przewyższyć rozumienie słownikowe z licznymi parami klucz-wartość dzięki pętli w C.

Porównanie z innymi metodami

W tej sekcji porównamy rozumienie słownikowe z dwiema alternatywnymi metodami tworzenia słowników w Pythonie: pętlami for i funkcjami lambda.

Dla pętli

Użycie pętli for do utworzenia słownika obejmuje zainicjowanie pustego słownika, a następnie iterację żądanej prawidłowej pary klucz-wartość, dodając każdą parę do słownika. Jest to bardziej szczegółowa metoda w porównaniu ze zrozumieniem słownikowym.

Poniżej znajduje się przykład tworzenia słownika przy użyciu pętli for:

dictionary = {}
for key, value in zip(keys, values):
    dictionary[key] = value

I odwrotnie, rozumienie słownikowe pozwala osiągnąć ten sam wynik w jednym wierszu:

dictionary = {key: value for key, value in zip(keys, values)}

Jak widać, rozumienie zapewnia zwięzły i bardziej czytelny sposób tworzenia słowników w Pythonie.

Funkcje lambdy

Możemy również użyć funkcji Lambda do tworzenia słowników. Funkcje lambda to sposób na tworzenie małych, anonimowych funkcji w Pythonie. Można ich używać w połączeniu z funkcją map() do tworzenia słowników.

Spójrzmy na przykład funkcji Lambda do tworzenia słowników:

keys = ['a', 'b', 'c']
values = [1, 2, 3]

key_value_pairs = map(lambda key, value: (key, value), keys, values)
dictionary = dict(key_value_pairs)

Dla porównania, oto jak ten sam słownik można utworzyć za pomocą rozumienia:

dictionary = {key: value for key, value in zip(keys, values)}

Ponownie, rozumienie słownikowe zapewnia zwięzłą i bardziej czytelną alternatywę dla tworzenia słowników przy użyciu funkcji lambda i funkcji map().

Najlepsze praktyki dotyczące rozumienia słownika

Podczas korzystania ze zrozumienia w języku Python konieczne jest przestrzeganie najlepszych praktyk w celu poprawy czytelności, łatwości konserwacji i wydajności. Oto kilka najlepszych praktyk do rozważenia:

1. Staraj się, aby rozumienie ze słownika było proste

Rozumienie słownika jest potężne, ale powinno być jasne i zwięzłe. Jeśli rozumienie staje się zbyt złożone lub obejmuje wiele wierszy, rozważ zamiast tego użycie tradycyjnej pętli for. Pomaga to w zrozumieniu kodu, szczególnie dla innych osób lub podczas ponownego odwiedzania pracy później.

2. Wykorzystaj wbudowane funkcje

Python oferuje wbudowane funkcje, takie jak zip() i enumerate(), które pomagają w tworzeniu zrozumienia. Użyj tych funkcji, aby usprawnić swój kod i uczynić go bardziej czytelnym.

Na przykład użycie metody zip() do połączenia dwóch list i utworzenia słownika daje zwięzły i przejrzysty kod, taki jak ten:

{key: value for key, value in zip(keys, values)}

3. Mądrze używaj instrukcji warunkowych

W razie potrzeby włącz instrukcje warunkowe do swojego rozumienia, ale nie nadużywaj ich. Mogą pomóc w filtrowaniu lub modyfikowaniu wynikowego słownika, ale zbyt wiele zagnieżdżonych warunków może sprawić, że kod będzie trudny do odczytania. Prostym przykładem instrukcji warunkowej jest:

{x: x**2 for x in range(10) if x % 2 == 0}

4. Uważaj na zagnieżdżone rozumienie słownika

Zagnieżdżone rozumienie słownika może generować słowniki z zagnieżdżonymi strukturami. Jednak, podobnie jak w przypadku instrukcji warunkowych, nadmiar słownika zagnieżdżonego może utrudnić odszyfrowanie kodu. Unikaj wychodzenia poza dwa poziomy zagnieżdżania w rozumieniu zagnieżdżonego słownika.

Czasami może być konieczne użycie słownika zagnieżdżonego wewnątrz pętli, aby osiągnąć pożądaną wydajność.

Nasze ostatnie zdanie

Do tej pory opanowałeś rozumienie ze słownika w Pythonie. Ta elegancka, wydajna technika pomaga tworzyć słowniki poprzez iterację elementów iterowalnych lub stosowanie warunków. Zrozumienia usprawniają kod, zwiększając czytelność i łatwość konserwacji.

Tworzenie nowych słowników jest łatwe ze zrozumieniem, oszczędzając czas i wysiłek w porównaniu z tradycyjnymi pętlami for. Są przydatne w rzeczywistych aplikacjach, takich jak przetwarzanie danych, mapowanie i transformacja.

Jeśli chcesz poszerzyć swoją wiedzę o Pythonie i stać się prawdziwym profesjonalistą, na nasz kurs Pythona i zobacz, jak tworzymy najlepszych na świecie użytkowników Pythona.