Curso de introducción a la programación con Python¶
Autor: Luis Fernando Apáez Álvarez
-Curso PyM-
Tarea 5: Conjuntos (sets) y diccionarios
Fecha de Entrega: 20 de Agosto del 2022
Autor: Luis Fernando Apáez Álvarez
-Curso PyM-
Tarea 5: Conjuntos (sets) y diccionarios
Fecha de Entrega: 20 de Agosto del 2022
La idea del concepto conjunto es muy intuitiva. Por ejemplo, podemos considerar un conjunto de días, un conjunto de archivos; podemos considerar que un refrigerador es un conjunto, donde sus elementos son justamente las cosas que tenemos dentro de él. De tal manera, intuitivamente, decimos que un conjunto es una agrupación de elementos que comparten características en común.
Por ejemplo, en el conjunto de días, sus elementos son los días de la semana los cuales claramente poseen característicamos en común, digamos por ejemplo que cada día tiene la característica de durar 24 horas. Luego, los elementos del conjunto refrigerador poseen la característica, digamos, de requerir cierta temperatura para mantenerse frescos. Así, en resumen, un conjunto es una agrupación de elementos, donde los elementos de dicho conjunto comparte al menos una característica. Dentro de las matemáticas, a los conjuntos los denotamos por llaves {}, y a sus elementos los colocaremos dentro de estas llaves. Por ejemplo:
Una característica importante sobre los conjuntos es que dentro de ellos el orden no importa, o más bien, los elementos dentro de un conjunto no tienen algún orden en específico. Por lo anterior, podemos decir que:
$$ \{1,2,3,4,5,6,7,8,9,10\}=\{1,3,4,2,10,9,7,6,5,8\} $$son exactamente el mismo conjunto. Otra característica importante es que los elementos dentro de un conjunto son únicos, es decir, si llegaramos a tener el conjunto $\{1,1,2,3\}$, en realidad dicho conjunto no es más que el conjunto $\{1,2,3\}$
Ahora bien, dentro de Python podemos también manejar conjuntos siguiendo la idea detrás de ellos que mencionamos antes. Cabe aclarar que, para definir un conjunto en Python, utilizamos también las llaves {}, pero a diferencia de los diccionarios no utilizaremos la idea de key-value. Además, los elementos de un conjunto pueden ser de distintos tipos de datos como cadenas o datos numéricos, e incluso booleanos (en particular sólo podemos utilizar el booleano False, pues el valor True dentro de los conjuntos no se toma en cuenta). Por ejemplo:
# Primer conjunto en Python
cjto1 = {1, "Hola", 3.1416}
print(cjto1)
print(type(cjto1))
print()
# Segundo conjunto en Python
# le agregaremos booleanos:
cjto2 = {1, "Hola", 3.1416, True, False}
print(cjto2)
print(type(cjto2))
{1, 3.1416, 'Hola'}
<class 'set'>
{False, 1, 3.1416, 'Hola'}
<class 'set'>
Vemos que, justamente, el booleano True no se toma en cuenta. Podemos utilizar la función len() para obtener el número de elementos deun set.
print(f"Número de elementos en el conjunto cjto2: {len(cjto1)}")
print(f"Número de elementos en el conjunto cjto2: {len(cjto2)}")
Número de elementos en el conjunto cjto2: 3 Número de elementos en el conjunto cjto2: 4
Dado que los conjuntos no poseen orden en sus elementos, en este caso no podremos acceder a éstos mediante índice, como lo hacíamos con las listas o tuplas, pero si podemos acceder cada uno de sus elementos utilizando un bucle for
# Para el conjunto 1
for _ in cjto1:
print(_)
print("-" * 30)
# Para el conjunto 2
for _ in cjto2:
print(_)
1 3.1416 Hola ------------------------------ False 1 3.1416 Hola
Nos podemos pregunar si cierto valor es un elemento de un conjunto. Por ejemplo, el valor "Hola" sí es un elemento del conjunto cjto2, pero 2.718281828 no es un elemento de este conjunto:
print("Hola" in cjto2)
print()
print(2.718281828 in cjto2)
True False
Podemos agregar nuevos elementos a nuestros conjuntos, para ello utilizaremos el método add() como sigue
# Agregaremos el numero 2.718281828 al conjunto cjto2
cjto2.add(2.718281828)
print(cjto2)
{False, 1, 2.718281828, 3.1416, 'Hola'}
Veamos de manera ilustrativa cómo los elementos de un conjunto son únicos. Por ejemplo, consideremos el conjunto {1,2,3}, después, con el método add() agregemos a dicho conjunto el valor 1, entonces parecería que obtenemos el conjunto {1,1,2,3}, pero recordemos que los elementos dentro de un conjunto son únicos. Por ende, después de aplicar el mètodo add(1) en realidad continuaremos teniendo el mismo conjunto {1,2,3}. En efecto:
# Conjunto 3
cjto3 = {1,2,3}
print(cjto3)
print()
# Agregamos el 1 a cjto3
cjto3.add(1)
print(cjto3)
{1, 2, 3}
{1, 2, 3}
Podemso remover elementos dentro de un conjunto. Para ello utilizaremos el método remove() como sigue
# Removeremos el elemento 3 de cjto3:
cjto3.remove(3)
print(cjto3)
{1, 2}
Podemos convertir conjuntos a listas y viceversa:
# Convirtamos el conjunto cjto3 a una lista
# mediante la funcion list():
cjto3_lista = list(cjto3)
print(cjto3_lista)
print(type(cjto3_lista))
[1, 2] <class 'list'>
# Agregamos algunos elementos a la lista resultante
cjto3_lista.append(3)
cjto3_lista.append(1)
print(cjto3_lista)
[1, 2, 3, 1]
Vemos que en una lista los elementos no son necesariamente únicos. Luego, convertimos la lista anterior en un conjunto mediante la función set():
cjto3_lista_cjto = set(cjto3_lista)
print(cjto3_lista_cjto)
print(type(cjto3_lista_cjto))
{1, 2, 3}
<class 'set'>
donde vimos que el uno duplicado de la lista fue omitido. Finalmente, también podemos considerar la idea de conjuntos de comprensión así como las listas de comprensión. Por ejemplo
cjto4 = { 3 * i for i in range(1, 10) }
print(cjto4)
{3, 6, 9, 12, 15, 18, 21, 24, 27}
Ejercicio 1: Completa según se te indique:
# Crear un conjunto que almacene los numeros 0,2,4,6,8,10 utilizando
# la idea de conjuntos de comprension:
pares_set = { _ _ _ }
# ------------------------------------------------------------------
# ------------------------------------------------------------------
# Agrega el elemento 12 a dicho conjunto
pares_set. _ _ _
# Remueve el elemento 4 de dicho conjunto
pares_set. _ _ _
# Agrega el elemento 0 a dicho conjunto
pares_set. _ _ _
# Imprime el numero de elementos de dicho conjunto
print( _ _ _ (pares_set))
Ejercicio 2: Responde las siguientes preguntas. Deberás responder con True o False según sea el caso
# ¿El valor 1 esta en el conjunto pares_set?
# (deberas usar la clausula in)
respuesta1 = _ _ _
# ------------------------------------------------------------------
# ------------------------------------------------------------------
# ¿El valor 10 esta en el conjunto pares_set?
respuesta2 = _ _ _
# ------------------------------------------------------------------
# ------------------------------------------------------------------
# ¿El valor 12 esta en el conjunto pares_set?
respuesta3 = _ _ _
# ------------------------------------------------------------------
# ------------------------------------------------------------------
# Imprime todas tus respuestas utilizando un mensaje claro
# para ello utiliza un f string.
print( _ _ _ )
Ejercicio 3: Deberás crear un diccionario y al final realizarás una impresión de la información de dicho diccionario, simulando una tabla (así como se hizo al final de la clase 5). Para ello
for y dando el formato adecuado, se imprimirá la información de todos los alumnos en una especie de tabla.Antes de ello, notemos que los values de un diccionario pueden ser también listas, tuplas o conjuntos, y las keys pueden ser del tipo de dato numérico:
# diccionario de ejemplo
# * las llaves son numeros enteros
# * los valores son listas, tuplas o sets
# Inclusive, los valores pueden ser diccionarios
dict_ej = {1: ["Luis", 24, "Curso Python"],
2: ("Lola", 84, "Curso Java"),
3: {"Alexa", 20, "Curso Excel"},
4: {4.1: "Luis 2", 4.2: 25, 4.3: "Curso Java"}
}
# Imprimimos nuestro diccionario utilizando
# la funcion pprint()
from pprint import pprint as pp
pp(dict_ej)
{1: ['Luis', 24, 'Curso Python'],
2: ('Lola', 84, 'Curso Java'),
3: {'Alexa', 20, 'Curso Excel'},
4: {4.1: 'Luis 2', 4.2: 25, 4.3: 'Curso Java'}}
Para este ejercicio utilizaremos como values tuplas (pues recordemos que éstas son inmutables); además, dado que requerimos cierto orden, por ello no ocuparemos sets y para evitar complejidad en el código, también evitaremos diccionarios. Por ello el elegido han sido las tuplas. De tal manera.
# Definimos el diccionario que almacenara
# la informacion de los alumnos.
# Las llaves (keys) seran numeros enteros consecutivos
# haciendo alusion asi al numero de alumno asociado
# En las tuplas tenemos el orden
# (nombre, edad, tipo de curso)
dict_info = {1: ("Luis", 24, "Curso Python"),
2: ("Lola", 84, "Curso Java"),
3: ("Alexa", 20, "Curso Excel"),
# agrega al menos otros dos alumnos
# (que los nombres no sean largos):
4: (_ _ _ , _ _ _ , _ _ _ ),
5: (_ _ _ , _ _ _ , _ _ _ )
}
# Imprime el diccionario anterior utilizando
# la impresion pprint
_ _ _ (dict_info)
Agrega un nuevo alumno al diccionario:
# -key- ------- value -------
dict_info[ _ _ _ ] = (_ _ _ , _ _ _ , _ _ _ )
# (Recuerda que los valores de nuestro diccionario son tuplas)
# Imprime el dicionario utilizando la impresion pprint
_ _ _ (dict_info)
Finalmente, imprimiremos la tabla que se nos pide. Pero antes notemos algo, consideremos que:
# Diccionario de ejemplo de alumnos
dict_info_ejemplo = {1: ("Luis", 24, "Curso Python"),
2: ("Lola", 84, "Curso Java"),
3: ("Alexa", 20, "Curso Excel")
}
# Podemos acceder a toda la informacion almacenada
# en dicho diccionario (recuerda que para acceder
# a los elementos de una tupla utilizamos indices)
# accedemos al value asociado a la key 1:
print(dict_info_ejemplo[1])
print()
# El value asociado es una tupla. Podemos acceder
# al segundo elemento de dicha tupla:
# ----es una tupla----|accedemos al segundo
# --------------------|elemento de esa
# --------------------|tupla
print(dict_info_ejemplo[1][1])
('Luis', 24, 'Curso Python')
24
Ahora si, imprimiremos toda la información que guarda nuestro diccionario dict_info y la mostraremos como una tabla:
# Completa:
# Declaramos una variable que almacene 84 guiones
guiones = "-" * 84
# Primer columna
print(f"|{guiones}|")
print("|{:^5}|{:^30}|{:^6}|{:^40}|".format("ID", "NOMBRE", _ _ _ , _ _ _ ))
print(f"|{guiones}|")
# Iteramos
for _ _ _ , _ _ _ in dict_info.items():
# alineamos al centro con ^
# -key | -Recuerda que los values
# -key | -son tuplas
print("|{:^5}|{:^30}|{:^6}|{:^40}|".format(_ _ _, _ _ _ [0], _ _ _ [1],
_ _ _ [2]))
print(f"|{guiones}|")
# Deberas obtener una tabla de la forma:
|------------------------------------------------------------------------------------| | ID | NOMBRE |_ _ _ | _ _ _ | |------------------------------------------------------------------------------------| | 1 | Luis | 24 | Curso Python | |------------------------------------------------------------------------------------| | 2 | Lola | 84 | Curso Java | |------------------------------------------------------------------------------------| | 3 | Alexa | 20 | Curso Excel | |------------------------------------------------------------------------------------| | 4 | _ _ _ |_ _ _ | _ _ _ | |------------------------------------------------------------------------------------| | 5 | _ _ _ |_ _ _ | _ _ _ | |------------------------------------------------------------------------------------|
donde los _ _ _ son sustituidos conforme a lo que fuiste resolviendo en el ejercicio.