Multimi (Sets) in Python

Ce este un Set?

Un set este o colectie neordonata de elemente unice. Seturile nu permit duplicate si nu au index.

Crearea Seturilor

# Cu acolade
fructe = {"mar", "para", "banana"}

# ATENTIE: {} creeaza dictionar gol, nu set!
gol = set()      # Set gol CORECT
nu_set = {}      # Dictionar gol!
print(type(nu_set))  # <class 'dict'>

# Din lista (elimina duplicate)
numere = set([1, 2, 2, 3, 3, 3])
print(numere)  # {1, 2, 3}

# Din string
litere = set("hello")
print(litere)  # {'h', 'e', 'l', 'o'}

Proprietati Cheie

Unicitate

numere = {1, 2, 2, 3, 3, 3}
print(numere)  # {1, 2, 3}
print(len(numere))  # 3

Neordonat (fara index)

fructe = {"mar", "para", "banana"}
# fructe[0]  # TypeError! Seturile nu au index

# Iterare functioneaza
for fruct in fructe:
    print(fruct)  # Ordinea nu e garantata

Elemente hashable

# Elemente valide (imutabile/hashable)
valid = {1, "text", (1, 2), True}

# Elemente INVALIDE
# invalid = {[1, 2]}     # TypeError - lista nu e hashable
# invalid = {{"a": 1}}   # TypeError - dict nu e hashable

Adaugarea Elementelor

add() - Adauga un element

fructe = {"mar", "para"}
fructe.add("banana")
print(fructe)  # {'mar', 'para', 'banana'}

# Adaugarea unui element existent nu face nimic
fructe.add("mar")
print(fructe)  # {'mar', 'para', 'banana'} - neschimbat

update() - Adauga multiple elemente

fructe = {"mar"}
fructe.update(["para", "banana"])
print(fructe)  # {'mar', 'para', 'banana'}

fructe.update("kiwi")  # Adauga caractere individual!
print(fructe)  # {'mar', 'para', 'banana', 'k', 'i', 'w'}

Stergerea Elementelor

remove() - Arunca KeyError daca nu exista

fructe = {"mar", "para", "banana"}
fructe.remove("para")
print(fructe)  # {'mar', 'banana'}

# fructe.remove("kiwi")  # KeyError!

discard() - Nu arunca eroare

fructe = {"mar", "para", "banana"}
fructe.discard("para")
print(fructe)  # {'mar', 'banana'}

fructe.discard("kiwi")  # OK, nu face nimic
print(fructe)  # {'mar', 'banana'}

pop() - Sterge si returneaza element arbitrar

fructe = {"mar", "para", "banana"}
elem = fructe.pop()
print(elem)    # Un element oarecare
print(fructe)  # Restul

# set().pop()  # KeyError pe set gol!

clear() - Sterge toate elementele

fructe = {"mar", "para"}
fructe.clear()
print(fructe)  # set()

Operatii pe Multimi

Reuniune (Union)

a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)           # {1, 2, 3, 4, 5}
print(a.union(b))      # {1, 2, 3, 4, 5}

Intersectie

a = {1, 2, 3}
b = {2, 3, 4}

print(a & b)               # {2, 3}
print(a.intersection(b))   # {2, 3}

Diferenta

a = {1, 2, 3}
b = {2, 3, 4}

print(a - b)             # {1} (in a dar nu in b)
print(a.difference(b))   # {1}
print(b - a)             # {4}

Diferenta Simetrica

a = {1, 2, 3}
b = {2, 3, 4}

print(a ^ b)                      # {1, 4}
print(a.symmetric_difference(b))  # {1, 4}

Operatii In-Place

a = {1, 2, 3}
b = {3, 4, 5}

a |= b  # sau a.update(b)
print(a)  # {1, 2, 3, 4, 5}

a = {1, 2, 3}
a &= b  # sau a.intersection_update(b)
print(a)  # {3}

a = {1, 2, 3}
a -= b  # sau a.difference_update(b)
print(a)  # {1, 2}

Comparatii intre Seturi

Submultime si Supramultime

a = {1, 2}
b = {1, 2, 3, 4}

print(a <= b)           # True - a e submultime
print(a.issubset(b))    # True

print(b >= a)           # True - b e supramultime
print(b.issuperset(a))  # True

print(a < b)            # True - submultime proprie

Disjuncte (fara elemente comune)

a = {1, 2}
b = {3, 4}

print(a.isdisjoint(b))  # True - nu au elemente comune

c = {2, 3}
print(a.isdisjoint(c))  # False - au 2 in comun

Frozen Set

Set imutabil - poate fi folosit ca cheie de dictionar:

fs = frozenset([1, 2, 3])
print(fs)  # frozenset({1, 2, 3})

# Nu poate fi modificat
# fs.add(4)  # AttributeError!

# Poate fi cheie de dictionar
d = {fs: "valoare"}
print(d[frozenset([1, 2, 3])])  # valoare

Aplicatii Practice

Eliminare duplicate

lista = [1, 2, 2, 3, 3, 3, 4]
unice = list(set(lista))
print(unice)  # [1, 2, 3, 4] (ordinea nu e garantata)

# Pastreaza ordinea (Python 3.7+)
unice = list(dict.fromkeys(lista))
print(unice)  # [1, 2, 2, 3, 3, 3, 4] -> [1, 2, 3, 4]

Verificare elemente comune

lista1 = [1, 2, 3, 4]
lista2 = [3, 4, 5, 6]

comune = set(lista1) & set(lista2)
print(comune)  # {3, 4}

Verificare unicitate

lista = [1, 2, 3, 4, 5]
are_duplicate = len(lista) != len(set(lista))
print(are_duplicate)  # False

Set Comprehension

patrate = {x**2 for x in range(10)}
print(patrate)  # {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

pare = {x for x in range(20) if x % 2 == 0}
print(pare)  # {0, 2, 4, 6, 8, 10, 12, 14, 16, 18}

Greseli Frecvente

1. Crearea setului gol

gol = {}       # GRESIT - e dictionar!
gol = set()    # CORECT

2. Adaugarea listei in set

s = {1, 2, 3}
# s.add([4, 5])  # TypeError!
s.update([4, 5])  # Adauga elementele

3. Asteptarea la ordine

s = {3, 1, 2}
# Nu presupune ordinea!
for x in s:
    print(x)  # Poate fi in orice ordine

Puncte Cheie pentru Examen

• Seturile contin doar elemente unice
• {} creeaza dict gol, nu set! Foloseste set()
• Elementele trebuie sa fie hashable
• remove() arunca eroare, discard() nu
• Operatori: | reuniune, & intersectie, - diferenta, ^ diferenta simetrica
• frozenset pentru seturi imutabile

Intrebari de Verificare

1. Cum creezi un set gol?
2. Ce diferenta e intre remove() si discard()?
3. Ce returneaza {1, 2} & {2, 3}?
4. De ce nu poti adauga o lista intr-un set?