Operacije z množicami (npr. določanje združitev množic, produktov množic in podmnožic) s Pythonovim tipom množice

Posel

Python ponuja vgrajeni podatkovni tip set, ki obravnava množice.

Vrsta množica je zbirka nepodvojenih elementov (elementi, ki nimajo enake vrednosti, edinstveni elementi) in lahko izvaja operacije množic, kot so unija množic, produkt množic in razlika množic.

V tem razdelku so z vzorčno kodo razložene osnovne operacije v množicah.

  • Ustvarjanje nastavljenih predmetov: {},set()
  • zapis za vključitev množice
  • Število elementov v množici:len()
  • Dodajanje elementa v niz:add()
  • Odstranitev elementa iz množice: discard(),remove(),pop(),clear()
  • Wasset (združitev, zveza):|operator,union()
  • Sklopi izdelkov (skupni deli, križišča, križišča):& operater,intersection()
  • relativno dopolnilo:-operator,difference()
  • niz razlik v simetriji:^ operater,symmetric_difference()
  • podmnožica ali ne:<= operater,issubset()
  • Zgornji set ali ne:>= operater,issuperset()
  • Ugotavljanje, ali so medsebojno praštevila ali ne:isdisjoint()

Tip množica je spremenljiv tip, ki lahko dodaja in briše elemente, obstaja pa tudi tip frozenset, ki ima enako operacijo množice in druge metode kot tip množica, vendar je nespremenljiv (ni ga mogoče spremeniti z dodajanjem, brisanjem ali drugim spreminjanjem elementov).

Ustvarjanje predmeta set:: {}, set()

Ustvari se z valovnimi oklepaji {}

Objekte tipa set lahko ustvarite tako, da elemente zaprete v oglate oklepaje {}.

Če obstajajo podvojene vrednosti, se ne upoštevajo in kot elementi ostanejo samo edinstvene vrednosti.

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

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

Kot elementi so lahko različne vrste. Vendar posodobljivih objektov, kot so tipi seznamov, ni mogoče registrirati. Dovoljeni so tupli.

Ker so vrste množic neurejene, se vrstni red, v katerem so ustvarjene, ne shranjuje.

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

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

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

Različni tipi, kot sta int in float, se štejejo za podvojene, če so njune vrednosti enakovredne.

s = {100, 100.0}

print(s)
# {100}

Ker prazen oklepaj {} velja za tip slovarja, lahko objekt tipa prazna množica (empty set) ustvarimo z uporabo konstruktorja, ki je opisan v nadaljevanju.

s = {}

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

Ustvari konstruktor set()

Objekte tipa set lahko ustvarite tudi s konstruktorjem set().

Če kot argument navedete iterabilen objekt, na primer seznam ali tuple, se ustvari objekt množice, katerega elementi so samo edinstvene vrednosti, pri čemer so podvojeni elementi izključeni.

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

Nespremenljivi tipi frozenset se ustvarijo s konstruktorjem frozenset().

fs_l = frozenset(l)

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

Če je argument izpuščen, se ustvari prazen objekt tipa množica (prazna množica).

s = set()

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

Podvojene elemente lahko s seznama ali trojice odstranite z uporabo funkcije set(), vendar se vrstni red prvotnega seznama ne ohrani.

Če želite vrsto množice pretvoriti v seznam ali tuple, uporabite funkcije list(),tuple().

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

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

Informacije o odstranjevanju podvojenih elementov ob ohranjanju vrstnega reda, izločanju samo podvojenih elementov in obdelavi podvojenih elementov v dvodimenzionalnem polju (seznamu seznamov) najdete v naslednjem članku.

zapis za vključitev množice

Poleg razumevanja seznamov obstajajo tudi razumevanja množic. Pri razumevanju seznamov preprosto zamenjajte oglate oklepaje [] z oglatimi oklepaji {}.

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

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

Za več informacij o zapisu razumevanja seznama glejte naslednji članek.

Število elementov v množici: len()

Število elementov v množici lahko dobite z vgrajeno funkcijo len().

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

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

Če želite prešteti število elementov v vsakem seznamu, ki ima elemente s podvojenimi vrednostmi, itd., si oglejte naslednji članek.

Dodajanje elementa v niz: add()

Za dodajanje elementa v množico uporabite metodo add().

s = {0, 1, 2}

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

Odstranitev elementa iz množice: discard(),remove(),pop(),clear()

Za odstranitev elementa iz množice uporabite metode discard(), remove(), pop() in clear().

Metoda discard() izbriše element, ki je naveden v argumentu. Če je navedena vrednost, ki ne obstaja v nizu, se ne naredi nič.

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() prav tako odstrani element, ki je naveden v argumentu, vendar se vrne napaka KeyError, če je navedena vrednost, ki ne obstaja v nizu.

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

Metoda pop() odstrani elemente iz množice in vrne njihove vrednosti. Ni mogoče izbrati, katere vrednosti se odstranijo. Pri prazni množici se pojavi napaka 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() odstrani vse elemente in naredi množico prazno.

s = {0, 1, 2}

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

Wasset (združitev, zveza): |operator, union()

Zbirko union (združitev, unija) lahko dobite z operatorjem | ali metodo 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}

Za metodo lahko določite več argumentov. Poleg vrste množice lahko kot argumente navedete tudi sezname in kupole, ki jih je mogoče pretvoriti v vrsto množice s funkcijo set(). Enako velja za naslednje operatorje in metode.

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}

Sklopi izdelkov (skupni deli, križišča, križišča): & operater, intersection()

Množico produktov (skupni del, presečišče in presečišče) lahko dobite z operatorjem & ali metodo 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}

relativno dopolnilo: -operator, difference()

Množico razlik lahko dobite z operatorjem – ali metodo 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}

niz razlik v simetriji: ^ operater, symmetric_difference()

Množico simetričnih razlik (množica elementov, ki jih vsebuje samo eden od obeh) lahko dobite z operatorjem ^ ali funkcijo symmetric_difference().

Enakovredno ekskluzivni disjunkciji (XOR) v logičnih operacijah.

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žica ali ne: <= operater, issubset()

Če želite ugotoviti, ali je množica podmnožica druge množice, uporabite operator <= ali metodo issubset().

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

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Tako operator <= kot metoda issubset() vrneta true za enakovredne množice.

Če želite ugotoviti, ali je podmnožica resnična, uporabite operator <=, ki za enakovredne množice vrne false.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Zgornji set ali ne: >= operater, issuperset()

Če želite ugotoviti, ali je ena množica nadmnožica druge, uporabite operator >= ali issuperset().

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

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Tako operator >= kot metoda issuperset() vrneta true za enakovredne množice.

Če želite ugotoviti, ali gre za pravo nadmnožico, uporabite operator >=, ki pri enakovrednih množicah vrne false.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Ugotavljanje, ali so medsebojno praštevila ali ne: isdisjoint()

Če želite ugotoviti, ali sta si dve množici enaki, uporabite metodo isdisjoint().

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

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True