En este tutorial, aprenderá los conceptos básicos de los conjuntos de Python y los diversos métodos de conjunto que puede usar para modificar los conjuntos de Python.
Los conjuntos son una de las estructuras de datos integradas en Python. Cuando necesite trabajar con una colección de elementos que no se repiten, utilizará el conjunto como la estructura de datos de acceso.
En las siguientes secciones, repasaremos los conceptos básicos de los conjuntos de python y los métodos de conjunto que puede usar para trabajar con ellos. Luego aprenderemos cómo realizar operaciones de conjuntos comunes en Python.
¡Vamos a empezar!
Tabla de contenido
Conceptos básicos de los conjuntos de Python
En Python, un conjunto es una colección desordenada de elementos que no se repiten. Esto significa que los elementos de un conjunto deben ser todos distintos.
Puede agregar y eliminar elementos de un conjunto; por lo tanto, el conjunto es una colección mutable. Puede contener elementos de diferentes tipos de datos. Sin embargo, los elementos individuales de un conjunto deben ser hashable.
En Python, se dice que un objeto es hashable si su valor hash nunca cambia. La mayoría de los objetos inmutables, como cadenas de Python, tuplas y diccionarios, se pueden modificar.
Aprenderemos a crear conjuntos en detalle. Por ahora, considere los siguientes dos conjuntos:
py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}
TypeError: unhashable type: 'list'
El primer conjunto contiene tres números, una tupla y una cadena. La inicialización del conjunto se ejecuta sin errores. Mientras que el segundo conjunto contiene una lista en lugar de una tupla. Una lista es una colección mutable, no se puede codificar y la inicialización arroja un TypeError.
📑 Poniéndolo todo junto, podemos definir un conjunto de Python como una colección mutable de elementos distintos y modificables.
Cómo crear un conjunto de Python
Comenzaremos aprendiendo cómo crear un conjunto en Python.
#1. Uso de inicialización explícita
Puede crear un conjunto en Python especificando los elementos del conjunto, separados por comas (,) y encerrados entre un par de llaves {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
set
Si ha trabajado con listas de Python antes, sabe que [] inicializa una lista vacía. Aunque un conjunto de Python está encerrado entre un par de llaves {}, no puede usar un par {} para inicializar un conjunto. Esto se debe a que {} inicializa un diccionario de Python y no un conjunto de Python.
py_set2 = {}
type(py_set2)
# Output
dict
Puede volver a llamar a la función type() para verificar que py_set es un diccionario (dict).
#2. Usando la función set()
Si desea inicializar un conjunto vacío y luego agregarle elementos, puede hacerlo usando la función set().
py_set3 = set() type(py_set3) # Output set
#3. Conversión de otros iterables en un conjunto
Otra forma de crear conjuntos es convertir otros iterables, como listas y tuplas, en conjuntos, usando set(iterable).
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # repeating element 'C' removed
type(py_set4)
# set
En el ejemplo anterior, py_list contiene ‘C’ dos veces. Pero en py_set4, ‘C’ aparece solo una vez, ya que el conjunto es una colección de elementos distintos. Esta técnica de conversión en el conjunto se usa a menudo para eliminar duplicados de las listas de Python.
Cómo agregar elementos a un conjunto de Python
Comencemos creando un conjunto py_set vacío y trabajemos con él durante el resto de este tutorial.
py_set = set() len(py_set) # returns the length of a set # Output 0
#1. Usando el método .add()
Para agregar elementos a un conjunto, puede usar el método .add(). set.add(element) agrega un elemento al conjunto.
Para mayor claridad, agregaremos elementos al conjunto de Python e imprimiremos el conjunto en cada paso.
▶️ Agreguemos la cadena ‘Python’ como elemento a py_set.
py_set.add('Python')
print(py_set)
# Output
{'Python'}
A continuación, añadiremos otro elemento.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Es importante comprender que el método .add() solo agrega un elemento al conjunto si aún no está presente. Si el conjunto ya contiene el elemento que desea agregar, la operación de agregar no tiene efecto.
Para verificar esto, intentemos agregar ‘C++’ a py_set.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
El conjunto contiene ‘C++’, por lo que la operación de agregar no tiene efecto.
▶️ Agreguemos algunos elementos más al conjunto.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Output
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Usando el método .update()
Hasta ahora, hemos visto cómo agregar elementos al conjunto existente, un elemento a la vez.
¿Qué sucede si desea agregar más de un elemento a una secuencia de elementos?
Puede hacerlo utilizando el método .update() con la sintaxis: set.update(colección) para agregar elementos de la colección a un conjunto. La colección puede ser una lista, una tupla, un diccionario, etc.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Este método es útil cuando desea agregar una colección de elementos a un conjunto sin crear otro objeto en la memoria.
En la siguiente sección, aprenderemos a eliminar elementos de un conjunto.
Cómo quitar elementos de un conjunto de Python
Consideremos el siguiente conjunto (py_set antes de la operación de actualización).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Usando el método .pop()
set.pop() elimina un elemento aleatoriamente del conjunto y lo devuelve. Llamemos al método pop en py_set y veamos qué devuelve.
py_set.pop() # Output 'Rust'
Esta vez, la llamada al método .pop() devolvió la cadena ‘Rust’.
Nota: Debido a que el método .pop() devuelve un elemento al azar, cuando ejecuta el código en su extremo, también puede obtener otro elemento.
Cuando examinamos el conjunto, ‘Rust’ ya no está presente en el conjunto.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}
#2. Uso de los métodos .remove() y descarte()
En la práctica, es posible que desee eliminar elementos específicos del conjunto. Para hacer esto, puede usar los métodos .remove() y .discard().
set.remove(elemento) elimina elementos del conjunto.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Si intentamos eliminar un elemento que no está presente en el conjunto, nos encontraremos con un KeyError.
py_set.remove('Scala')
# Output
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'
Echemos un vistazo a py_set de nuevo. Ahora tenemos tres elementos.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Con la sintaxis set.discard(element), el método .discard() también elimina elementos del conjunto.
py_set.discard('C++')
print(py_set)
# Output
{'JavaScript', 'Python'}
Sin embargo, se diferencia del método .remove() en que no genera un KeyError cuando intentamos eliminar un elemento que no está presente.
Si intentamos eliminar ‘Scala’ (que no existe) de la lista usando el método .discard(), no vemos ningún error.
py_set.discard('Scala') #no error!
print(py_set)
# Output
{'JavaScript', 'Python'}
Cómo acceder a los elementos de un conjunto de Python
Hasta ahora, hemos aprendido cómo agregar y quitar elementos de los conjuntos de Python. Sin embargo, aún no hemos visto cómo acceder a elementos individuales en un conjunto.
Como un conjunto es una colección desordenada, no es indexable. Por lo tanto, si intenta acceder a los elementos de un conjunto utilizando el índice, se encontrará con un error, como se muestra.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])
TypeError: 'set' object is not subscriptable
Entonces, ¿cómo se accede a los elementos de un conjunto?
Hay dos formas comunes de hacer esto:
- Recorra el conjunto y acceda a cada elemento
- Comprobar si un elemento en particular es miembro del conjunto
▶️ Recorra el conjunto y acceda a los elementos mediante un bucle for.
for elt in py_set: print(elt) # Output C++ JavaScript Python Rust C
En la práctica, es posible que desee verificar si un elemento determinado está presente en el conjunto mediante el operador in.
Nota: el elemento en el conjunto devuelve True si el elemento está presente en el conjunto; de lo contrario, devuelve False.
En este ejemplo, py_set contiene ‘C++’ y no contiene ‘Julia’ y el operador in devuelve True y False, respectivamente.
'C++' in py_set # True 'Julia' in py_set # False
Cómo encontrar la longitud de un conjunto de Python
Como se vio anteriormente, puede usar la función len() para obtener la cantidad de elementos presentes en un conjunto.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5
Cómo borrar un conjunto de Python
Para borrar un conjunto eliminando todos los elementos, puede usar el método .clear().
Llamemos al método .clear() en py_set.
py_set.clear()
Si intenta imprimirlo, obtendrá set(), lo que indica que el conjunto está vacío. También puede llamar a la función len() para verificar que la longitud del conjunto sea cero.
print(py_set) # set() print(len(py_set)) # 0
Hasta ahora, hemos aprendido cómo realizar operaciones CRUD básicas en conjuntos de Python:
- Crear: uso de la función set (), conversión de tipo e inicialización
- Leer: acceder a los elementos del conjunto mediante bucles y en el operador para la prueba de membresía
- Actualizar: agregue, elimine elementos de conjuntos y actualice conjuntos
- Eliminar: borre un conjunto eliminando todos los elementos de él
Operaciones de conjuntos comunes, explicadas con el código de Python
Los conjuntos de Python también nos permiten realizar las operaciones básicas de conjuntos. Aprenderemos sobre ellos en esta sección.
#1. Unión de conjuntos en Python
En teoría de conjuntos, la unión de dos conjuntos es el conjunto de todos los elementos en al menos uno de los dos conjuntos. Si hay dos conjuntos, A y B, entonces la unión contiene elementos que están presentes solo en A, solo en B, y los elementos presentes tanto en A como en B.
Para encontrar la unión de conjuntos, puedes usar el | operador o el método .union() con la sintaxis: setA.union(setB).
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
La unión de conjuntos es una operación conmutativa; entonces AUB es lo mismo que BU A. Verifiquemos esto intercambiando las posiciones de setA y setB en la llamada al método .union().
setB.union(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Intersección de Conjuntos en Python
Otra operación conjunta de conjuntos es esta intersección de dos conjuntos, A y B. La operación de intersección de conjuntos devuelve un conjunto que contiene todos los elementos presentes tanto en A como en B.
Para calcular la intersección, puede usar el operador & o el método .intersection(), como se explica en el fragmento de código a continuación.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}
En este ejemplo, el elemento 9 está presente tanto en setA como en setB; por lo que el conjunto de intersección contiene solo este elemento.
Al igual que la unión de conjuntos, la intersección de conjuntos también es una operación conmutativa.
setB.intersection(setA)
# Output
{9}
#3. Establecer diferencia en Python
Dados dos conjuntos, la unión y la intersección nos ayudan a encontrar los elementos presentes en ambos y al menos en uno de los conjuntos, respectivamente. Por otro lado, la diferencia de conjuntos nos ayuda a encontrar los elementos presentes en un conjunto pero no en el otro.
– setA.difference(setB) da el conjunto de elementos que están presentes solo en setA y no en setB.
– setB.difference(setA) da el conjunto de elementos que están presentes solo en setB y no en setA.
print(setA - setB)
print(setB - setA)
# Output
{1, 3, 5, 7}
{8, 2, 4, 6}
Claramente, AB no es lo mismo que BA, por lo que la diferencia de conjuntos no es una operación conmutativa.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Diferencia de conjuntos simétricos en Python
Mientras que la intersección de conjuntos nos da elementos presentes en ambos conjuntos, la diferencia simétrica de conjuntos devuelve el conjunto de elementos presentes en exactamente uno de los conjuntos.
Considere el siguiente ejemplo.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
Para calcular el conjunto de diferencias simétricas, puede usar el operador ^ o el método .symmetric_difference().
print(setA ^ setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Los elementos 10 y 12 están presentes tanto en el conjunto A como en el conjunto B. Por lo tanto, no están presentes en el conjunto de diferencias simétricas.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Como la operación de diferencia de conjuntos simétrica recopila todos los elementos que aparecen exactamente en uno de los dos conjuntos, el conjunto resultante es el mismo independientemente del orden en que se recopilan los elementos. Por lo tanto, una diferencia de conjunto simétrica es una operación conmutativa.
setB.symmetric_difference(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Subconjuntos y superconjuntos en Python
En la teoría de conjuntos, los subconjuntos y superconjuntos ayudan a comprender la relación entre dos conjuntos.
Dados dos conjuntos A y B, el conjunto B es un subconjunto del conjunto A si todos los elementos del conjunto B también están presentes en el conjunto A. Y el conjunto A es el superconjunto del conjunto B.
Considere el ejemplo de dos conjuntos: languages y languages_extended.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
En Python, puede usar el método .issubset() para verificar si un conjunto dado es un subconjunto de otro conjunto.
setA.issubset(setB) devuelve True si setA es un subconjunto de setB; de lo contrario, devuelve False.
En este ejemplo, languages es un subconjunto de languages_extended.
languages.issubset(languages_extended) # Output True
De manera similar, puede usar el método .issuperset() para verificar si un conjunto dado es un superconjunto de otro conjunto.
setA.issuperset(setB) devuelve True si setA es un superconjunto de setB; de lo contrario, devuelve False.
languages_extended.issuperset(languages) # Output True
Como languages_extended es un superconjunto de idiomas, languages_extended.issuperset(languages) devuelve True, como se ve arriba.
Conclusión
Espero que este tutorial lo haya ayudado a comprender el funcionamiento de los conjuntos de Python, los métodos establecidos para las operaciones CRUD y las operaciones comunes de conjuntos. Como siguiente paso, puede intentar usarlos en sus proyectos de Python.
Puede consultar otras guías detalladas de Python. ¡Feliz aprendizaje!