Un conjunt de programació Python és un tipus de dades de col·lecció no ordenada que és iterable, mutable i no té elements duplicats.
El conjunt es representa amb { } (valors tancats entre claus)
El principal avantatge d'utilitzar un conjunt, a diferència d'un llista , és que té un mètode molt optimitzat per comprovar si un element concret està contingut en el conjunt. Es basa en una estructura de dades coneguda com a taula hash. Com que els conjunts no estan ordenats, no podem accedir als elements mitjançant índexs com ho fem a les llistes.
Exemple de conjunts Python
Python 3
var>=> {>'Geeks'>,>'for'>,>'Geeks'>}> type>(var)> |
>
>
Sortida:
set>
Complexitat temporal: O(1)
Espai auxiliar: O(1)
Escriviu el mètode Casting amb Python Set
El mètode set() de Python s'utilitza per al càsting de tipus.
Python 3
# typecasting list to set> myset>=> set>([>'a'>,>'b'>,>'c'>])> print>(myset)> # Adding element to the set> myset.add(>'d'>)> print>(myset)> |
>
>
Sortida:
char en cadena java
El conjunt de Python és un tipus de dades no ordenat, el que significa que no podem saber en quin ordre s'emmagatzemen els elements del conjunt.
{'c', 'b', 'a'} {'d', 'c', 'b', 'a'}> Complexitat temporal: O(n)
Espai auxiliar: O(n)
Comprova únic i immutable amb el conjunt de Python
Els conjunts de Python no poden tenir un valor duplicat i un cop creats no podem canviar-ne el valor.
Python 3
# Python program to demonstrate that> # a set cannot have duplicate values> # and we cannot change its items> # a set cannot have duplicate values> myset>=> {>'Geeks'>,>'for'>,>'Geeks'>}> print>(myset)> # values of a set cannot be changed> myset[>1>]>=> 'Hello'> print>(myset)> |
>
>
Sortida:
El primer codi explica que el conjunt no pot tenir un valor duplicat. Cada element que hi ha és un valor únic.
El segon codi genera un error perquè no podem assignar ni canviar un valor un cop creat el conjunt. Només podem afegir o eliminar elements del conjunt.
{'Geeks', 'for'} TypeError: 'set' object does not support item assignment> Element heterogeni amb conjunt de Python
Els conjunts de Python hi poden emmagatzemar elements heterogenis, és a dir, un conjunt pot emmagatzemar una barreja de tipus de dades de cadena, enters, booleans, etc.
Python 3
# Python example demonstrate that a set> # can store heterogeneous elements> myset>=> {>'Geeks'>,>'for'>,>10>,>52.7>,>True>}> print>(myset)> |
>
>
Sortida:
{True, 10, 'Geeks', 52.7, 'for'}> Complexitat temporal: O(n)
Espai auxiliar: O(n)
Conjunts congelats de Python
Conjunts congelats a Python són objectes immutables que només admeten mètodes i operadors que produeixen un resultat sense afectar el conjunt o conjunts congelats als quals s'apliquen. Es pot fer amb el mètode frozenset() a Python.
Tot i que els elements d'un conjunt es poden modificar en qualsevol moment, els elements del conjunt congelat segueixen sent els mateixos després de la creació.
Si no es passa cap paràmetre, retorna un conjunt congelat buit.
Python
# Python program to demonstrate differences> # between normal and frozen set> # Same as {'a', 'b','c'}> normal_set>=> set>([>'a'>,>'b'>,>'c'>])> print>(>'Normal Set'>)> print>(normal_set)> # A frozen set> frozen_set>=> frozenset>([>'e'>,>'f'>,>'g'>])> print>(>'
Frozen Set'>)> print>(frozen_set)> # Uncommenting below line would cause error as> # we are trying to add element to a frozen set> # frozen_set.add('h')> |
>
mapa en java
>
Sortida:
Normal Set {'a', 'c', 'b'} Frozen Set {'e', 'g', 'f'}> Complexitat temporal: O(n)
Espai auxiliar: O(n)
Funcionament intern de Set
Es basa en una estructura de dades coneguda com a taula hash. Si hi ha diversos valors a la mateixa posició d'índex, el valor s'afegeix a aquesta posició d'índex per formar una llista enllaçada.
En, els conjunts de Python s'implementen mitjançant un diccionari amb variables simulades, on els éssers clau els membres estableixen amb majors optimitzacions a la complexitat del temps.
Implementació del conjunt:
Conjunts amb nombroses operacions en una sola Taula Hash:
Mètodes per a conjunts
Afegir elements als conjunts de Python
La inserció al conjunt es fa a través del set.add( ), on es crea un valor de registre adequat per emmagatzemar-lo a la taula hash. El mateix que comprovar un element, és a dir, O(1) de mitjana. No obstant això, en el pitjor dels casos pot arribar a ser O(n) .
Python 3
# A Python program to> # demonstrate adding elements> # in a set> # Creating a Set> people>=> {>'Jay'>,>'Idrish'>,>'Archi'>}> print>(>'People:'>, end>=> ' '>)> print>(people)> # This will add Daxit> # in the set> people.add(>'Daxit'>)> # Adding elements to the> # set using iterator> for> i>in> range>(>1>,>6>):> >people.add(i)> print>(>'
Set after adding element:'>, end>=> ' '>)> print>(people)> |
>
>
Sortida:
People: {'Idrish', 'Archi', 'Jay'} Set after adding element: {1, 2, 3, 4, 5, 'Idrish', 'Archi', 'Jay', 'Daxit'}> Complexitat temporal: O(n)
Espai auxiliar: O(n)
Operació d'unió en conjunts de Python
Es poden combinar dos conjunts mitjançant la funció union() o | operador. S'accedeix als dos valors de la taula Hash i es recorre amb l'operació de fusió que es realitza per combinar els elements, alhora que s'eliminen els duplicats. La complexitat temporal d'això és O(len(s1) + len(s2)) on s1 i s2 són dos conjunts la unió dels quals cal fer.
Python 3
llista de matrius
# Python Program to> # demonstrate union of> # two sets> people>=> {>'Jay'>,>'Idrish'>,>'Archil'>}> vampires>=> {>'Karan'>,>'Arjun'>}> dracula>=> {>'Deepanshu'>,>'Raju'>}> # Union using union()> # function> population>=> people.union(vampires)> print>(>'Union using union() function'>)> print>(population)> # Union using '|'> # operator> population>=> people|dracula> print>(>'
Union using '|' operator'>)> print>(population)> |
>
>
Sortida:
Union using union() function {'Karan', 'Idrish', 'Jay', 'Arjun', 'Archil'} Union using '|' operator {'Deepanshu', 'Idrish', 'Jay', 'Raju', 'Archil'}> Complexitat temporal: O(n)
Espai auxiliar: O(n)
Operació d'intersecció en conjunts de Python
Això es pot fer mitjançant l'operador intersection() o &. Es seleccionen els elements comuns. Són similars a la iteració sobre les llistes Hash i combinen els mateixos valors a les dues taules. Temps La complexitat d'aquest és O(min(len(s1), len(s2)) on s1 i s2 són dos conjunts la unió dels quals s'ha de fer.
Python 3
# Python program to> # demonstrate intersection> # of two sets> set1>=> set>()> set2>=> set>()> for> i>in> range>(>5>):> >set1.add(i)> for> i>in> range>(>3>,>9>):> >set2.add(i)> # Intersection using> # intersection() function> set3>=> set1.intersection(set2)> print>(>'Intersection using intersection() function'>)> print>(set3)> # Intersection using> # '&' operator> set3>=> set1 & set2> print>(>'
Intersection using '&' operator'>)> print>(set3)> |
>
>
carter
Sortida:
Intersection using intersection() function {3, 4} Intersection using '&' operator {3, 4}> Complexitat temporal: O(n)
Espai auxiliar: O(n)
Trobar diferències de conjunts en Python
Per trobar diferències entre conjunts. Similar a trobar diferències a la llista enllaçada. Això es fa mitjançant l'operador difference() o –. La complexitat temporal de trobar la diferència s1 – s2 és O(len(s1))
Python 3
# Python program to> # demonstrate difference> # of two sets> set1>=> set>()> set2>=> set>()> for> i>in> range>(>5>):> >set1.add(i)> for> i>in> range>(>3>,>9>):> >set2.add(i)> # Difference of two sets> # using difference() function> set3>=> set1.difference(set2)> print>(>' Difference of two sets using difference() function'>)> print>(set3)> # Difference of two sets> # using '-' operator> set3>=> set1>-> set2> print>(>'
Difference of two sets using '-' operator'>)> print>(set3)> |
>
>
Sortida:
Difference of two sets using difference() function {0, 1, 2} Difference of two sets using '-' operator {0, 1, 2}> Complexitat temporal: O(n)
Espai auxiliar: O(n)
Esborrar conjunts de Python
El mètode Set Clear() buida tot el conjunt al seu lloc.
Python 3
# Python program to> # demonstrate clearing> # of set> set1>=> {>1>,>2>,>3>,>4>,>5>,>6>}> print>(>'Initial set'>)> print>(set1)> # This method will remove> # all the elements of the set> set1.clear()> print>(>'
Set after using clear() function'>)> print>(set1)> |
>
>
Sortida:
Initial set {1, 2, 3, 4, 5, 6} Set after using clear() function set()> Complexitat temporal: O(n)
Espai auxiliar: O(n)
Tanmateix, hi ha dos inconvenients principals als conjunts de Python:
- El conjunt no manté elements en cap ordre particular.
- Només es poden afegir instàncies de tipus immutables a un conjunt de Python.
Complexitat temporal dels conjunts
| Funcionament | Cas mitjà | Pitjor dels casos | notes |
|---|---|---|---|
| x en s | O(1) | O(n) | |
| Unió s|t | O(len(s)+len(t)) | ||
| Intersecció s&t | O(min(len(s), len(t))) | O(len(s) * len(t)) | substituïu min per max si t no és un conjunt |
| Intersecció múltiple s1&s2&..&sn | (n-1)*O(l) on l és màxim(len(s1),...,len(sn)) | ||
| Diferència s-t | O(només(s)) |
Operadors per a conjunts
Els conjunts i els conjunts congelats admeten els operadors següents:
| Operadors | Notes |
|---|---|
| clau en s | control de contenció |
| clau no al s | control de no contenció |
| s1 == s2 | s1 és equivalent a s2 |
| s1 != s2 | s1 no és equivalent a s2 |
| s1 <= s2 | s1 és el subconjunt de s2 |
| s1 | s1 és el subconjunt propi de s2 |
| s1>= s2 | s1 és el superconjunt de s2 |
| s1> s2 | s1 és el superconjunt propi de s2 |
| s1 | s2 | la unió de s1 i s2 |
| s1 i s2 | la intersecció de s1 i s2 |
| s1-s2 | el conjunt d'elements en s1 però no en s2 |
| s1 ˆ s2 | el conjunt d'elements en precisament un de s1 o s2 |
Articles recents sobre Python Set.