Conjuntos en Python – set

Conjuntos en Python

Los conjuntos son uno de los tipos básicos que provee Python y bastante utilizados. Representan un objeto capaz de almacenar elementos únicos, que además están indexados, por lo que son de gran utilidad para buscar elementos.

¿Qué es un conjunto en Python?

Los conjuntos son utilizados en álgebra de conjuntos para hacer operaciones sobre grupos de valores, además de ser utilizados en muchos ámbitos del cálculo.

En Python los conjuntos pueden almacenar valores numéricos o de cualquier tipo, siempre y cuando los valores sean «hasheables». Los conjuntos son tipos mutables, se garantiza que todos sus elementos son únicos, pero no se garantiza que estén ordenados.

Por lo tanto, algunos ejemplos de tipos hasheables son: los enteros, las cadenas de caracteres, o las tuplas. Sin embargo, las listas no son hasheables, por tanto un conjunto no puede contener listas, pero sí cadenas de caracteres o números.

Ejemplo de conjuntos

Se utilizará el siguiente ejemplo para mostrar operaciones con conjuntos. Hay un grupo de personas (estudiantes) que están en tres grupos A, B y C. Algunos estudiantes están en varios grupos.

  • Primer grupo – Grupo A: Ana, Marcos, Carlos, Mario.
  • Segundo grupo – Grupo B: Ana, Pedro, Carlos, Antonio.
  • Tercer Grupo – Grupo C: Ana, Antonio, Marcos, Pepe.

La representación gráfica de estos conjuntos sería:

Representación de conjuntos sobre los alumnos de cada grupo

Crear conjuntos en Python

La forma de crear un conjunto es usando el constructor de listas set o como literal usando {<argumentos>}. A continuación se pueden ver ejemplos.

>>> group_a = set(['Ana', 'Marcos', 'Carlos', 'Mario'])
>>> group_b = {'Ana', 'Pedro', 'Carlos', 'Antonio'}
>>> group_c = {'Ana', 'Antonio', 'Marcos', 'Pepe'}
>>> all_students = group_a.union(group_b).union(group_c)
>>> all_students
{'Marcos', 'Carlos', 'Mario', 'Pepe', 'Antonio', 'Pedro', 'Ana'}
>>> a_and_b = group_a.intersection(group_b)
>>> a_and_b
{'Ana', 'Carlos'}
>>> a_and_c = group_a.intersection(group_c)
>>> a_and_c
{'Ana', 'Marcos'}
>>> b_and_c = group_b.intersection(group_c)
>>> b_and_c
{'Ana', 'Antonio'}
>>> common_all = group_a.intersection(group_b).intersection(group_c)
>>> common_all
{'Ana'}

Se pueden realizar operaciones interesantes como saber el grupo al que pertenece cada estudiante de forma simple.

>>> group_a = {'Ana', 'Marcos', 'Carlos', 'Mario'}
>>> group_b = {'Ana', 'Pedro', 'Carlos', 'Antonio'}
>>> group_c = {'Ana', 'Antonio', 'Marcos', 'Pepe'}
>>> all_students = group_a.union(group_b).union(group_c)
>>> for student in all_students:
...     groups_in = []
...     for letter, group in zip('ABC', [group_a, group_b, group_c]):
...         if student in group:
...             groups_in.append(letter)
...     groups_str = '-'.join(groups_in)
...     plural = 's' if len(groups_in) > 1 else ''
...     print(f'{student} en grupo{plural}: {groups_str}')
... 
Ana en grupos: A-B-C
Antonio en grupos: B-C
Pedro en grupo: B
Pepe en grupo: C
Carlos en grupos: A-B
Marcos en grupos: A-C
Mario en grupo: A

Métodos disponibles sobre set

A continuación se muestran los métodos disponibles para conjuntos:

>>> dir(set)
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__',
'__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__',
'__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__',
'__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__',
'__sub__', '__subclasshook__', '__xor__',
'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection',
'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove',
'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
MétodoDescripciónEjemplo
addAñade un elemento al final del conjuntoset.append(5)
clearElimina toda la información del conjuntoset.clear()
copyDevuelve una copia del conjuntoset.copy()
differenceDevuelve las diferencias entre un conjunto sobre otroset.difference(st2)
difference_updateAplica las diferencias al primer conjuntoset.difference_update(st2)
discardIntenta eliminar un elemento del conjunto, exista o noset.discard('e')
intersectionDevuelve un conjunto con los elementos que están en otros dosset.intersection(st2)
intersection_updateSimila a intersection pero actualizando el primer conjunto con el resultadoset.intersection_update(st2)
isdisjointDevuelve True si la intersección de los conjuntos vacíaset.isdisjoint(st2)
issubsetDevuelve True si el otro conjunto contiene el primeroset.issubset(st2)
issupersetDevuelve True si el primer conjunto contiene el segundoset.issuperset(st2)
popDevuelve y elimina un elemento arbitrario o devuelve un error si está vacíoset.pop()
removeIntenta eliminar un elemento del conjunto, si no existe eleva un errorset.remove(2)
symmetric_differenceDevuelve los elementos que están exactamente en uno de los setsset.symmetric_difference(st2)
symmetric_difference_updateSimilar a symmetric_difference pero actualizando el primer conjuntoset.symmetric_difference_update(st2)
unionDevuelve un conjunto con todos los elementos de ambos conjuntosset.union(st2)
updateActualiza el primer conjunto con otroset.update(st2)

