Joukko-operaatiot (esim. unionijoukkojen, tulojoukkojen ja osajoukkojen määrittäminen) Pythonin joukko-tyypin avulla.

liiketoiminta

Python tarjoaa sisäänrakennetun tietotyypin set, joka käsittelee joukkoja.

Tyyppi set on kokoelma ei-duplikoituvia elementtejä (elementtejä, joilla ei ole samaa arvoa, uniikkeja elementtejä), ja sillä voidaan suorittaa joukko-operaatioita, kuten union set, product set ja difference set.

Tässä jaksossa selitetään joukko-tyyppisten joukko-operaatioiden perusoperaatiot esimerkkikoodin avulla.

  • Asetettujen objektien luominen: {},set()
  • set inclusion notation
  • Joukon elementtien lukumäärä:len()
  • Elementin lisääminen joukkoon:add()
  • Elementin poistaminen joukosta: discard(),remove(),pop(),clear()
  • Wasset (fuusio, liitto):|operator,union()
  • Tuotesarjat (yhteiset osat, risteyskohdat, risteyskohdat):& operaattori,intersection()
  • suhteellinen komplementti:-operaattori,difference()
  • symmetriaerojoukko:^ operaattori,symmetric_difference()
  • osajoukko vai ei:<= operaattori,issubset()
  • Ylempi sarja tai ei:>= operaattori,issuperset()
  • Sen määrittäminen, ovatko ne keskenään alkulukuja vai eivät.:isdisjoint()

Set-tyyppi on muuttuva tyyppi, joka voi lisätä ja poistaa elementtejä, ja lisäksi on olemassa frozenset-tyyppi, jolla on sama set-operaatio ja muut metodit kuin set-tyypillä, mutta joka on muuttumaton (sitä ei voi muuttaa lisäämällä, poistamalla tai muulla tavoin muuttamalla elementtejä).

Set-objektin luominen:: {}, set()

Tuotettu aaltosulkeilla {}

Joukkotyyppisiä objekteja voidaan luoda sulkemalla elementit sulkeisiin {}.

Jos on päällekkäisiä arvoja, ne jätetään huomiotta ja vain ainutlaatuiset arvot jäävät elementeiksi.

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

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

Elementteinä voi olla erilaisia tyyppejä. Päivitettäviä objekteja, kuten luettelotyyppejä, ei kuitenkaan voi rekisteröidä. Tuplat ovat sallittuja.

Koska joukkotyypit ovat järjestämättömiä, niiden muodostamisjärjestystä ei myöskään tallenneta.

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

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

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

Erilaisia tyyppejä, kuten int ja float, pidetään päällekkäisinä, jos niiden arvot vastaavat toisiaan.

s = {100, 100.0}

print(s)
# {100}

Koska tyhjää hakasulkeista {} pidetään sanakirjatyyppinä, tyhjän joukon tyyppiobjekti (tyhjä joukko) voidaan luoda seuraavassa kuvatulla konstruktorilla.

s = {}

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

Luodaan konstruktorilla set()

Set-tyyppisiä objekteja voidaan luoda myös konstruktorilla set().

Kun argumenttina on iteroituva objekti, kuten lista tai tuple, luodaan joukko-objekti, jonka elementit ovat vain yksilöllisiä arvoja, eikä päällekkäisiä elementtejä oteta huomioon.

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

Muuttumattomat frozenset-tyypit luodaan konstruktorilla frozenset().

fs_l = frozenset(l)

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

Jos argumentti jätetään pois, luodaan tyhjä set-tyyppinen objekti (tyhjä joukko).

s = set()

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

Kaksinkertaiset elementit voidaan poistaa listasta tai tuplasta komennolla set(), mutta alkuperäisen listan järjestys ei säily.

Jos haluat muuntaa set-tyypin listaksi tai tuplaksi, käytä list(),tuple().

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

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

Seuraavassa artikkelissa on tietoja päällekkäisten elementtien poistamisesta järjestys säilyttäen, vain päällekkäisten elementtien poimimisesta ja päällekkäisten elementtien käsittelystä kaksiulotteisessa joukossa (listojen luettelo).

set inclusion notation

