Un conjunto en la programación de Python es un tipo de datos de colección desordenado que es iterable, mutable y no tiene elementos duplicados.
El conjunto está representado por { } (los valores entre llaves)
La principal ventaja de utilizar un conjunto, a diferencia de un lista , es que tiene un método altamente optimizado para verificar si un elemento específico está contenido en el conjunto. Esto se basa en una estructura de datos conocida como tabla hash. Dado que los conjuntos están desordenados, no podemos acceder a los elementos utilizando índices como lo hacemos en las listas.
Ejemplo de conjuntos de Python
Python3
var>=> {>'Geeks'>,>'for'>,>'Geeks'>}> type>(var)> |
>
>
Producción:
set>
Complejidad del tiempo: O(1)
Espacio auxiliar: O(1)
Type Casting con el método Python Set
El método set() de Python se utiliza para la conversión de tipos.
Python3
# typecasting list to set> myset>=> set>([>'a'>,>'b'>,>'c'>])> print>(myset)> # Adding element to the set> myset.add(>'d'>)> print>(myset)> |
>
>
ipconfig en Ubuntu
Producción:
El conjunto de Python es un tipo de datos desordenado, lo que significa que no podemos saber en qué orden se almacenan los elementos del conjunto.
{'c', 'b', 'a'} {'d', 'c', 'b', 'a'}> Complejidad del tiempo: O(n)
Espacio auxiliar: O(n)
Verifique único e inmutable con Python Set
Los conjuntos de Python no pueden tener un valor duplicado y una vez creados no podemos cambiar su valor.
Python3
# 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)> |
>
>
Producción:
El primer código explica que el conjunto no puede tener un valor duplicado. Cada elemento que contiene tiene un valor único.
El segundo código genera un error porque no podemos asignar o cambiar un valor una vez creado el conjunto. Sólo podemos agregar o eliminar elementos del conjunto.
{'Geeks', 'for'} TypeError: 'set' object does not support item assignment> Elemento heterogéneo con conjunto Python
Los conjuntos de Python pueden almacenar elementos heterogéneos en él, es decir, un conjunto puede almacenar una combinación de tipos de datos de cadena, entero, booleano, etc.
Python3
# Python example demonstrate that a set> # can store heterogeneous elements> myset>=> {>'Geeks'>,>'for'>,>10>,>52.7>,>True>}> print>(myset)> |
>
>
Producción:
{True, 10, 'Geeks', 52.7, 'for'}> Complejidad del tiempo: O(n)
Espacio auxiliar: O(n)
Conjuntos congelados de Python
Conjuntos congelados En Python hay objetos inmutables que solo admiten métodos y operadores que producen un resultado sin afectar el conjunto o conjuntos congelados a los que se aplican. Se puede hacer con el método frozenset() en Python.
Si bien los elementos de un conjunto se pueden modificar en cualquier momento, los elementos del conjunto congelado permanecen iguales después de la creación.
Si no se pasan parámetros, devuelve un frozenset vacío.
Pitón
# 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')> |
industria y fábrica
>
>
Producción:
Normal Set {'a', 'c', 'b'} Frozen Set {'e', 'g', 'f'}> Complejidad del tiempo: O(n)
Espacio auxiliar: O(n)
Funcionamiento interno de Set
Esto se basa en una estructura de datos conocida como tabla hash. Si hay varios valores presentes en la misma posición de índice, entonces el valor se agrega a esa posición de índice para formar una lista vinculada.
En, los conjuntos de Python se implementan utilizando un diccionario con variables ficticias, donde las claves son los miembros establecidos con mayores optimizaciones para la complejidad del tiempo.
Establecer implementación:
Conjuntos con numerosas operaciones en una sola HashTable:
Métodos para conjuntos
Agregar elementos a conjuntos de Python
La inserción en el conjunto se realiza a través del conjunto.add( ), donde se crea un valor de registro apropiado para almacenar en la tabla hash. Lo mismo que verificar un artículo, es decir, O(1) en promedio. Sin embargo, en el peor de los casos puede llegar a ser En) .
Python3
# 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)> |
>
>
Producción:
People: {'Idrish', 'Archi', 'Jay'} Set after adding element: {1, 2, 3, 4, 5, 'Idrish', 'Archi', 'Jay', 'Daxit'}> Complejidad del tiempo: O(n)
Espacio auxiliar: O(n)
centos vs sombrero rojo
Operación de unión en conjuntos de Python
Se pueden fusionar dos conjuntos usando la función union() o | operador. Se accede a ambos valores de la tabla Hash y se los recorre con la operación de fusión que se realiza en ellos para combinar los elementos, al mismo tiempo que se eliminan los duplicados. La complejidad temporal de esto es O(len(s1) + len(s2)) donde s1 y s2 son dos conjuntos cuya unión es necesario realizar.
Python3
# 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)> |
>
>
Producción:
Union using union() function {'Karan', 'Idrish', 'Jay', 'Arjun', 'Archil'} Union using '|' operator {'Deepanshu', 'Idrish', 'Jay', 'Raju', 'Archil'}> Complejidad del tiempo: O(n)
Espacio auxiliar: O(n)
Operación de intersección en conjuntos de Python
Esto se puede hacer mediante el operador intersección() o &. Se seleccionan los elementos comunes. Son similares a la iteración sobre las listas Hash y combinan los mismos valores en ambas tablas. La complejidad temporal de esto es O(min(len(s1), len(s2)) donde s1 y s2 son dos conjuntos cuya unión debe realizarse.
Python3
# 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)> |
saltar lista
>
>
Producción:
Intersection using intersection() function {3, 4} Intersection using '&' operator {3, 4}> Complejidad del tiempo: O(n)
Espacio auxiliar: O(n)
Encontrar diferencias de conjuntos en Python
Encontrar diferencias entre conjuntos. Similar a encontrar diferencias en la lista vinculada. Esto se hace mediante diferencia() o – operador. La complejidad temporal de encontrar la diferencia s1 – s2 es O(len(s1))
Python3
# 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)> |
>
>
Producción:
Difference of two sets using difference() function {0, 1, 2} Difference of two sets using '-' operator {0, 1, 2}> Complejidad del tiempo: O(n)
Espacio auxiliar: O(n)
Borrar conjuntos de Python
El método Set Clear() vacía todo el conjunto en su lugar.
Python3
# 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)> |
>
>
Producción:
Initial set {1, 2, 3, 4, 5, 6} Set after using clear() function set()> Complejidad del tiempo: O(n)
Espacio auxiliar: O(n)
Sin embargo, existen dos problemas importantes en los conjuntos de Python:
- El conjunto no mantiene elementos en ningún orden particular.
- Solo se pueden agregar instancias de tipos inmutables a un conjunto de Python.
Complejidad temporal de los conjuntos
| Operación | Caso promedio | Peor de los casos | notas |
|---|---|---|---|
| x en s | O(1) | En) | |
| Unión m|t | O(len(s)+len(t)) | ||
| Intersección científica y tecnológica | O(min(len(s), len(t)) | O(len(s) * len(t)) | reemplace min con max si t no es un conjunto |
| Intersección múltiple s1&s2&..&sn | (n-1)*O(l) donde l es max(len(s1),..,len(sn)) | ||
| diferencia s-t | O(sólo(s)) |
Operadores para conjuntos
Los conjuntos y conjuntos congelados admiten los siguientes operadores:
| Operadores | Notas |
|---|---|
| clave en s | control de contención |
| clave no en s | control de no contención |
| s1 == s2 | s1 es equivalente a s2 |
| s1 != s2 | s1 no es equivalente a s2 |
| s1 <= s2 | s1 es un subconjunto de s2 |
| s1 | s1 es el subconjunto propio de s2 |
| s1>= s2 | s1 es un superconjunto de s2 |
| s1> s2 | s1 es el superconjunto propio de s2 |
| s1 | s2 | la unión de s1 y s2 |
| s1 y s2 | la intersección de s1 y s2 |
| s1 – s2 | el conjunto de elementos en s1 pero no en s2 |
| s1 ˆ s2 | el conjunto de elementos en precisamente uno de s1 o s2 |
Artículos recientes sobre Python Set.