Conjuntos en Python: Una guía completa con ejemplos de código

En este tutorial, aprenderá los conceptos básicos de los conjuntos de Python y los diversos métodos de conjuntos que puede utilizar para modificar los conjuntos de Python.

Los conjuntos son una de las estructuras de datos incorporadas en Python. Cuando necesite trabajar con una colección no repetitiva de elementos, utilizará el conjunto como la estructura de datos a la que recurrir.

A lo largo de las siguientes secciones, repasaremos los conceptos básicos de los conjuntos en Python y los métodos de conjuntos que puede utilizar para trabajar con ellos. A continuación, aprenderemos a realizar operaciones comunes con conjuntos en Python.

Comencemos

Conceptos básicos de los conjuntos en 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 añadir y eliminar elementos de un conjunto; por lo tanto, el conjunto es una colección mutable. Puede contener elementos de distintos tipos de datos. Sin embargo, los elementos individuales de un conjunto deben ser hashables.

En Python, se dice que un objeto es hashable si su valor hash nunca cambia. La mayoría de los objetos inmutables como las cadenas, tuplas y diccionarios de Python son hashables.

Aprenderemos sobre la creación de conjuntos en detalle. Por ahora, considere los dos conjuntos siguientes

py_set = {0,1,2,(2,3,4),'¡Genial!'}
py_set = {0,1,2,[2,3,4],'¡Uy!'}

# Salida
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> en <module>()
---->
 1 py_set = {0,1,2,[2,3,4],'¡Uy!'}

TypeError: unhashable type: 'list'

El primer conjunto contiene tres números, una tupla y una cadena. La inicialización del conjunto se ejecuta sin error. Mientras que el segundo conjunto contiene una lista en lugar de una tupla. Una lista es una colección mutable, no puede ser hash, y la inicialización lanza un TypeError.

📑 Poniéndolo todo junto, podemos definir un conjunto Python como una colección mutable de elementos distintos y con hash.

Cómo crear un conjunto Python

Comenzaremos aprendiendo cómo crear un conjunto en Python.

#1. Usando Inicialización Explícita

Puede crear un conjunto en Python especificando los elementos del conjunto, separados por comas (,) y encerrados en un par de llaves {}.

py_set1 = {'Python','C','C ','JavaScript'}
type(py_set1)

# Salida
set

Si ha trabajado antes con listas Python, sabrá que [] inicializa una lista vacía. Aunque un conjunto Python está encerrado en un par de llaves {}, no puede utilizar un par {} para inicializar un conjunto. Esto se debe a que {} inicializa un diccionario Python y no un conjunto Python.

py_set2 = {}
type(py_set2)

# Salida
dict

Puede llamar de nuevo a la función type () para verificar que py_set es un diccionario(dict).

#2. Uso de la función set()

Si desea inicializar un conjunto vacío y luego añadirle elementos, puede hacerlo utilizando la función set ().

py_set3 = set()
type(py_set3)

# Salida
set

#3. Transformación de otros iterables en conjuntos

Otra forma de crear conjuntos es convertir otros iterables, como listas y tuplas, en conjuntos, utilizando set(iterable).

py_list = ['Python','C','C ','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C ', 'C', 'JavaScript', 'Python'} # elemento repetido 'C' eliminado
type(py_set4)
# set

En el ejemplo anterior, py_list contiene ‘C’ dos veces. Pero en py_set4, ‘C’ sólo aparece una vez, ya que el conjunto es una colección de elementos distintos. Esta técnica de fundición en el conjunto se utiliza a menudo para eliminar duplicados de las listas de Python.

Cómo añadir elementos a un conjunto Python

Empecemos creando un conjunto vacío py_set y trabajemos con él durante el resto de este tutorial.

py_set = set()
len(py_set) # devuelve la longitud de un conjunto
# Salida
0

#1. Utilización del método .add()

Para añadir elementos a un conjunto, puede utilizar el método . add (). set.add(element) añade un elemento al conjunto.

Para mayor claridad, añadiremos elementos al conjunto de Python e imprimiremos el conjunto en cada paso.

▶️ Añadamos la cadena ‘Python’ como elemento a py_set.

py_set.add('Python')
print(py_set)