Operaciones de álgebra de conjuntos en Python

A continuación se muestran ejemplos de uso del álgebra de conjuntos, para el cual usaremos el ejemplo de los estudiantes en los grupos.

>>> group_a.union(group_b)
{'Ana', 'Antonio', 'Pedro', 'Carlos', 'Marcos', 'Mario'}
>>> group_a.difference(group_b)
{'Marcos', 'Mario'}
>>> group_a.intersection(group_b)
{'Ana', 'Carlos'}
>>> group_a.isdisjoint(group_b)
False
>>> group_a.isdisjoint({1, 2})
True
>>> group_a.issubset(group_b)
False
>>> group_a.issubset({'Marcos'})
False
>>> group_a.issubset(group_a)
True
>>> group_a.issuperset(group_a)
True
>>> group_a.issuperset(group_b)
False
>>> group_a.issuperset({'Marcos'})
True
>>> group_a.symmetric_difference(group_b)
{'Antonio', 'Pedro', 'Marcos', 'Mario'}

Operaciones con conjuntos

También se pueden realizar operaciones usuales sobre conjuntos como sumas, eliminaciones de elementos o comparaciones.

>>> len(group_a)
4
>>> group_a.add('Pepe')
>>> group_a
{'Ana', 'Pepe', 'Carlos', 'Marcos', 'Mario'}
>>> group_a.remove('Ana')
>>> group_a
{'Pepe', 'Carlos', 'Marcos', 'Mario'}
>>> group_a.pop()
'Pepe'
>>> group_a
{'Carlos', 'Marcos', 'Mario'}
>>> group_a.pop()
'Carlos'
>>> group_a
{'Marcos', 'Mario'}
>>> group_a.remove('Pepe')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Pepe'
>>> group_a.discard('Pepe')
>>> group_a > group_b
False
>>> group_a + group_b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'set' and 'set'
>>> group_a or group_b
{'Marcos', 'Mario'}
>>> group_a and group_b
{'Ana', 'Carlos', 'Antonio', 'Pedro'}
>>> group_a, group_b
({'Marcos', 'Mario'}, {'Ana', 'Carlos', 'Antonio', 'Pedro'})

Frozenset en Python

Los conjuntos son mutables en Python, sin embargo, existe un tipo similar que son los frozenset (conjuntos congelados).

La diferencia principal con respecto a los conjuntos (set) es que son inmutables por lo que no se pueden añadir ni eliminar elementos una vez creados, pero sus características son similares.

  • Contienen elementos únicos.
  • Se representan en forma de vectores.
  • La creación se hace usando frozenset(argumentos).
  • Los elementos no se pueden alterar una vez inicializados.
  • Sus elementos no están ordenados.
  • Ocupan menos espacio que los conjuntos.
>>> frozenset(range(5))
frozenset({0, 1, 2, 3, 4})
>>> fs = frozenset(range(5))
>>> fs.add(9)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
>>> 2 in fs
True
>>> frozenset([1, 45, 3j, 'hola'])
frozenset({'hola', 1, 3j, 45})
>>> dir(frozenset)
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']

Libros recomendados para aprender Python

Estos son los libros que pueden ayudarte a aprender Python, aprender a programar, tipos de datos, algoritmia y mucho más.

Disponible en:

Compartir

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Ver más

  • Responsable: Oscar Ramirez.
  • Finalidad:  Moderar los comentarios.
  • Legitimación:  Por consentimiento del interesado.
  • Destinatarios y encargados de tratamiento: No se ceden o comunican datos a terceros para prestar este servicio. El Titular ha contratado los servicios de alojamiento web a ionos (1&1) que actúa como encargado de tratamiento.
  • Derechos: Acceder, rectificar y suprimir los datos.
  • Información Adicional: Puede consultar la información detallada en la Política de Privacidad.

Publicar un comentario