Python oferă un tip de date încorporat, set, care gestionează seturile.
Setul de tip este o colecție de elemente care nu se dublează (elemente care nu au aceeași valoare, elemente unice) și poate efectua operații de set, cum ar fi setul de uniune, setul produs și setul diferență.
În această secțiune sunt explicate operațiile de bază în operațiile cu seturi de tip set, însoțite de un exemplu de cod.
- Crearea de obiecte de set:
{},set() - notația de includere a setului
- Numărul de elemente din set:
len() - Adăugarea unui element la un set:
add() - Eliminarea unui element dintr-un set:
discard(),remove(),pop(),clear()
- Wasset (fuziune, uniune):|operator,
union() - Seturi de produse (părți comune, intersecții, intersecții):& operator,
intersection() - complementul relativ:-operator,
difference() - set de diferențe de simetrie:^ operator,
symmetric_difference() - subset sau nu:<= operator,
issubset() - Set superior sau nu:Operatorul >=,
issuperset() - Determinarea dacă sunt sau nu prime între ele:
isdisjoint()
Tipul set este un tip mutabil care poate adăuga și șterge elemente și există, de asemenea, un tip frozenset care are aceeași operație de set și alte metode ca și tipul set, dar este imuabil (nu poate fi modificat prin adăugarea, ștergerea sau modificarea în alt mod a elementelor).
- Crearea unui obiect set:: {}, set()
- notația de includere a setului
- Numărul de elemente din set: len()
- Adăugarea unui element la un set: add()
- Eliminarea unui element dintr-un set: discard(),remove(),pop(),clear()
- Wasset (fuziune, uniune): |operator, union()
- Seturi de produse (părți comune, intersecții, intersecții): & operator, intersection()
- complementul relativ: -operator, difference()
- set de diferențe de simetrie: ^ operator, symmetric_difference()
- subset sau nu: <= operator, issubset()
- Set superior sau nu: Operatorul >=, issuperset()
- Determinarea dacă sunt sau nu prime între ele: isdisjoint()
Crearea unui obiect set:: {}, set()
Generată de parantezele de valuri {}
Obiectele de tip set pot fi create prin înglobarea elementelor între paranteze {}.
În cazul în care există valori duplicate, acestea sunt ignorate și doar valorile unice rămân ca elemente.
s = {1, 2, 2, 3, 1, 4}
print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>
Este posibil să existe diferite tipuri de elemente. Cu toate acestea, obiectele care pot fi actualizate, cum ar fi tipurile de liste, nu pot fi înregistrate. Sunt permise tuplurile.
De asemenea, deoarece tipurile de seturi nu sunt ordonate, ordinea în care sunt generate nu este stocată.
s = {1.23, 'abc', (0, 1, 2), 'abc'}
print(s)
# {(0, 1, 2), 1.23, 'abc'}
# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'
Tipuri diferite, cum ar fi int și float, sunt considerate duplicate dacă valorile lor sunt echivalente.
s = {100, 100.0}
print(s)
# {100}
Deoarece o acoladă goală {} este considerată un tip de dicționar, un obiect de tip set gol (set gol) poate fi creat cu ajutorul constructorului descris în continuare.
s = {}
print(s)
print(type(s))
# {}
# <class 'dict'>
Generat de constructorul set()
Obiectele de tip set pot fi, de asemenea, create cu ajutorul constructorului set().
Specificarea ca argument a unui obiect iterabil, cum ar fi o listă sau un tupluplu, generează un obiect set ale cărui elemente sunt numai valori unice, cu excluderea elementelor duplicate.
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'>
Tipurile de frozenset imuabile sunt create cu ajutorul constructorului frozenset().
fs_l = frozenset(l)
print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>
Dacă argumentul este omis, se creează un obiect de tip set gol (set gol).
s = set()
print(s)
print(type(s))
# set()
# <class 'set'>
Elementele duplicate pot fi eliminate dintr-o listă sau dintr-un tupluplu folosind set(), dar ordinea din lista originală nu este păstrată.
Pentru a converti un tip de set într-o listă sau un tupluplu, utilizați list(),tuple().
l = [2, 2, 3, 1, 3, 4]
l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]
Consultați următorul articol pentru informații privind eliminarea elementelor duplicate păstrând ordinea, extragerea numai a elementelor duplicate și prelucrarea elementelor duplicate într-o matrice bidimensională (listă de liste).
notația de includere a setului
Pe lângă înțelegerile de liste, există și înțelegeri de seturi. Pur și simplu înlocuiți parantezele pătrate [] cu paranteze {} în cazul înțelegerilor de listă.
s = {i**2 for i in range(5)}
print(s)
# {0, 1, 4, 9, 16}
Consultați următorul articol pentru mai multe informații despre notația de înțelegere a listei.
Numărul de elemente din set: len()
Numărul de elemente dintr-un set poate fi obținut cu ajutorul funcției încorporate len().
s = {1, 2, 2, 3, 1, 4}
print(s)
print(len(s))
# {1, 2, 3, 4}
# 4
Dacă doriți să numărați numărul de elemente din fiecare listă care are elemente cu valori duplicate etc., consultați următorul articol.
Adăugarea unui element la un set: add()
Pentru a adăuga un element la un set, se utilizează metoda add().
s = {0, 1, 2}
s.add(3)
print(s)
# {0, 1, 2, 3}
Eliminarea unui element dintr-un set: discard(),remove(),pop(),clear()
Pentru a elimina un element dintr-un set, utilizați metodele discard(), remove(), pop() și clear().
Metoda discard() șterge elementul specificat în argument. În cazul în care se specifică o valoare care nu există în set, nu se face nimic.
s = {0, 1, 2}
s.discard(1)
print(s)
# {0, 2}
s = {0, 1, 2}
s.discard(10)
print(s)
# {0, 1, 2}
Metoda remove() elimină, de asemenea, elementul specificat în argument, dar se returnează o eroare KeyError în cazul în care se specifică o valoare care nu există în set.
s = {0, 1, 2}
s.remove(1)
print(s)
# {0, 2}
# s = {0, 1, 2}
# s.remove(10)
# KeyError: 10
Metoda pop() elimină elemente dintr-un set și returnează valorile acestora. Nu este posibilă selectarea valorilor care trebuie eliminate. Un set gol va genera o eroare de tip KeyError.
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'
Metoda clear() elimină toate elementele și face ca setul să fie gol.
s = {0, 1, 2}
s.clear()
print(s)
# set()
Wasset (fuziune, uniune): |operator, union()
Setul de uniune (fuziune, uniune) poate fi obținut cu ajutorul operatorului | sau al metodei 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}
Se pot specifica mai multe argumente pentru o metodă. Pe lângă tipul set, pot fi specificate ca argumente și listele și tuplurile care pot fi convertite în tipul set prin set(). Același lucru este valabil și pentru operatorii și metodele ulterioare.
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}
Seturi de produse (părți comune, intersecții, intersecții): & operator, intersection()
Setul de produse (partea comună, intersecția și intersecția) poate fi obținut cu ajutorul operatorului & sau al metodei 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}
complementul relativ: -operator, difference()
Setul de diferențe poate fi obținut cu ajutorul operatorului – sau al metodei 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}
set de diferențe de simetrie: ^ operator, symmetric_difference()
Setul de diferențe simetrice (setul de elemente conținute în doar unul dintre cele două) poate fi obținut cu ajutorul operatorului ^ sau cu symmetric_difference().
Echivalent cu disjuncția exclusivă (XOR) în operațiile logice.
s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}
s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}
subset sau nu: <= operator, issubset()
Pentru a determina dacă un set este un subset al unui alt set, utilizați operatorul <= sau metoda issubset().
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s1 <= s2)
# True
print(s1.issubset(s2))
# True
Atât operatorul <=, cât și metoda issubset() returnează true pentru seturi echivalente.
Pentru a determina dacă este un subset adevărat, utilizați operatorul <=, care returnează fals pentru seturi echivalente.
print(s1 <= s1)
# True
print(s1.issubset(s1))
# True
print(s1 < s1)
# False
Set superior sau nu: Operatorul >=, issuperset()
Pentru a determina dacă un set este un superset al altui set, utilizați operatorul >= sau issuperset().
s1 = {0, 1}
s2 = {0, 1, 2, 3}
print(s2 >= s1)
# True
print(s2.issuperset(s1))
# True
Atât operatorul >=, cât și metoda issuperset() returnează true pentru seturi echivalente.
Pentru a determina dacă este un supraansamblu adevărat, utilizați operatorul >=, care returnează fals pentru seturi echivalente.
print(s1 >= s1)
# True
print(s1.issuperset(s1))
# True
print(s1 > s1)
# False
Determinarea dacă sunt sau nu prime între ele: isdisjoint()
Pentru a determina dacă două seturi sunt prime unul față de celălalt, utilizați metoda isdisjoint().
s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}
print(s1.isdisjoint(s2))
# False
print(s1.isdisjoint(s3))
# True