# Salida
{'Python'}

A continuación, añadiremos otro elemento

py_set.add('C ')
print(py_set)

# Salida
{'Python', 'C '}

Es importante entender que el método .add( ) sólo añade un elemento al conjunto si no está ya presente. Si el conjunto ya contiene el elemento que desea añadir, la operación add no tiene ningún efecto.

Para comprobarlo, probemos a añadir ‘C ‘ a py_set.

py_set.add('C ')
print(py_set)

# Salida
{'Python', 'C '}

El conjunto contiene ‘C ‘, por lo que la operación de adición no tiene ningún efecto.

▶️ Añadamos 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)

# Salida
{'Python', 'C ', 'C'}
{'JavaScript', 'Python', 'C ', 'C'}
{'Rust', 'JavaScript', 'Python', 'C ', 'C'}

#2. Utilizando el método .update()

Hasta ahora, hemos visto cómo añadir elementos al conjunto existente – un elemento a la vez.

¿Qué ocurre si desea añadir más de un elemento a una secuencia de elementos?

Puede hacerlo utilizando el método .update() con la sintaxis: set.update(collection) para añadir elementos de la colección a un conjunto. La colección puede ser una lista, tupla, diccionario, etc.

py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)

# Salida
{'C', 'C ', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}

Este método es útil cuando se desea añadir una colección de elementos a un conjunto sin crear otro objeto en memoria.

En la siguiente sección, vamos a aprender cómo eliminar elementos de un conjunto.

Eliminar elementos de un conjunto Python

Consideremos el siguiente conjunto(py_set antes de la operación de actualización).

py_set = {'C ', 'JavaScript', 'Python', 'Rust', 'C'}

#1. Utilización del método .pop()

set.pop () elimina un elemento aleatoriamente del conjunto y lo devuelve. Llamemos al método pop sobre py_set y veamos lo que devuelve.

py_set.pop()

# Salida
'Rust'

Esta vez, la llamada al método . pop () devuelve la cadena ‘Rust’.

Nota: Dado que el método . pop () devuelve un elemento al azar, cuando ejecute el código en su extremo, es posible que obtenga otro elemento.

Cuando examinamos el conjunto, ‘Rust’ ya no está presente en el conjunto.

print(py_set)

# Salida
{'JavaScript', 'Python', 'C ', 'C'}

#2. Utilización de los métodos .remove() y discard()

En la práctica, es posible que desee eliminar elementos específicos del conjunto. Para ello, puede utilizar los métodos .remove( ) y . discard().

set.remove(elemento ) elimina elementos del conjunto.

py_set.eliminar('C')
print(py_set)

# Salida
{'JavaScript', 'Python', 'C '}

Si intentamos eliminar un elemento que no está presente en el conjunto, nos encontraremos con un KeyError.

py_set.remove('Scala')

# Salida
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> en <module>()
---->
 1 py_set.remove('Scala')

KeyError: 'Scala'

Echemos un vistazo a py_set de nuevo. Ahora tenemos tres elementos.

print(py_set)

# Salida
{'JavaScript', 'Python', 'C '}

Con la sintaxis set.discard(elemento), el método .discard( ) también elimina elementos del conjunto.

py_set.descart('C ')
print(py_set)

# Salida
{'JavaScript', 'Python'}

Sin embargo, difiere del método .remove() en que no lanza un KeyError cuando intentamos eliminar un elemento que no está presente.

Si intentamos eliminar ‘Scala’ (que no existe) de la lista utilizando el método .discard ( ), no veremos ningún error.

py_set.discard('Scala') #¡no hay error!
print(py_set)

#Salida
{'JavaScript', 'Python'}

Acceder a los elementos de un conjunto Python

Hasta ahora, hemos aprendido cómo añadir y eliminar elementos de conjuntos Python. Sin embargo, aún no hemos visto cómo acceder a elementos individuales de 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<x>[0]</x>)

# Salida
---------------------------------------------------------------------------
TypeError Traceback (última llamada más reciente)
<ipython-entrada-27-0329274f4580> en <modulo>()
---->
 1 print(py_set<x>[0]</x>)

TypeError: El objeto 'set' no es subscriptible

