Clase 24 de 31 • Curso de Introducción al Pensamiento Computacional con Python
Contenido del curso
Ingrid Natalia Rodriguez Ovalle
María José Ledesma
Maria Guadalupe Diaz Escobar
Sebastian CA
Carlos Franco
Maria Guadalupe Diaz Escobar
JAVIER SANTIAGO SALGADO
Beder Danilo Casa Condori
Fabrizio Fasanando Sotelo
Maria Guadalupe Diaz Escobar
Juan Alberto Hernandez De Leon
Luis Enrique Huamán Quispe
Jose Antonio Rojas Ollarves
Daniela Funes
Santiago Rios Olaya
rusbel bermúdez rivera
Martí Falcón Padró
David Logacho
Roberto Cruz Segura
Luis Enrique Huamán Quispe
Juan Nuñez
Raúl Camacho
Marlon Piero Rivera Centurión
freddy molleda
- -
Angel Armando Martínez Blanco
Luis Fernando Cruz Carrillo
Gabriel Missael Barco
Andrés Soret Chacin
Jorge Eliecer Barcasnegras Deavila
JESUS ALBERTO CARREÑO MARTINEZ
Carlos Alfonso Bayter Rey
Alex Casanova
Cristian Nicolás Pereira
Qué es una función Hash? Una función hash es método para generar claves o llaves que representen de manera unívoca a un documento o conjunto de datos. Es una operación matemática que se realiza sobre este conjunto de datos de cualquier longitud, y su salida es una huella digital, de tamaño fijo e independiente de la dimensión del documento original. El contenido es ilegible.
Es posible que existan huellas digitales iguales para objetos diferentes, porque una función hash tiene un número de bits definido. En el caso del SHA-1, tiene 160bits, y los posibles objetos a resumir no tienen un tamaño límite. A partir de un hash o huella digital, no podemos recuperar el conjunto de datos originales. Los más conocidos son el MD5 y el SHA-1, aunque actualmente no son seguros utilizarlos ya que se han encontrado colisiones. Cifrar una huella digital se conoce como firma digital.
Requisitos que deben cumplir las funciones hash:
Imposibilidad de obtener el texto original a partir de la huella digital. Imposibilidad de encontrar un conjunto de datos diferentes que tengan la misma huella digital (aunque como hemos visto anteriormente es posible que este requisito no se cumpla). Poder transformar un texto de longitud variable en una huella de tamaño fijo (como el SHA-1 que es de 160bits). Facilidad de empleo e implementación.
¡gracias por aporte!
Gracias por el aporte
Escribí este pequeño programa que te permite guardar la contraseña de tus cuentas en redes sociales:
#Para cada elemento se define la estructura clave:valor: #Store the names of the users and the passwords #sotre user names and passwords and ask the user to sing in try: import sys except ImportError: print() print("ERROR: Module 'sys' wasn't found") else: pass list1 = [] def add_element_function(listt): """ask for service name, username and password then store it in the list (Remember to press "Q" to quit this windows!) """ service_name = str(input("Enter web site/app name: ")) user_name = str(input("Enter user name: ")) user_password = str(input("Enter user password: ")) new_item = { "service": service_name, "user": user_name, "password": user_password } listt.append(new_item) print("Status: Element added") print(f"Current elements: {len(listt)}") print() return listt def list_viewer(listt): """view all elements in a given list (Remember to press "Q" to quit this windows!) """ if len(listt) == 0: print("There are no elements") print() else: i = 0 for dictionary in listt: i += 1 print(f"Account #{i} »»") print( "\tService Name: ", dictionary["service"], "\n", "\tUser Name: ", dictionary["user"], "\n", "\tPassword: ", dictionary["password"], "\n", ) def process_info(process): """Show the information of the processes executed in each command (Remember to press "Q" to quit this windows!) """ help(process) def remove_element(listt): """Prints all the registered accounts Asks user which one does he/she wants to remove Remove the account (Remember to press "Q" to quit this windows!) """ for dictionary in listt: print( dictionary["service"], "\n", dictionary["user"], "\n", dictionary["password"], "\n", ) user_input = int(input("Which account do you wanna delete from here? (please type the position): ")) del listt[user_input] print() return listt menu = { "1": "Add new element", "2": "View all current elements", "3": "Info", "4": "Remove", "5": "Exit" } while(True): for key, value in menu.items(): print(key +")", value) try: user_option = input() if user_option not in menu: raise TypeError except TypeError: print(f"ERROR: '{user_option}' is not a valid command, please type a valid one (1/2/3/4/5)") else: pass if user_option == "1": add_element_function(listt = list1) elif user_option == "2": list_viewer(listt = list1) elif user_option == "3": while(True): option1 = str(input("Which process do you wanna know how it works? (1/2/3/4): ")) if option1 == "1": process_info(process = add_element_function) break elif option1 == "2": process_info(process = list_viewer) break elif option1 == "3": process_info(process = process_info) break elif option1 == "4": process_info(process = remove_element) break else: print(f"'{option1}' is not a command, please type a valid command (1/2/3/4): ") print() elif user_option == "4": remove_element(listt = list1) else: if user_option == "5": print("Glad I helped you!") sys.exit()
Interesante!!
Gracias por el aporte
genial
Los dictionary comprehension tienen una sintaxis muy similar a los list comprehension: {llave : valor for variable in <iterable>}, y para ponerle un "filtro" se puede agregar un if después de el iterable para solo utilizar aquellos objetos que cumplan dicha condición :)
Gracias por el aporte
Dictionary Comprehension es un metodo que te permite crear un nuevo diccionario apartir de un diccionario ya existente, y poder modificar las llaves y valores de acuerdo a tus necesidades, la sintaxis es:
my_dict={'Juan' : 20, 'Ana': 30, 'Arturo' : 45} Nuevo_dict = {k:v for (k:v) in my_dict.items() if v<40}
en donde: Nuevo_dict = Es el nuevo diccionario que se hara apartir de un diccionario ya existente ( my_dict) k:v = key : Values del nuevo diccionario ( Nuevo_dict) For = Loop (k:v) in my_dict.items() = Key : values del diccionario existente ( my_dict) If = Condicionante v = condicion (value<40)
Dando como resultado:
print(Nuevo_dict) {'Juan' : 20, 'Ana': 30}
Otro ejemplo:
my_dict={'Juan' : 20, 'Ana': 30, 'Arturo' : 45} Estudiantes_dict = {'Estudiante ' + k:v*2 for (k:v) in my_dict.items()}
En este caso se le agrega la palabra estudiante a todos las llaves y su valor se multiplica por 2, no hay condicionante:
print(Estudiantes_dict) {'Estudiante Juan' : 40, 'Estudiante Ana': 60, 'Estudiante Arturo' : 90}
Espero les ayude amigos, saludos.
Corrección: despues del for es (k,v)
Nuevo_dict = {k:v for (k,v) in my_dict.items() if v<40} Estudiantes_dict = {'Estudiante ' + k:v*2for (k,v) in my_dict.items()}``` :
Diccionario: En los diccionarios los datos se encierran entre { }, Un diccionario es una estructura de datos y un tipo de dato en Python con caracateristicas especiales que nos permiten alcenar cualquier valor ya sea int, float, booleano, string, listas, funciones. Estos se identifican por una clave (Key)
Uso del diccionario: Para definir un diccionario, se encierra el listado de valores entre llaves. Las parejas de clave y valor se separan con comas, y la clave y el valor se separan con dos puntos
diccionario = {'nombre' : 'jose', 'edad' : 26, 'cursos': ['Python','Django','JavaScript'] }
--> Podemos acceder al elemento de un Diccionario mediante la clave de este elemento, como veremos a continuación:
print diccionario['nombre'] #jose print diccionario['edad']#26 print diccionario['cursos'] #['Python','Django','JavaScript']
--> También es posible insertar una lista dentro de un diccionario. Para acceder a cada uno de los valores usamos los índices:
print diccionario['cursos'][0]#Python print diccionario['cursos'][1]#Django print diccionario['cursos'][2]#JavaScript
Recorrer un diccionario con for: Para recorrer todo el Diccionario, podemos hacer uso de la estructura for
for pais in poblacion.keys(): print(pais) for pais in poblacion.values(): print(pais)
.values(): Devuelve el valor de las keys dentro del diccionario .items(): Imprimir ambos valores del diccionario el key y el valor, para ello tenemos que colocar dos indices en el ciclo for y mandar a imprimir los dos en concatenacion: for pais, poblacion in poblacion_paises.items(): print(pais + "tiene "+ str(poblacion) + "habitantes")
IMPORTANTE Hacer numeros grandes mas legibles puedes colocar _ entre ellos para hacerlos mas legibles como 44_938_712
Excelentes apuntes, muchas gracias 💚
se pueden moddificar mediante operaciones o ciertos filtros tanto las llaves como los valores asociados a ellas
dict_variable = {key:value for key,value in dictionary.items()} dict_variable = {key:operation(value) for key, value in dictionary.items()} dict_variable = {key: value for key, value in dictionary.items() if value #condition dict_variable = {key: value for key, value in dictionary.items() if key #condition
Para saber los metodos aplicables a cualquier objeto,ejemplo laclase anterior listas tenemos e la built-in function dir()
>>> dir(my_list) ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
de momento omitan aquelos que son doble underscore:
'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'
Excelente aporte
#dict_variable = {key:value for (key,value) in dictonary.items()} my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5} print(my_dict) double_dict1 = {k:v*2 for (k,v) in my_dict.items()} print(double_dict1) #{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5} #{'a': 2, 'b': 4, 'c': 6, 'd': 8, 'e': 10} numbers = range(10) new_dict_comp = {n:n**2 for n in numbers if n%2 == 0} print(new_dict_comp) #0: 0, 2: 4, 4: 16, 6: 36, 8: 64}
""" Diccionary comprehension: Es una elegante y concisa forma de crear diccionarios """ #creacion de un diccionario sin usar metodo comprehension cuadrado_dict = dict() for num in range(1, 11): cuadrado_dict[num] = num*num print(cuadrado_dict) #cracions del diccionario usando diccionary comprehension cuadrado_dict_2 = {num: num*num for num in range(1, 11)} print(cuadrado_dict) """ sintaxis dictionary comprehension: dictionary = {key: value for vars in iterable} haciendo una comparacion con el ejemplo anterior: {key: value for vars in iterable} | | | | {num: num*num for num in range(1, 11)} """ #ejemplo diccionario con condicional #cracion de un diccionario con nombres y edades dict_original = { 'jack': 38, 'michael': 48, 'guido': 57, 'john': 33, } #crear un nuevo diccionario con la informacion de las personas con edad par dict_par = {k : v for (k, v) in dict_original.items() if v % 2 == 0} print(dict_par)
Muy bien explicado, muchas gracias
ejemplo de dictionary comprenhension para almacenar los números pares del 0 al 10 en la llave y su cuadrado en el valor:
mi_diccionario={a:a**2 for a in range(11) if a%2 == 0}
Gracias por tu aporte Juan
Un resumen de la clase :D
""" CLASE: DICCIONARIOS """ # IMPORTANTE: Para definir los diccionarios usaremos {} my_dict = { 'David' : 35, 'Erika' : 32, 'Jaime' : 50, } #acceder a un valor print(my_dict['David']) #Cuando queremos acceder al diccionario y no sabemos que una llave existe, y si no existe queremos evitar un error podemos hacer que nos regrese un valor mediante el metodo get print(my_dict.get('Piero', 21)) #Regresa el valor 21 ya que Piero no existe """ Reasignar un valor """ my_dict['Jaime'] = 20 print(my_dict['Jaime']) #Ahora Jaime es más joven """¿Como asignar un nuevo valor al dic?""" my_dict['Pedro'] = 70 print(my_dict) """ Borrar """ del my_dict['Jaime'] print(my_dict) #Bye Jaime """¿Como iterar a lo largo de este dic?""" #Podemos iterar a lo largo de las llaves, los valores o en ambos. #Iteracion por llave for llave in my_dict.keys (): #el metodo keys nos permite imprimir las llaves, keys = llaves print(llave) #Iteracion por valor for valor in my_dict.values (): #el metodo values nos permite imprimir los valores, values = valores print(valor) #Iteracion por llave y valor for llave, valor in my_dict.items(): print('Para la llave ' + llave + ' el valor es ' + str(valor)) """¿Como saber si existe una llave en el dic?""" print('David' in my_dict) print('Tom' in my_dict)
Como vimos en la clase, la función range() nos devuelve una secuencia de números, la cual la podemos guardar en una lista o una tupla, ya que estas estructuras de datos tienen un índice asociado a cada elemento. Pero con los diccionarios no pasa lo mismo ya que en este tipo de estructuras debemos indicar las llaves, que fungen como índice de cada valor. Por esa razón la función range() no nos es útil ya que solo devuelve un valor, para solucionar eso podemos usar la función enumerate(). Esta función nos devuelve dos valores lo cual nos permite aprovecharlos para usar un valor como llave y el otro como valor de esa llave. Por ejemplo:
diccionario = {llave:valor for llave,valor in enumerate( range(1,20) )} print (diccionario) ouput . . . {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19}
Una funcion de hashing es una funcion que crea una llave de un solo camino (comunmente usada con propositos de encriptar la informacion).
List Comprehension en un diccionario Se puede lograr empleando el keyword enumerate. Éste método toma una lista o una estructora de datos que está enumerada y devuelve dos valores: indice, valor. Por ejemplo:
x = [] y = [] for i, j in enumerate(range(0,11,2)): x.append(i) y.append(j)
Esto entrega en cada iteración el íncide de cada valor del rango en la variable i y el valor en el rango con j. Por lo tanto las estructuras x y y tendrán los siguientes datos:
>>> x [0, 1, 2, 3, 4, 5] >>> y [0, 2, 4, 6, 8, 10]
Para hacer list Comprehension en un diccionario y poner estos valores en una sola línea de código, la sintaxis es la siguiente: { clave:valor for clave, valor in enumerate(range(0,11,2)) } En este caso se generará un diccionario con la siguiente información:
>>> {clave:valor for clave, valor in enumerate(range(0,11,2))} {0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10}
Este es un método. También se pueden emplear listas o tuplas en lugar del range()
Dict comprehension
Son necesarios dos listas o tuplas, una para las claves y otra para los valores:
k = ['a', 'b', 'c'] v = [1, 2, 3]
Ahora las comprimimos con la función zip dentro de la comprehesión, aquí la documentación de zip: https://www.w3schools.com/python/ref_func_zip.asp
d = {key:value for key, value in zip(k,v)} print(d) {'a': 1, 'b': 2, 'c': 3}
Sin embargo se escrime menos así, y es el mismo resultado:
d = dict(zip(k,v)) print(d) {'a': 1, 'b': 2, 'c': 3}
Notas :) Diccionarios
dict.keys()dict.values()dict.items(), (tienes que hacer unpacking)#Estructura general de un diccionario. my_dict = {'key1' : 'value1', 'key2' : 'value2', 'key3' : 'value3'} value_3 = my_dict['key3'] #Para acceder a un valor #Para revisar si hay una entrada 'key5' in my_dict #Regresa otra cosa si no existe my_dict.get('key4', 'No key in dict') #Para reasiganar un valor: my_dict['key2'] = 'new_value2' #Nuevo valor en diccionario my_dict['key4'] = 'value4' #Para borrar valor del my_dict['key1']
Para hacer dictionary comprehension:
dict_variable = {key:value for (key,value) in dictonary.items()}
Fuente
Muchas gracias por haber compartido tus apuntes bro 👌👌
No me quedo claro el metodo keys(), si no se hubiese colocado que hubiese pasado? el método es para que me corra el ciclo tomando en cuenta solo las llaves ignorando los valores?
Hola Primero hay que recordar en que consisten los diccionarios Los diccionarios cuentan con valores y claves Ej: 'Juan':4 Juan es el valor y la clave es 4 Pues el método keys() devuelve las listas o valores del diccionario
>>> versiones = dict(python=2.7, zope=2.13, plone=5.1) >>> versiones.keys() ['zope', 'python', 'plone']
Saludos
Hola, Teniendo en cuenta que en un diccionario guardas la relación Llave-Valor, existen tres metodos distintos que te devuelven solo el valor de las llaves, solo el valor de los valores, o el valor de ambos.
En el primer for imprimes las llaves, que en este caso son los nombres de cada pais.
En el segundo for imprimes solos los valores, que son la población de cada pais.
En el tercer for puedes usar tanto la llave como el valor para poder mostrar :"Colombia tiene 50 habitantes"
poblacion_paises = { 'Argentina' : 44938000, 'Brazil' : 210472000, 'Colombia' : 50370000 } for pais in poblacion_paises.keys(): print(pais) for poblacion in poblacion_paises.values(): print(poblacion) for pais, poblacion in poblacion_paises.items(): print(pais + ' tiene ' + str(poblacion) + ' habitantes')``` Espero poder haberte ayudado :)
Templete General para un diccionario de comprensión en Python:
dict_variable = {key:value for (key,value) in dictonary.items()}
my_dict = { ... 'Tim':21, ... 'Carlos':27, ... 'George':31, ... 'Finn':17, ... 'Tom':12, ... 'Fei':37 ... } my_dict_comp = {keys:values+1 for keys,values in my_dict.items()} {'Tim': 22, 'Carlos': 28, 'George': 32, 'Finn': 18, 'Tom': 13, 'Fei': 38}```