Los Conjuntos en Python

Son una colección de objetos sin ordenar no duplicados es decir no puede haber dos elementos iguales y estos no guardan orden alguno. No se pueden indexar pero si se pueden recorrer. Es una colección mutable, en la que se puede usar add() para añadir elementos. 

Se usan para almacenar múltiples elementos en una sola variable.

miconjunto = {"manzana", "platano", "anacardo"}

o

>>> letras = set('abracadabra')

>>> print(letras)
{'r', 'c', 'a', 'd', 'b'}

Como ves, un conjunto o set en inglés se especifica encerrando sus elementos entre llaves. 

Los conjuntos son uno de los 4 tipos de datos que se usan en Python para almacenar elementos, los otros 3 son las listas, las tuplas y los diccionarios.

Nota: al no estar ordenados, tu los guardas si, pero no puedes estar seguro en que orden se mostrarán cuando los necesites. Pueden aparecer en un orden distinto cada vez y no tienen por tanto ningún índice asociado.

Una vez que el conjunto está creado, no puedes modificar sus elementos, pero si puedes añadir nuevos con add()

Una cosa importante de los conjuntos es que no permiten elementos duplicados, lo cual nos puede ser útil. Por ejemplo imaginemos que tenemos una serie con números pero solo nos interesa saber cuales no están repetidos. Para esto podemos usar los conjuntos.

Ej:

>>> set = {1,3,6,9,4,6,3,2,1,9,7,4,3}

>>> print(set)

{1, 2, 3, 4, 6, 7, 9}

Los valores que están duplicados se ignoran.

Accediendo a los elementos.

No podemos acceder a los elementos de un conjunto usando un índice o una clave.

Pero si podemos recorre sus valores usando un bucle for, o preguntando a Python si un determinado elemento está presente en el conjunto usando la palabra clave in.

# Ejemplo de bucle en un conjunto para poder ver sus valores.
>>> conjunto = {'manzana','naranja','platano','pera'}
>>> for i in conjunto:
>>>    print(i)
naranja
manzana
platano
pera

>>> # Ejemplo ver si la 'pera' está en el conjunto
>>> conjunto = {'manzana','naranja','platano','pera'}
>>> print('pera' in conjunto)
True

{1, 2, 3, 4, 6, 7, 9}

Añadiendo Nuevos Elementos.

Como ya dijimos, una vez que un conjunto está creado no se puden cambiar sus elementos, pero si se puede añadir nuevos.

Para añadir un nuevo elemento usaremos el método add()

>>> # Ejemplo para añadir el 'melon' al conjunto
>>> conjunto = {'manzana','naranja','platano','pera'}
>>> conjunto.add('melon')
>>> print(conjunto)
{'platano', 'manzana', 'pera', 'melon', 'naranja'}

Podemos añadir elementos de otro conjunto, a nuestro conjunto actual usando el método update()

>>> # Ejemplo de añadir un conjunto a otro
>>> conjunto = {'manzana','naranja','platano','pera'}
>>> otroconjunto ={'piña', 'kiwi'}
>>> conjunto.update(otroconjunto)
>>> print(conjunto)
{'pera', 'manzana', 'kiwi', 'piña', 'platano', 'naranja'}

El objeto que le pasamos al método update() no tiene porque ser un conjunto, puede ser cualquier iterable (tupla, lista, diccionario etc)

>>> # Ejemplo de añadir cualquier iterable
>>> conjunto = {'manzana','naranja','platano','pera'}
>>> listafrutas = ['cereza', 'pera', 'sandia']
>>> conjunto.update(listafrutas)
>>> print(conjunto)
{'platano', 'naranja', 'pera', 'manzana', 'cereza', 'sandia'}

Eliminar Elementos de un Conjunto.

Para eliminar elementos de un conjunto ya creado podemos usar los métodos remove() o discard()

>>> # Ejemplo de eliminar un elemento
>>> conjunto = {'manzana','naranja','platano','pera'}
>>> conjunto.remove('naranja')
>>> print(conjunto)
{'manzana', 'pera', 'platano'}

Si intentas eliminar un elemento que no existe te dará un error si usas remove(), pero NO con discard().

Para borrar completamente un conjunto podemos usar el método clear() o la función del().

>>> # Ejemplo de eliminar todo un conjunto y dejarlo vacio
>>> conjunto = {'manzana','naranja','platano','pera'}
>>> conjunto.clear()
>>> print(conjunto)
set()