Entonces, ¿cómo se accede a los elementos de un conjunto?

Hay dos formas comunes de hacerlo

Recorrer el conjunto en bucle y acceder a cada elemento
Comprobar si un elemento concreto es miembro del conjunto

▶️ Recorra el conjunto y acceda a los elementos mediante un bucle for.

for elt in py_set:
  print(elt)

# Salida
C 
JavaScript
Python
Rust
C

En la práctica, puede que desee comprobar si un elemento dado está presente en el conjunto utilizando el operador in.

Nota: elemento en conjunto devuelve Verdadero si el elemento está presente en el conjunto; en caso contrario devuelve Falso.

En este ejemplo, py_set contiene ‘C ‘ y no contiene’ Julia’ y el operador in devuelve Verdadero y Falso, respectivamente.

'C ' en py_set
# Verdadero
'Julia' en py_set
# Falso

Encontrar la longitud de un conjunto Python

Como se ha visto anteriormente, puede utilizar la función len() para obtener el número de elementos presentes en un conjunto.

py_set = {'C ', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)

# Salida: 5

Cómo borrar un conjunto Python

Para borrar un conjunto eliminando todos los elementos, puede utilizar el método . clear ().

Llamemos al método . clear () sobre py_set.

py_set.clear()

Si intenta imprimirlo, obtendrá set() – indicando que el conjunto está vacío. También puede llamar a la función len () para verificar que la longitud del conjunto es cero.

print(py_set)
# set()
print(len(py_set))
# 0

Hasta ahora, hemos aprendido a realizar operaciones CRUD básicas sobre conjuntos de Python:

Crear: Uso de la función set (), fundición de tipos e inicialización
Leer: Acceder a elementos del conjunto utilizando bucles y el operador in para la comprobación de la pertenencia
Actualizar: Añadir, eliminar elementos de conjuntos, y actualizar conjuntos
Borrar: Borrar un conjunto eliminando todos los elementos del mismo

Operaciones comunes con conjuntos, explicadas con código de Python

Los conjuntos de Python también nos permiten realizar las operaciones básicas de conjuntos. Aprenderemos sobre ellas en esta sección.

#1. Unión de conjuntos

En teoría de conjuntos, la unión de dos conjuntos es el conjunto de todos los elementos de al menos uno de los dos conjuntos. Si hay dos conjuntos, A y B, entonces la unión contiene los elementos que están presentes sólo en A, sólo en B, y los elementos presentes tanto en A como en B.

Para hallar la unión de conjuntos, puede utilizar el operador | o el método .union() con la sintaxis: conjuntoA.union(conjuntoB).

conjuntoA = {1,3,5,7,9}
conjuntoB = {2,4,6,8,9}

print(conjuntoA | conjuntoB)
# Salida
{1, 2, 3, 4, 5, 6, 7, 8, 9}

conjuntoA.unión(conjuntoB)

# Salida
{1, 2, 3, 4, 5, 6, 7, 8, 9}

La unión de conjuntos es una operación conmutativa, por lo que A U B es lo mismo que B U A. Verifiquemos esto intercambiando las posiciones de conjuntoA y conjuntoB en la llamada al método .union().

conjuntoB.union(conjuntoA)

# Salida
{1, 2, 3, 4, 5, 6, 7, 8, 9}

#2. Intersección de conjuntos

Otra operación conjunta de conjuntos es la 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 utilizar el operador & o el método .intersection(), como se explica en el fragmento de código siguiente.

print(conjuntoA & conjuntoB)

# Salida
{9}

conjuntoA.intersección(conjuntoB)

# Salida
{9}

En este ejemplo, el elemento 9 está presente tanto en el conjuntoA como en el conjuntoB, por lo que el conjunto intersección sólo contiene este elemento.

Al igual que la unión de conjuntos, la intersección de conjuntos también es una operación conmutativa.

conjuntoB.intersección(conjuntoA)

# Salida
{9}

#3. Diferencia de conjuntos

Dados dos conjuntos cualesquiera, la unión y la intersección nos ayudan a encontrar los elementos presentes en ambos conjuntos y al menos en uno de ellos, respectivamente. En cambio, la diferencia de conjuntos nos ayuda a encontrar los elementos presentes en un conjunto pero no en el otro.

