Tutorial Python - Seturi şi Dicţionare

Seturi (Mulţimi)

Un set (mulţime) este o colecţie neordonată de iteme de orice tip immutable.
Elementele apar într-un singur exemplar (nu există duplicate) şi nu apar în ordine.
Set-urile suportă operaţiile standard de reuniune, intersecţie, diferenţă, şi diferenţă simetrică.
Un set se defineşte ca şi o listă, dar cu acolade în loc de paranteze pătrate.

>>> A = {4}
>>> vid = set()
>>> A
{4}
>>> vid
set()

Setul vid (mulţimea vidă) se defineşte folosind funcţia set(). Sintaxa {} defineşte un dicţionar vid.
Tot cu această funcţie puteţi crea un set pornind de la o listă set(lst) unde lst este o listă.
Putem crea un set pornind de la un string.

>>> litere = set('tutorialeplusplus')
>>> litere
{'u', 't', 's', 'r', 'p', 'e', 'a', 'o', 'l', 'i'}

Observaţi că elementele sunt unice, iar ordinea nu se păstrează.
Putem adăuga elemente noi la un set. Dacă valoarea adăugată există deja, nu se întâmplă nimic: no-op (no operation).

>>> a = {1}
>>> a.add(2)
>>> a
{1, 2}
>>> a.add(3)
>>> a
{1, 2, 3}
>>> a.add(2)
>>> a
{1, 2, 3}

Putem folosi funcţia update să adăugăm mai multe elemente (fie de la alte seturi, fie de la liste).

>>> a.update({4,7,9})
>>> a
{1, 2, 3, 4, 7, 9}
>>> a.update({1, 10}, {13, 11})
>>> a
{1, 2, 3, 4, 7, 9, 10, 11, 13}
>>> a.update([40, 42, 50])
>>> a
{1, 2, 3, 4, 7, 9, 10, 11, 13, 40, 42, 50}

Această funcţie acceptă orice număr de parametri (seturi, liste, tuple, etc.).
Eliminăm elemente cu funcţiile discard şi remove.
Atunci când remove încearcă să elimine un element inexistent va lansa excepţia (eroarea) KeyError, în timp ce discard nu face nimic (no-op).

>>> a.discard(11)
>>> a
{1, 2, 3, 4, 7, 9, 10, 13, 40, 42, 50}
>>> a.discard(11)
>>> a
{1, 2, 3, 4, 7, 9, 10, 13, 40, 42, 50}
>>> a.remove(13)
>>> a
{1, 2, 3, 4, 7, 9, 10, 40, 42, 50}
>>> a.remove(13)
Traceback (most recent call last):
  File "<pyshell#31>", line 1, in <module>
    a.remove(13)
KeyError: 13

Cu funcţia clear() putem şterge toate elementele setului.
Operaţiile standard mulţimilor le suportă şi tipul set.

>>> a = {1, 2, 3, 4}
>>> b = {3, 4, 5, 6}
>>> a.union(b) # Reuniune
{1, 2, 3, 4, 5, 6}
>>> a | b
{1, 2, 3, 4, 5, 6}
>>> a.intersection(b) # Intersectie
{3, 4}
>>> a & b
{3, 4}
>>> a.difference(b) # Diferenta
{1, 2}
>>> a - b
{1, 2}
>>> a.symmetric_difference(b) # Diferenta simetrica
{1, 2, 5, 6}
>>> a ^ b
{1, 2, 5, 6}

Observaţi că am pus şi operatorii specifici fiecărei operaţii. Atât funcţiile cât şi operatorii returnează seturi noi.
Puteţi testa dacă un element se află într-un set cu operatorul in (vezi liste).
De asemenea, există şi funcţiile issubset şi issuperset care testează dacă un set este un subset sau un superset al unui alt set.

>>> a = {1,  2}
>>> b = {1, 2, 3, 4}
>>> a.issubset(b)
True
>>> b.issuperset(a)
True
>>> a.add(7)
>>> a.issubset(b)
False
>>> b.issuperset(a)
False

În contextele booleene seturile vide sunt False, iar cele nevide sunt True.
Mai multe informaţii:

>>> help('set')

Dictionaries (Dicţionare)

Dicţionarul este un tip de dată compus. Este o mulţime neordonată de perechi key - value (cheie - valoare).
Dicţionarele sunt optimizate pentru extragerea valorilor atunci când se cunosc cheile. Aceste chei pot fi obiecte de tip immutable (stringuri, numere, tuple care conţin numai elemente immutable).
Listele nu pot fi chei deoarece pot fi modificate. Dicţionarele se definesc cu acolade. Cheile şi valorile asociate se precizează folosind sintaxa key:value.
Perechea {} defineşte un dicţionar vid.

>>> bob = {'a': 1, 'b': 2, 'c':3}
>>> vid = {}
>>> bob
{'a': 1, 'c': 3, 'b': 2}
>>> vid
{}

Apoi putem folosi notaţia de la liste (numai că de data aceasta în loc de indici numerici avem chei) ca să extragem valorile din dicţionar. Dacă o cheie nu există va fi lansată o eroare.

>>> bob['b']
2
>>> bob['a']
1
>>> bob[2]
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    bob[2]
KeyError: 2

Puteţi adăuga elemente noi folosind sinxtaxa dictionar[key] = value.
Puteţi modifica elemente existente folosind aceeaşi sintaxă. Cu del se pot şterge elemente.

>>> bob[2] = 'doi'
>>> bob
{2: 'doi', 'a': 1, 'c': 3, 'b': 2}
>>> bob['c'] = 5
>>> bob
{2: 'doi', 'a': 1, 'c': 5, 'b': 2}
>>> del bob[2]
>>> bob
{'a': 1, 'c': 5, 'b': 2}

Dintr-un dicţionar se pot extrage cheile, valorile şi itemele în liste.

>>> list(bob.keys())
['a', 'c', 'b']
>>> list(bob.items())
[('a', 1), ('c', 5), ('b', 2)]
>>> list(bob.values())
[1, 5, 2]

Folosiţi operatorul in pentru a testa dacă o cheie (nu o valoare!) se află în dicţionar.

>>> 'a' in bob
True
>>> 1 in bob
False

În contextele booleene dicţionarele vide sunt False, iar cele nevide sunt True.
Informaţii suplimentare:

>>> help('dict')