Warning: Undefined array key "pl" in /home/host1693024/python-3.com/htdocs/www/875348534534.php on line 2036
Zrozumienia zestawów Pythona: jak i kiedy ich używać

Zrozumienia zestawów Pythona: jak i kiedy ich używać

Wyjaśnienia zestawów w języku Python zapewniają zwięzły sposób tworzenia zestawów i manipulowania nimi w kodzie. Generują zestawy z czystą składnią, dzięki czemu Twój kod jest bardziej czytelny i Pythoniczny. Dzięki zrozumieniu zestawów możesz tworzyć, przekształcać i filtrować zestawy, co jest świetną umiejętnością, którą warto dodać do zestawu narzędzi programistycznych w języku Python.

Pod koniec tego samouczka zrozumiesz, że:

  • Python ma ustawione zrozumienie , które pozwalają tworzyć zestawy z zwięzłą składnią .
  • Python ma cztery typy zrozumienie: lista , set , słownik i generator Wyrażenia.
  • Zrozumienie zbioru można zapisać jako {wyrażenie elementu w iterowalnym [warunek if].
  • Zestawy nie mogą zawierać duplikatów, ponieważ zapewniają one, że wszystkie ich elementy są unikalne.

Aby jak najlepiej wykorzystać ten samouczek, powinieneś zapoznać się z podstawowymi pojęciami Python, takimi jak dla pętli , iterables, rozumianie list i zrozumienie słownika.

Tworzenie i przekształcanie zbiorów w Pythonie

W programowaniu Python może być konieczne tworzenie, zapełnienie i przekształcenie zestawów. Aby to zrobić, możesz użyć Set Literals, set() Konstruktor i dla pętli . W poniższych sekcjach szybko przyjrzysz się, jak korzystać z tych narzędzi. Dowiesz się również o zestawach Set, które są potężnym sposobem na manipulowanie zestawami w Python.

Tworzenie zbiorów za pomocą literałów i set()

Aby utworzyć nowe zestawy, możesz użyć literałów. Literał ustawiający to seria elementów ujętych w nawiasy klamrowe. Poniżej pokazano składnię literału zestawu:

{element_1, element_2,..., element_N}

Elementy muszą być obiektami do skróconego. Obiekty w literaturze mogą być zduplikowane, ale tylko jeden instancja będzie przechowywana w uzyskanym zestawie. Zestawy nie pozwalają na zduplikowane elementy. Oto szybki przykład zestawu:

>>> colors = {"blue", "red", "green", "orange", "green"}
>>> colors
{'red', 'green', 'orange', 'blue'}

>>> colors.add("purple")
>>> colors
{'red', 'green', 'orange', 'purple', 'blue'}

W tym przykładzie tworzysz zestaw zawierający nazwy kolorów. Elementy w wynikowym zestawie są unikalnymi obiektami typu string. Możesz dodawać nowe elementy za pomocą metody .add(). Pamiętaj, że zestawy są kolekcjami nieuporządkowanymi, dlatego w większości przypadków kolejność elementów w wynikowym zestawie nie będzie odpowiadać kolejności wstawiania.

Możesz także utworzyć nowy zestaw, używając konstruktora set() i iterowalnej liczby obiektów:

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

>>> set(numbers)
{1, 2, 3, 4}

W tym przykładzie tworzysz nowy zestaw za pomocą set() z listą wartości liczbowych. Zwróć uwagę, że wynikowy zestaw nie zawiera zduplikowanych elementów. W praktyce konstruktor set() jest doskonałym narzędziem do eliminowania zduplikowanych wartości w iterables.

Aby utworzyć pusty zestaw, użyj konstruktora set() bez argumentów:

>>> set()
set()

Nie możesz utworzyć pustego zestawu z literałem, ponieważ para nawiasów klamrowych {} reprezentuje pusty słownik, a nie zbiór. Aby utworzyć pusty zbiór, należy użyć konstruktora set().

Używając pętli do wypełniania zestawów

Czasami musisz zacząć od pustego zestawu i dynamicznie wypełnić go elementami. Aby to zrobić, możesz użyć pętli dla . Na przykład powiedz, że chcesz utworzyć zestaw unikalnych słów z tekstu. Oto jak to zrobić z pętlą:

>>> unique_words = set()

>>> text = """
... Beautiful is better than ugly
... Explicit is better than implicit
... Simple is better than complex
... Complex is better than complicated
... """.lower()

>>> for word in text.split():
...     unique_words.add(word)
...

>>> unique_words
{
    'beautiful',
    'ugly',
    'better',
    'implicit',
    'complicated',
    'than',
    'explicit',
    'is',
    'complex',
    'simple'
}

W tym przykładzie najpierw tworzysz pusty zestaw za pomocą funkcji set(). Do tekstu stosujesz małe litery za pomocą metody .lower(), aby wyodrębnianie słów nie uwzględniało wielkości liter. Następnie uruchamiasz pętlę na liście słów wyodrębnionych z tekstu.

W ramach szybkiego podejścia użyłeś metody .split(), aby podzielić tekst na pojedyncze słowa, używając znaku spacji jako separatora.

W każdej iteracji pętla próbuje dodać słowo do zbioru. Jeśli jednak słowo jest już w zestawie, żadne nowe wystąpienie nie zostanie dodane. Dlatego wynikowy zestaw ma na przykład tylko jedno wystąpienie lepszego. Pętla jest czytelna i przejrzysta, ale możesz użyć zrozumienia zestawu, aby kod był jeszcze bardziej zwięzły.

Wprowadzenie zestawu zestawu

Rozumienia zestawów umożliwiają budowanie zestawów za pomocą jednowierszowej pętli for. Jeśli znasz wyrażenia listowe, szybko zrozumiesz wyrażenia zbiorowe. Obie konstrukcje mają podobną składnię. Główna różnica polega na tym, że w wyrażeniach zbiorczych używane są nawiasy klamrowe zamiast nawiasów kwadratowych.

Oto składnia rozumienia zbioru:

{expression for member in iterable [if condition]}

Zestaw zrozumienia zwraca nowy zestaw. Aby zbudować ten zestaw, obliczasz elementy z elementów wejściowych. Składnia zawiera opcjonalne warunkowe na końcu, którego można użyć do warunkowego filtrowania istniejących kolekcji lub generowania elementów.

Składnia rozumienia zestawu składa się z czterech kluczowych elementów:

  1. Nawiasy otaczające: Nawiasy klamrowe ({}) służą do definiowania wyrażeń zbiorów.
  2. Wyrażenie rozumiejące: wyrażenie dostarczające element w każdej iteracji.
  3. bieżący członek : To nazwa bieżącego elementu lub wartości w iterable.
  4. iterable : Może to być dowolny obiekt Python iterable, w tym lista, tuple, set, generator lub podobne typy.

Poniższy kod pokazuje, jak można zbudować zestaw unikalnych słów, korzystając ze zrozumienia:

>>> text = """
... Beautiful is better than ugly
... Explicit is better than implicit
... Simple is better than complex
... Complex is better than complicated
... """.lower()

>>> {word for word in text.split()}
{
    'beautiful',
    'ugly',
    'better',
    'implicit',
    'complicated',
    'than',
    'explicit',
    'is',
    'complex',
    'simple'
}

W tym przykładzie używasz ustalonego zrozumienia, aby wyodrębnić unikalne słowa z oryginalnego tekstu. Składnia jest zwięzła i jasna, co poprawia czytelność kodu.

W praktyce, gdy nie musisz przekształcać danych w celu wygenerowania elementów zestawu, możesz zastąpić pętlę z poprzedniej sekcji i powyższe zrozumienie następującym kodem:

>>> set(text.split())
{
    'beautiful',
    'ugly',
    'better',
    'implicit',
    'complicated',
    'than',
    'explicit',
    'is',
    'complex',
    'simple'
}

W tym przykładzie przekazujesz podzielony tekst bezpośrednio do konstruktora set() i otrzymujesz ten sam wynik jak w przypadku pętli lub rozumienia. Możesz to zrobić, ponieważ ustawione elementy nie muszą przechodzić przez transformację.

Wyrażenia mogą także zawierać więcej niż jedną klauzulę for. Gdy tak się stanie, for znajdujący się najbardziej na lewo wykonuje iterację po zewnętrznej kolekcji, następny for od lewej do prawej wykonuje iterację po pierwszym poziomie zagnieżdżenia i tak dalej.

Aby zilustrować, powiedz, że masz listę list. Każda zagnieżdżona lista zawiera liczby i chcesz utworzyć zestaw z ich wartościami kwadratowymi. Aby to zrobić, możesz użyć zrozumienia z dwoma klauzulami , jak pokazano poniżej:

>>> matrix = [
...     [9, 3, 8, 3],
...     [4, 5, 2, 8],
...     [6, 4, 3, 1],
...     [1, 0, 4, 5],
... ]

>>> {value**2 for row in matrix for value in row}
{64, 1, 0, 4, 36, 9, 16, 81, 25}

W tym przykładzie pierwsza pętla for wykonuje iterację po wierszach macierzy. Druga pętla for iteruje po liczbie w każdym wierszu. W rezultacie otrzymujesz zestaw wartości kwadratowych.

Należy zauważyć, że w tym przykładzie zamiast 16 elementów otrzymasz tylko dziewięć. Dzieje się tak dlatego, że elementy zestawu są unikalne. Kiedy element jest powielany, nowe wystąpienie nie jest dodawane do końcowego zestawu.

Wykorzystanie ustalonych zrozumienia w Pythonie

Dzięki Zestawowi zrozumienia możesz tworzyć nowe zestawy, przekształcić istniejące, a nawet elementy filtrowania za pomocą warunków. W poniższych sekcjach dowiesz się, jak korzystać z zestawu Set rozumie, aby podejść do tych przypadków użycia.

Na początek dowiesz się, jak używać wyrażeń do tworzenia nowych zbiorów na podstawie istniejących iteracji.

Tworzenie zbiorów z obiektów iterowalnych

Czasami masz iterację danych i chcesz utworzyć zestaw za pomocą elementów danych do generowania elementów poprzez transformację danych.

Załóżmy na przykład, że masz listę narzędzi i bibliotek. Trzeba na bieżąco sprawdzać, czy dane narzędzie znajduje się na liście. Aby to zrobić, użyj testów członkostwa. Musisz także sprawić, aby Twój kod nie uwzględniał wielkości liter, więc decydujesz się przekształcić wszystkie słowa na małe litery.

Zestawy są bardziej wydajne niż listy w testach członkowskich. Dlatego decydujesz się również przekonwertować listę narzędzi na zestaw małych słów:

>>> tools = ["Python", "Django", "Flask", "pandas", "NumPy"]

>>> tools_set = {tool.lower() for tool in tools}
>>> tools_set
{'django', 'numpy', 'flask', 'pandas', 'python'}

>>> "python".lower() in tools_set
True
>>> "Pandas".lower() in tools_set
True
>>> "Numpy".lower() in tools_set
True

W wyróżnionym wierszu używasz rozumienia zestawu, normalizując wszystkie wartości na małe litery, aby zapewnić spójne porównania. Następnie za pomocą operatora in uruchamiasz testy członkostwa i sprawdzasz, czy dane narzędzie znajduje się na Twojej oryginalnej liście.

Ponownie, jeśli nie musisz stosować żadnej transformacji danych do elementów iterowalnego wejścia, nie musisz używać rozumienia zbioru. Zamiast tego możesz użyć set(iterable). W powyższym przykładzie transformacja polega na zamianie nazw narzędzi na małe litery.

Przekształcanie istniejących zestawów

Można także używać wyrażeń zbiorów, aby szybko przekształcać istniejące zbiory. Załóżmy, że masz zestaw adresów e-mail wprowadzonych przez użytkownika. Zauważyłeś, że niektóre adresy zawierają spacje początkowe i końcowe, a także wielkie litery i chcesz to naprawić. Co ważniejsze, zauważyłeś, że istnieje zduplikowany adres e-mail.

Zdecydujesz się to oczyścić ze zrozumieniem:

>>> emails = {
...     " alice@example.org ",
...     "BOB@example.com",
...     "charlie@EXAMPLE.com",
...     "David@example.net",
...     " bob@example.com",
...     "JohnDoe@example.com",
... }

>>> {email.strip().lower() for email in emails}
{
    'alice@example.org',
    'bob@example.com',
    'johndoe@example.com',
    'charlie@example.com',
    'david@example.net'
}

W podświetlonej linii znajduje się zestaw rozumiejący, który usuwa spacje początkowe i końcowe z każdego adresu za pomocą metody .strip(). Następnie stosuje małe litery do wszystkich adresów za pomocą funkcji .lower(). W wyniku czyszczenia zduplikowany adres jest eliminowany, ponieważ zestawy mogą zawierać tylko unikalne elementy.

Filtrowanie elementów z zestawów

Czasami zachodzi potrzeba przefiltrowania istniejącego zestawu i stworzenia nowego z elementami spełniającymi dane wymaganie lub warunek. Załóżmy na przykład, że chcesz przefiltrować adresy e-mail ustawione tak, aby wyodrębniać tylko e-maile z domeny .com. Aby to zrobić, możesz użyć następującego zrozumienia:

>>> emails_set = {
...     "alice@example.org",
...     "bob@example.com",
...     "johndoe@example.com",
...     "charlie@example.com",
...     "david@example.net",
... }

>>> {email for email in emails_set if email.endswith(".com")}
{'bob@example.com', 'charlie@example.com', 'johndoe@example.com'}

W tym przykładzie używasz warunku do utworzenia zestawu zawierającego tylko adresy e-mail w domenie .com.

Decydowanie, kiedy użyć zestawu zestawu zestawu

Podejmując decyzję, czy użyć rozumienia zbioru zamiast zwykłej pętli lub kombinacji wywołań funkcji, należy wziąć pod uwagę następujące czynniki:

  • Zwięzłość: wyrażenia setów zmniejszają ilość kodu w porównaniu z równoważnymi pętlami for.
  • Czytelność: zrozumienie zestawu może sprawić, że Twój kod będzie bardziej przejrzysty i czytelny.

W praktyce wyrażeń zbiorowych można używać, gdy trzeba wykonać następujące operacje:

  • Utwórz zestawy z istniejących iterabinów, stosując transformacje danych
  • Przekształć elementy istniejącego zestawu
  • Odfiltruj elementy istniejącego zestawu

Jak dotąd nauczyłeś się wykonywać wszystkie te operacje przy użyciu wyrażeń na zbiorach. Mimo to możesz znaleźć inne dobre przypadki użycia wyrażeń zbiorów podczas programowania w języku Python.

Ponadto istnieją sytuacje, w których używanie wyrażeń zbiorowych może nie być konieczne. Na przykład, jeśli chcesz usunąć zduplikowane elementy z iterowalnego elementu, możesz po prostu użyć następującej składni:

>>> set([2, 2, 1, 4, 2, 3])
{1, 2, 3, 4}

Jeśli nie musisz przekształcać danych wejściowych w celu wygenerowania elementów SET, możesz po prostu użyć konstruktora set() . Jest to świetny sposób na usunięcie duplikatów z iterowalnych. Należy jednak zauważyć, że obiekty w wejściu iterable muszą być haszalne, a pierwotna kolejność elementów nie zostanie zachowana.

Badanie wspólnych złych praktyk

Istnieje kilka złych praktyk, których chcesz uniknąć podczas pracy z ustalonymi zrozumieniem w kodzie Python. Niektóre z najczęstszych to:

  • Używanie złożonych wyrażeń w zrozumieniu
  • Pisanie zagnieżdżone zrozumienie z kilkoma klauzulami lub kodem
  • Próba dostępu do zmiennych rozumienia z zewnątrz
  • Przeprowadzanie kosztownych transformacji podczas budowania elementów zestawu

Czasami możesz mieć ustalone zrozumienie, w którym wyrażenie zrozumienia jest zbyt skomplikowane.

Załóżmy na przykład, że utworzyłeś zestaw z listy liczb. Jeśli liczba jest parzysta, chcesz jej kwadrat. W przeciwnym razie chcesz jego kostkę. Aby to zrobić, możesz użyć następującego zrozumienia:

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

>>> {number**2 if number % 2 == 0 else number**3 for number in numbers}
{64, 1, 4, 36, 100, 16, 343, 729, 27, 125}

W tym rozumieniu do generowania elementów zestawu używa się stosunkowo złożonego wyrażenia. Odczytanie tego ze zrozumieniem i rozszyfrowanie jego działania może być trudne. Kiedy skomplikowane wyrażenie utrudnia odczytanie kodu, zamiast tego możesz skorzystać ze zwykłej pętli for:

>>> result_set = set()

>>> for number in numbers:
...     if number % 2 == 0:
...         value = number**2
...     else:
...         value = number**3
...     result_set.add(value)
...

>>> result_set
{64, 1, 4, 36, 100, 16, 343, 729, 27, 125}

Ta pętla daje taki sam wynik jak zrozumienie, ale może być bardziej jednoznaczna, dzięki czemu kod będzie bardziej czytelny.

Zagnieżdżone zrozumienie z kilkoma klauzulami dla lub warunki warunkowe mogą sprawić, że kod jest mniej czytelny. Dlatego ogólnie powinieneś ich unikać i używać bardziej czytelnych konstrukcji, takich jak zwykła pętla.

Próba użycia zmiennych zdefiniowanych w rozumieniu poza samym zrozumieniem nie jest możliwa:

>>> {number**3 for number in range(1, 11)}
{64, 1, 512, 8, 1000, 343, 216, 729, 27, 125}

>>> number
Traceback (most recent call last):
    ...
NameError: name 'number' is not defined

Zmienna number jest widoczna tylko w rozumieniu. Jeśli spróbujesz użyć go poza zrozumieniem, pojawi się wyjątek NameError.

Czasami podczas pracy ze wyrażeniami zbiorów może zaistnieć potrzeba przeprowadzenia kosztownych transformacji danych w celu wygenerowania elementów zbioru. W takich sytuacjach należy mieć świadomość, że zbudowanie ostatecznego zestawu może zająć sporo czasu. Możliwym obejściem jest użycie generatora, który wytwarza elementy na żądanie.

Wniosek

Dowiedziałeś się, że Python Set Fothensions szczegółowo. Są potężnym narzędziem do tworzenia, przekształcania i filtrowania zestawów za pomocą zwięzłej i czystej składni. Dowiedziałeś się również o złych praktykach, których powinieneś unikać podczas pracy z ustaleniami.

Zestaw zrozumienia jest doskonałym narzędziem dla programistów Pythona. Zapewniają pyażny i usprawniony sposób manipulowania zestawami w Python.

W tym samouczku:

  • utworzone nowe zestawy z zwięzłą składnią
  • transformowane istniejące zestawy z rozumianiem
  • filtrowane niechciane elementy z istniejących zestawów
  • Zdecydowano, kiedy używać wyrażeń zestawów w kodzie

Dzięki tym umiejętnościom możesz napisać bardziej czytelny i Pythoniczny kod do przetwarzania zbiorów. W miarę dalszego korzystania ze wyrażeń zbiorów przekonasz się, że są one nieocenionym narzędziem.

Często zadawane pytania

Teraz, gdy masz pewne doświadczenie z ustalonymi zrozumieniem w Python, możesz użyć poniższych pytań i odpowiedzi, aby sprawdzić swoje zrozumienie i podsumować to, czego się nauczyłeś.

Te często zadawane pytania są związane z najważniejszymi pojęciami, które omówiłeś w tym samouczku. Kliknij przełącznik show/hide obok każdego pytania, aby ujawnić odpowiedź:

Set rozumienie to zwięzły sposób tworzenia zestawów w Pythonie za pomocą składni podobnej do rozumienia listy. Główna różnica polega na tym, że Set Skutevension używa klamrowych klamrów {} , podczas gdy rozumienie listy używa nawiasów kwadratowych [] . Rezultatem jest zestaw, który jest nieuporządkowaną kolekcją unikalnych elementów.

Możesz utworzyć zbiór z obiektu iterowalnego, używając składni rozumienia zestawu: {wyrażenie elementu członkowskiego w iterowalnym. Spowoduje to ocenę wyrażenia dla każdego elementu iterowalnego i dodanie wyniku do zestawu, upewniając się, że wszystkie elementy są unikalne.

Powinieneś rozważyć użycie zestawu Set Frission nad regularnymi pętlami, gdy chcesz zwięźle tworzyć zestawy i poprawić czytelność kodu. Są one szczególnie przydatne podczas transformacji lub filtrowania danych z iterowalnych do generowania unikalnych elementów ustawionych.

Wspólne złe praktyki obejmują stosowanie zbyt złożonych wyrażeń w zakresie zrozumienia, pisanie zagnieżdżonych zrozumienia z wieloma klauzulami kod lub warunkami, próba dostępu do zmiennych zrozumienia poza zrozumieniem oraz wykonywanie kosztownych transformacji, które mogą degradować wydajność.

Tak, możesz używać wyrażeń zbiorowych do filtrowania elementów, dodając warunek na końcu wyrażenia: {wyrażenie elementu członkowskiego w iterowalnym warunku. Będzie to obejmować tylko te elementy, dla których warunek ma wartość True.