Kompletní průvodce s příklady kódu
V tomto návodu si osvojíte základy práce s množinami v Pythonu a seznámíte se s různými metodami, které vám umožní tyto množiny efektivně upravovat.
Množiny patří mezi základní datové struktury, které Python nabízí. Pokud potřebujete pracovat s kolekcí jedinečných prvků, je množina ideální volbou.
V následujících sekcích si detailně probereme základy množin v Pythonu a představíme si metody pro práci s nimi. Poté se naučíme provádět běžné operace, které se s množinami pojí.
Pojďme se do toho pustit!
Základní informace o množinách v Pythonu
V Pythonu je množina definována jako neuspořádaná kolekce jedinečných prvků. To znamená, že žádný prvek se v množině nemůže opakovat.
Prvky můžete do množiny přidávat i odebírat, což z ní činí proměnlivou datovou strukturu. Může obsahovat prvky různého datového typu. Nicméně, jednotlivé prvky musí být hašovatelné.
V Pythonu se o objektu říká, že je hašovatelný, pokud jeho hodnota hash se nikdy nemění. Většina neměnných objektů, jako jsou řetězce, n-tice a čísla, jsou hašovatelné.
Pojďme si ukázat, jak se množiny tvoří. Prozatím si představme následující dvě množiny:
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'
První množina obsahuje čísla, n-tici a řetězec, a její inicializace proběhne bez chyby. Druhá množina se naopak pokouší obsahovat seznam, který je na rozdíl od n-tice proměnlivý. Protože seznam není hašovatelný, inicializace vyvolá chybu TypeError.
📑 Suma sumárum, můžeme říci, že množina v Pythonu je proměnlivá kolekce jedinečných a hašovatelných prvků.
Jak vytvořit množinu v Pythonu
Začněme tím, že si ukážeme, jak se množina v Pythonu vytváří.
#1. Explicitní inicializace
Množinu v Pythonu vytvoříte tak, že vypíšete její prvky oddělené čárkami a uzavřete je do složených závorek {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
set
Pokud již máte zkušenosti s Pythonem, možná víte, že prázdný seznam se inicializuje pomocí hranatých závorek []. Nicméně, i když se množina inicializuje pomocí složených závorek {}, nelze k vytvoření prázdné množiny použít pouhé {}. Je to proto, že {} vytváří prázdný slovník (dict), nikoliv množinu.
py_set2 = {}
type(py_set2)
# Output
dict
Pomocí funkce `type()` si můžete ověřit, že `py_set2` je skutečně slovník.
#2. Použití funkce `set()`
Pokud potřebujete inicializovat prázdnou množinu a teprve později do ní přidávat prvky, použijte funkci `set()`.
py_set3 = set() type(py_set3) # Output set
#3. Přetypování jiných iterovatelných objektů na množinu
Další způsob, jak vytvořit množinu, je přetypovat existující iterovatelné objekty, jako jsou seznamy nebo n-tice, na množinu pomocí funkce `set(iterable)`.
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # duplicitní prvek 'C' byl odstraněn
type(py_set4)
# set
V uvedeném příkladu seznam `py_list` obsahuje prvek 'C' dvakrát. V množině `py_set4` se však 'C' objeví pouze jednou, protože množina obsahuje pouze jedinečné prvky. Tato technika se často používá pro odstranění duplicitních prvků ze seznamu.
Jak přidávat prvky do množiny v Pythonu
Na začátek si vytvoříme prázdnou množinu `py_set`, kterou budeme používat pro zbytek tohoto návodu.
py_set = set() len(py_set) # vrací délku množiny # Output 0
#1. Použití metody `.add()`
K přidávání prvků do množiny slouží metoda `.add()`. Konkrétně `set.add(element)` přidá daný prvek do množiny.
Pro větší přehlednost budeme v následujících příkladech po každém přidání prvku množinu vypisovat.
▶️ Přidejme do `py_set` řetězec 'Python'.
py_set.add('Python')
print(py_set)
# Output
{'Python'}
Nyní přidáme další prvek.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Je důležité si uvědomit, že metoda `.add()` přidá prvek do množiny pouze tehdy, pokud se v ní ještě nenachází. Pokud již prvek v množině existuje, operace přidání nemá žádný efekt.
Abychom si to ověřili, zkusíme přidat 'C++' do `py_set` znovu.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Množina již 'C++' obsahuje, takže operace přidání nemá žádný vliv.
▶️ Přidejme do množiny další prvky.
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. Použití metody `.update()`
Zatím jsme se naučili, jak do existující množiny přidávat prvky - jeden po druhém.
Co když chceme přidat více prvků najednou?
To lze udělat pomocí metody `.update()`, která má syntaxi `set.update(collection)` a slouží k přidání prvků z dané kolekce do množiny. Kolekcí může být seznam, n-tice, slovník a podobně.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Tato metoda je užitečná, když chcete přidat kolekci prvků do množiny, aniž byste vytvářeli další objekty v paměti.
V následující sekci se naučíme, jak odebírat prvky z množiny.
Jak odebírat prvky z množiny v Pythonu
Představme si následující množinu (stav `py_set` před použitím metody `update()`).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Použití metody `.pop()`
`set.pop()` odebere náhodný prvek z množiny a vrátí ho. Zavoláme metodu `pop` na `py_set` a uvidíme, co vrátí.
py_set.pop() # Output 'Rust'
V tomto případě metoda `.pop()` vrátila řetězec 'Rust'.
Poznámka: Protože metoda `.pop()` vrací prvek náhodně, při spuštění kódu u vás může dojít k vrácení jiného prvku.
Když se podíváme na množinu znovu, vidíme, že 'Rust' už v ní není.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}
#2. Použití metod `.remove()` a `.discard()`
V praxi budete chtít odebírat konkrétní prvky z množiny. K tomu slouží metody `.remove()` a `.discard()`.
`set.remove(element)` odebere daný prvek z množiny.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Pokud se pokusíme odebrat prvek, který v množině neexistuje, narazíme na chybu `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'
Pojďme se znovu podívat na `py_set`. Nyní v ní máme tři prvky.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Syntaxí `set.discard(element)` metoda `.discard()` také odebírá prvky z množiny.
py_set.discard('C++')
print(py_set)
# Output
{'JavaScript', 'Python'}
Na rozdíl od metody `.remove()` však metoda `.discard()` nevyvolá chybu `KeyError`, pokud se pokusíme odstranit prvek, který v množině neexistuje.
Pokud se pokusíme odebrat 'Scala' (která neexistuje) pomocí metody `.discard()`, nedostaneme žádnou chybu.
py_set.discard('Scala') # žádná chyba!
print(py_set)
# Output
{'JavaScript', 'Python'}
Jak přistupovat k prvkům množiny v Pythonu
Zatím jsme se naučili, jak do množiny přidávat a odebírat prvky. Ještě jsme si ale neukázali, jak přistupovat k jednotlivým prvkům v množině.
Protože je množina neuspořádaná kolekce, nelze ji indexovat. Pokud se tedy pokusíte získat prvek množiny pomocí indexu, narazíte na chybu, jak je vidět v následujícím příkladu:
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 tedy k prvkům v množině přistupovat?
Existují dva běžné způsoby:
- Procházení množiny a přístup ke každému prvku
- Ověření, zda je konkrétní prvek členem množiny
▶️ Projděte množinu a získejte přístup k prvkům pomocí smyčky `for`.
for elt in py_set: print(elt) # Output C++ JavaScript Python Rust C
Často budete potřebovat zkontrolovat, zda se daný prvek nachází v množině. To lze snadno udělat pomocí operátoru `in`.
Poznámka: Výraz `prvek in množina` vrátí `True`, pokud je daný prvek v množině přítomen, a `False` v opačném případě.
V tomto příkladu `py_set` obsahuje 'C++', ale neobsahuje 'Julia', takže operátor `in` vrací `True`, respektive `False`.
'C++' in py_set # True 'Julia' in py_set # False
Jak zjistit délku množiny v Pythonu
Jak jsme si již ukázali, k získání počtu prvků v množině slouží funkce `len()`.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5
Jak vyprázdnit množinu v Pythonu
Pokud chcete z množiny odebrat všechny prvky, použijte metodu `.clear()`.
Zavolejte metodu `.clear()` na `py_set`.
py_set.clear()
Pokud se ji pokusíte vypsat, dostanete `set()`, což značí, že množina je prázdná. Můžete také zavolat funkci `len()` a ověřit, že délka množiny je skutečně nula.
print(py_set) # set() print(len(py_set)) # 0
Zatím jsme se naučili, jak provádět základní CRUD operace s množinami v Pythonu:
- Vytvoření: Pomocí funkce `set()`, přetypováním a explicitní inicializací
- Čtení: Přístup k prvkům množiny pomocí smyček `for` a testování členství pomocí operátoru `in`
- Aktualizace: Přidávání, odebírání prvků a aktualizace množin
- Smazání: Vyprázdnění množiny odstraněním všech jejích prvků
Běžné množinové operace vysvětlené pomocí kódu v Pythonu
Množiny v Pythonu nám také umožňují provádět základní množinové operace. V této části si je představíme.
#1. Sjednocení množin v Pythonu
V teorii množin je sjednocení dvou množin množina, která obsahuje všechny prvky z obou množin. Máme-li dvě množiny, A a B, pak sjednocení obsahuje prvky, které se nacházejí pouze v A, pouze v B i v obou množinách A a B.
Pro výpočet sjednocení množin můžete použít operátor `|` nebo metodu `.union()` se syntaxí `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}
Sjednocení množin je komutativní operace, takže A ∪ B je totéž jako B ∪ A. Můžete si to ověřit prohozením `setA` a `setB` ve volání metody `.union()`.
setB.union(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Průnik množin v Pythonu
Další operací s množinami je průnik dvou množin, A a B. Průnik množin vrací množinu, která obsahuje všechny prvky, které se nacházejí v A i v B.
Pro výpočet průniku můžete použít operátor `&` nebo metodu `.intersection()`, jak je vysvětleno v následujícím kódu.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}
V tomto příkladu se prvek 9 nachází v množině `setA` i `setB`, takže množina průniku obsahuje pouze tento prvek.
Stejně jako u sjednocení množin, je i průnik množin komutativní operací.
setB.intersection(setA)
# Output
{9}
#3. Rozdíl množin v Pythonu
Máme-li dvě množiny, sjednocení a průnik nám pomohou najít prvky, které se nacházejí v obou, respektive alespoň v jedné z množin. Rozdíl množin nám na druhou stranu pomáhá najít prvky, které se nacházejí v jedné množině, ale ne v druhé.
– `setA.difference(setB)` vrací množinu prvků, které se nacházejí pouze v `setA`, ale ne v `setB`.
– `setB.difference(setA)` vrací množinu prvků, které se nacházejí pouze v `setB`, ale ne v `setA`.
print(setA - setB)
print(setB - setA)
# Output
{1, 3, 5, 7}
{8, 2, 4, 6}
Je zřejmé, že A - B není totéž jako B - A, takže rozdíl množin není komutativní operací.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Symetrický rozdíl množin v Pythonu
Zatímco průnik množin nám dává prvky, které se nacházejí v obou množinách, symetrický rozdíl množin vrací množinu prvků, které se nacházejí právě v jedné z množin.
Představme si následující příklad.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
Pro výpočet symetrického rozdílu množin můžete použít operátor `^` nebo metodu `.symmetric_difference()`.
print(setA ^ setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Prvky 10 a 12 se nacházejí jak v `setA`, tak v `setB`, takže se v symetrickém rozdílu množin nenacházejí.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Protože operace symetrického rozdílu shromažďuje všechny prvky, které se nacházejí právě v jedné ze dvou množin, výsledná množina je stejná bez ohledu na pořadí, ve kterém jsou prvky shromažďovány. Symetrický rozdíl množin je tedy komutativní operací.
setB.symmetric_difference(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Podmnožiny a nadmnožiny v Pythonu
V teorii množin pomáhají podmnožiny a nadmnožiny pochopit vztah mezi dvěma množinami.
Máme-li dvě množiny, A a B, je množina B podmnožinou množiny A, pokud se všechny prvky v množině B nacházejí také v množině A. Množina A je v takovém případě nadmnožinou množiny B.
Představme si příklad dvou množin: `languages` a `languages_extended`.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
V Pythonu můžete pomocí metody `.issubset()` zkontrolovat, zda je daná množina podmnožinou jiné množiny.
`setA.issubset(setB)` vrátí `True`, pokud je `setA` podmnožinou `setB`, a `False` v opačném případě.
V tomto příkladu je `languages` podmnožinou `languages_extended`.
languages.issubset(languages_extended) # Output True
Podobně můžete použít metodu `.issuperset()` ke kontrole, zda je daná množina nadmnožinou jiné množiny.
`setA.issuperset(setB)` vrátí `True`, pokud je `setA` nadmnožinou `setB`, a `False` v opačném případě.
languages_extended.issuperset(languages) # Output True
Protože je `languages_extended` nadmnožinou `languages`, výraz `languages_extended.issuperset(languages)` vrátí `True`, jak vidíme výše.
Závěr
Doufám, že vám tento návod pomohl pochopit, jak v Pythonu pracovat s množinami, jak používat metody pro operace CRUD a jak provádět běžné množinové operace. Doporučuji vám, abyste se pokusili využít tyto znalosti ve svých projektech v Pythonu.
Můžete si prohlédnout další podrobné návody o Pythonu. Příjemné učení!
