2.10. Mulțimi

O mulțime este o colecție neordonată de elemente unice. Adăugarea unei valori care este deja prezentă nu are niciun efect; iterarea produce fiecare valoare exact o dată. Mulțimile sunt instrumentul potrivit atunci când apartenența și eliminarea duplicatelor contează, iar ordonarea nu.

2.10.1. Crearea unei mulțimi

Folosește acolade pentru o mulțime nevidă sau set() pentru una vidă:

colours = {"red", "green", "blue"}
empty = set()

Acoladele arată ca un literal dict; {} de unul singur este un dict vid, nu o mulțime vidă – unul dintre accidentele istorice ale Python. Folosește set() pentru cazul vid.

set() construiește de asemenea o mulțime dintr-un iterabil oarecare, ceea ce reprezintă modul standard de a elimina duplicatele dintr-o secvență:

nums = [1, 2, 2, 3, 1, 4]
unique = set(nums)
print(unique)

Rezultat:

{1, 2, 3, 4}

Ordinea de afișare poate varia – mulțimile nu promit să itereze într-o anumită ordine.

2.10.2. Mulțime vs dict

Atât mulțimile, cât și dicționarele stochează elemente unice într-un tabel de dispersie. Diferența o face ceea ce poartă cu sine fiecare element:

  • Un dict stochează perechi cheie-valoare. Căutarea unei chei returnează valoarea acesteia.

  • O set stochează doar elementele. Căutarea unui element îți spune dacă acesta există acolo.

Alegerea între cele două se reduce la dacă valoarea de lângă fiecare element înseamnă ceva:

  • Apelează la o mulțime când nicio valoare nu trebuie să stea lângă fiecare element – te interesează doar dacă elementul este prezent sau combini grupuri de elemente unice prin reuniune / intersecție.

  • Apelează la un dict când fiecare element este împerecheat cu date pe care căutarea trebuie să le recupereze – o hartă de configurare, un cache, un contor indexat după nume.

Cele două tipuri împărtășesc multă sintaxă de suprafață, de unde provine cea mai mare parte a confuziei. Diferențele într-un singur bloc:

set

dict

conține

elemente unice

chei unice, fiecare cu o valoare

literal populat

{1, 2, 3}

{"a": 1, "b": 2}

literal vid

set()

{}

test de apartenență

x in s

k in d (doar chei)

obține o valoare

n/a

d[k]

adaugă un element

s.add(x)

d[k] = v

iterare

produce elemente

produce chei (folosește d.items() pentru perechi)

Asimetria dintre literalii populați și cei vizi este capcana care merită semnalată:

  • Acoladele cu elemente în interior – {1, 2, 3} – sunt un literal de mulțime; acoladele cu perechi cheie-valoare – {"a": 1} – sunt un literal de dict. Parserul le diferențiază după ceea ce se află în interior.

  • Acoladele cu nimic în interior – {} – sunt un dict vid, nu o mulțime vidă. Dicționarele au apărut primele; literalul vid le aparține. O mulțime vidă nu are deloc un literal cu acolade și trebuie scrisă set().

Un șablon comun atunci când doar cheile unui dict sunt vreodată citite este trecerea la o mulțime – aceasta face intenția evidentă și elimină valorile neutilizate din memorie.

2.10.3. Adăugare și eliminare

s = {1, 2, 3}
s.add(4)
s.discard(99)            # silent: 99 not in s
s.remove(2)
print(s)

Rezultat:

{1, 3, 4}

2.10.4. Apartenență

Operatorul in testează apartenența. Pe o mulțime, acesta are un timp aproximativ constant, indiferent de dimensiune – ceea ce este motivul principal pentru a alege o mulțime în locul unei list atunci când trebuie doar să întrebi „se află această valoare acolo”:

if "red" in colours:
    print("colour is allowed")

O list cu același conținut ar scana de la început de fiecare dată, ceea ce este în regulă pentru zece elemente, dar lent pentru zece mii.

2.10.5. Operații pe mulțimi

Două mulțimi pot fi combinate cu operațiile matematice obișnuite. Fiecare are atât o formă de operator, cât și o formă de metodă:

  • a | b sau a.union(b) – tot ce se află în oricare dintre mulțimi.

  • a & b sau a.intersection(b) – doar ceea ce apare în ambele.

  • a - b sau a.difference(b) – în a dar nu în b.

  • a ^ b sau a.symmetric_difference(b) – într-una, dar nu în ambele.

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a | b)
print(a & b)
print(a - b)
print(a ^ b)

Rezultat:

{1, 2, 3, 4, 5, 6}
{3, 4}
{1, 2}
{1, 2, 5, 6}

Formele de operator sunt doar pentru citire; formele de metodă acceptă orice iterabil în dreapta, nu doar o altă mulțime (a.union([5, 6])). Alege oricare se citește mai bine în context.

2.10.6. Ce poate intra într-o mulțime

Elementele unei mulțimi trebuie să fie hashable – aceeași constrângere ca pentru cheile dict. int, float, str, bool, bytes și tuple (când conținutul său este la rândul lui hashable) funcționează toate. list și dict nu; încercarea de a adăuga una declanșează TypeError.

2.10.7. frozenset

O set obișnuită este mutabilă: fiecare apel la add / remove / discard schimbă obiectul pe loc. Această mutabilitate o descalifică de la a fi hashable, așa că o mulțime nu poate fi folosită ca o cheie dict sau ca membru al altei mulțimi.

frozenset este omologul imuabil. Are aceleași căutări și operatori (in, |, &, -, ^) ca set, dar fără add / remove și fără metode care modifică. Deoarece nimic nu îi poate schimba vreodată conținutul, hash-ul unui frozenset este bine definit – așa că este hashable:

primary = frozenset({"red", "green", "blue"})
secondary = frozenset({"yellow", "purple", "orange"})

palettes = {
    primary: "RGB",
    secondary: "mixed",
}

print(palettes[primary])

Rezultat:

RGB

Construiește un frozenset dintr-un iterabil oarecare – frozenset() pentru cazul vid, frozenset(some_set) pentru a face un instantaneu imuabil al unei mulțimi existente:

snapshot = frozenset(s)         # immutable copy of s
s.add("new")                    # snapshot does not change

Două motive comune pentru a apela la el:

  • Utilizare ca cheie de dict sau membru de mulțime. Oriunde o singură valoare nu poate captura ceea ce ai nevoie, un frozenset de valori poate – „mulțimea de caracteristici suportate de acest driver”, „mulțimea de pini pe care îi folosește acest profil”.

  • Blocarea unei constante. Un frozenset la nivel de modul de nume permise nu poate fi modificat accidental de un apelant; o set obișnuită poate. Preferă frozenset pentru orice este menit să fie doar pentru citire după construcție.