Operace s množinami (např. určování sjednocení množin, součinů množin a podmnožin) pomocí typu množiny jazyka Python

Podnikání

Python nabízí vestavěný datový typ set, který pracuje s množinami.

Typ množina je kolekce neduplicitních prvků (prvky, které nemají stejnou hodnotu, jedinečné prvky) a lze s ní provádět množinové operace, jako je sjednocení množin, součin množin a rozdíl množin.

V této části jsou vysvětleny základní operace v množinových operacích s ukázkovým kódem.

  • Vytváření objektů sady: {},set()
  • notace začlenění sady
  • Počet prvků v množině:len()
  • Přidání prvku do sady:add()
  • Odstranění prvku z množiny: discard(),remove(),pop(),clear()
  • Wasset (fúze, unie):|operátor,union()
  • Sady výrobků (společné části, průsečíky, průsečíky):& operátor,intersection()
  • relativní doplněk:-operátor,difference()
  • sada rozdílů symetrie:^ operátor,symmetric_difference()
  • podmnožina nebo ne:<= operátor,issubset()
  • Horní sada nebo ne:Operátor >=,issuperset()
  • Určení, zda jsou vzájemně prvočíselné, nebo ne:isdisjoint()

Typ množina je proměnný typ, který může přidávat a mazat prvky, a existuje také typ frozenset, který má stejné operace s množinami a další metody jako typ množina, ale je neměnný (nelze jej měnit přidáváním, mazáním nebo jinou úpravou prvků).

Vytvoření objektu sady:: {}, set()

Generováno vlnovými závorkami {}

Objekty typu set lze vytvořit uzavřením prvků do závorek {}.

Pokud existují duplicitní hodnoty, jsou ignorovány a jako prvky zůstávají pouze jedinečné hodnoty.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

Jako prvky lze použít různé typy. Aktualizovatelné objekty, jako jsou typy seznamů, však nelze registrovat. Tuply jsou povoleny.

Vzhledem k tomu, že typy množin jsou neuspořádané, neukládá se ani pořadí, v jakém jsou generovány.

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

Různé typy, například int a float, jsou považovány za duplicitní, pokud jsou jejich hodnoty rovnocenné.

s = {100, 100.0}

print(s)
# {100}

Protože prázdná závorka {} je považována za slovníkový typ, lze objekt typu prázdná množina (empty set) vytvořit pomocí konstruktoru popsaného dále.

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

Generuje konstruktor set()

Objekty typu set lze také vytvořit pomocí konstruktoru set().

Zadáním iterovatelného objektu, například seznamu nebo tuple, jako argumentu se vygeneruje objekt množiny, jehož prvky jsou pouze jedinečné hodnoty, přičemž duplicitní prvky jsou vyloučeny.

l = [1, 2, 2, 3, 1, 4]

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

Neměnné typy frozenset se vytvářejí pomocí konstruktoru frozenset().

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

Pokud je argument vynechán, je vytvořen prázdný objekt typu množina (prázdná množina).

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

Duplicitní prvky lze ze seznamu nebo tuple odstranit pomocí funkce set(), ale pořadí původního seznamu se nezachová.

Chcete-li převést typ množiny na seznam nebo tuple, použijte příkazy list(),tuple().

l = [2, 2, 3, 1, 3, 4]

l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]

Informace o odstraňování duplicitních prvků při zachování pořadí, extrakci pouze duplicitních prvků a zpracování duplicitních prvků ve dvourozměrném poli (seznamu seznamů) najdete v následujícím článku.

notace začlenění sady

Kromě seznamových srozumitelností existují i srozumitelnosti množinové. Stačí nahradit hranaté závorky [] závorkami {} v seznamových porozuměních.

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

Další informace o zápisu srozumitelnosti seznamu naleznete v následujícím článku.

Počet prvků v množině: len()

Počet prvků v množině lze zjistit pomocí vestavěné funkce len().

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

Pokud chcete spočítat počet prvků v každém seznamu, který obsahuje prvky s duplicitními hodnotami atd., viz následující článek.

Přidání prvku do sady: add()

Chcete-li přidat prvek do množiny, použijte metodu add().

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

Odstranění prvku z množiny: discard(),remove(),pop(),clear()

K odstranění prvku z množiny slouží metody discard(), remove(), pop() a clear().

Metoda discard() odstraní prvek uvedený v argumentu. Pokud je zadána hodnota, která v množině neexistuje, neprovede se nic.

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

Metoda remove() rovněž odstraní prvek uvedený v argumentu, ale pokud je zadána hodnota, která v množině neexistuje, je vrácena chyba KeyError.

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

Metoda pop() odstraní prvky z množiny a vrátí jejich hodnoty. Není možné vybrat, které hodnoty se mají odstranit. Prázdná množina způsobí chybu KeyError.

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

Metoda clear() odstraní všechny prvky a množinu vyprázdní.

s = {0, 1, 2}

s.clear()
print(s)
# set()

Wasset (fúze, unie): |operátor, union()

Sjednocení množiny (merger, union) lze získat pomocí operátoru | nebo metody union().

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

Pro metodu lze zadat více argumentů. Kromě typu set lze jako argumenty zadat také seznamy a tuply, které lze na typ set převést pomocí funkce set(). Totéž platí pro následné operátory a metody.

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

Sady výrobků (společné části, průsečíky, průsečíky): & operátor, intersection()

Součinovou množinu (společnou část, průnik a průsečík) lze získat pomocí operátoru & nebo metody intersection().

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

relativní doplněk: -operátor, difference()

Rozdílovou množinu lze získat pomocí operátoru – nebo metody difference().

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

sada rozdílů symetrie: ^ operátor, symmetric_difference()

Symetrickou rozdílovou množinu (množinu prvků obsažených pouze v jedné z nich) lze získat pomocí operátoru ^ nebo symmetric_difference().

Ekvivalent exkluzivní disjunkce (XOR) v logických operacích.

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

podmnožina nebo ne: <= operátor, issubset()

Chcete-li zjistit, zda je množina podmnožinou jiné množiny, použijte operátor <= nebo metodu issubset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Operátor <= i metoda issubset() vracejí true pro ekvivalentní množiny.

Chcete-li zjistit, zda se jedná o pravdivou podmnožinu, použijte operátor <=, který pro ekvivalentní množiny vrací false.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Horní sada nebo ne: Operátor >=, issuperset()

Chcete-li zjistit, zda je jedna množina nadmnožinou jiné, použijte operátor >= nebo issuperset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Operátor >= i metoda issuperset() vracejí true pro ekvivalentní množiny.

Chcete-li zjistit, zda se jedná o pravdivou nadmnožinu, použijte operátor >=, který v případě ekvivalentních množin vrací nepravdu.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Určení, zda jsou vzájemně prvočíselné, nebo ne: isdisjoint()

Chcete-li zjistit, zda jsou dvě množiny navzájem prvočíselné, použijte metodu isdisjoint().

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True
Copied title and URL