Conjuntos

Equivalente en Java: —->

Otro tipo de estructura de datos es el conjunto. Consiste en una colección
de datos que no está ordenado ni indexado. Puede contener tuplas (que no son mutables), pero no listas ni diccionarios, aunque puede contener elementos de listas y de diccionarios.
Cuando se imprime el valor de un conjunto, al no estar ordenado, puede
mostrar sus elementos aleatoriamente, sin orden definido.

numero=121
diccionario={"primero":100,"segundo":200}
lista=[1,2,3]
mi_conjunto={numero,34,43,11,1,0,5,lista[2],diccionario["primero"]}
print(mi_conjunto)

Posible resultado:

{0, 1, 34, 3, 100, 5, 11, 43, 121}

Recorrer los elementos de un conjunto.

Como un conjunto no está indexado, no podemos acceder de forma independiente a sus elementos, pero sí que podemos recorrer un conjunto y comprobarlos u operar con ellos.

mi_conjunto={14,22,45,2,100}
suma=0
for numero in mi_conjunto:
        suma+=numero
print(f"La suma de todos los elementos de mi_conjunto es: {suma}.")

Resultado:

La suma de todos los elementos de mi_conjunto es: 183.

Comprobar si un elemento está incluido en un conjunto.

Es posible comprobar si un elemento está incluido dentro de un conjunto.

lista=["desayuno","comida","cena"]
conjunto_a={"melón","sandía",4,5,lista[2]}
if "cena" in conjunto_a:
    print("cena está en conjunto_a")
else:
    print("cena no está en conjunto_a")

cena está en conjunto_a

Con la función len (conjunto), se puede averiguar el número de elementos que posee el conjunto incluido como argumento.

lista=["desayuno","comida","cena"]
conjunto_a={"melón","sandía",4,5,lista[2]}
cantidad=len(conjunto_a)
print(f"El conjunto_a tiene {cantidad} elementos.")

Resultado:

El conjunto_a tiene 5 elementos.

El método conjunto.add(elemento) permite añadir el elemento al conjunto.

Con este método podemos añadir cualquier tipo de elemento individual. Puede ser un número, una cadena, un elemento de una lista, o incluso puede ser una tupla que quedaría añadida como conjunto de datos (pero no como elemento individual).

lista=["desayuno","comida","cena"]
conjunto_a={"melón","sandía",4,5,lista[2]}
conjunto_a.add("merienda")
print(conjunto_a)

Resultado:

{4, 5, 'sandía', 'cena', 'merienda', 'melón'}

conjunto.update(lista) Con este método es posible añadir todos los elementos de una lista a un conjunto. Es importante tener en cuenta, que lo que añadimos son todos los elementos de la lista pero no la lista como tal, ya que las listas no pueden formar parte de un
conjunto.

lista=["desayuno","comida","cena"]
conjunto_a={"melón","sandía",4,5,lista[2]}
print(conjunto_a)
conjunto_a.update(lista)
print(conjunto_a)

Resultado:

{4, 5, 'sandía', 'melón', 'cena'}
{'desayuno', 4, 5, 'sandía', 'melón', 'comida', 'cena'}

IMPORTANTE: Podemos observar que al conjunto se han añadido dos nuevos elementos, sin embargo “lista” tenía tres elementos. Esto ocurre porque los
elementos de un conjunto NO pueden tener elementos repetidos, y “cena” ya estaba en el conjunto antes de actualizarlo.
Si intentamos añadir un elemento que ya está incluido dentro del conjunto, el programa no nos dará error. Sencillamente no se volverá a incluir.

Con el método anterior podemos añadir a un conjunto una estructura de datos como puede ser una lista, un conjunto o una tupla. En todos estos casos se
añaden todos los elementos de dicha estructura, pero como elementos individuales.

Si intentamos añadir una cadena con update se añadiría al conjunto la cadena, pero carácter a carácter (como elementos individuales). Por lo tanto como regla general, para añadir una cadena se utilizará .add

conjunto_a={1,2,3,4,5,6}
conjunto_b={5,6,7,8,9}
conjunto_a.update(conjunto_b)
mi_cadena="Mi cadena."
conjunto_a.update(mi_cadena)
print(conjunto_a)

Resultado:

{1, 2, 3, 4, 5, 6, 7, 8, 9, 'M', 'i', 'd', 'n', 'c', '.', ' ', 'a', 'e'}

