Metode si Operatii cu Dictionare

Metode de Vizualizare

keys(), values(), items()

student = {"nume": "Ana", "varsta": 20, "nota": 9}

# Cheile
print(student.keys())    # dict_keys(['nume', 'varsta', 'nota'])
print(list(student.keys()))  # ['nume', 'varsta', 'nota']

# Valorile
print(student.values())  # dict_values(['Ana', 20, 9])
print(list(student.values()))  # ['Ana', 20, 9]

# Perechile
print(student.items())   # dict_items([('nume', 'Ana'), ...])
print(list(student.items()))  # [('nume', 'Ana'), ('varsta', 20), ...]

Metode de Modificare

update() - Actualizeaza/Adauga multiple

student = {"nume": "Ana", "varsta": 20}

# Cu alt dictionar
student.update({"nota": 9, "varsta": 21})
print(student)  # {'nume': 'Ana', 'varsta': 21, 'nota': 9}

# Cu keyword arguments
student.update(email="ana@mail.com")
print(student)  # {'nume': 'Ana', ..., 'email': 'ana@mail.com'}

# Cu lista de tupluri
student.update([("telefon", "123"), ("adresa", "Cluj")])

setdefault() - Obtine sau seteaza

student = {"nume": "Ana"}

# Daca cheia exista, returneaza valoarea
rezultat = student.setdefault("nume", "Bob")
print(rezultat)  # Ana
print(student)   # {'nume': 'Ana'}

# Daca cheia nu exista, o seteaza si returneaza
rezultat = student.setdefault("nota", 10)
print(rezultat)  # 10
print(student)   # {'nume': 'Ana', 'nota': 10}

Metode de Stergere

pop() - Sterge cheie specifica

student = {"nume": "Ana", "varsta": 20, "nota": 9}

# Sterge si returneaza
valoare = student.pop("nota")
print(valoare)  # 9
print(student)  # {'nume': 'Ana', 'varsta': 20}

# Cu default pentru cheie inexistenta
valoare = student.pop("email", "N/A")
print(valoare)  # N/A (nu arunca eroare)

popitem() - Sterge ultima pereche (LIFO)

student = {"nume": "Ana", "varsta": 20}

pereche = student.popitem()
print(pereche)  # ('varsta', 20)
print(student)  # {'nume': 'Ana'}

# KeyError pe dictionar gol
# {}.popitem()  # KeyError!

clear() - Sterge tot

student = {"nume": "Ana", "varsta": 20}
student.clear()
print(student)  # {}

Copierea Dictionarelor

Copie superficiala

original = {"a": 1, "b": [1, 2, 3]}

# Metode de copiere superficiala
copie1 = original.copy()
copie2 = dict(original)
copie3 = {**original}  # unpacking

copie1["a"] = 99
print(original["a"])  # 1 - neschimbat

# DAR pentru nested:
copie1["b"].append(4)
print(original["b"])  # [1, 2, 3, 4] - modificat!

Copie profunda

import copy

original = {"a": 1, "b": [1, 2, 3]}
copie = copy.deepcopy(original)

copie["b"].append(4)
print(original["b"])  # [1, 2, 3] - neschimbat!

Dict Comprehension

# Baza
patrate = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Cu conditie
pare = {x: x**2 for x in range(10) if x % 2 == 0}
# {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

# Inversare cheie-valoare
d = {"a": 1, "b": 2, "c": 3}
inversat = {v: k for k, v in d.items()}
# {1: 'a', 2: 'b', 3: 'c'}

# Din doua liste
chei = ["a", "b", "c"]
valori = [1, 2, 3]
d = {k: v for k, v in zip(chei, valori)}
# {'a': 1, 'b': 2, 'c': 3}

Merge Dictionare (Python 3.9+)

d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}

# Operator | (merge)
combinat = d1 | d2
print(combinat)  # {'a': 1, 'b': 3, 'c': 4}

# Operator |= (update)
d1 |= d2
print(d1)  # {'a': 1, 'b': 3, 'c': 4}

# Pentru Python < 3.9:
combinat = {**d1, **d2}

Functii Utile

fromkeys() - Creeaza cu chei predefinite

chei = ["a", "b", "c"]

d = dict.fromkeys(chei)
print(d)  # {'a': None, 'b': None, 'c': None}

d = dict.fromkeys(chei, 0)
print(d)  # {'a': 0, 'b': 0, 'c': 0}

Sortare dictionare

d = {"banana": 3, "mar": 1, "para": 2}

# Dupa chei
sortat = dict(sorted(d.items()))
# {'banana': 3, 'mar': 1, 'para': 2}

# Dupa valori
sortat = dict(sorted(d.items(), key=lambda x: x[1]))
# {'mar': 1, 'para': 2, 'banana': 3}

Pattern-uri Comune

Numarare elemente

text = "abracadabra"
frecventa = {}
for litera in text:
    frecventa[litera] = frecventa.get(litera, 0) + 1
print(frecventa)
# {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}

# Sau cu collections.Counter
from collections import Counter
frecventa = Counter(text)

Grupare elemente

cuvinte = ["ana", "bob", "ana", "cris", "bob", "ana"]
grupat = {}
for cuvant in cuvinte:
    if cuvant not in grupat:
        grupat[cuvant] = []
    grupat[cuvant].append(cuvant)

# Sau cu setdefault
grupat = {}
for cuvant in cuvinte:
    grupat.setdefault(cuvant, []).append(cuvant)

Default dict

from collections import defaultdict

# Valoare default pentru chei noi
d = defaultdict(list)
d["a"].append(1)
d["a"].append(2)
d["b"].append(3)
print(dict(d))  # {'a': [1, 2], 'b': [3]}

d = defaultdict(int)
d["count"] += 1
print(d["count"])  # 1

Greseli Frecvente

1. Modificare in timpul iterarii

d = {"a": 1, "b": 2}
# GRESIT
# for k in d:
#     d.pop(k)  # RuntimeError!

# CORECT
for k in list(d.keys()):
    d.pop(k)

2. Confuzie intre d[k] si d.get(k)

d = {"a": 1}
# d["b"]     # KeyError!
d.get("b")   # None - sigur

3. fromkeys cu valoare mutabila

# GRESIT - aceeasi lista pentru toate
d = dict.fromkeys(["a", "b"], [])
d["a"].append(1)
print(d)  # {'a': [1], 'b': [1]} - ambele modificate!

# CORECT
d = {k: [] for k in ["a", "b"]}

Puncte Cheie pentru Examen

• update() merge dictionare
• setdefault() obtine sau seteaza default
• pop(key) sterge si returneaza, popitem() sterge ultimul
• copy() face copie superficiala
• Dict comprehension: {k: v for k, v in items}
• in verifica cheile, nu valorile

Intrebari de Verificare

1. Ce face setdefault("a", 1) daca “a” exista?
2. Cum combini doua dictionare?
3. Ce returneaza pop() daca cheia nu exista?
4. Cum sortezi un dictionar dupa valori?