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()
- 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-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