nombre_conjunto=set( ) Podemos crear un conjunto con unos elementos iniciales encerrados entre paréntesis. Pero también podemos crear un conjunto vació con esta instrucción y posteriormente ir añadiendo elementos.

conjunto_a={"Tenis","Atletismo","Parchís"}
mi_conjunto=set()
mi_conjunto.add("Baloncesto.")
mi_conjunto.add("Ajedrez.")
mi_conjunto.update(conjunto_a)
print(mi_conjunto)

Resultado: 

{'Baloncesto.', 'Ajedrez.', 'Parchís', 'Tenis', 'Atletismo'}

conjunto.discard(elemento) // conjunto.remove(elemento) Cualquiera de estos dos métodos elimina del conjunto el elemento pasado como argumento. La diferencia está en que .remove lanzará un mensaje de error si el elemento no está en el conjunto mientras que discart permite que el programa se siga ejecutando aunque el elemento no se encuentre en el conjunto.

conjunto_a={1,2,3,4,5,6}
conjunto_a.discard(4)
print(conjunto_a)
conjunto_a.remove(7)

Resultado:

{1, 2, 3, 5, 6}
Traceback (most recent call last):
  File "/home/keduardo/Documentos/Python/prueba.py", line 4, in <module>
    conjunto_a.remove(7)
KeyError: 7

.discard ha eliminado el elemento, mientras que remove ha provocado que se detenga el programa ya que 7 no se encuentra incluido en el conjunto.

eliminado=mi_conjunto.pop( ) Esta es otra forma de eliminar un elemento de un conjunto. Hay que tener en cuenta, que al no llevar un orden los elementos de un conjunto, el elemento que se elimina no tiene por qué ser el que creemos que es el último.
La parte buena de este método es que el elemento eliminado queda
almacenado en la variable que hayamos indicado a la izquierda del igual.

mi_conjunto={14,23,18,222,43,344,115,36,47,48}
eliminado=mi_conjunto.pop()
print(eliminado)

Resultado:

36

conjunto.clear( ) // conjunto=set( )Para eliminar todos los elementos de un conjunto, disponemos del método
.clear. También podemos volver a redefinir el conjunto como un conjunto vacío, con la instrucción conjunto=set( ).

conjunto_a={1,2,3,4,5,6}
conjunto_a.discard(4)
print(conjunto_a)
conjunto_a=set() ##También valía: conjunto_a.clear()
print(conjunto_a)

Resultado:

{1, 2, 3, 5, 6}
set()

conj_c=conj_a.union(conj_b) También vale conj_c=conj_a. | (conj_b)
Tal y como hemos visto, con el método .update podemos actualizar un
conjunto con los datos que tiene otro conjunto. En realidad hemos unido los dos conjuntos en uno de ellos, pero no hemos creado ningún conjunto nuevo. El otro conjunto queda igual que estaba.
También podemos crear un tercer conjunto tomando como base la unión de
dos conjuntos., los cuales permanecerán igual que estaban anteriormente.
Para ello disponemos de dos posibilidades. El método .union o la operación
conjunto_a | conjunto_b

conjunto_a={1,2,3,4,5,6}
conjunto_b={4,5,"fresa","cereza"}
conjunto_c=conjunto_a | conjunto_b
##También vale: conjunto_c=conjunto_a.union(conjunto_b)
print(conjunto_c)

Resultado:

{1, 2, 3, 4, 5, 6, 'cereza', 'fresa'}

Recordemos que en la unión de los dos conjuntos, solo van a aparecer una vez los elementos que están en ambos conjuntos, ya que un conjunto no puede tener elementos repetidos.

nueva_lista=list(conjunto) Con esta función podemos obtener una lista a partir de los elementos contenidos en un conjunto.

conjunto_a={"Tenis","Atletismo","Parchís","Baloncesto","Ajedrez"}
mi_lista=list(conjunto_a)
print(mi_lista)

Resultado:

['Ajedrez', 'Atletismo', 'Parchís', 'Baloncesto', 'Tenis']

conjunto=set(lista) De manera semejante, se puede obtener un conjunto a partir de los elementos que contiene una lista. Incluso podemos delimitar los elementos de la lista que pasarán a formar el nuevo conjunto.

