W tym samouczku poznasz podstawy zestawów Pythona i różne metody zestawów, których możesz użyć do modyfikowania zestawów Pythona.
Zestawy są jedną z wbudowanych struktur danych w Pythonie. Gdy musisz pracować z niepowtarzającą się kolekcją elementów, użyjesz zestawu jako struktury danych do przejścia.
W kolejnych kilku sekcjach omówimy podstawy zestawów Pythona i metody zestawów, których możesz użyć do pracy z nimi. Następnie nauczymy się wykonywać typowe operacje na zbiorach w Pythonie.
Zaczynajmy!
Spis treści:
Podstawy zestawów Pythona
W Pythonie zbiór jest nieuporządkowaną kolekcją niepowtarzających się elementów. Oznacza to, że wszystkie elementy w zestawie powinny być różne.
Możesz dodawać i usuwać elementy z zestawu; dlatego zestaw jest zmienną kolekcją. Może zawierać elementy różnych typów danych. Jednak poszczególne elementy w zestawie powinny być haszowalny.
W Pythonie mówi się, że obiekt jest haszowalny, jeśli jego wartość hash nigdy się nie zmienia. Większość niezmiennych obiektów, takich jak łańcuchy, krotki i słowniki Pythona, można haszować.
Dowiemy się szczegółowo o tworzeniu zestawów. Na razie rozważ następujące dwa zestawy:
py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}
TypeError: unhashable type: 'list'
Pierwszy zestaw zawiera trzy liczby, krotkę i łańcuch. Inicjalizacja zestawu przebiega bez błędów. Natomiast drugi zestaw zawiera listę zamiast krotki. Lista jest zmienną kolekcją, nie można jej zahaszować, a inicjalizacja generuje błąd TypeError.
📑 Łącząc to wszystko razem, możemy zdefiniować zestaw Pythona jako zmienną kolekcję odrębnych i dających się haszować elementów.
Jak stworzyć zestaw Pythona
Zaczniemy od nauki tworzenia zestawu w Pythonie.
#1. Korzystanie z jawnej inicjalizacji
Możesz utworzyć zestaw w Pythonie, określając elementy zestawu, oddzielone przecinkami (,) i ujęte w parę nawiasów klamrowych {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
set
Jeśli pracowałeś wcześniej z listami Pythona, wiesz, że [] inicjuje pustą listę. Mimo że zestaw Pythona jest ujęty w parę nawiasów klamrowych {}, nie można użyć pary {} do zainicjowania zestawu. Dzieje się tak, ponieważ {} inicjuje słownik Pythona, a nie zestaw Pythona.
py_set2 = {}
type(py_set2)
# Output
dict
Możesz ponownie wywołać funkcję type(), aby sprawdzić, czy py_set jest słownikiem (dict).
#2. Korzystanie z funkcji set()
Jeśli chcesz zainicjować pusty zestaw, a następnie dodać do niego elementy, możesz to zrobić za pomocą funkcji set().
py_set3 = set() type(py_set3) # Output set
#3. Przerzucanie innych elementów iterowalnych do zestawu
Innym sposobem tworzenia zestawów jest rzutowanie innych elementów iteracyjnych, takich jak listy i krotki, w zestawy za pomocą set(iterable).
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # repeating element 'C' removed
type(py_set4)
# set
W powyższym przykładzie py_list zawiera dwa razy 'C’. Ale w py_set4, 'C’ pojawia się tylko raz, ponieważ zbiór jest zbiorem odrębnych elementów. Ta technika rzutowania do zestawu jest często używana do usuwania duplikatów z list Pythona.
Jak dodawać elementy do zestawu Pythona
Zacznijmy od utworzenia pustego zestawu py_set i pracuj z nim do końca tego samouczka.
py_set = set() len(py_set) # returns the length of a set # Output 0
#1. Korzystanie z metody .add()
Aby dodać elementy do zestawu, możesz użyć metody .add(). set.add(element) dodaje element do zestawu.
Dla jasności dodamy elementy do zestawu Pythona i wydrukujemy zestaw na każdym kroku.
▶️ Dodajmy ciąg 'Python’ jako element do py_set.
py_set.add('Python')
print(py_set)
# Output
{'Python'}
Następnie dodamy kolejny element.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Ważne jest, aby zrozumieć, że metoda .add() dodaje element do zestawu tylko wtedy, gdy nie jest jeszcze obecny. Jeśli zestaw zawiera już element, który chcesz dodać, operacja dodawania nie przynosi efektu.
Aby to sprawdzić, spróbujmy dodać 'C++’ do py_set.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Zestaw zawiera 'C++’, więc operacja dodawania nie daje żadnego efektu.
▶️ Dodajmy do zestawu jeszcze kilka elementów.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Output
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Korzystanie z metody .update()
Do tej pory widzieliśmy, jak dodawać elementy do istniejącego zestawu – po jednym elemencie na raz.
Co zrobić, jeśli chcesz dodać więcej niż jeden element do sekwencji elementów?
Możesz to zrobić za pomocą metody .update() ze składnią: set.update(collection), aby dodać elementy z kolekcji do zestawu. Kolekcja może być listą, krotką, słownikiem i tak dalej.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Ta metoda jest przydatna, gdy chcesz dodać kolekcję elementów do zestawu bez tworzenia innego obiektu w pamięci.
W następnej sekcji nauczmy się usuwać elementy z zestawu.
Jak usunąć elementy z zestawu Pythona?
Rozważmy następujący zestaw (py_set przed operacją aktualizacji).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Korzystanie z metody .pop()
set.pop() losowo usuwa element ze zbioru i zwraca go. Wywołajmy metodę pop na py_set i zobaczmy, co zwraca.
py_set.pop() # Output 'Rust'
Tym razem wywołanie metody .pop() zwróciło ciąg 'Rust’.
Uwaga: Ponieważ metoda .pop() zwraca element losowo, gdy uruchomisz kod na swoim końcu, równie dobrze możesz uzyskać inny element.
Kiedy przyjrzymy się zestawowi, „Rdza” już nie występuje w zestawie.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}
#2. Korzystanie z metod .remove() i remove()
W praktyce możesz chcieć usunąć określone elementy z zestawu. W tym celu możesz użyć metod .remove() i .discard().
set.remove(element) usuwa elementy z zestawu.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Jeśli spróbujemy usunąć element nieobecny w zestawie, natkniemy się na KeyError.
py_set.remove('Scala')
# Output
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'
Przyjrzyjmy się jeszcze raz py_set. Mamy teraz trzy elementy.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Dzięki składni set.discard(element) metoda .discard() usuwa również elementy ze zbioru.
py_set.discard('C++')
print(py_set)
# Output
{'JavaScript', 'Python'}
Różni się jednak od metody .remove() tym, że nie zgłasza KeyError, gdy próbujemy usunąć element, którego nie ma.
Jeśli spróbujemy usunąć „Scalę” (która nie istnieje) z listy za pomocą metody .discard(), nie widzimy błędu.
py_set.discard('Scala') #no error!
print(py_set)
# Output
{'JavaScript', 'Python'}
Jak uzyskać dostęp do elementów zestawu Pythona
Do tej pory nauczyliśmy się dodawać i usuwać elementy z zestawów Pythona. Jednak nie widzieliśmy jeszcze, jak uzyskać dostęp do poszczególnych elementów w zestawie.
Ponieważ zestaw jest kolekcją nieuporządkowaną, nie można go indeksować. Dlatego, jeśli spróbujesz uzyskać dostęp do elementów zestawu za pomocą indeksu, napotkasz błąd, jak pokazano.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])
TypeError: 'set' object is not subscriptable
Jak więc uzyskać dostęp do elementów w zestawie?
Można to zrobić na dwa sposoby:
- Przejdź przez zestaw i uzyskaj dostęp do każdego elementu
- Sprawdź, czy dany element należy do zbioru
▶️ Przeprowadź pętlę przez zestaw i uzyskaj dostęp do elementów za pomocą pętli for.
for elt in py_set: print(elt) # Output C++ JavaScript Python Rust C
W praktyce możesz chcieć sprawdzić, czy dany element występuje w zestawie za pomocą operatora in.
Uwaga: element w zestawie zwraca True, jeśli element jest obecny w zestawie; w przeciwnym razie zwraca False.
W tym przykładzie py_set zawiera 'C++’ i nie zawiera 'Julia’, a operator in zwraca odpowiednio True i False.
'C++' in py_set # True 'Julia' in py_set # False
Jak znaleźć długość zestawu Pythona?
Jak pokazano wcześniej, możesz użyć funkcji len(), aby uzyskać liczbę elementów obecnych w zestawie.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5
Jak wyczyścić zestaw Pythona
Aby wyczyścić zestaw, usuwając wszystkie elementy, możesz użyć metody .clear().
Wywołajmy metodę .clear() na py_set.
py_set.clear()
Jeśli spróbujesz go wydrukować, otrzymasz set() – wskazujący, że zestaw jest pusty. Możesz również wywołać funkcję len(), aby sprawdzić, czy długość zestawu wynosi zero.
print(py_set) # set() print(len(py_set)) # 0
Do tej pory nauczyliśmy się wykonywać podstawowe operacje CRUD na zbiorach Pythona:
- Tworzenie: za pomocą funkcji set(), rzutowania typu i inicjalizacji
- Przeczytaj: Uzyskaj dostęp do elementów zestawu za pomocą pętli i operatora w celu testowania członkostwa
- Aktualizacja: dodawaj, usuwaj elementy z zestawów i aktualizuj zestawy
- Usuń: Wyczyść zestaw, usuwając z niego wszystkie elementy
Wspólne operacje na zestawach, wyjaśnione za pomocą kodu Pythona
Zbiory Pythona pozwalają nam również na wykonywanie podstawowych operacji na zbiorach. Dowiemy się o nich w tej sekcji.
#1. Unia zbiorów w Pythonie
W teorii mnogości suma dwóch zbiorów jest zbiorem wszystkich elementów w co najmniej jednym z dwóch zbiorów. Jeśli istnieją dwa zestawy, A i B, to połączenie zawiera elementy, które są obecne tylko w A, tylko w B oraz elementy obecne zarówno w A, jak i B.
Aby znaleźć sumę zbiorów, możesz użyć | operator lub .union() metoda o składni: setA.union(setB).
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
Set union jest operacją przemienną; więc AUB jest tym samym co BU A. Zweryfikujmy to, zamieniając pozycje setA i setB w wywołaniu metody .union().
setB.union(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Przecięcie zbiorów w Pythonie
Inną wspólną operacją na zbiorach jest to przecięcie dwóch zbiorów, A i B. Operacja przecięcia zbiorów zwraca zbiór, który zawiera wszystkie elementy obecne zarówno w A, jak i B.
Aby obliczyć przecięcie, możesz użyć operatora & lub metody .intersection(), jak wyjaśniono w poniższym fragmencie kodu.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}
W tym przykładzie element 9 jest obecny zarówno w setA jak i setB; więc zbiór przecięcia zawiera tylko ten element.
Podobnie jak suma zbioru, przecięcie zbioru jest również operacją przemienną.
setB.intersection(setA)
# Output
{9}
#3. Ustaw różnicę w Pythonie
Biorąc pod uwagę dowolne dwa zbiory, suma i przecięcie pomagają nam znaleźć elementy obecne odpowiednio w obu i co najmniej jednym ze zbiorów. Z drugiej strony, różnica zestawu pomaga nam znaleźć elementy obecne w jednym zestawie, ale nie w drugim.
– setA.difference(setB) podaje zbiór elementów, które występują tylko w zbiorzeA, a nie w zbiorzeB.
– setB.difference(setA) podaje zbiór elementów, które występują tylko w zbiorzeB, a nie w zbiorzeA.
print(setA - setB)
print(setB - setA)
# Output
{1, 3, 5, 7}
{8, 2, 4, 6}
Oczywiście AB to nie to samo, co BA, więc ustawiona różnica nie jest operacją przemienną.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Symetryczna różnica zestawów w Pythonie
Podczas gdy przecięcie zbiorów daje nam elementy obecne w obu zbiorach, symetryczna różnica zbiorów zwraca zbiór elementów obecnych w dokładnie jednym ze zbiorów.
Rozważmy następujący przykład.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
Aby obliczyć zestaw różnic symetrycznych, możesz użyć operatora ^ lub metody .symmetric_difference() .
print(setA ^ setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Elementy 10 i 12 są obecne zarówno w zestawie A, jak i zestawie B. Nie są więc obecne w zestawie różnic symetrycznych.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Ponieważ operacja symetrycznej różnicy zestawów zbiera wszystkie elementy, które pojawiają się dokładnie w jednym z dwóch zestawów, wynikowy zestaw jest taki sam, niezależnie od kolejności, w jakiej elementy są zbierane. Dlatego symetryczna różnica zbiorów jest operacją przemienną.
setB.symmetric_difference(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Podzbiory i nadzbiory w Pythonie
W teorii zbiorów podzbiory i nadzbiory pomagają zrozumieć związek między dwoma zbiorami.
Mając dwa zbiory A i B, zbiór B jest podzbiorem zbioru A, jeśli wszystkie elementy zbioru B są również obecne w zbiorze A. A zbiór A jest nadzbiorem zbioru B.
Rozważmy przykład dwóch zestawów: languages i languages_extended.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
W Pythonie możesz użyć metody .issubset(), aby sprawdzić, czy dany zestaw jest podzbiorem innego zestawu.
setA.issubset(setB) zwraca True, jeśli zbA jest podzbiorem zbB; w przeciwnym razie zwraca False.
W tym przykładzie języki są podzbiorem languages_extended.
languages.issubset(languages_extended) # Output True
Podobnie możesz użyć metody .issuperset(), aby sprawdzić, czy dany zestaw jest nadzbiorem innego zestawu.
setA.issuperset(setB) zwraca True, jeśli zbA jest nadzbiorem zbioru zb; w przeciwnym razie zwraca False.
languages_extended.issuperset(languages) # Output True
Ponieważ languages_extended jest nadzbiorem języków, languages_extended.issuperset(languages) zwraca True, jak pokazano powyżej.
Wniosek
Mam nadzieję, że ten samouczek pomógł ci zrozumieć działanie zestawów Pythona, metody zestawów dla operacji CRUD i typowe operacje na zestawach. W następnym kroku możesz spróbować użyć ich w swoich projektach w Pythonie.
Możesz sprawdzić inne szczegółowe przewodniki po Pythonie. Miłej nauki!