No obstante si usas del() borraras del todo la variable dejando de existir por lo que si tratas de usar print() te dará un error porque la variable, no es que esté vacía, es que no existe.

 Para crear un conjunto vacío se utiliza la siguiente expresión, ya que si utilizaras {} Python entenderá que quieres crear un diccionario vacio, que es un tipo de datos que veremos próximamente.

>>> conjunto_vacio = set()
>>> diccionario_vacio = {}
>>> print(type(conjunto_vacio))
>>> print(type(diccionario_vacio))
<class 'set'>
<class 'dict'>

Otros métodos y funciones que se pueden aplicar a conjuntos.

- Número de elementos de un conjunto. len(set)

>>> conjunto = {1,2,3,4,5,6,7,8,9}
>>> print("El conjunto tiene",len(conjunto),"elementos")
El conjunto tiene 9 elementos

- ¿Está el elemento 'x' en el conjunto?. x in s

conjunto = {1,2,3,4,5,6,7,8,9}
print("Está el número 2 en el conjunto =", 2 in conjunto)
Está el número 2 en el conjunto = True

- ¿No está "x" en el conjunto?. x not in s

>>> conjunto = {1,2,3,4,5,6,7,8,9}
>>> print("¿No está el número 15 en el conjunto =", 15 not in conjunto)
¿No está el número 15 en el conjunto? = True
>>> print("¿No está el número 2 en el conjunto? =", 2 not in conjunto)
¿No está el número 2 en el conjunto? = False

-  ¿No tienen dos conjuntos algún elemento en común? s1.isdisjoint(s2)

Devuelve True si los dos conjuntos no tienen ningún elemento en común y False en caso contrario.

>>> s1 = {1,2,3}
>>> s2 = {3,4,5}
>>> print(s1.isdisjoint(s2))
False
>>> # El resultado es false porque s1 y s2 comparten elemento 3.

-  ¿ Es s2 un subconjunto de s1? Es decir todos los elementos de s2 están en s1. 

método s2.issubset(s1) u operador s2 <= s1

Devuelve True si es así y False en caso contrario.

>>> s1 = {1,2,3,4,7,9}
>>> s2 = {3,4,9}
>>> print(s2.issubset(s1))
True
>>> print(s2<=s1)
True

- Crear un conjunto que contenga los elementos diferentes entre dos o más conjuntos.

método s1.difference(*conjuntos) u operador s1 - s2

>>> s1 = {'pera','melocoton','limon','zanahoria'}
>>> s2 = {'casa','coche','limon','pera'}
>>> print(s1.difference(s2))
>>> print(s1-s2)
>>> # elementos del conjunto s1 que no están en s2
{'zanahoria', 'melocoton'}
{'zanahoria', 'melocoton'}

- Conjunto con los elementos no comunes a s1 y s2. 

método s1.symmetric_difference(s2) u operador s1 ^ s2

>>> s1 = {'pera','melocoton','limon','zanahoria'}
>>> s2 = {'casa','coche','limon','pera'}
>>> print(s1.symmetric_difference(s2))
>>> print(s1 ^ s2)
{'zanahoria', 'melocoton', 'coche', 'casa'}
{'zanahoria', 'melocoton', 'coche', 'casa'}

- Copia superficial de un conjunto. s1.copy()

>>> s1={1,2,3,4,5}
>>> s2={2,4}
>>> print(s2)
{1, 2, 3}

- s2 es un subconjunto de s1 pero no son iguales. s2 < s1 o s1.issuperset(s2)

>>> s1={1,2,3,4,5}
>>> s2={2,4}
>>> print(s2<s1)
True
>>> print(s1.issuperset(s2))
True

Para que ocurra lo anterior también se verifica que s2 <= s1 y s2 != s1

- Unir dos o más conjuntos en uno nuevo. Método s1.union(*conjuntos) o s1 | s2

>>> s1={1,2,3}
>>> s2={4,5,6}
>>> s3={7,8,9}
>>> print(s1.union(s2,s3))
{1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> print(s1 | s2 | s3)
{1, 2, 3, 4, 5, 6, 7, 8, 9}

- Generar un nuevo conjunto que contenga SOLO los elementos comunes a todos los conjuntos implicados. Método s1.intersection(*conjuntos) o s1 & s2 & s3 ...

>>> s1={1,2,3}
>>> s2={4,5,6,2}
>>> s3={7,8,9,2}
>>> print(s1.intersection(s2,s3))
{2}
>>> print(s1 & s2 & s3)
{2}