mi_lista=[4,1,8,3,2,3,4,5,6,7,8]
mi_conjunto=set(mi_lista)
otro_conjunto=set(mi_lista[1:7])
print(mi_conjunto)
print(otro_conjunto)

Resultado:

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

De nuevo observamos que se han eliminado los repetidos.

conj_d= conj_a & conj_b & conj_c…. Con esto obtenemos un nuevo conjunto que será la intersección de dos o más conjuntos.
El nuevo conjunto creado, tendrá todos los elementos que sean comunes a todos los conjuntos.

tu_conjunto={3,42,18,22,344,36,443}
su_conjunto={56,18,45,344,14}
nuevo=mi_conjunto & tu_conjunto & su_conjunto
otro=mi_conjunto & su_conjunto
print(nuevo)
print(otro)

Resultado:

{344, 18}
{344, 18, 14}

miconjunto= tuconjunto – suconjunto Al restar dos conjuntos vamos a obtener un nuevo conjunto que contiene todos los elementos del primer conjunto que no estén en el segundo.

mi_conjunto={14,23,18,222,43,344,115}
su_conjunto={56,18,45,344,14}
otro=mi_conjunto - su_conjunto
print(otro)

Resultado:

{43, 115, 222, 23}

Operaciones de comparación entre conjuntos. Las operaciones de comparación con >, >=, <, <=, = están permitidas, pero
tenemos que tener en cuenta que para que un conjunto sea mayor que otro, TODOS los elementos del segundo conjunto tienen que estar incluidos en el primer conjunto.

conjunto_a={14,23,18,222,43,344,115}
conjunto_b={14,23,18,7}
conjunto_c={14,23,18}
if conjunto_a > conjunto_b:
    print("El conjunto_a es mayor que el conjunto_b.")
else:
    print("El conjunto_a NO es mayor que el conjunto_b.")
if conjunto_c <= conjunto_b:
    print("El conjunto_c es menor o igual que el conjunto_b.")
else:
    print("El conjunto_c NO es menor o igual que el conjunto_b.")

Resultado:

El conjunto_a NO es mayor que el conjunto_b.
El conjunto_c es menor o igual que el conjunto_b.

conjunto_b=set.copy(conjunto_a) Si necesitamos obtener una copia de un conjunto, debemos utilizar la función set.copy(conjunto). En caso de utilizar simplemente conjunto_a=conjunto_b obtendríamos un mismo conjunto con dos nombres diferentes.

conjunto_a={14,23,18,222,43,344,115}
conjunto_b=conjunto_a
conjunto_b.discard(23)
print(conjunto_a)
print(conjunto_b)

Resultado:

{18, 115, 344, 43, 222, 14}
{18, 115, 344, 43, 222, 14}

conjunto_a={14,23,18,222,43,344,115}
conjunto_b=set.copy(conjunto_a)
conjunto_b.discard(23)
print(conjunto_a)
print(conjunto_b)

Resultado:

{18, 115, 23, 344, 43, 222, 14}
{18, 115, 344, 43, 222, 14}

set.isdisjoint(conjunto_a,conjunto_b) Si la intersección de dos conjuntos es el conjunto vacío, esta instrucción
dará como resultado “True”, en caso contrario dará “False”. En realidad equivale a esta otra instrucción:
(conjunto_a & conjunto_b)==set()

conjunto_a={14,23,18,222,43,344,115}
conjunto_b=set.copy(conjunto_a)
conjunto_b.discard(23)
conjunto_a=conjunto_a-conjunto_b
print (set.isdisjoint(conjunto_b,conjunto_a))
if (conjunto_a & conjunto_b)==set():
    print(True)

Resultado:

True
True

set.symmetric_difference(conjunto_a,conjunto_b) Con esta instrucción vamos a obtener un tercer conjunto formado por todos
los elementos que están solo en el primer conjunto, y todos los elementos que están solo en el segundo conjunto. En realidad es justo lo opuesto a la intersección.

conjunto_a={14,23,18,222,43,344,115}
conjunto_b={14,23,18,222,8,0,-44}
conjunto_c=set.symmetric_difference(conjunto_a,conjunto_b)
conjunto_d=conjunto_a & conjunto_b
print(conjunto_c)
print(conjunto_d)

Resultado:

{0, 8, 43, 115, -44, 344}
{18, 14, 222, 23}

Podemos observar que si unimos los dos resultados, lo que obtenemos es la unión de los dos conjuntos iniciales.