Operácie s množinami (napr. určenie zjednotenia množín, súčinu množín a podmnožín) pomocou typu množiny v jazyku Python

obchodné

Python poskytuje vstavaný dátový typ set, ktorý spracováva množiny.

Typ množina je kolekcia neduplicitných prvkov (prvky, ktoré nemajú rovnakú hodnotu, jedinečné prvky) a môže vykonávať množinové operácie, ako je napríklad zjednotenie množiny, súčin množiny a rozdiel množiny.

V tejto časti sú vysvetlené základné operácie v množinových operáciách so vzorovým kódom.

  • Vytváranie objektov sady: {},set()
  • notácia zahrnutia množiny
  • Počet prvkov v množine:len()
  • Pridanie prvku do množiny:add()
  • Odstránenie prvku z množiny: discard(),remove(),pop(),clear()
  • Wasset (fúzia, únia):|operátor,union()
  • Sady výrobkov (spoločné časti, križovatky, priesečníky):& operátor,intersection()
  • relatívny doplnok:-operátor,difference()
  • súbor rozdielov symetrie:^ operátor,symmetric_difference()
  • podmnožina alebo nie:<= operátor,issubset()
  • Horná sada alebo nie:>= operátor,issuperset()
  • Určenie, či sú navzájom prvočíselné alebo nie:isdisjoint()

Typ množina je premenlivý typ, ktorý môže pridávať a odstraňovať prvky, a existuje aj typ frozenset, ktorý má rovnakú operáciu množina a ďalšie metódy ako typ množina, ale je nemenný (nemožno ho meniť pridávaním, odstraňovaním alebo inou úpravou prvkov).

Vytvorenie nastaveného objektu:: {}, set()

Generované vlnovými zátvorkami {}

Objekty typu set možno vytvoriť uzavretím prvkov do zátvoriek {}.

Ak existujú duplicitné hodnoty, ignorujú sa a ako prvky zostanú len jedinečné hodnoty.

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

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

Ako prvky je možné použiť rôzne typy. Aktualizovateľné objekty, ako sú typy zoznamov, však nie je možné registrovať. Tuply sú povolené.

Keďže typy množín nie sú usporiadané, neukladá sa ani poradie, v akom sú generované.

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ôzne typy, napríklad int a float, sa považujú za duplicitné, ak sú ich hodnoty rovnocenné.

s = {100, 100.0}

print(s)
# {100}

Keďže prázdna zátvorka {} sa považuje za slovníkový typ, objekt typu prázdna množina (empty set) možno vytvoriť pomocou konštruktora opísaného ďalej.

s = {}

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

Generované konštruktorom set()

Objekty typu set možno vytvoriť aj pomocou konštruktora set().

Zadaním iterovateľného objektu, napríklad zoznamu alebo tuple, ako argumentu sa vygeneruje objekt množiny, ktorého prvky sú len jedinečné hodnoty, pričom duplicitné prvky sú vylúčené.

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'>

Nemenné typy frozenset sa vytvárajú pomocou konštruktora frozenset().

fs_l = frozenset(l)

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

Ak je argument vynechaný, vytvorí sa prázdny objekt typu množina (prázdna množina).

s = set()

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

Duplicitné prvky možno zo zoznamu alebo kôpky odstrániť pomocou funkcie set(), ale poradie pôvodného zoznamu sa nezachová.

Ak chcete previesť typ množiny na zoznam alebo tuple, použite list(),tuple().

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

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

Informácie o odstraňovaní duplicitných prvkov pri zachovaní poradia, extrahovaní iba duplicitných prvkov a spracovaní duplicitných prvkov v dvojrozmernom poli (zozname zoznamov) nájdete v nasledujúcom článku.

notácia zahrnutia množiny

Okrem zoznamových porozumení existujú aj množinové porozumenia. Stačí nahradiť hranaté zátvorky [] zátvorkami {} v zoznamových porozumeniach.

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

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

Viac informácií o zápise porozumenia zoznamu nájdete v nasledujúcom článku.

Počet prvkov v množine: len()

Počet prvkov v množine možno zistiť pomocou vstavanej funkcie len().

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

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

Ak chcete spočítať počet prvkov v každom zozname, ktorý má prvky s duplicitnými hodnotami atď., pozrite si nasledujúci článok.

Pridanie prvku do množiny: add()

Ak chcete pridať prvok do množiny, použite metódu add().

s = {0, 1, 2}

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

Odstránenie prvku z množiny: discard(),remove(),pop(),clear()

Ak chcete odstrániť prvok z množiny, použite metódy discard(), remove(), pop() a clear().

Metóda discard() odstráni prvok uvedený v argumente. Ak je zadaná hodnota, ktorá v množine neexistuje, nevykoná sa nič.

s = {0, 1, 2}

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

s = {0, 1, 2}

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

Metóda remove() tiež odstráni prvok uvedený v argumente, ale ak je uvedená hodnota, ktorá v množine neexistuje, vráti sa chyba KeyError.

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

Metóda pop() odstráni prvky z množiny a vráti ich hodnoty. Nie je možné vybrať, ktoré hodnoty sa majú odstrániť. Prázdna množina spô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'

Metóda clear() odstráni všetky prvky a množinu vyprázdni.

s = {0, 1, 2}

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

Wasset (fúzia, únia): |operátor, union()

Množinu union (zlúčenie, zjednotenie) možno získať pomocou operátora | alebo metódy 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}

Pre metódu je možné zadať viacero argumentov. Okrem typu množina možno ako argumenty uviesť aj zoznamy a tuply, ktoré možno konvertovať na typ množina pomocou funkcie set(). To isté platí pre následné operátory a metódy.

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ýrobkov (spoločné časti, križovatky, priesečníky): & operátor, intersection()

Súčinovú množinu (spoločnú časť, priesečník a priesečník) možno získať pomocou operátora & alebo metódy 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}

relatívny doplnok: -operátor, difference()

Rozdielovú množinu možno získať pomocou operátora – alebo metódy 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}

súbor rozdielov symetrie: ^ operátor, symmetric_difference()

Symetrickú rozdielovú množinu (množinu prvkov obsiahnutých len v jednom z dvoch) možno získať pomocou operátora ^ alebo symmetric_difference().

Ekvivalent exkluzívnej disjunkcie (XOR) v logických operáciá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 alebo nie: <= operátor, issubset()

Ak chcete zistiť, či je množina podmnožinou inej množiny, použite operátor <= alebo metódu issubset().

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

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Operátor <= aj metóda issubset() vracajú true pre ekvivalentné množiny.

Ak chcete zistiť, či ide o pravdivú podmnožinu, použite operátor <=, ktorý v prípade ekvivalentných množín vráti false.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Horná sada alebo nie: >= operátor, issuperset()

Ak chcete zistiť, či je jedna množina nadmnožinou inej, použite operátor >= alebo issuperset().

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

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Operátor >= aj metóda issuperset() vracajú true pre ekvivalentné množiny.

Ak chcete zistiť, či ide o pravdivú nadmnožinu, použite operátor >=, ktorý v prípade ekvivalentných množín vráti hodnotu false.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Určenie, či sú navzájom prvočíselné alebo nie: isdisjoint()

Ak chcete zistiť, či sú dve množiny navzájom primárne, použite metódu isdisjoint().

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

print(s1.isdisjoint(s2))
# False

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