Asignación de variables
#Resumen#Variables sin ningun significadoa = 2#El valor 2 se los asignamos a la variable ax = 4#La variable x apunta donde vive 4 adentro de la memoriaz = (a * x) / 2#Resultado de una expressión asignadas a la variable z#Tipos de variables con significado que los seniors suelen escribirbase = 2altura = 4area = (base * altura) / 2#Reasignando una variablemy_var = 'hello, Platzi’
print(my_var)
#‘hello, Platzi’my_var = 3
print(my_var)
#3#La variable o el nombre sigue siendo el mismo pero esta apuntando a diferentes luugares#de memoria#La variable my_var apunta primero al lugar de memoria 0x0001#Y luego, al asignar el 3 apunta al lugar de memoria 0x0002#Todo esto esta en hexadecimal. Las direcciones de memoria en binario
Ademas de esto, ahi algo que se llama el garbage colector
#Este elimina variables y objetos que estan en diferentes areas de la memoria para asi#poder usarlo para crear nuevos objetos```Cadenas
#Cadenas (strings)
‘123’
‘123’ * 3 #Este operador repite las cadenas las veces que le pedimos
’123’ + ‘456’ #Concatenar estas cadenas. Ponerlas junta.
(‘Hip ’ * 3) + ’ ’ + ‘hurra’ #Esta es la union de los operadores enla linea 2-3
f’{"Hip " * 3} hurra’ #Forma lejible de combinar operadores
#Algunas de las funciones quese pueden usar con las cadenas
cadena = ‘Platzi’
len(cadena) #Nos da la longitud dela cadena.
cadena[0] #Pone la ‘P’ de Platzi, que es lo que esta asignado a la variable cadena.
cadena[2:] # cadena[comienzo:final:paso] #El comentario anterior es la manera enlaque funciona slicing. La primera parte es el indice con la letra que comenzará. La segunda es hasta que letra llegará(Si se deja vacio llegara hasta el final). Y la tercera mueve la primera parte de uno en uno, si nose le asigna valor o el valor es uno, o del valor quese le asigne.
cadena[:-2] #En este caso es desde el principio hasta antes de las dos ultimas letras
cadena[::2] #Esta salta de dos letras
‘Yo amo a ’ + cadena # Estamos concatenando estas cadenas(strings)
#Nota: este modo no es muy lejible
f’Yo amo a {cadena}’ #Esta es la mejor manera.
numero_de_veces = 1000
f’Yo amo a {cadena}’ * numero_de_veces #Y aqui usamos un operador para repetirlo el numero de veces quese repita.
#Una mejor formade ver el operador de multiplicacion usandolo con cadenas es como el operador de repeticion.
#Nota importante: al momento de creear una cadena. Esta es asignada a un espacio enla memoria. Y si nosotros asignamos algo más a la cadena, esto no modifica la cadena anterior. Sino que crea un nuevo espacio en memoria, 0x0002, y la variable apunta este otro espacio.
nombre = input('Cuál es tu nombre: ‘) #A la variable nombre le asignamos lo que introdusca el usuario. En este caso, deberia ser un nombre.
print(f’Tu nombre es {nombre}’) # Usando laforma lejible de concatenar cadenas(strings) imprimimos una cadena con el nombre del usuario
numero = input('Escribe un numero: ‘)
print(f’El numero que {nombre} inserto es {numero} de tipo {type(numero)}’) #Usando laforma lejible, las dos variables, nombre y numero del usuario, Y la nueva función aprendida, type().
numero = int(numero)
print(f’Ahora el tipo del numero es {type(numero)}’) #Esto se debe a que clonamos la variable numero de tipo cadena y le cambiamos el tipo a un numero entero con la función int().
#Todo esto nos da flexibilidad para hacer una mayor cantidad de trabajos.
###################Reto######################
saludo_con_nombre = f’Saludo {input("Dime tu nombre: ")}‘
longitud = len(saludo_con_nombre)
print(f’La longitud de tu saludo con el nombre es {longitud}’)```
Programas Ramificados
#El objetivo de este python es crear un programa que tome decisiones.
#Operadores de comparación
2 == 3 # Este es el operador igual
2 != 3 # Este es el de desigualdad y en este caso es verdadero
2 > 3 # Major que
2 < 3 # Menor que
2 <= 3 # Menor o igual que
2 >= 3 # Mayor o igual que
#Comparadores lógicos
#And
#or
#not
2 > 1 and 3 < 4 #Esto es verdadero porque ambas son verdaderos
2 == 1 or 3 < 4 #Verdadero, porque una de las dos opciones es verdadera.
not 2 > 3 #Este es verdadero, porque el comparador lógico ‘no’ es lo opuesto
num_1 = int(input('Escoge un entero: ')) #Pide un numero al usuario y lo combierte de una cadena a un entero
num_2 = int(input('Escoge otro entero: ')) #Pide un numero al usuario y lo combierte de una cadena a un entero
if num_1 > num_2: #Si el numero 1 es mayor que el numero 2 ejecuta la expresiónprint(‘El primer numero es mayor que el segundo.’) #Imprime la cadena
elif num_1 < num_2: #Si el primer if es falso y el numero 1 es menor que el numero 2 ejecuta la siguiente expressiónprint(‘El segundo numero es mayor que el primero.’) #Imprime la cadena
else: #Si ninguno de los if fue verdadero, ejecuta la expression.
print(‘Los dos numeros son iguales.’) #Imprime la cadena
print()
#Reto: Crea un programa quecompare las edades de dos usuarios y me diga quien es mayor
#Algo que me gustaria implementa es laforma legible de comhinar cadenas y variables.
print(‘Aqui empieza el Reto: crear un programa quecompare las edades de dos usuarios y me diga quien es mayor’)
print()
nombre_usuario_1 = input('Nombre del usuario 1: ')
edad_usuario_1 = int(input(f’Digame la edad de {nombre_usuario_1}: '))
nombre_usuario_2 = input("CNombre del usuario 2: ")
edad_usuario_2 = int(input('Cual es la edad de {nombre_usuario_2}: '))
if edad_usuario_1 > edad_usuario_2:
usuario_de_mas_edad = nombre_usuario_1
edad_de_usuario_mayor = edad_usuario_1
else:
usuario_de_mas_edad = nombre_usuario_2
edad_de_usuario_mayor = edad_usuario_2
if edad_usuario_1 != edad_usuario_2:
print(f’{usuario_de_mas_edad} de {edad_de_usuario_mayor} años es mayor.’)
else:
misma_edad = usuario_de_mas_edad
print(f’{nombre_usuario_1} y {nombre_usuario_2} tienen ambos {misma_edad} años.’)```
Iteraciones
#Notas#While loop, bucle while, iteración while#Lo mas sensillo es verlo como un reloj#Loop simple
contador = 0
while contador < 10: #Mientras el contador sea menor que 10print(contador) #Imprime contador
contador += 1 # contador = contador + 1#Loop dentro de un loop
contador_externo = 0 #contador externo es el número 0
contador_interno = 0 #contador interno es el número 0while contador_externo < 5: #Mientras que el contador externo sea menor que 5while contador_interno < 6: #Mientras que el contador interno sea menor que 6print(contador_externo, contador_interno) #Imprimir el contador externo y el contador interno
contador_interno += 1 #Sumar 1 al contador interno #··Si se elimina seria infinitoif contador_interno >= 3: #Si el contador interno es mayor o igual que 3break#Detener el whileloop
contador_externo += 1 #Sumar 1 al contador externo
contador_interno = 0 #Cambiar el contador interno a 0Bucles for
#Bucles for
#Los bucles son usados para repetir una expressiónen una colecciónde objectos
#En python esto ve expresa como
’’‘
forin : #Para cada variable en el conjunto iterable
n>#Ejecuta la expresión.
’’’n>
frutas = [‘manzana’, ‘pera’, ‘mango’]
for fruta in frutas: #Para cada fruta en el conjunto de frutas
print(f’La fruta es {fruta}.’) #Printea la fruta ‘x’. x --> Nombre dela fruta
### Usando bucle foren diccionarios
estudiantes = { #diccionario estudiantes porque tiene llave
’mexico’: 10, #Mexico es la llave 0, y el numero 10 es su valor
’colombia’: 15, #Colombia es la llave 1 y el numero 15 es su valor
’puerto_rico’: 4#Puerto_rico es la llave 2 y el numero 4 es su valor.
}
for pais in estudiantes: #Este iter repite la expresion con cada llave o en este caso pais.
print(pais) #Esta expressión imprime cada pais.
for pais in estudiantes.keys():#Este iter hace totalmente lo mismo que el anterior.
print(pais)
for numero_de_estudiantes in estudiantes.values(): #Extrae cada valor del diccionario, el dela derecha a la llave, y repite la expresion con cada valor.
print(numero_de_estudiantes) #numero_de_estudiantes vendria siendo cada valor en el diccionario estudiantes. Entonces, estariamos imprimiendo cada valor.
for pais, numero_de_estudiantes in estudiantes.items(): #Crea un tuple, la llave y su valor. Los asigna a dos variables, pais y numero_de_estudiantes y los usa enla expresion. Y se repite con cada llave y valor.
print(f’En {pais} hay {numero_de_estudiantes} estudiantes activos.’) #Usar la llave y el valor enlaforma lejible de imprimir.
#Reto Personal
#Persona, comida favorita
diccionario = {
‘Rubi’ : ‘los Chitos’,
‘Ismael’ : ‘la Pizza’,
‘Perla’ : ‘el Sancocho’,
‘Migue’ : ‘el Arroz con Pollo’,
‘Enrique’ : ‘el Arroz con Berenjena’
}
#Imprimir una frase que incluya la llave y el valor
for nombre, comida in diccionario.items():
if comida[-1] == ‘s’:
singular_o_plural = 'gustan’
else:
singular_o_plural = ‘gusta’
print(f’A {nombre} le {singular_o_plural} {comida}.’)```
Enumeracion Exhaustiva
#Enumeración exhaustiva
objetivo = int(input('Escoge un entero: ')) #Encontrar la raiz cuadrada de un numero
respuesta = 0
while respuesta**2 < objetivo: #Mientras el cuadrado de un numero sea menor que el objetivo
print(respuesta)#Di el numero actual
respuesta += 1#Agregale uno al numero actual
if respuesta**2 == objetivo: #Si se encuentra raiz cuadrada exacta
print(f’La raiz cuadrada de {objetivo} es {respuesta}’)#Imprime la oracion siguiente con las variables objetivo y respuesta
else: #Si no tiene variable exacta
print(f’{objetivo} no tiene una raiz cuadrada exacta’)#Imprime lo anterior``````
Aproximacion de soluciones
objetivo = int(input('Escoge un numero: ')) ; print(f'Obtenemos el numero {objetivo} del usuario')
epsilon = 0.01 ; print(f'Guardamos el {epsilon} enla variable epsilon')
paso = epsilon**2 ; print(f'Guardamos otro numero, {paso} en otra variable llamada paso')
respuesta = 0.0 ; print(f'Guardamos la flotante {respuesta} en una variable llamada respuesta')
print()
whileabs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
print(f'Mientras el {respuesta}, dela variable respuesta al cuadrado menos el {objetivo} que obtenimos de el usuario,')
print(f'sea menor o igual que el {epsilon} dela variable epsilon. Y que {respuesta}, valor dela variable respuesta, sea menor')
print(f'o igual que {objetivo}, el valor que obtenemos del usuario.')
respuesta += paso #Al 0.0 dela respuesta se le suma el paso, |linea 3|
print(f'Entonces, al {respuesta} dela variable respuesta se le sumara {paso} dela variable paso')
print()
print(f'Debido a que {abs(respuesta**2 - objetivo)}, dela variable respuesta al cuadrado menos que {objetivo} dela variable objetivo, no es mayor o igual que {epsilon} dela variable epsilon')
print(f'o que {respuesta} no es menor o igual que {objetivo} dela variable objetivo el while loop se detiene.')
print()
ifabs(respuesta**2 - objetivo) >= epsilon:
print(f'Nose encontro la raiz cuadrada {objetivo}')
else:
print(f'La raiz cuadrada de {objetivo} es {respuesta}')``````
Busqueda Binaria
objetivo = int(input('Escoge un numero: '))
print()
print(f'el numero {objetivo} lo guardamos enla variable objetivo')
epsilon = 0.01; print(f'Guardamos {epsilon} enla variable epsilon')
bajo = 0.0;print(f'Guardamos {bajo} enla variable bajo')
alto = max(1.0, objetivo);print(f'Si el objetivo, {objetivo}, es mayor que 1.0 se le asignará la variable alto. De lo contrario asignamos 1.0')
respuesta = (alto + bajo) / 2; print(f'El numero entre la variable bajo({bajo}) y la variable alto({alto}) es {respuesta} y se asignara a la variable respuesta.')
print()
print(f'Hasta ahora tenemos las variables: objetivo({objetivo}), epsilon({epsilon}), bajo({bajo}), alto({alto}) y respuesta({respuesta}).')
print()
whileabs(respuesta**2 - objetivo) >= epsilon:
print(f'Mientras quela respuesta({respuesta}) al cuadrado({respuesta**2}) menos el objetivo({objetivo}) sea mayor o igual que epsilon({epsilon}). Es decir, mientras queno sean casi el mismo numero 0.1 menos o 0.1 mas.')
if respuesta**2 < objetivo:
bajo = respuesta
print(f'Si la respuesta({respuesta}) al cuadrado({respuesta**2}) es menor que el objetivo({objetivo}). Asigna la respuesta a la variable bajo')
else:
alto = respuesta
print(f'Si la respuesta({respuesta}) no es menor que el objetivo({objetivo}). Asigna la respuesta a la variable alto')
respuesta = (alto + bajo) / 2
print(f'El calculo siguiente es sumar las variables alto({alto}) y bajo({bajo}). Dividirlas entre dos y asignarlas a la variable respuesta.')
print()
print(f'Las variables que tenemos son: objetivo({objetivo}), epsilon({epsilon}), bajo({bajo}), alto({alto}) y respuesta({respuesta}).')
print()
print(f'La raiz cuadrada del objetivo es {respuesta}')```
Funciones y Abstraccion
objetivo = int(input('Escoge un numero: '))
print()
print(f’el numero {objetivo} lo guardamos enla variable objetivo’)
epsilon = 0.01; print(f’Guardamos {epsilon} enla variable epsilon’)
bajo = 0.0;print(f’Guardamos {bajo} enla variable bajo’)
alto = max(1.0, objetivo);print(f’Si el objetivo, {objetivo}, es mayor que 1.0 se le asignará la variable alto. De lo contrario asignamos 1.0’)
respuesta = (alto + bajo) / 2; print(f’El numero entre la variable bajo({bajo}) y la variable alto({alto}) es {respuesta} y se asignara a la variable respuesta.’)
print()
print(f’Hasta ahora tenemos las variables: objetivo({objetivo}), epsilon({epsilon}), bajo({bajo}), alto({alto}) y respuesta({respuesta}).’)
print()
whileabs(respuesta2 - objetivo) >= epsilon:
print(f’Mientras quela respuesta({respuesta}) al cuadrado({respuesta2}) menos el objetivo({objetivo}) sea mayor o igual que epsilon({epsilon}). Es decir, mientras queno sean casi el mismo numero 0.1 menos o 0.1 mas.’)
if respuesta2 < objetivo:
bajo = respuesta
print(f’Si la respuesta({respuesta}) al cuadrado({respuesta2}) es menor que el objetivo({objetivo}). Asigna la respuesta a la variable bajo’)
else:
alto = respuesta
print(f’Si la respuesta({respuesta}) no es menor que el objetivo({objetivo}). Asigna la respuesta a la variable alto’)
respuesta = (alto + bajo) / 2
print(f'El calculo siguiente es sumar las variables alto({alto}) y bajo({bajo}). Dividirlas entre dos y asignarlas a la variable respuesta.')
print()
print(f'Las variables que tenemos son: objetivo({objetivo}), epsilon({epsilon}), bajo({bajo}), alto({alto}) y respuesta({respuesta}).')
print()
print(f’La raiz cuadrada del objetivo es {respuesta}’)```
Scope o Alcance
#Este es un pequeño programa para mejorar el conocimiento de Scope Global y Scope Local.print('Bienvenido a la lecciónde scope o alcance. Aquí trabajaras en tu definiciónde scope mediante ejercicios sencillos.')
print('Empecemos!!!')
print()
print('En primer lugar empezaremos en el Scope global.')
print()
print('El Scope global tiene:')
whileTrue:
opcion_1 = '1\. Una funcion con el nombre saludo'
opcion_2 = '2\. Una segunda funcion con el nombre usuario'
opcion_3 = '3\. Y una llamada a la funcion saludo'print(opcion_1);print(opcion_2);print(opcion_3)
print()
print('¿Cuál opcion crees que python tomará primero?(Por favor, inserte un numero)')
opcion = input('Numero: ')
print()
print(f'Usted a elegido la opción {opcion}')
if opcion == '3':
print('Bien hecho, su respuesta es correcta.')
print()
breakelse:
print('Esta opcion esta incorrecta. Vuela a intentarlo')
print(f'Ahora quela funcion saludo fue llamada, y recordando que tenemos: {opcion_1}, {opcion_2} y {opcion_3}, ¿en cuál Scope estamos?')
print()
whileTrue:
opcion_1 = '1\. Scope global'
opcion_2 = '2\. Scope localdela funcion saludo'
opcion_3 = '3\. Scope localdela funcion usuario'print(opcion_1);print(opcion_2);print(opcion_3)
print()
opcion = input('Numero: ')
print()
if opcion == '2':
print('Bien hecho, su respuesta es correcta.')
breakelse:
print('Esta opcion esta incorrecta. Vuela a intentarlo')
print()
whileTrue:
print('Ahora, dejeme preguntarle, si desde el Scope localdela función saludo entramos a la función usuario y luego volvemos a la funcion saludo, ¿cuál seria el scope?')
opcion_1 = '1\. Scope global'
opcion_2 = '2\. Scope localdela funcion saludo'
opcion_3 = '3\. Scope localdela funcion usuario'print(opcion_1);print(opcion_2);print(opcion_3)
print()
opcion = input('Numero: ')
print()
if opcion == '2':
print('Enorabuena, Usted a aprendido un poco más sobre Scope Global y Scope local!!!')
breakelse:
print('Esta opcion esta incorrecta. Vuela a intentarlo')``````
Especificaciones del codigo
def a(cualquier_parametro):
""“Descripcion de lo que hace nuestra funcion
cualquier_parametro int cualquier entero
returns cualquier_parametro + 5
"”"
return cualquier_parametro + 5
print(’#Asignamos la función a al scope global. Esta función tiene un parametro’)
print(’\t\t—’)
print(’\t\t |’)
print(’\t\t v’)
print(‘def a(cualquier_parametro):\n “”“Descripcion de lo que hace nuestra funcion\n cualquier_parametro int cualquier entero\n returns cualquier_parametro + 5\n “””\n return cualquier_parametro + 5’)
print(’\n\n#Agregamos un docstring o descripcion de la función.’)
print(‘Y usamos la función help para mostrar esta descripción’)
print(’\t\t—’)
print(’\t\t |’)
print(’\t\t v’)
help(a)``````
Recursividad
print('1# Definimos la función factorial con un parametro. En este caso n.')
print('\t-');print('\t|');print('\tv')
print('def factorial(n):')
print()
print('2# Agregamos el docstring')
print('\t -');print('\t |');print('\t v')
print("'''Calcula el factorial de n.\n n int > 0\n returns n!\n'''")
print()
print('3# Escribimos dentro dela función factorial la formula dela recursividad')
print('\t-');print('\t|');print('\tv')
print('ifn == 1:')
print(' return 1')
print()
print('returnn * factorial(n - 1)')
print()
print('###Y el resultado final seria:')
print()
print('def factorial(n):')
print(" '''Calcula el factorial de n.\n n int > 0\n returns n!\n '''")
print(' ifn == 1:')
print(' return 1')
print()
print(' returnn * factorial(n - 1)')```
Typlas
#las tuplas son secuencias inmutables de objetos
#las tuplas se pueden usar para devolver más de un valor
my_tuple = () #una tupla vacía se puede definir solamente con paréntesis
type(my_tuple) #Esto es para saber qué es de tipo tupla
#asignándoles valores de mi tupla
my_tuple = (1, ‘dos’, True) #reaccionando la tupla con valores de diferente tipo
#imprimiendo estos valores
print(my_tuple[0]) #esto debería imprimir el primer valor de mi tupla porque en programación al índice empieza en 0. En este caso sería el entero 1
print(my_tuple[1]) #en este caso se imprimiria el segundo valor de mi dupla Qué es la cadena ‘dos’.
#conociendo el error al intentar cambiar un valor asignado a mi tupla
#my_tuple[0] = 2 #A qué intentamos cambiar el primer valor, que sería el número 1, por el número 2.
#my_tuple = (1) #si podemos reasignar una tupla pero para que sea de tipo tupla necesita coma después del primer valor.
#type(my_tuple) #aquí diría que es un entero y no una tupla
my_other_tuple = (2, 3, 4) #Creamos otra tupla
my_tuple += my_other_tuple #Creamos un nuevo espacio de memoria con los valores de my_tuple y my_other_tuple. Y ponemos a la variable my_tuple a apuntar a ese espacio de memoria
my_tuple = (1, 2, 3)
variable_1, variable_2, variable_3 = my_tuple #si tengo una tupla de tres números yo puedo asignar esos numeros a tres variables diferente.
def coordenadas():
return (5, 4)
x, y = coordenadas()
print(x, y)
#aquí yo aprendí qué las tuplas las puedo usar para asignar una cierta cantidad de números a una cierta cantidad de variables y también puedo con las funciones devolver más de un número mediante tuplas```
Rangos
#los rangos al igual que las tuplas no se pueden modificar
#Structura
#range(comienzo, fin, pasos)
#ejemplo
my_range = range(1, 5)
type(my_range)
foriin my_range:
print(i)
print()#Aprendizaje: este rango o este for loop va desde uno hasta cuatro porque el último número no lo incluye
#Otros ejemplos
#El primero
my_range = range(0, 7, 2)
#El segundo
my_other_range = range(0,8,2)
#Comparando ambos ejemplos
my_range == my_other_range #Ambos ejemplos son iguales
#Explicacion: #Ambos ejemplos imprimen los mismos numeros
foriin my_range:
print(i)
print()
foriin my_other_range:
print(i)
#Algo nuevo que aprendi es a ver en que espacio de memoria se almacenan los valores asignados
#Esto se hace con la funcion id
#Ejemplo1
id_1 = id(my_range) #esta línea me da el ID donde se guarda el primer rango
print(id_1)#Ejemplo2
id_2 = id(my_other_range) #esta línea me da el ID donde se guarda el segundo rango
print(id_2)#Aprendizaje: Ambos ids son muy cercanos.
#Ejemplo3
variable = 'name'print(id(variable)) #En este caso el id de esta cadena está lejisimo de los rangos
#Aprendiendo otra función para diferenciar object equality usando --> is
comparando_objetos = my_range is my_other_range
print(comparando_objetos)#Ejercicio1:
#queremos imprimir todos los números pares del cero al 100
foriin range(0, 101, 2):
print(i)
#Aprendemos: al número que queremos que termine tenemos que agregarle 1. Por eso escribimos 101 para que sí llegué hasta el 100#Reto:imprime todos los números impares desde el 0 hasta el 100#En primer lugar debemos recordar que al valor en qué queremos que nuestro por lo termine tenemos que agregarle 1
foriin range(1, 101, 2):
print(i)```
Listas y mutabilidad
#Aquí voy a explorar las listas más a fondo
my_list = [1, 2, 3] #aquí estoy definiendo una lista con tres enteros
my_list_id = id(my_list) #luego estoy viendo el ID. Qué es el espacio en la memoria en la que se guarda mi lista
print(f’{my_list} \t#Esta es una lista con el ID: {my_list_id}’)
#una aplicación de las listas ver cada valor que contiene mediante sus índices
#ejemplo
my_list[0] #esto daría el primer valor también lista, qué sería el entero 1.
#aplicaciones de una lista
####[inicio:] #lo primero que tenemos es el inicio, dos puntos y un espacio vacío
#está lista irá desde el número que le digamos hasta el final de la lista
#ejemplo:
ejemplo = my_list[1:] #
print(f’{ejemplo} \t#Lista desde la indice 1 hasta el final.’) #esto va a imprimir desde el segundo valores de mi lista, que es el entero 2, hasta el último valor
####.append(el valor que quieres agregarle)
#Ejemplo:
my_list.append(4) #esta función agregaría el número el entero 4 al final de nuestra lista
print(f’{my_list} \t#Aqui tenemos la lista completa con el 4 que le agregamos usando append().’)
my_list[0] = 'a’
print(f"{my_list} \t#En este caso cambiamos el valor del indice 0, que era 1, por la cadena ‘a’")
###.pop()
#Ejemplo:
my_list.pop()
print(f’{my_list} \t#Usando el metodo pop le quitamos el ultimo valor a nuestra lista, en este caso el cuatro.’)
print(’\n#Usando un forloop para imprimir cada valor de mi lista’)
for element in my_list:
print(element)
a = [1,2,3]
b = a
print(id(a), id(b))
a.append(5) #A ambas listas se le agrega 5
print(a)
print(b)
c = [a,b]
print©
a = [1,2,3]
b = a
print(id(a))
print(id(b))
c = list(a) #Usando list podemos clonar una lista para que sus id sean diferente
print(id©)
#Otra forma de clonar una lista es:
d = a[::]
print(id(d))
#List comprehension
my_list = list(range(100)) #Arrecuerdate de agregar uno mas al numero que quieres que termine
print(my_list)
double = [i * 2 for i in my_list]
print(double)
pares = [i for i in my_list if i % 2 == 0] #Forma del video
pares = [i for i in my_list[0::2]] #Esta es otra forma de sacar numeros pares
print(pares)```
Diccionarios
#Diccionarios#Definición: Los diccionarios son similares a las listas. Pero para llamar los valores no se usa el indice sino las llaves.#Dato: Los diccionarios no tienen que ser copiados#Como crear un diccionario
my_dict = {
'David':35,
'Erika':32,
'Jaime':50,
}
#Como llamar el valor de un diccionario
print(my_dict['David'])
#Error cuando se usa la llave equivocada'''print(my_dict['davi'])'''#Como evitar este error
print(my_dict.get('davi', 30)) #Si la llave no existe, entonces me dará el valor que le ponga si no existe.
print(my_dict.get('David', 30)) #Si existe devolvería el valor que tiene en el diccionario.#Como reasignar(similar a cambiar) un valor a una llave de nuestro diccionario
my_dict['Jaime'] = 20#A la llave Jaime le cambiamos el valor de 50 a 20
print(my_dict)
#Como eliminar una llave de nuestro diccionariodel my_dict['Jaime'] #Aqui eliminamos la llave Jaime de nuestro diccionario.
print(my_dict)
#Como iterar o usar for loops en diccionariosfor llave in my_dict.keys():#Esto imprimiria las llaves en mi diccionario
print(llave)
for valor in my_dict.values():#Esto imprimiria los valores de mi diccionario
print(valor)
for llave, valor in my_dict.items(): #Esto imprimiria las llaves y valores de mi diccionario
print(llave, valor)
#Como saber si una llave esta en nuestro diccionario
print('David'in my_dict) #Esto deveria ser verdad
print('Tom'in my_dict) #Esto deberia ser falso. 'Tom' no existe en nuestro diccionario#Reto: Usar list comprehension pero con diccionarios#Entendiendo list comprehension#double = [i * 2 for i in my_list]#En el ejemplo se for loop en la lista de manera muy similar a como la usamos en un diccionario#En el diccionario deberia ser:
double = {valor * 2for valor in my_dict.values()}
print(double)
#Conclusion: fue bastante sencillo porque se logra de la misma manera que con las listas#Ejercicio personal: buscar en que ayudaria saber sobre los diccionarios#Quiero insertar mi información de estudiante en un diccionario
diccionario = {
'Nombre':'M.B.',
'Universidad':'C.C.',
'Materias': 4,
}
#Ya que tengo mi diccionario, lo siguieria imprimirlofor llave, valor in diccionario.items():
print(f'|{llave}: {valor}|')```
Pruebas de caja negra
#Caja negra
#¿Qué es la prueba de caja negra?
#Es la forma para que un module funcione solo y en conjunto con otros modulos.
#¿Qué se necesita para usar la prueba de caja negra? importar el unittest module y poner una clase con unittest.TestCase como parametro.
#Definir la función que queremos probar. Y usar self.assertEqual(El valor de la funcion, El valor que queremos obtener).
#Ya luego poner unittest.main() en un if name==‘main’ para inicializarlo.
#Ejemplo:
import unittest
def suma(num_1, num_2):
return num_1 + num_2
class CajaNegraTest(unittest.TestCase):
def test_suma_dos_positivos(self):
num_1 = 10
num_2 = 5
resultado = suma(num_1, num_2)
self.assertEqual(resultado, 15)
deftest_suma_dos_negativos(self):
num_1 = -10num_2 = -5resultado = suma(num_1, num_2)
self.assertEqual(resultado, -15)
if name==‘main’:
unittest.main()```
Ejercicio personal:
#Ejercicio Personal: Repetir el proceso de caja negra con modulus, una operación algo confusa para mi. Todo con el objetivo de obtener los valores primos de una lista y sumarlos.
import unittest
deflista(inicio, final):
my_list = list(range(inicio, final+1)) #Esta es laforma usada anteriormente de crear una lista con 100 numeros.
return my_list
deffiltrar_enteros():
enteros = [i for i in lista(int(input('El numero en el que empezará su lista: ')), int(input('El numero enque acabará su lista: '))) if i % 2 == 0]
return enteros
defsumar_lista():
empezar = 0
for i in filtrar_enteros():
empezar += i
return empezar
classCajaNegraTest(unittest.TestCase):
deftest_filtrar_valores_primos_de_una_lista(self):
resultado = sumar_lista()
print(resultado)
self.assertEqual(resultado, resultado)
if __name__=='__main__':
unittest.main()```
Manejo de excepciones
#Manejo de Excepciones
#Definición: Si el resultado de la funcion es un error, el ejecuta un segmento de codigo.
#Entre los cuales se puede poner el error para verlo más facilmente. Esto evita que nuestro programa deje de funcionar cuando se encuentre con estos errores.
def divide_elementos_de_lista(lista, divisor):
try:
return [i / divisor for i in lista]
except ZeroDivisionError as e:
print(e)
return lista
lista = list(range(10))
divisor = 0
print(divide_elementos_de_lista(lista, divisor))```
Este es un reto personal tratando de implementar algunas de las herramientas que eh aprendido de este curso incluyendo manejo de excepciones.
import unittest
definformacion_grado_de_estudiante():
notas_examen_y_participacion = {2:85, 3:80, 3:90}
return notas_examen_y_participacion
defnotas_de_examen():
examen = 0
foriin informacion_grado_de_estudiante().keys():
examen += i
return examen / len(informacion_grado_de_estudiante())
defnotas_de_participacion():
participacion = 0
foriin informacion_grado_de_estudiante().values():
participacion += i
return participacion / len(informacion_grado_de_estudiante())
defnotas_de_estudiantes():
notas_de_estudiantes = notas_de_examen() + notas_de_participacion()
return notas_de_estudiantes
defaverage_de_estudiantes():
return notas_de_estudiantes() / 2classCajaNegraTest(unittest.TestCase):
deftest_notas_de_estudiantes(self):
print(f'The student average grade is {average_de_estudiantes()}')
try:
self.assertGreaterEqual(average_de_estudiantes(), 50)
except AssertionError as e:
print(e)
if __name__=='__main__':
unittest.main()
Afirmaciones
#Afirmaciones#Si una condicion es falsa, un error sera disparado al usuario.
#Ejemplo:
#assert ,
defprimera_letra(lista_de_palabras):
primeras_letras = []
for palabra in lista_de_palabras:
assert type(palabra) == str, f'{palabra} nno es str'
assert len(palabra) > 0, 'No se permiten str vacios'
primeras_letras.append(palabra[0])
return primeras_letras
lista = ['hello', '', 'pedro']
primera_letra(lista)```
Reto personal
def divide(n, d):
assert d != 0, ‘Al dividir por cero nuestro resultado es indeterminado’
returnn / dnumerador = 5
denominador = 0
resultado = divide(numerador, denominador)
print(resultado)