– conjuntoA.diferencia(conjuntoB ) da el conjunto de elementos que están presentes sólo en el conjuntoA y no en el conjuntoB.

– conjuntoB.diferencia(conjuntoA) da el conjunto de elementos que están presentes sólo en el conjuntoB y no en el conjuntoA.

print(conjuntoA - conjuntoB)

print(conjuntoB - conjuntoA)

# Salida
{1, 3, 5, 7}
{8, 2, 4, 6}

Evidentemente, A\B no es lo mismo que B\A, por lo que la diferencia de conjuntos no es una operación conmutativa.

conjuntoA.diferencia(conjuntoB)
# {1, 3, 5, 7}

conjuntoB.diferencia(conjuntoA)
# {2, 4, 6, 8}

#4. Diferencia simétrica de conjuntos

Mientras que la intersección de conj untos nos da los elementos presentes en ambos conjuntos, la diferencia simétrica de conjuntos nos devuelve el conjunto de elementos presentes exactamente en uno de los conjuntos.

Considere el siguiente ejemplo.

conjuntoA = {1,3,5,7,10,12}
conjuntoB = {2,4,6,8,10,12}

Para calcular el conjunto de diferencias simétricas, puede utilizar el operador ^ o el método .symmetric_difference().

print(conjuntoA ^ conjuntoB)

# Salida
{1, 2, 3, 4, 5, 6, 7, 8}

Los elementos 10 y 12 están presentes tanto en el conjuntoA como en el conjuntoB. Por tanto, no están presentes en el conjunto de diferencias simétricas.

conjuntoA.diferencia_simétrica(conjuntoB)

# Salida
{1, 2, 3, 4, 5, 6, 7, 8}

Como la operación de diferencia simétrica de conjuntos recoge todos los elementos que aparecen exactamente en uno de los dos conjuntos, el conjunto resultante es el mismo independientemente del orden en que se recojan los elementos. Por lo tanto, una diferencia simétrica de conjuntos es una operación conmutativa.

conjuntoB.diferencia_simétrica(conjuntoA)

# Salida
{1, 2, 3, 4, 5, 6, 7, 8}

#5. Subconjuntos y superconjuntos

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.

Consideremos el ejemplo de dos conjuntos: lenguajes y lenguajes_extendidos.

idiomas = {'Python', 'JavaScript','C','C '}
languages_extended = {'Python', 'JavaScript','C','C ','Rust','Go','Scala'}

En Python, puede utilizar el método .issubset() para comprobar si un conjunto dado es un subconjunto de otro conjunto.

conjuntoA.issubset(conjuntoB) devuelve True si conjuntoA es un subconjunto de conjuntoB; en caso contrario, devuelve False.

En este ejemplo, lenguas es un subconjunto de lenguas_extendidas.

lenguas.issubset(lenguas_extendidas)
# Salida
Verdadero

De forma similar, puede utilizar el método .issuperset() para comprobar si un conjunto dado es un superconjunto de otro conjunto.

conjuntoA.issuperset(conjuntoB) devuelve True si conjuntoA es un superconjunto de conjuntoB; en caso contrario, devuelve False.

idiomas_extendidos.issuperset(idiomas)
# Devuelve
Verdadero

Como lenguas_extendidas es un superconjunto de lenguas, lenguas_extendidas.issuperset(lenguas) devuelve True, como se ha visto anteriormente.

Conclusión

Espero que este tutorial le haya ayudado a entender el funcionamiento de los conjuntos de Python, los métodos de conjuntos para operaciones CRUD y las operaciones comunes de conjuntos. Como siguiente paso, puede intentar utilizarlos en sus proyectos Python.

Puede consultar otras guías de Python en profundidad. ¡Feliz aprendizaje!

Bala Priya C
Colaborador
Bala Priya es una desarrolladora y redactora técnica india con más de tres años de experiencia en la redacción de contenidos técnicos. Comparte sus conocimientos con la comunidad de desarrolladores escribiendo tutoriales técnicos, guías prácticas y mucho más. Actualmente trabaja como editora técnica en Geekflare. También colabora activamente en otras publicaciones técnicas como freeCodeCamp y KDnuggets.