Conjuntos
Contents
Conjuntos#
Important
¿Qué debemos tener presente?
Objetos mutables e inmutables
Un conjunto es un objeto el cual se puede crear de dos maneras, la primera es escribiendo los elementos entre llaves {} separados por comas, y la otra es mediante la función set(), en la cual el argumento es un iterable el cual contiene los elementos del conjunto que deseamos crear:
{0,1,2,3}
{0, 1, 2, 3}
set([0,1,2,3])
{0, 1, 2, 3}
set((0,1,2,3))
{0, 1, 2, 3}
Particularidades:#
Los conjuntos no permiten repeticiones, por ejemplo:
print(set([1,2,3,1,2,1]))
# es el mismo conjunto:
print({1,2,3})
{1, 2, 3}
{1, 2, 3}
Los conjuntos no tienen un orden, como lo tenían las listas y las tuplas:
print({1,2,3})
print({3,1,2})
print({2,3,1})
{1, 2, 3}
{1, 2, 3}
{1, 2, 3}
Los elementos de un conjunto no pueden ser objetos mutables, como listas, conjuntos o diccionarios:
print({1,[2,3]})
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [6], in <cell line: 1>()
----> 1 print({1,[2,3]})
TypeError: unhashable type: 'list'
print({1,{2,3}})
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-7-87021e2e51b7> in <module>
----> 1 print({1,{2,3}})
TypeError: unhashable type: 'set'
print({1,{"dos":2,"tres":3}})
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-8-65a58b1af8f4> in <module>
----> 1 print({1,{"dos":2,"tres":3}})
TypeError: unhashable type: 'dict'
Pero sí puede tener elementos del tipo tupla:
print({1,(2,3)})
{(2, 3), 1}
Los conjuntos no tienen un índice, esto es completamente diferente a lo que habíamos trabajado hasta el momento, y es natural dado que los elementos no tienen un orden:
c = {1,2,3}
c[0]
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-11-71463270cd6c> in <module>
----> 1 c[0]
TypeError: 'set' object is not subscriptable
Lo anterior implica que los elementos de los conjuntos no se pueden modificar, podemos agregar o quitar elementos pero no remplazar los que teníamos en la definición del conjunto:
c2 = {"uno",2,3.0}
Para agregar un único elemento empleamos el siguiente método:
c2.add(4)
c2
{2, 3.0, 4, 'uno'}
Para agregar múltiples elementos a un conjunto empleamos el método update, teniendo presente que las repeticiones de elementos serán omitidas:
c2.update([1,2,3])
c2
{1, 2, 3.0, 4, 'uno'}
Del mismo modo en que agregamos elementos, podemos quitarlos de nuestros conjuntos, con los métodos remove o discard. La diferencia entre ellos es que si al emplear el método remove el elemento no está en el conjunto, arroja error; pero con discard el conjunto no se ve afectado ni erroja errores:
c2.remove(3)
c2
{1, 2, 4, 'uno'}
c2.remove(5)
c2
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-16-989e2b2523b8> in <module>
----> 1 c2.remove(5)
2 c2
KeyError: 5
c2.discard(5)
c2
{1, 2, 4, 'uno'}
c2.discard("uno")
c2
{1, 2, 4}
El método pop elimina un elemento del conjunto, por lo general toma el primer elemento de éste luego del ordenamiento interno realizado:
c2.pop()
c2
{2, 4}
Si queremos eliminar todos los elementos del conjunto, basta emplear el método clear:
c2.clear()
c2
set()
Operaciones entre conjuntos#
Como hemos podido ver, los conjuntos que hemos trabajado en el cuderno se comportan de la misma manera que los conjuntos que usualmente trabajamos en matemáticas, además están las operaciones usuales entre ellos: unión, intersección, diferencia y diferencia simétrica:
Unión#
Como bien sabemos, la unión de dos conjuntos se define como los el conjunto formado por los elementos que hacen parte de uno u otro. Si definimos los conjuintos:
u1 = {"a","e","i","o","u"}
u2 = {1,2,3,4}
#La unión entre ellos se realiza así:
u1.union(u2)
{1, 2, 3, 4, 'a', 'e', 'i', 'o', 'u'}
Intersección#
La intersección entre dos conjuntos, como bien sabemos, es el conjunto formado por los elementos que hay en común entre ellos:
La forma de hacer dicha operación con los conjuntos de Python es la siguiente:
i1 = {"a","e","i","o","u"}
i2 = {"a",2,3,"u"}
i3 = {"e","o",5}
print(i1.intersection(i2))
print(i1.intersection(i3))
print(i3.intersection(i2))
{'a', 'u'}
{'o', 'e'}
set()
Por su lado el método intersection_update, remplaza el contenido de un conjunto por el de la intersección de él con otro conjunto dado
#i1 será remplazado por la intersección {'e', 'o'}
i1.intersection_update(i3)
i1
{'e', 'o'}
Diferencia#
La diferencia entre el conjunto A y el conjunto B, son los elementos que tiene A que no tiene B. Ésta operación, a diferencia de la unión y la intersección, no es conmutativa.
El código que debe ejecutarse para hacer dicha operación entre dos conjuntos es el siguiente:
d1 = {"h","o","l","a"}
d2 = {"b","u","e","n","a","s"}
d1.difference(d2)
{'h', 'l', 'o'}
d2.difference(d1)
{'b', 'e', 'n', 's', 'u'}
También podemos actualizar el contenido de un conjunto por la diferencia de él con otro conjunto, empleando el método difference_update, así:
d2.difference_update(d1)
d2
{'b', 'e', 'n', 's', 'u'}
Diferencia simétrica#
Ésta operación, dados dos conjuntos A y B, se puede ver de dos maneras: La primera es como la diferencia de A y B unida con la diferencia de B con A. La segunda es como la diferencia entre la unión de A con B con la intersección de los dos conjuntos. La forma gráfica de entenderla es la siguiente:
d1 = {"h","o","l","a"}
d2 = {"b","u","e","n","a","s"}
d1.symmetric_difference(d2)
{'b', 'e', 'h', 'l', 'n', 'o', 's', 'u'}
d1.union(d2).difference(d1.intersection(d2))
{'b', 'e', 'h', 'l', 'n', 'o', 's', 'u'}
Con el método symmetric_difference_update, podemos actualizar el contenido de un conjunto por la diferencia simétrica de él con otro conjunto, como podemos ver a continuación:
d1.symmetric_difference_update(d2)
d1
{'b', 'e', 'h', 'l', 'n', 'o', 's', 'u'}
Ejercicios#
Investiga la diferencia entre los objetos del tipo
frozensety los tiposet, que estudiamos en el presente cuaderno.
Diccionarios#
Los diccionarios son una colección ordenada de elementos, y para cada elemento en él existe una pareja key : value asociada.
Éstos objetos están optimizados para mostrar el “valor” cuando conocemos la “llave” o “clave”.
La creación de éstos es muy sencilla, cada pareja key : value debe ir separada de la otra con coma, y las llaves deben ser objetos inmutables str, int, float o tuple, así:
{llave_1:valor_1, llave_2:valor_2, ... ,llave_n:valor_n}
dic1 = {"Nombre":"Pepito","Apellido":"Pérez","Edad":20}
Éstos también se pueden crear con la función dict
dict([("nombre","Pepito"),("Apellido","Pérez"),("edad",20)])
{'nombre': 'Pepito', 'Apellido': 'Pérez', 'edad': 20}
Los diccionarios pueden tener llaves de un único tipo, como en el ejemplo anterior, o pueden ser mixtas:
dic2 = {1:"Arroz",2:"Aceite",3:20,4:1}
Si deseamos acceder a un valor en especial, debemos seguir la idea de las listas, pero el índice se remplaza por el nombre de la llave así;
elemento = diccionario["llave"]
por ejemplo:
dic1["Nombre"]
'Pepito'
dic2[1]
'Arroz'
O con el método get()
dic2.get(2)
'Aceite'
Para añadir elementos a un diccionario, basta con llamar al diccionario, la llave que deseamos modificar y asignar el valor deseado
diccionario["llave"] = valor
dic2[5] = "pan"
dic2
{1: 'Arroz', 2: 'Aceite', 3: 20, 4: 1, 5: 'pan'}
O mediante el método update, el cual como argumento tendrá la pareja key : value que se desea anexar en el diccionario:
dic2.update({6:"chocolate"})
dic2
{1: 'Arroz', 2: 'Aceite', 3: 20, 4: 1, 5: 'pan', 6: 'chocolate'}
Ejercicio:#
Cree un diccionario que se llame notas, en el cual estén los nombres y los valores de cuatro notas obtenidas por “Pepito Pérez”.
Notas = {"Quiz1":3.5, "Parcial1":2.3, "AulaVirtual":5.0, "Taller1":4.3 }
Notas
{'Quiz1': 3.5, 'Parcial1': 2.3, 'AulaVirtual': 5.0, 'Taller1': 4.3}
Ahora agregaremos el diccionario de antes, al primero que creamos
dic1["Notas"] = Notas
dic1
{'Nombre': 'Pepito',
'Apellido': 'Pérez',
'Edad': 20,
'Notas': {'Quiz1': 3.5, 'Parcial1': 2.3, 'AulaVirtual': 5.0, 'Taller1': 4.3}}
El ejemplo anterior nos muestra que podemos anidar diccionarios, es decir, un elemento de un diccionario puede ser otro diccionario.
Para acceder a dichos valores debemos llamar las dos llaves:
dic1["Notas"]["Quiz1"]
3.5
Para modificar los elementos del diccionario, accedemos a su llave y cambiamos el valor, por ejemplo:
dic1["Edad"] = 15
dic1
{'Nombre': 'Pepito',
'Apellido': 'Pérez',
'Edad': 15,
'Notas': {'Quiz1': 3.5, 'Parcial1': 2.3, 'AulaVirtual': 5.0, 'Taller1': 4.3}}
Si nuestro interés es eliminar elementos del diccionario tenemos dos métodos: pop() y popitem().
El argumento de pop() es la llave del elemento que deseamos eliminar, mientras que popitem() no necesita de argumentos, ya que elimina un elemento al azar.
dic2.pop(1,"Arroz")
dic2
{2: 'Aceite', 3: 20, 4: 1, 5: 'pan', 6: 'chocolate'}
dic2.popitem()
(6, 'chocolate')
y al igual que con los conjuntos, el método clear permite eliminar todos los elementos del diccionario:
dic2.clear()
dic2
{}
Los diccionarios también se pueden crear por comprensión, de la misma manera en la que hicimos las listas:
cuadrados = {x:x**2 for x in range(0,5)}
cuadrados
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
De los diccionarios también podemos extraer las listas de las llaves y de los valores, así:
list(cuadrados.keys())
[0, 1, 2, 3, 4]
list(cuadrados.values())
[0, 1, 4, 9, 16]
Ejercicios#
Cree un diccionario con la siguiente estructura:
Notas = {nombre : [lista_de_notas]}
con por lo menos 5 estudiantes, los cuales cada uno deberá tener 6 notas numéricas entre 0 y 5.0 2. Cree una función la cual calcule la definitivad de los estudiantes del ejercicio anterior teniendo en cuenta que las tres primeras notas valen el 10% cada una, las dos siguientes 15% cada una y la última nota el 40% de la nota definitiva.