Luettelokäsitteiden lisäksi on olemassa joukko-käsitteitä. Yksinkertaisesti korvaa listakäsittelyissä hakasulkeet [] hakasulkeilla {}.

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

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

Seuraavassa artikkelissa on lisätietoa listan ymmärtämisen merkintätavoista.

Joukon elementtien lukumäärä: len()

Joukon alkioiden lukumäärä saadaan käyttämällä sisäänrakennettua funktiota len().

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

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

Jos haluat laskea niiden elementtien lukumäärän, joissa on päällekkäisiä arvoja sisältäviä elementtejä, katso seuraava artikkeli.

Elementin lisääminen joukkoon: add()

Kun haluat lisätä elementin joukkoon, käytä add()-metodia.

s = {0, 1, 2}

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

Elementin poistaminen joukosta: discard(),remove(),pop(),clear()

Voit poistaa elementin joukosta käyttämällä metodeja discard(), remove(), pop() ja clear().

Metodi discard() poistaa argumentissa määritetyn elementin. Jos annetaan arvo, jota ei ole joukossa, mitään ei tehdä.

s = {0, 1, 2}

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

s = {0, 1, 2}

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

Metodi remove() poistaa myös argumentissa määritetyn elementin, mutta virhe KeyError palautetaan, jos määritetään arvo, jota ei ole joukossa.

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

Pop()-metodi poistaa elementtejä joukosta ja palauttaa niiden arvot. Ei ole mahdollista valita, mitkä arvot poistetaan. Tyhjä joukko johtaa KeyError-virheeseen.

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'

Metodi clear() poistaa kaikki elementit ja tekee joukosta tyhjän.

s = {0, 1, 2}

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

Wasset (fuusio, liitto): |operator, union()

Union-joukko (fuusio, unioni) saadaan |-operaattorilla tai union()-menetelmällä.

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}

Metodille voidaan määrittää useita argumentteja. Joukkotyypin lisäksi argumentteina voidaan antaa myös listoja ja tupleja, jotka voidaan muuntaa joukko-tyyppisiksi set()-menetelmällä. Sama pätee myöhempiin operaattoreihin ja metodeihin.

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}

Tuotesarjat (yhteiset osat, risteyskohdat, risteyskohdat): & operaattori, intersection()

Tuotejoukko (yhteinen osa, leikkaus ja leikkaus) saadaan &-operaattorilla tai intersection()-menetelmällä.

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}

suhteellinen komplementti: -operaattori, difference()

Erotusjoukko saadaan -operaattorilla tai difference()-menetelmällä.

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}

symmetriaerojoukko: ^ operaattori, symmetric_difference()

Symmetrinen erotusjoukko (niiden elementtien joukko, jotka sisältyvät vain jompaankumpaan) saadaan operaattorilla ^ tai symmetric_difference().

Vastaa eksklusiivista disjunktiota (XOR) loogisissa operaatioissa.

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

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

osajoukko vai ei: <= operaattori, issubset()

Voit määrittää, onko joukko toisen joukon osajoukko, käyttämällä <=-operaattoria tai issubset()-menetelmää.

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

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Sekä <=-operaattori että issubset()-menetelmä palauttavat totuuden vastaaville joukoille.

Jos haluat määrittää, onko se tosi osajoukko, käytä <=-operaattoria, joka palauttaa epätosi vastaaville joukoille.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Ylempi sarja tai ei: >= operaattori, issuperset()

Jos haluat määrittää, onko jokin joukko toisen joukon yläjoukko, käytä >=-operaattoria tai issuperset()-operaattoria.

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

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Sekä >=-operaattori että issuperset()-menetelmä palauttavat true-arvon vastaaville joukoille.

Määrittääksesi, onko kyseessä tosi superjoukko, käytä >=-operaattoria, joka palauttaa epätosi, jos kyseessä on samanarvoinen joukko.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Sen määrittäminen, ovatko ne keskenään alkulukuja vai eivät.: isdisjoint()

Voit määrittää, ovatko kaksi joukkoa toistensa alkulukuja, käyttämällä isdisjoint()-menetelmää.

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

print(s1.isdisjoint(s2))
# False

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