Python pakub sisseehitatud andmetüüpi set, mis tegeleb kogumitega.
Tüüpkogum on mittekorduvate elementide kogum (elemendid, mis ei ole sama väärtusega, unikaalsed elemendid) ja võib sooritada kogumioperatsioone, nagu liidukogum, tootekogum ja erinevuskogum.
Selles jaotises selgitatakse koos näidiskoodiga kogumitüüpi kogumioperatsioonide põhilisi operatsioone.
- Komplektide loomine:
{},set() - komplekti kaasamise märkimine
- Kogumi elementide arv:
len() - Elemendi lisamine komplekti:
add() - Elemendi eemaldamine komplektist:
discard(),remove(),pop(),clear()
- Wasset (ühinemine, liit):|operaator,
union() - Tootekomplektid (ühised osad, ristumised, ristumised):& operaator,
intersection() - suhteline täiendus:-operaator,
difference() - sümmeetria erinevuse komplekt:^ operaator,
symmetric_difference() - alamhulk või mitte:<= operaator,
issubset() - Ülemine komplekt või mitte:>= operaator,
issuperset() - Selle kindlaksmääramine, kas nad on vastastikku primaarsed või mitte:
isdisjoint()
Kogumitüüp on muutuv tüüp, mis võib lisada ja kustutada elemente, ning on olemas ka tüüp frozenset, millel on samad kogumioperatsioonid ja muud meetodid kui kogumitüübil, kuid mis on muutumatu (seda ei saa muuta elementide lisamise, kustutamise või muul viisil muutmise teel).
- Komplektobjekti loomine:: {}, set()
- komplekti kaasamise märkimine
- Kogumi elementide arv: len()
- Elemendi lisamine komplekti: add()
- Elemendi eemaldamine komplektist: discard(),remove(),pop(),clear()
- Wasset (ühinemine, liit): |operaator, union()
- Tootekomplektid (ühised osad, ristumised, ristumised): & operaator, intersection()
- suhteline täiendus: -operaator, difference()
- sümmeetria erinevuse komplekt: ^ operaator, symmetric_difference()
- alamhulk või mitte: <= operaator, issubset()
- Ülemine komplekt või mitte: >= operaator, issuperset()
- Selle kindlaksmääramine, kas nad on vastastikku primaarsed või mitte: isdisjoint()
Komplektobjekti loomine:: {}, set()
Genereeritud lainesulgudes {}
Kogumitüüpi objekte saab luua, ümbritsedes elemendid sulgudes {}.
Kui esineb dubleerivaid väärtusi, ignoreeritakse neid ja elementideks jäävad ainult unikaalsed väärtused.
s = {1, 2, 2, 3, 1, 4}
print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>
Elementidena on võimalik kasutada erinevaid tüüpe. Siiski ei saa registreerida uuendatavaid objekte, näiteks loenditüüpe. Tuplid on lubatud.
Samuti, kuna kogumitüübid on järjestamata, ei salvestata nende genereerimise järjekorda.
s = {1.23, 'abc', (0, 1, 2), 'abc'}
print(s)
# {(0, 1, 2), 1.23, 'abc'}
# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'
Erinevad tüübid, näiteks int ja float, loetakse duplikaatideks, kui nende väärtused on samaväärsed.
s = {100, 100.0}
print(s)
# {100}
Kuna tühja sulgu {} loetakse sõnastiku tüübiks, saab tühja komplekti tüüpi objekti (tühja komplekti) luua järgnevalt kirjeldatud konstruktori abil.
s = {}
print(s)
print(type(s))
# {}
# <class 'dict'>
Genereeritud konstruktori set() abil
Set tüüpi objekte saab luua ka konstruktori set() abil.
Märkides argumendina iteratiivse objekti, näiteks loendi või tupli, genereeritakse hulkobjekt, mille elemendid on ainult unikaalsed väärtused, kusjuures dubleerivad elemendid on välistatud.
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'>
Muutumatud frozenset-tüübid luuakse konstruktoriga frozenset().
fs_l = frozenset(l)
print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>
Kui argument on välja jäetud, luuakse tühi hulk-tüüpi objekt (tühi hulk).
s = set()
print(s)
print(type(s))
# set()
# <class 'set'>
Topeltelemendid saab nimekirjast või tuplist eemaldada, kasutades funktsiooni set(), kuid algse nimekirja järjekorda ei säilitata.
Kogumitüübi teisendamiseks loendiks või tupliks kasutage list(),tuple().
l = [2, 2, 3, 1, 3, 4]
l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]
Järgnevast artiklist leiate teavet dubleeritud elementide eemaldamise kohta, säilitades samal ajal järjekorra, ainult dubleeritud elementide väljavõtmise ja dubleeritud elementide töötlemise kohta kahemõõtmelises massiivis (loendite loendis).
komplekti kaasamise märkimine
Lisaks loetelumõistetele on olemas ka kogumõisted. Lihtsalt asendage loetelude mõistes nurksulgud [] sulgudega {}.
s = {i**2 for i in range(5)}
print(s)
# {0, 1, 4, 9, 16}
Lisateavet loendi mõistmise märkimise kohta leiate järgmisest artiklist.
Kogumi elementide arv: len()
Kogumi elementide arvu saab teada sisseehitatud funktsiooniga len().
s = {1, 2, 2, 3, 1, 4}
print(s)
print(len(s))
# {1, 2, 3, 4}
# 4
Kui soovite loendada igas nimekirjas nende elementide arvu, millel on dubleerivate väärtustega elemendid jne, vaadake järgmist artiklit.
Elemendi lisamine komplekti: add()
Elemendi lisamiseks komplekti kasuta meetodit add().
s = {0, 1, 2}
s.add(3)
print(s)
# {0, 1, 2, 3}
Elemendi eemaldamine komplektist: discard(),remove(),pop(),clear()
Elemendi eemaldamiseks kogumist kasuta meetodeid discard(), remove(), pop() ja clear().
Meetod discard() kustutab argumendis määratud elemendi. Kui on määratud väärtus, mida kogumis ei ole, ei tehta midagi.
s = {0, 1, 2}
s.discard(1)
print(s)
# {0, 2}
s = {0, 1, 2}
s.discard(10)
print(s)
# {0, 1, 2}
Meetod remove() eemaldab samuti argumendis määratud elemendi, kuid tagastatakse viga KeyError, kui on määratud väärtus, mida ei ole komplektis olemas.
s = {0, 1, 2}
s.remove(1)
print(s)
# {0, 2}
# s = {0, 1, 2}
# s.remove(10)
# KeyError: 10
Meetod pop() eemaldab elemendid hulgast ja tagastab nende väärtused. Ei ole võimalik valida, milliseid väärtusi eemaldada. Tühja kogumi korral tekib KeyError-viga.
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'
Meetod clear() eemaldab kõik elemendid ja muudab kogumi tühjaks.
s = {0, 1, 2}
s.clear()
print(s)
# set()
Wasset (ühinemine, liit): |operaator, union()
Liitude kogumi (ühinemine, liit) saab kätte operaatoriga | või meetodiga 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}
Meetodile võib määrata mitu argumenti. Lisaks kogumitüübile võib argumentidena määrata ka loendeid ja tupleid, mida saab set() abil kogumitüüpi teisendada. Sama kehtib ka järgnevate operaatorite ja meetodite kohta.
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}
Tootekomplektid (ühised osad, ristumised, ristumised): & operaator, intersection()
Tootekogumi (ühisosa, lõikumine ja ristumine) saab kätte operaatoriga & või meetodiga 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}
suhteline täiendus: -operaator, difference()
Diferentsikomplekti võib saada operaatoriga – või meetodiga 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ümmeetria erinevuse komplekt: ^ operaator, symmetric_difference()
Sümmeetrilise erinevuse hulga (elementide hulk, mis sisaldub ainult ühes neist kahest) saab kätte operaatoriga ^ või symmetric_difference().
Vastab eksklusiivsele disjunktsioonile (XOR) loogilistes operatsioonides.
s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}
s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}
alamhulk või mitte: <= operaator, issubset()
Selleks, et teha kindlaks, kas hulk on teise hulga alamhulk, kasutage operaatorit <= või meetodit issubset().
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s1 <= s2)
# True
print(s1.issubset(s2))
# True
Nii operaator <= kui ka meetod issubset() annavad võrdväärsete hulkade puhul tagasi true.
Et teha kindlaks, kas tegemist on tõese alamhulgaga, kasutage operaatorit <=, mis võrdväärsete hulkade puhul tagastab vale väärtuse.
print(s1 <= s1)
# True
print(s1.issubset(s1))
# True
print(s1 < s1)
# False
Ülemine komplekt või mitte: >= operaator, issuperset()
Selleks, et teha kindlaks, kas üks hulk on teise hulga ülemhulk, kasutage operaatorit >= või issuperset().
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s2 >= s1)
# True
print(s2.issuperset(s1))
# True
Nii operaator >= kui ka meetod issuperset() annavad võrdväärsete komplektide puhul tagasi true.
Et teha kindlaks, kas tegemist on tõelise ülemhulgaga, kasutage operaatorit >=, mis võrdväärsete hulkade puhul tagastab vale väärtuse.
print(s1 >= s1)
# True
print(s1.issuperset(s1))
# True
print(s1 > s1)
# False
Selle kindlaksmääramine, kas nad on vastastikku primaarsed või mitte: isdisjoint()
Selleks, et teha kindlaks, kas kaks kogumit on omavahel primaarsed, kasutage meetodit isdisjoint().
s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}
print(s1.isdisjoint(s2))
# False
print(s1.isdisjoint(s3))
# True
