V tomto tutoriálu se naučíte základy sad Pythonu a různé metody sad, které můžete použít k úpravě sad Pythonu.
Sady jsou jednou z vestavěných datových struktur v Pythonu. Když potřebujete pracovat s neopakující se kolekcí prvků, použijete sadu jako datovou strukturu.
V následujících několika částech projdeme základy sad pythonu a metod sad, které můžete použít k práci s nimi. Poté se naučíme, jak provádět běžné operace množin v Pythonu.
Pojďme začít!
Table of Contents
Základy sad Python
V Pythonu je množina neuspořádaná kolekce neopakujících se prvků. To znamená, že všechny prvky v sadě by měly být odlišné.
Můžete přidávat a odebírat prvky ze sady; sada je tedy proměnlivá kolekce. Může obsahovat prvky různých datových typů. Jednotlivé prvky v sadě by však měly být hašovatelné.
V Pythonu se o objektu říká, že je hašovatelný, pokud se jeho hašovací hodnota nikdy nezmění. Většina neměnných objektů, jako jsou pythonovské řetězce, n-tice a slovníky, jsou hašovatelné.
Podrobně se seznámíme s vytvářením sad. Prozatím zvažte následující dvě sady:
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í sada obsahuje tři čísla, n-tici a řetězec. Nastavená inicializace proběhne bez chyby. Zatímco druhá sada obsahuje seznam namísto n-tice. Seznam je proměnlivá kolekce, nelze jej hashovat a inicializace vyvolá chybu TypeError.
📑 Když to dáme dohromady, můžeme definovat sadu Python jako proměnlivou kolekci odlišných a hašovatelných prvků.
Jak vytvořit sadu Python
Začneme tím, že se naučíme, jak vytvořit sadu v Pythonu.
#1. Použití Explicitní inicializace
Sadu můžete vytvořit v Pythonu zadáním prvků sady, oddělených čárkami (,) a uzavřenými ve složených závorkách {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
set
Pokud jste již dříve pracovali se seznamy Pythonu, víte to [] inicializuje prázdný seznam. I když je sada Pythonu uzavřena do páru složených závorek {}, nemůžete použít pár {} k inicializaci sady. Je to proto, že {} inicializuje slovník Pythonu a ne sadu Pythonu.
py_set2 = {}
type(py_set2)
# Output
dict
Opět můžete zavolat funkci type() a ověřit, že py_set je slovník (dict).
#2. Pomocí funkce set().
Pokud byste chtěli inicializovat prázdnou sadu a poté do ní přidat prvky, můžete tak učinit pomocí funkce set().
py_set3 = set() type(py_set3) # Output set
#3. Casting dalších iterables do sady
Dalším způsobem, jak vytvořit množiny, je přetypovat další iterovatelné položky, jako jsou seznamy a n-tice, do množin 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
Ve výše uvedeném příkladu obsahuje py_list ‚C‘ dvakrát. Ale v py_set4 se ‚C‘ objeví pouze jednou, protože sada je sbírka odlišných prvků. Tato technika přetypování do sady se často používá k odstranění duplikátů ze seznamů Pythonu.
Jak přidat prvky do sady Python
Začněme vytvořením prázdné sady py_set a pracujme s ní po zbytek tohoto tutoriálu.
py_set = set() len(py_set) # returns the length of a set # Output 0
#1. Pomocí metody .add().
Chcete-li přidat prvky do sady, můžete použít metodu .add(). set.add(element) přidá prvek do sady.
Pro přehlednost přidáme prvky do sady Python a v každém kroku sadu vytiskneme.
▶️ Přidejme řetězec ‚Python‘ jako prvek do py_set.
py_set.add('Python')
print(py_set)
# Output
{'Python'}
Dále přidáme další prvek.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Je důležité pochopit, že metoda .add() přidá prvek do sady pouze v případě, že ještě není přítomen. Pokud sada již obsahuje prvek, který chcete přidat, operace přidání nemá žádný účinek.
Chcete-li to ověřit, zkuste přidat ‚C++‘ do py_set.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Sada obsahuje ‚C++‘, takže operace přidání nemá žádný účinek.
▶️ Pojďme do sady přidat pár dalších prvků.
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. Pomocí metody .update().
Zatím jsme viděli, jak přidat prvky do stávající sady – jeden prvek po druhém.
Co když chcete do sekvence prvků přidat více než jeden prvek?
Můžete tak učinit pomocí metody .update() se syntaxí: set.update(collection) pro přidání prvků v kolekci do sady. Kolekce může být seznam, n-tice, slovník a tak dále.
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 sady bez vytvoření dalšího objektu v paměti.
V další části se naučíme, jak odstranit prvky ze sady.
Jak odebrat prvky ze sady Python
Uvažujme následující sadu (py_set před operací aktualizace).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Pomocí metody .pop().
set.pop() náhodně odebere prvek ze sady a vrátí jej. Zavoláme metodu pop na py_set a uvidíme, co vrátí.
py_set.pop() # Output 'Rust'
Tentokrát volání metody .pop() vrátilo řetězec ‚Rust‘.
Poznámka: Protože metoda .pop() vrací prvek náhodně, při spuštění kódu na vašem konci můžete také získat další prvek.
Když sadu prozkoumáme, ‚Rust‘ se již v sadě nevyskytuje.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}
#2. Pomocí metod .remove() a discard().
V praxi můžete chtít odstranit konkrétní prvky ze sady. K tomu můžete použít metody .remove() a .discard().
set.remove(element) odebere prvky ze sady.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Pokud se pokusíme odstranit prvek, který není v sadě přítomen, narazíme 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'
Pojďme se znovu podívat na py_set it. Nyní máme tři prvky.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Pomocí syntaxe set.discard(element) metoda .discard() také odstraňuje prvky ze sady.
py_set.discard('C++')
print(py_set)
# Output
{'JavaScript', 'Python'}
Od metody .remove() se však liší tím, že nevyvolá chybu KeyError, když se pokoušíme odstranit prvek, který není přítomen.
Pokud se pokusíme odstranit ‚Scala‘ (který neexistuje) ze seznamu pomocí metody .discard(), nevidíme žádnou chybu.
py_set.discard('Scala') #no error!
print(py_set)
# Output
{'JavaScript', 'Python'}
Jak získat přístup k prvkům sady Python
Zatím jsme se naučili přidávat a odebírat prvky ze sad Pythonu. Zatím jsme však neviděli, jak přistupovat k jednotlivým prvkům v sadě.
Jelikož je sada neuspořádanou kolekcí, nelze ji indexovat. Pokud se tedy pokusíte získat přístup k prvkům sady pomocí indexu, narazíte na chybu, jak je znázorněno.
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 přistupovat k prvkům v sadě?
Existují dva běžné způsoby, jak to udělat:
- Projděte sadu a získejte přístup ke každému prvku
- Zkontrolujte, zda je určitý prvek členem sady
▶️ Projděte sadu 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
V praxi můžete chtít zkontrolovat, zda je daný prvek přítomen v sadě pomocí operátoru in.
Poznámka: prvek v sadě vrátí True, pokud je prvek v sadě přítomen; jinak vrátí False.
V tomto příkladu py_set obsahuje ‚C++‘ a neobsahuje ‚Julia‘ a operátor in vrací True a False.
'C++' in py_set # True 'Julia' in py_set # False
Jak zjistit délku sady Python
Jak jsme viděli dříve, můžete použít funkci len() k získání počtu prvků přítomných v sadě.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5
Jak vymazat sadu Python
Chcete-li vymazat sadu odstraněním všech prvků, můžete použít metodu .clear().
Zavolejte metodu .clear() na py_set.
py_set.clear()
Pokud se ji pokusíte vytisknout, dostanete set() – což znamená, že sada je prázdná. Můžete také zavolat funkci len() a ověřit, že délka sady je nula.
print(py_set) # set() print(len(py_set)) # 0
Zatím jsme se naučili, jak provádět základní operace CRUD na sadách Pythonu:
- Vytvořit: Pomocí funkce set() přetypování typu a inicializace
- Číst: Přístup k prvkům sady pomocí smyček a v operátoru pro testování členství
- Aktualizovat: Přidat, odebrat prvky ze sad a aktualizovat sady
- Smazat: Vymaže sadu odstraněním všech prvků z ní
Společné operace sady, vysvětlené pomocí kódu Python
Sady Pythonu nám také umožňují provádět operace se základními sadami. Dozvíme se o nich v této sekci.
#1. Sjednocení množin v Pythonu
V teorii množin je spojením dvou množin množina všech prvků alespoň v jedné ze dvou množin. Pokud existují dvě množiny, A a B, pak sjednocení obsahuje prvky, které jsou přítomné pouze v A, pouze v B, a prvky přítomné v A i B.
Chcete-li najít spojení 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 AUB je totéž jako BU A. Ověřte si to výměnou pozic 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í spojené množiny je průnik dvou množin, A a B. Operace množina průniku vrátí množinu, která obsahuje všechny prvky přítomné v A i B.
K výpočtu průsečíku můžete použít operátor & nebo metodu .intersection(), jak je vysvětleno ve fragmentu kódu níže.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}
V tomto příkladu je prvek 9 přítomen v saděA i v saděB; takže množina průniku obsahuje pouze tento prvek.
Stejně jako sjednocení množin je i průnik množin komutativní operací.
setB.intersection(setA)
# Output
{9}
#3. Nastavit rozdíl v Pythonu
Jsou-li dány jakékoli dvě množiny, sjednocení a průnik nám pomohou najít prvky přítomné v obou a alespoň v jedné z množin. Na druhou stranu, rozdíl množin nám pomáhá najít prvky přítomné v jedné množině, ale ne ve druhé.
– setA.difference(setB) udává množinu prvků, které jsou přítomny pouze v saděA a nikoli v saděB.
– setB.difference(setA) udává množinu prvků, které jsou přítomny pouze v saděB a nikoli v saděA.
print(setA - setB)
print(setB - setA)
# Output
{1, 3, 5, 7}
{8, 2, 4, 6}
Je zřejmé, že AB není totéž jako BA, takže nastavený rozdíl není komutativní operací.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Symetrický souborový rozdíl v Pythonu
Zatímco průnik množin nám dává prvky přítomné v obou množinách, symetrický rozdíl množin vrací množinu prvků přítomných právě v jedné z množin.
Zvažte následující příklad.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
K výpočtu symetrické množiny rozdílů 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 jsou přítomny jak v saděA, tak v saděB. Nejsou tedy přítomny v sadě symetrických rozdílů.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Protože operace rozdílu symetrických množin shromažďuje všechny prvky, které se vyskytují přesně v jedné ze dvou množin, je výsledná množina stejná bez ohledu na pořadí, ve kterém jsou prvky shromažďovány. Proto je rozdíl symetrických množin 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.
Jsou-li dány dvě množiny A a B, je množina B podmnožinou množiny A, pokud jsou všechny prvky v množině B také přítomny v množině A. A množina A je nadmnožinou množiny B.
Zvažte příklad dvou sad: 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á sada podmnožinou jiné sady.
setA.issubset(setB) vrátí True, pokud je setA podmnožinou sadyB; jinak vrátí False.
V tomto příkladu jsou jazyky podmnožinou languages_extended.
languages.issubset(languages_extended) # Output True
Podobně můžete použít metodu .issuperset() ke kontrole, zda je daná sada nadmnožinou jiné sady.
setA.issuperset(setB) vrátí True, pokud je setA nadmnožinou sadyB; jinak vrátí False.
languages_extended.issuperset(languages) # Output True
Protože languages_extended je nadmnožinou jazyků, languages_extended.issuperset(languages) vrací True, jak je vidět výše.
Závěr
Doufám, že vám tento tutoriál pomohl porozumět práci sad Pythonu, metodám sad pro operace CRUD a běžným operacím sad. Jako další krok je můžete zkusit použít ve svých projektech Pythonu.
Můžete se podívat na další podrobné průvodce Pythonem. Šťastné učení!