├── Cap5 ├── archivo1 ├── prueba_with ├── precios ├── archivo2 ├── Reporte_olimpico ├── __pycache__ │ ├── archivos.cpython-37.pyc │ ├── auxiliar.cpython-37.pyc │ ├── lecturas.cpython-37.pyc │ └── geometrico.cpython-37.pyc ├── palabras ├── juegos ├── Ejemplo 5_8.py ├── Ejemplo 5_4.py ├── Programa 5_14.py ├── Programa 5_11.py ├── Ejemplo 5_2.py ├── Ejemplo 5_6.py ├── Ejemplo 5_5.py ├── Ejemplo 5_9.py ├── Programa 5_13.py ├── Programa 5_12.py ├── Programa 5_2.py ├── geometrico.py ├── Programa 5_9.py ├── Programa 5_8.py ├── Programa 5_5.py ├── Programa 5_10.py ├── Programa 5_7.py ├── Programa 5_3.py ├── Programa 5_4.py ├── Ejemplo 5_7.py ├── Programa 5_15.py ├── Ejemplo 5_3.py ├── Ejemplo 5_1.py ├── lecturas.py ├── Programa 5_1.py ├── Programa 5_6.py ├── archivos.py └── auxiliar.py ├── Cap1 ├── Programa 1_1.py ├── Ejemplo 1_5.py ├── Ejemplo 1_2.py ├── Ejemplo 1_6.py ├── Ejemplo 1_1.py ├── Ejemplo 1_7.py ├── Ejemplo 1_4.py └── Ejemplo 1_3.py ├── Cap2 ├── Programa 2_1.py ├── Programa 2_15.py ├── Programa 2_2.py ├── Programa 2_6.py ├── Programa 2_3.py ├── Programa 2_9.py ├── Programa 2_12.py ├── Programa 2_4.py ├── Programa 2_16.py ├── Programa 2_5.py ├── Programa 2_7.py ├── Programa 2_8.py ├── Programa 2_11.py ├── Programa 2_10.py ├── Programa 2_13.py ├── Programa 2_14.py ├── Ejemplo 2_2.py ├── Ejemplo 2_3.py └── Ejemplo 2_1.py ├── Cap4 ├── Programa 4_5.py ├── Programa 4_7.py ├── Programa 4_1.py ├── Programa 4_9.py ├── Programa 4_35.py ├── Programa 4_6.py ├── Programa 4_13.py ├── Programa 4_33.py ├── Programa 4_23.py ├── Programa 4_18.py ├── Programa 4_19.py ├── Programa 4_16.py ├── Programa 4_10.py ├── Programa 4_25.py ├── Programa 4_21.py ├── Programa 4_2.py ├── Programa 4_31.py ├── Programa 4_40.py ├── Programa 4_17.py ├── Programa 4_8.py ├── Programa 4_22.py ├── Programa 4_32.py ├── Programa 4_12.py ├── Programa 4_11.py ├── Programa 4_28.py ├── Programa 4_36.py ├── Ejemplo 4_6.py ├── Programa 4_14.py ├── Programa 4_29.py ├── Programa 4_39.py ├── Ejemplo 4_5.py ├── Programa 4_3.py ├── Ejemplo 4_2.py ├── Programa 4_34.py ├── Programa 4_30.py ├── Programa 4_15.py ├── Programa 4_37.py ├── Programa 4_20.py ├── Ejemplo 4_3.py ├── Programa 4_38.py ├── Ejemplo 4_1.py ├── Programa 4_24.py ├── Programa 4_27.py ├── Programa 4_4.py ├── Programa 4_26.py ├── Ejemplo 4_4.py └── Ejemplo 4_7.py ├── Cap3 ├── Programa 3_1.py ├── Programa 3_12.py ├── Programa 3_8.py ├── Programa 3_2.py ├── Programa 3_3.py ├── Programa 3_5.py ├── Programa 3_7.py ├── Programa 3_16.py ├── Programa 3_22.py ├── Programa 3_4.py ├── Programa 3_6.py ├── Programa 3_14.py ├── Programa 3_10.py ├── Ejemplo 3_1.py ├── Programa 3_9.py ├── Programa 3_11.py ├── Programa 3_25.py ├── Programa 3_18.py ├── Programa 3_19.py ├── Programa 3_15.py ├── Programa 3_28.py ├── Programa 3_26.py ├── Ejemplo 3_2.py ├── Programa 3_21.py ├── Programa 3_13.py ├── Programa 3_24.py ├── Programa 3_27.py ├── Programa 3_20.py ├── Programa 3_23.py ├── Programa 3_17.py ├── Programa 3_29.py ├── Ejemplo 3_3.py └── Ejemplo 3_4.py └── README.md /Cap5/archivo1: -------------------------------------------------------------------------------- 1 | 12.5 2 | 5 3 | 4 4 | 0 5 | 8.7 6 | -2 7 | -------------------------------------------------------------------------------- /Cap5/prueba_with: -------------------------------------------------------------------------------- 1 | a 2 | b 3 | c 4 | d 5 | e 6 | f 7 | g 8 | -------------------------------------------------------------------------------- /Cap5/precios: -------------------------------------------------------------------------------- 1 | 12.5 2 | 8.3 3 | 98.45 4 | 10.45 5 | 11 6 | 24.3 7 | -------------------------------------------------------------------------------- /Cap5/archivo2: -------------------------------------------------------------------------------- 1 | 12.5 2 | 5 3 | hola 4 | 0 5 | 8.7 6 | -2 7 | True 8 | -------------------------------------------------------------------------------- /Cap5/Reporte_olimpico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ebookscg-python/Libro1-python/HEAD/Cap5/Reporte_olimpico -------------------------------------------------------------------------------- /Cap1/Programa 1_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | """ 5 | 6 | print("Mi primer programa en Python") -------------------------------------------------------------------------------- /Cap5/__pycache__/archivos.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ebookscg-python/Libro1-python/HEAD/Cap5/__pycache__/archivos.cpython-37.pyc -------------------------------------------------------------------------------- /Cap5/__pycache__/auxiliar.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ebookscg-python/Libro1-python/HEAD/Cap5/__pycache__/auxiliar.cpython-37.pyc -------------------------------------------------------------------------------- /Cap5/__pycache__/lecturas.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ebookscg-python/Libro1-python/HEAD/Cap5/__pycache__/lecturas.cpython-37.pyc -------------------------------------------------------------------------------- /Cap5/__pycache__/geometrico.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ebookscg-python/Libro1-python/HEAD/Cap5/__pycache__/geometrico.cpython-37.pyc -------------------------------------------------------------------------------- /Cap5/palabras: -------------------------------------------------------------------------------- 1 | los 2 | gatos 3 | son 4 | un 5 | amor 6 | con 7 | los 8 | niños 9 | de 10 | mis 11 | vecinos 12 | el 13 | gris 14 | es 15 | el 16 | mejor 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /Cap5/juegos: -------------------------------------------------------------------------------- 1 | 1984 los angeles 1984 2 | 1988 seul 1988 3 | 1992 barcelona 1992 4 | 1996 atlanta 1996 5 | 2000 sydney 2000 6 | 2004 atenas 2004 7 | 2008 beijing 2008 8 | 2012 londres 2012 9 | 2016 rio de janeiro 2016 -------------------------------------------------------------------------------- /Cap2/Programa 2_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.1 5 | Calcula e imprime el promedio de dos números enteros. 6 | """ 7 | 8 | entero1 = int(input('Ingrese un número entero: ')) 9 | entero2 = int(input('Ingrese un número entero: ')) 10 | promedio = (entero1 + entero2) / 2 11 | print('\nPromedio:', promedio) 12 | -------------------------------------------------------------------------------- /Cap4/Programa 4_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.5 5 | Calcula e imprime el valor de la serie: 6 | 1 + 1/1 + 1/2 + ...+ 1/n 7 | """ 8 | 9 | n = int(input('Ingrese el valor de n: ')) 10 | suma = 0 11 | for i in range(1, n + 1): 12 | suma += 1 / i 13 | print(f'El resultado de la serie es: {suma:.2f}') -------------------------------------------------------------------------------- /Cap3/Programa 3_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.1 5 | Dada la calificación de un alumno, luego de analizarla, se imprime 6 | un mensaje en caso de que sea aprobatoria. 7 | """ 8 | 9 | calificacion = float(input('\nIngrese la calificación del alumno: ')) 10 | if calificacion >= 6: 11 | print('\nAprobado', end = ':)') 12 | -------------------------------------------------------------------------------- /Cap4/Programa 4_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.7 5 | Calcula e imprime el resultado de la serie: 6 | 1**1 + 2**2 + 3**3 + … + n**n 7 | """ 8 | 9 | 10 | n = int(input('Ingrese el valor de n: ')) 11 | serie = 0 12 | for i in range(1, n + 1): 13 | serie += i ** i 14 | print(f'El resultado de la serie es: {serie}') -------------------------------------------------------------------------------- /Cap4/Programa 4_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.1 5 | Calcula e imprime la nómina que debe pagar una empresa por sus 10 empleados. 6 | """ 7 | 8 | nomina = 0 9 | for i in range (1, 11): 10 | sueldo = float(input(f'Ingrese el sueldo {i}: $')) 11 | nomina += sueldo 12 | print('\nLa nómina que debe pagarse es: $', nomina) 13 | -------------------------------------------------------------------------------- /Cap4/Programa 4_9.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.9 5 | Imprime un número de 4 dígitos, dígito por dígito, de derecha a izquierda. 6 | """ 7 | 8 | numero = int(input('Ingrese un número entero de 4 dígitos: ')) 9 | for _ in range(1, 5): 10 | digito = numero % 10 11 | print(digito, ' ', end = '') 12 | numero = numero // 10 13 | -------------------------------------------------------------------------------- /Cap3/Programa 3_12.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.12 5 | Dado un número entero, determina e imprime un mensaje indicando 6 | si el número es par o impar. 7 | """ 8 | 9 | entero = int(input('Ingrese un número entero: ')) 10 | if entero % 2 == 0: 11 | print('El número es par.'.center(40)) 12 | else: 13 | print('El número es impar.'.center(40)) 14 | -------------------------------------------------------------------------------- /Cap4/Programa 4_35.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.35 5 | Encuentra e imprime todos los pares de números que satisfacen 6 | la siguiente ecuación: 7 | p**4 + r**3 < 510 8 | """ 9 | 10 | p = 1 11 | r = 1 12 | while p** 4 + r ** 3 < 510: 13 | while p** 4 + r ** 3 < 510: 14 | print(f'{p} y {r} < 510') 15 | r += 1 16 | r = 1 17 | p += 1 -------------------------------------------------------------------------------- /Cap4/Programa 4_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.6 5 | Calcula e imprime la productoria para un número n > 0. 6 | """ 7 | 8 | n = int(input('Ingrese el valor de n: ')) 9 | producto = 1 10 | # A partir de 2: multiplicar por 1 no cambia el resultado. 11 | for i in range(2, n + 1): 12 | producto *= i 13 | print(f'El resultado de la productoria es: {producto:.2f}') -------------------------------------------------------------------------------- /Cap3/Programa 3_8.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.8 5 | Dada la calificación de un alumno, luego de analizarla, se imprime 6 | un mensaje indicando si el alumno aprobó o no. 7 | """ 8 | 9 | calificacion = float(input('\nIngrese la calificación del alumno: ')) 10 | if calificacion >= 6: 11 | print('\nAprobó', end = ':)') 12 | else: 13 | print('\nNo aprobó', end = ':(') 14 | -------------------------------------------------------------------------------- /Cap3/Programa 3_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.2 5 | Dado el sueldo actual de un empleado, si este es menor a $8000 6 | se incrementa en un 12% y, además, se imprime el nuevo sueldo. 7 | """ 8 | 9 | sueldo = float(input('Ingrese el sueldo del trabajador: $')) 10 | if sueldo < 8000: 11 | nuevo_sueldo = sueldo * 1.12 12 | print(f'\nEl nuevo sueldo es = ${nuevo_sueldo:.2f}') 13 | 14 | -------------------------------------------------------------------------------- /Cap3/Programa 3_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.3 5 | Calcula e imprime la temperatura ambiente en función del 6 | número de sonidos emitidos por un grillo. 7 | """ 8 | 9 | numero_sonidos = int(input('¿Número de sonidos del grillo? ')) 10 | if numero_sonidos >= 0: 11 | temperatura = 10 + (numero_sonidos - 40) / 7 12 | print(f'\nLa temperatura en grados Celsius es = {temperatura:.2f}°C') 13 | -------------------------------------------------------------------------------- /Cap2/Programa 2_15.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.15 5 | Obtiene e imprime la corriente de un circuito de corriente alterna, 6 | con base en el voltaje y la impedancia (E = IxZ). 7 | """ 8 | 9 | voltaje = complex(input('Ingrese el voltaje del circuito: ')) 10 | impedancia = complex(input('Ingrese la impedancia del circuito: ')) 11 | corriente = voltaje / impedancia 12 | print(f'\nLa corriente es: {corriente}') -------------------------------------------------------------------------------- /Cap2/Programa 2_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.2 5 | Imprime en orden inverso los 4 números leídos. 6 | """ 7 | 8 | entero1 = int(input('Ingrese un número entero: ')) 9 | entero2 = int(input('Ingrese un número entero: ')) 10 | entero3 = int(input('Ingrese un número entero: ')) 11 | entero4 = int(input('Ingrese un número entero: ')) 12 | print("\n", entero4, '\t', entero3, '\t', entero2, '\t', entero1) 13 | -------------------------------------------------------------------------------- /Cap3/Programa 3_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 3.5 5 | Determina si nos alcanza para pagar nuestro antojo en el cine. 6 | Si es así, imprime un mensaje adecuado. 7 | """ 8 | 9 | dinero_disponible = float(input('Ingrese el monto de dinero del que dispone: $')) 10 | antojo = 135 + 45 # El precio del sándwich y del refresco. 11 | if dinero_disponible >= antojo: 12 | print('\nSí nos alcanza:)') 13 | -------------------------------------------------------------------------------- /Cap4/Programa 4_13.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 4.13 5 | Genera e imprima la tabla de multiplicar desde 1 hasta el valor de un 6 | número ingresado por el usuario. 7 | """ 8 | 9 | numero = int(input('Ingrese un número entero: ')) 10 | print(f'\nTabla de multiplicar del {numero} hasta el {numero}\n'.upper()) 11 | for valor in range(1, numero + 1): 12 | print(f'{valor} x {numero} = {valor * numero:5d}') -------------------------------------------------------------------------------- /Cap2/Programa 2_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.6 5 | Calcula e imprime el área y el volumen de una esfera. 6 | """ 7 | 8 | import math # Módulo math para usar la constante π (pi) 9 | 10 | radio = float(input('Ingrese el radio de la esfera: ')) 11 | area = 4 * math.pi * radio ** 2 12 | volumen = math.pi * radio ** 3 / 3 13 | print(f'\nÁrea de la esfera = {area:5.2f}') 14 | print(f'Volumen de la esfera = {volumen:4.2f}') 15 | 16 | -------------------------------------------------------------------------------- /Cap4/Programa 4_33.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.33 5 | Genera una secuencia de números a partir de un número dado. 6 | """ 7 | 8 | valor = int(input('\nIngrese un número entero positivo: ')) 9 | if valor <= 0: 10 | print('\nError en el dato.'.upper()) 11 | else: 12 | for renglon in range(1, valor + 1): 13 | for numero in range(1, renglon + 1): 14 | print(numero, ' ', end = '') 15 | print() -------------------------------------------------------------------------------- /Cap4/Programa 4_23.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.23 5 | Calcula e imprime el cuadrado y el cubo de los números naturales 6 | ingresados hasta que se proporcione un número negativo. 7 | """ 8 | 9 | num_natural = int(input('Número -para calcular su cuadrado y su cubo: ')) 10 | while num_natural >= 0: 11 | print(f'{num_natural}, {num_natural ** 2}, {num_natural ** 3}') 12 | num_natural = int(input('Siguiente número (para terminar un negativo): ')) -------------------------------------------------------------------------------- /Cap3/Programa 3_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 3.7 5 | Determina si dos números dados satisfacen la expresión: 6 | p3 + q3 – 2*p*q2 < 970 7 | Si es así, se imprimen los valores de p y q. 8 | """ 9 | 10 | p = int(input('Ingrese el primer número: ')) 11 | q = int(input('Ingrese el segundo número: ')) 12 | resultado = p ** 3 + q ** 3 - 2 * p * q ** 2 13 | if resultado < 970: 14 | print(f'\nLos números {p} y {q} sí satisfacen la ecuación.') -------------------------------------------------------------------------------- /Cap5/Ejemplo 5_8.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 5_8 5 | Uso del módulo geometrico.py 6 | """ 7 | 8 | # Importa todo el módulo geometrico. 9 | import geometrico 10 | 11 | salon_l1 = 5.2 12 | salon_l2 = 6.5 13 | area_salon = geometrico.area_rectangulo(salon_l1, salon_l2) 14 | print(f'\nEl área del salón es = {area_salon:.2f} m2') 15 | 16 | radio_mesa = 1.0 17 | area_mesa = geometrico.area_circulo(radio_mesa) 18 | print(f'\nEl área de la mesa es = {area_mesa:.2f} m2') -------------------------------------------------------------------------------- /Cap2/Programa 2_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.3 5 | Calcula e imprime el perímetro y el área de un rectángulo. 6 | """ 7 | 8 | base = float(input('Ingrese la base del rectángulo: ')) 9 | altura = float(input('Ingrese la altura del rectángulo: ')) 10 | perimetro = 2 * (base + altura) 11 | area = base * altura 12 | perim_rect = 'Perímetro del rectángulo' 13 | area_rect = 'Área del rectángulo' 14 | print(f'\n{perim_rect} = {perimetro:8.2f} \n{area_rect} = {area:8.2f}') 15 | -------------------------------------------------------------------------------- /Cap4/Programa 4_18.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 4.18 5 | Calcula e imprime el factorial de un número entero positivo. 6 | """ 7 | 8 | numero = int(input('Ingrese un número entero positivo: ')) 9 | if numero > 0: 10 | factorial = 1 11 | for valor in range(numero, 1, -1): # Uso de un for decreciente. 12 | factorial *= valor 13 | print(f'El factorial de {numero} es = {factorial}') 14 | else: 15 | print(f'\nError en el dato.'.upper()) -------------------------------------------------------------------------------- /Cap3/Programa 3_16.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.16 5 | Calcula e imprime el valor de la función de acuerdo a los datos ingresados. 6 | """ 7 | 8 | k = int(input('Ingrese el valor de k: ')) 9 | x = float(input('Ingrese el valor de x: ')) 10 | if k == 1: 11 | resultado = x / 5 12 | elif k == 2 or k == 3: 13 | resultado = x ** 2 14 | elif k == 4: 15 | resultado = x ** 3 + 5 16 | else: 17 | resultado = x ** 0.5 18 | print(f'\nF(x) = {resultado:.2f}') 19 | -------------------------------------------------------------------------------- /Cap3/Programa 3_22.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.22 5 | Calcula e imprime el valor de f(x), dado como dato un número entero (x). 6 | """ 7 | 8 | x = int(input('Ingrese el valor de x (entero): ')) 9 | if x < 0 or x > 40: 10 | y = 0 11 | else: 12 | if x <= 10: 13 | y = 5 * x + 12 14 | elif x <= 20: 15 | y = x ** 2 16 | elif x <= 30: 17 | y = x ** 3 + 5 18 | else: 19 | y = x // 6 + x ** 2 20 | print(f'\nx = {x:d} --> f(x) = {y:d}') -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_5 5 | Uso de algunas de las secuencias de escape de Python. 6 | """ 7 | 8 | print("\nHola otoño") # Baja un renglón e imprime Hola otoño. 9 | print("\\Hola otoño") # Imprime \Hola otoño. 10 | print("Saludo: \t¡Hola otoño!") # Tabula horizontalmente e imprime Hola otoño. 11 | print("\"Hola otoño\"") # Imprime "Hola otoño". 12 | print("\'Hola otoño\'") # Imprime 'Hola otoño'. 13 | print("\aHola otoño") # Imprime Hola otoño y suena un timbre. 14 | -------------------------------------------------------------------------------- /Cap4/Programa 4_19.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.19 5 | Calcula e imprime la suma de los dígitos contenidos en una cadena. 6 | """ 7 | 8 | cadena_caracteres = input('Ingrese la cadena de caracteres: ') 9 | suma_digitos = 0 10 | for caracter in cadena_caracteres: 11 | try: 12 | suma_digitos += int(caracter) 13 | except ValueError: 14 | pass # Si no es un dígito, no hay nada que hacer. 15 | print(f'\nLa suma de los dígitos contenidos en la cadena es = {suma_digitos}') -------------------------------------------------------------------------------- /Cap4/Programa 4_16.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 4.16 5 | Calcula e imprime el resultado de la serie: 6 | 1 + 1/2 - 1/3 + ...(+ -) 1/n 7 | """ 8 | 9 | numero = int(input('Ingrese un número entero positivo: ')) 10 | if numero > 0: 11 | suma = 1 12 | signo = 1 13 | for valor in range(2, numero + 1): 14 | suma += 1 / valor * signo 15 | signo *= -1 16 | print(f'El resultado de la serie es = {suma:.2f}') 17 | else: 18 | print(f'\nError en el dato.'.upper()) -------------------------------------------------------------------------------- /Cap4/Programa 4_10.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.10 5 | Imprime, dígito por dígito, un número de 4 dígitos. 6 | """ 7 | 8 | numero = int(input('Ingrese un número entero de 4 dígitos: ')) 9 | if numero >= 1000 and numero <= 9999: 10 | denominador = 1000 11 | for _ in range(1, 5): 12 | digito = numero // denominador 13 | print(digito, ' ', end = '') 14 | numero = numero % denominador 15 | denominador //= 10 16 | else: 17 | print('El número ingresado no está en el rango esperado.') -------------------------------------------------------------------------------- /Cap4/Programa 4_25.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.25 5 | Calcula e imprime la serie generada a partir de la conjetura de Ulam. 6 | """ 7 | 8 | n = int(input('Ingrese un entero positivo: ')) 9 | if n <= 0: 10 | print('\nError en el dato.') 11 | else: 12 | print('\nNúmeros de la serie de Ulam:') 13 | while n != 1: 14 | print(n, ' ', end = '') 15 | if n % 2 == 0: 16 | n //= 2 17 | else: 18 | n = n * 3 + 1 19 | print(n) # El 1 no se imprime en el ciclo. 20 | -------------------------------------------------------------------------------- /Cap3/Programa 3_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.4 5 | Calcula e imprime el total a pagar por un cliente considerando que, si 6 | el monto de la compra es mayor a $3000, se le hará un descuento del 15%. 7 | """ 8 | 9 | compra = float(input('Ingrese el monto de la compra del cliente: $')) 10 | descuento = 0 11 | pago = compra 12 | if compra > 3000: 13 | descuento = compra * 0.15 14 | pago = compra - descuento 15 | print(f'\nCompra = ${compra:.2f} --> descuento = ${descuento:.2f}') 16 | print(f'Total a pagar = ${pago:.2f}') -------------------------------------------------------------------------------- /Cap3/Programa 3_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 3.6 5 | Determina si una persona tiene problemas de bajo peso usando el 6 | Indice de Masa Corporal. 7 | IMC = al peso dividido la estatura al cuadrado. 8 | Si es así, imprime un mensaje adecuado. 9 | """ 10 | 11 | peso = float(input('Ingrese el peso de la persona en kilos: ')) 12 | estatura = float(input('Ingrese la altura de la persona en metros: ')) 13 | IMC = peso / estatura ** 2 14 | if IMC < 18.5: 15 | print('\nSí tiene problemas de bajo peso. Busque ayuda.') 16 | -------------------------------------------------------------------------------- /Cap4/Programa 4_21.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.21 5 | Calcula e imprime el total gastado durante un viaje. 6 | No se conoce el total de compras y gastos por lo que, cuando ya no haya 7 | valores que ingresar, se dará un -1 (bandera de fin de datos). 8 | """ 9 | 10 | gasto = float(input('Ingrese el importe del gasto o de la compra: $')) 11 | suma_gastos = 0 12 | while gasto > 0: 13 | suma_gastos += gasto 14 | gasto = float(input('Ingrese el siguiente importe: $')) 15 | print(f'\nTotal gastado durante el viaje = ${suma_gastos:.2f}') -------------------------------------------------------------------------------- /Cap3/Programa 3_14.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 3.14 5 | Determina e imprime un mensaje indicando si el tercer dato dado 6 | está comprendido o no entre los otros dos. 7 | """ 8 | 9 | num1 = int(input('Ingrese el primer número: ')) 10 | num2 = int(input('Ingrese el segundo número: ')) 11 | num3 = int(input('Ingrese el tercer número: ')) 12 | if num3 >= num1 and num3 <= num2: 13 | print(f'\nEl {num3} está comprendido entre el {num1} y el {num2}.') 14 | else: 15 | print(f'\nEl {num3} no está comprendido entre el {num1} y el {num2}.') -------------------------------------------------------------------------------- /Cap3/Programa 3_10.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.10 5 | Calcula e imprime el total a pagar por un boleto de tren, considerando 6 | la distancia a recorrer y el número de días entre el viaje de ida y el 7 | de vuelta. 8 | """ 9 | 10 | distancia = float(input('Ingrese la distancia de punto a punto: ')) 11 | dias = int(input('Número de días entre el viaje de ida y vuelta: ')) 12 | if distancia * 2 > 500 and dias > 10: 13 | costo = distancia * 2 * 1.9 * 0.80 14 | else: 15 | costo = distancia * 2 * 1.9 16 | print(f'\nCosto del boleto= ${costo:.2f}') 17 | -------------------------------------------------------------------------------- /Cap4/Programa 4_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.2 5 | Calcula e imprime la suma y el promedio de n números enteros. 6 | """ 7 | 8 | n = int(input('Ingrese la cantidad de números a procesar: ')) 9 | suma = 0 10 | for i in range (1, n + 1): 11 | numero = int(input(f'Ingrese el número {i}: ')) 12 | suma += numero 13 | try: 14 | promedio = suma / n 15 | except ZeroDivisionError: 16 | print('\nNo es posible calcular el promedio.') 17 | else: 18 | print('\nSuma =', suma) 19 | print(f'Promedio = {promedio:.2f}') 20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /Cap4/Programa 4_31.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 4.31 5 | Calcula el valor de π con una precisión menor o igual a 0.0000001, 6 | utilizando la serie: 7 | π = 4/1 - 4/3 + 4/5 - 4/7 + 4/9-… 8 | """ 9 | 10 | import math 11 | print('\nValor de π dado por Python:', math.pi) 12 | 13 | valor_pi = 4 14 | termino = 4 15 | signo = -1 16 | denominador = 3 17 | while termino > 0.0000001: 18 | termino = 4 / denominador 19 | valor_pi += termino * signo 20 | signo *= -1 21 | denominador += 2 22 | print(f'\nEl valor de π calculado: {valor_pi}') -------------------------------------------------------------------------------- /Cap2/Programa 2_9.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | 4 | @author: guardati 5 | Solución del problema 2.9 6 | Calcula e imprime el equivalente en euros, dólares americanos, 7 | dólares canadienses y francos suizos de una cierta cantidad 8 | dada en pesos mexicanos. 9 | """ 10 | 11 | pesos = float(input('Ingrese precio de venta del auto: $')) 12 | euros = pesos * 0.045 13 | dolares_ame = pesos * 0.051 14 | dolares_can = pesos * 0.068 15 | francos_sui = pesos * 0.050 16 | print(f'Los ${pesos:10.2f} equivalen a: EUR{euros:10.2f}, U$S{dolares_ame:10.2f},' 17 | f' C${dolares_can:10.2f} y Fr{francos_sui:10.2f}') -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_1 5 | Alternativa de solución del problema 3.10 6 | 7 | Calcula e imprime el total a pagar por un boleto de tren, considerando 8 | la distancia a recorrer y el número de días entre el viaje de ida y el 9 | de vuelta. 10 | """ 11 | 12 | distancia = float(input('Ingrese la distancia de punto a punto: ')) 13 | dias = int(input('Número de días entre el viaje de ida y vuelta: ')) 14 | costo = distancia * 2 * 1.9 15 | if distancia * 2 > 500 and dias > 10: 16 | costo = costo * 0.80 17 | print(f'\nCosto del boleto= ${costo:.2f}') 18 | -------------------------------------------------------------------------------- /Cap2/Programa 2_12.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.12 5 | Codifica una frase llevando sus dos primeros caracteres 6 | al final y dejando la frase solo con minúsculas. 7 | """ 8 | 9 | frase = input('Ingrese la frase: ') 10 | frase_minusculas = frase.lower() # Pasa la frase a minúsculas. 11 | # Extrae los 2 primeros caracteres. 12 | dos_primeras_letras = frase_minusculas[0:2] 13 | resto = frase_minusculas[2:] # Extrae el resto de la frase. 14 | # Concatena las 2 cadenas obtenidas. 15 | codificada = resto + dos_primeras_letras 16 | print('\nLa frase codificada es:', codificada) 17 | -------------------------------------------------------------------------------- /Cap2/Programa 2_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.4 5 | Calcula e imprime el área de un triángulo por medio de la fórmula de Herón. 6 | """ 7 | # Módulo math necesario para calcular la raíz cuadrada (sqrt). 8 | import math 9 | 10 | lado1 = float(input('Ingrese el primer lado del triángulo: ')) 11 | lado2 = float(input('Ingrese el segundo lado del triángulo: ')) 12 | lado3 = float(input('Ingrese el tercer lado del triángulo: ')) 13 | sp = (lado1 + lado2 + lado3) / 2 14 | area = math.sqrt(sp * (sp-lado1) * (sp-lado2) * (sp-lado3)) 15 | print(f'\nEl área del triángulo es = {area:.2f}') 16 | -------------------------------------------------------------------------------- /Cap3/Programa 3_9.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.9 5 | Dado el sueldo actual de un empleado, si este es menor a $8000 6 | se incrementa un 12%. En caso contrario, el incremento 7 | es del 8%. Una vez determinado y calculado el aumento se imprime 8 | junto con el nuevo sueldo. 9 | """ 10 | 11 | sueldo = float(input('Ingrese el sueldo del trabajador: $')) 12 | if sueldo < 8000: 13 | aumento = sueldo * 0.12 14 | else: 15 | aumento = sueldo * 0.08 16 | nuevo_sueldo = sueldo + aumento 17 | print(f'\nAumento = ${aumento:.2f} y nuevo sueldo = ${nuevo_sueldo:.2f}') 18 | 19 | -------------------------------------------------------------------------------- /Cap4/Programa 4_40.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 4.40 5 | Encuentra e imprime todas las ternas de números que 6 | satisfacen la siguiente ecuación: 7 | 4 * x**4 + 2 * y**3 + z**3 < 6321 8 | """ 9 | 10 | x = 1 11 | y = 1 12 | z = 1 13 | while 4 * x ** 4 + 2 * y ** 3 + z ** 3 < 6321: 14 | while 4 * x ** 4 + 2 * y ** 3 + z ** 3 < 6321: 15 | while 4 * x ** 4 + 2 * y ** 3 + z ** 3 < 6321: 16 | print(f'{x} - {y} - {z} < 6321') 17 | z += 1 18 | z = 1 19 | y += 1 20 | z = 1 21 | y = 1 22 | x += 1 23 | 24 | 25 | -------------------------------------------------------------------------------- /Cap2/Programa 2_16.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | """ 5 | 6 | # Solución del problema 2.16 7 | pais = int(input('Ingrese el prefijo del país: ')) 8 | ciudad = int(input('Ingrese el prefijo de la ciudad: ')) 9 | numero = int(input('Ingrese el número: ')) 10 | numero_telefonico = (pais, ciudad, numero) 11 | print('\nEl número telefónico es:', numero_telefonico) 12 | 13 | # Solución del problema 2.17 14 | dia = int(input('Ingrese el día: ')) 15 | mes = int(input('Ingrese el mes (1 a 12): ')) 16 | anio = int(input('Ingrese el año: ')) 17 | fecha = (anio, mes, dia) 18 | print('\nLa fecha es:', fecha) 19 | 20 | -------------------------------------------------------------------------------- /Cap2/Programa 2_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.5 5 | Calcula e imprime la distancia entre dos puntos. 6 | """ 7 | 8 | import math # Módulo math para usar la función raíz cuadrada (sqrt). 9 | 10 | x1 = float(input('Ingrese la coordenada x del primer punto: ')) 11 | y1 = float(input('Ingrese la coordenada y del primer punto: ')) 12 | x2 = float(input('Ingrese la coordenada x del segundo punto: ')) 13 | y2 = float(input('Ingrese la coordenada y del segundo punto: ')) 14 | distancia = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2) 15 | print(f'\nLa distancia entre los puntos es: {distancia:.2f}') 16 | 17 | -------------------------------------------------------------------------------- /Cap5/Ejemplo 5_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 5_4 5 | Alcance de variables. 6 | """ 7 | 8 | def func1(x): 9 | x = x + 2 # Se modifica el valor del parámetro formal. 10 | print(f'Desde func1, el valor de x = {x}') 11 | 12 | def func2(): 13 | x = 'rojo' # x es variable local a la función. 14 | z = x + 'blanco' 15 | print(f'Desde func2, el valor de x = {x}') 16 | print(f'Desde func2, el valor de z = {z}') 17 | 18 | x = 5 19 | print(f'Valor de x = {x}') # Imprime 5 20 | func1(x) 21 | print(f'Valor de x = {x}') # Imprime 5 22 | func2() 23 | print(f'Valor de x = {x}') # Imprime 5 -------------------------------------------------------------------------------- /Cap5/Programa 5_14.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.17 5 | Calcula, con la ayuda de la función calcula_edad(), e imprime la edad 6 | de una persona a partir de su fecha de nacimiento. 7 | """ 8 | 9 | import auxiliar 10 | 11 | fecha_nac = input('\nIngrese fecha de nacimiento (dd/mm/aaaa): ') 12 | pos = fecha_nac.index('/') 13 | dia = int(fecha_nac[0:pos]) 14 | fecha_nac = fecha_nac[pos + 1:] 15 | pos = fecha_nac.index('/') 16 | mes = int(fecha_nac[0:pos]) 17 | anio = int(fecha_nac[pos + 1:]) 18 | edad = auxiliar.calcula_edad((dia, mes, anio)) 19 | print('\nAños cumplidos al día de hoy:', edad) 20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /Cap4/Programa 4_17.py: -------------------------------------------------------------------------------- 1 | 2 | # -*- coding: utf-8 -*- 3 | """ 4 | 5 | @author: guardati 6 | Solución del problema 4.17 7 | Calcula e imprime la suma de los números impares comprendidos entre 39 y 181. 8 | Note que en este problema no se ingresan datos. 9 | """ 10 | 11 | suma_impares = 0 12 | ''' 13 | En el for se usa un incremento de 2 lo cual resulta en que la variable numero 14 | es siempre un número impar: 39, 41, 43, etc. De esta manera evitamos evaluar si 15 | el número es o no impar adentro del for. 16 | ''' 17 | for numero in range(39, 182, 2): 18 | suma_impares += numero 19 | print(f'\nLa suma de los impares entre 39 y 181 es = {suma_impares}') -------------------------------------------------------------------------------- /Cap2/Programa 2_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.7 5 | Calcula e imprime el área de un triángulo. 6 | """ 7 | 8 | x1 = float(input('Ingrese la coordenada x del primer punto: ')) 9 | y1 = float(input('Ingrese la coordenada y del primer punto: ')) 10 | x2 = float(input('Ingrese la coordenada x del segundo punto: ')) 11 | y2 = float(input('Ingrese la coordenada y del segundo punto: ')) 12 | x3 = float(input('Ingrese la coordenada x del tercer punto: ')) 13 | y3 = float(input('Ingrese la coordenada y del tercer punto: ')) 14 | area = abs(x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0 15 | print(f'\nÁrea del triángulo: {area:.2f}') -------------------------------------------------------------------------------- /Cap3/Programa 3_11.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.11 5 | Calcula e imprime el resultado de dos expresiones aritméticas, 6 | siempre que el cuarto dato sea diferente de 0. 7 | """ 8 | 9 | print('\nIngrese cuatro números enteros: ') 10 | n1 = int(input()) 11 | n2 = int(input()) 12 | n3 = int(input()) 13 | n4 = int(input()) 14 | if n4 != 0: 15 | resultado1 = (n1 - n2) ** 3 / n4 16 | resultado2 = (n2 * n3) ** 5 / n4 17 | print(f'\nResultado primera expresión= {resultado1:.2f}') 18 | print(f'\nResultado segunda expresión= {resultado2:.2f}') 19 | else: 20 | print('\n¡El cuarto número debe ser distinto de 0!'.upper()) 21 | -------------------------------------------------------------------------------- /Cap5/Programa 5_11.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.14 5 | Obtiene e imprime los primeros n (n > 0) números primos cuya representación 6 | binaria es un palíndromo. 7 | """ 8 | import auxiliar 9 | 10 | n = int(input('\n¿Cuántos primos con notación binaria palíndroma quiere calcular? ')) 11 | contador = 0 12 | numero = 3 # Se descartan los números pares. 13 | while contador < n: 14 | if auxiliar.es_primo(numero): 15 | binario = auxiliar.convierte_a_binario(numero) 16 | if auxiliar.es_palindromo(binario): 17 | print(numero, '-', binario) 18 | contador += 1 19 | numero += 2 20 | 21 | 22 | -------------------------------------------------------------------------------- /Cap4/Programa 4_8.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.8 5 | Calcula e imprime: 6 | - el término número doceavo de la serie de Fibonacci. 7 | - la suma de los primeros doce términos de la serie de Fibonacci. 8 | """ 9 | 10 | fibo_ant1 = 0 11 | fibo_ant2 = 1 12 | suma_terminos = fibo_ant2 13 | for _ in range(3, 13): # Llega hasta el 12. 14 | fibonacci = fibo_ant1 + fibo_ant2 15 | suma_terminos += fibonacci 16 | fibo_ant1 = fibo_ant2 17 | fibo_ant2 = fibonacci 18 | print('\nTérmino 12 de la serie de Fibonacci:', fibonacci) 19 | print('Suma de los primeros 12 términos de la serie de Fibonacci:', suma_terminos) 20 | 21 | -------------------------------------------------------------------------------- /Cap4/Programa 4_22.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.22 5 | Genera e imprime los términos de la serie: 6 | 1 5 8 12 15 19 22 26 29 … 3100 (o el menor que corresponda) 7 | También imprime la suma de esos términos. 8 | """ 9 | 10 | termino = 1 # Siempre empieza en 1. 11 | # Se va a generar a partir del segundo término. 12 | suma_terminos = termino 13 | suma4 = True 14 | while termino <= 3100: 15 | print(termino,' ', end = '') 16 | if suma4: 17 | termino += 4 18 | else: 19 | termino += 3 20 | suma_terminos += termino 21 | suma4 = not suma4 22 | print(f'\nLa suma de los términos es = {suma_terminos}') 23 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Libro1-python 2 | Código de los ejemplos y problemas presentados en el libro: "De cero al infinito. Aprende a programar en Python". 3 | 4 | Problemas: 5 | Se sugiere al lector revisar las soluciones almacenadas en este repositorio una vez desarrollada la propia solución 6 | para que el código visto no condicione su manera de resolver los problemas. 7 | En aquellos problemas en los cuales no pueda avanzar en el diseño e implementaión de un algoritmo propio, revisar la 8 | solución propuesta puede ser de gran ayuda. 9 | 10 | En el caso de los ejemplos, se sugiere ejecutarlos y, además, probar todas las variantes que se le ocurra para, 11 | de esta manera, despejar dudas y afianzar los conceptos. 12 | -------------------------------------------------------------------------------- /Cap4/Programa 4_32.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.32 5 | Encuentra e imprime todos los números perfectos comprendidos 6 | entre 1 y un valor dado por el usuario. 7 | """ 8 | 9 | valor = int(input('\nIngrese un número entero positivo: ')) 10 | if valor <= 0: 11 | print('\nError en el dato.'.upper()) 12 | else: 13 | for numero in range(1, valor + 1): 14 | suma_divisores = 0 15 | limite = numero // 2 + 1 16 | for divisor in range(1, limite): 17 | if numero % divisor == 0: 18 | suma_divisores += divisor 19 | if numero == suma_divisores: 20 | print('Número perfecto:', numero) -------------------------------------------------------------------------------- /Cap4/Programa 4_12.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.12 5 | Determina e imprime si un número es perfecto o no. 6 | Se dice que un número es perfecto si la suma de todos sus divisores, 7 | excepto el mismo, es igual al número. 8 | """ 9 | 10 | numero = int(input('Ingrese un número entero positivo: ')) 11 | suma_divisores = 0 12 | limite = numero // 2 + 1 # El posible divisor más grande. 13 | for divisor in range(1, limite): 14 | if numero % divisor == 0: 15 | suma_divisores += divisor 16 | if numero == suma_divisores: 17 | print('\nEl número', numero, 'es un número perfecto.') 18 | else: 19 | print('\nEl número', numero, 'no es un número perfecto.') -------------------------------------------------------------------------------- /Cap2/Programa 2_8.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.8 5 | Calcula e imprime el total de: yardas, rods cuadrados, acres, 6 | homesteads y millas cuadradas que equivalen una cierta cantidad de hectáreas. 7 | """ 8 | 9 | ha = float(input('Ingrese total de hectáreas de la estancia: ')) 10 | yarda2 = ha * 10000 / 0.83612736 11 | rod2 = yarda2 / 30.25 12 | acre = rod2 / 160 13 | homestead = acre / 160 14 | milla2 = homestead / 4 15 | print('\nLa estancia tiene:'.upper()) 16 | print(f'{yarda2:14.2f} yardas cuadradas') 17 | print(f'{rod2:14.2f} rods cuadrados') 18 | print(f'{acre:14.2f} acres') 19 | print(f'{homestead:14.2f} homesteads') 20 | print(f'{milla2:14.2f} millas cuadradas') 21 | -------------------------------------------------------------------------------- /Cap3/Programa 3_25.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 3.25 5 | Calcula e imprime el bono anual a pagar a un empleado de una empresa de 6 | producción de lácteos. 7 | El bono se calcula de acuerdo a la antigüedad y al sueldo del empleado. 8 | """ 9 | 10 | sueldo = float(input('Ingrese el sueldo del empleado: $')) 11 | antiguedad = int(input('Ingrese la antigüedad del empleado (en años): ')) 12 | bono = sueldo * antiguedad 13 | if antiguedad <= 10: 14 | bono *= 0.06 15 | elif antiguedad <= 20: 16 | bono *= 0.065 17 | else: 18 | bono *= 0.07 19 | if antiguedad > 30: 20 | bono += sueldo * 0.22 21 | print(f'\nBono anual = ${bono:.2f}') 22 | -------------------------------------------------------------------------------- /Cap3/Programa 3_18.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.18 5 | Calcula e imprime el total a pagar por una llamada telefónica 6 | internacional, la cual se cobra de acuerdo a la región a la cual 7 | se llamó y a la duración de la misma. 8 | """ 9 | 10 | clave = int(input('Ingrese la clave del área geográfica: ')) 11 | duracion = int(input('Ingrese la duración en número de minutos: ')) 12 | if clave == 12: 13 | costo = 9 14 | elif clave == 15: 15 | costo = 8 16 | elif clave == 21: 17 | costo = 16 18 | elif clave == 23: 19 | costo = 19 20 | elif clave == 29: 21 | costo = 24 22 | costo *= duracion 23 | print(f'\nTotal a pagar por la llamada = ${costo:.2f}') 24 | -------------------------------------------------------------------------------- /Cap4/Programa 4_11.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.11 5 | Genera el número espejo de un número de 5 dígitos: a partir del dato dado 6 | se obtiene otro número con sus dígitos colocados de derecha a izquierda. 7 | """ 8 | 9 | numero = int(input('Ingrese un número entero positivo de 5 dígitos: ')) 10 | if numero >= 10000 and numero <= 99999: 11 | nuevo_numero = 0 12 | temporal = numero 13 | for _ in range(1, 6): 14 | digito = temporal % 10 15 | nuevo_numero = nuevo_numero * 10 + digito 16 | temporal = temporal // 10 17 | print(f'\n{numero} --> {nuevo_numero}') 18 | else: 19 | print('\nEl dato no está dentro del rango esperado.') -------------------------------------------------------------------------------- /Cap4/Programa 4_28.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.28 5 | Encuentra e imprime el MCD (máximo común divisor) 6 | de dos números enteros positivos. 7 | """ 8 | 9 | 10 | numero1 = int(input('\nIngrese el primer número entero positivo: ')) 11 | numero2 = int(input('Ingrese el segundo número entero positivo: ')) 12 | bandera = True 13 | mcd = 1 14 | if numero1 >= numero2: 15 | divisor = numero2 // 2 16 | else: 17 | divisor = numero1 // 2 18 | while bandera and divisor >= 1: 19 | if numero1 % divisor == 0 and numero2 % divisor == 0: 20 | mcd = divisor 21 | bandera = not bandera 22 | divisor -= 1 23 | print(f'\nEl MCD de {numero1} y {numero2} es: {mcd}') -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_2 5 | Impresiones en Python, usando métodos de las cadenas. 6 | """ 7 | 8 | # Pasa a mayúscula la primera letra. 9 | print("los días son cortos".capitalize()) 10 | # Centra considerando 20 espacios. 11 | print("Primavera".center(20)) 12 | # Centra y rellena con * a izquierda y derecha. 13 | print("Primavera".center(20,'*')) 14 | print("Primavera".ljust(20)) # Justifica a izquierda. 15 | # Justifica a izquierda y rellena con * a derecha. 16 | print("Primavera".ljust(20, '*')) 17 | print("Primavera".rjust(20)) # Justifica a derecha. 18 | # Justifica a derecha y rellena con * a izquierda. 19 | print("Primavera".rjust(20, '*')) 20 | 21 | -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_6 5 | 6 | Ejemplos de tipado automático de variables. 7 | Las 2 variables usadas tienen un tipo asociado, dependiendo del valor asignado. 8 | """ 9 | 10 | numero = 45 # Se asigna un valor entero. 11 | print('\nVariable \"numero\" es de tipo: ', type(numero)) 12 | 13 | numero = 45.16 # Se asigna un valor real. 14 | print('¡Cambió! Ahora \"numero\" es de tipo: ', type(numero)) 15 | 16 | nombre_mascota = "Charrúa" # Se asigna una cadena de caracteres. 17 | print('\nVariable \"nombre_mascota\" de tipo: ',type(nombre_mascota)) 18 | 19 | nombre_mascota = True # Se asigna un valor booleano. 20 | print('¡Cambió! Ahora \"nombre_mascota\" es de tipo: ', type(nombre_mascota)) -------------------------------------------------------------------------------- /Cap3/Programa 3_19.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 3.19 5 | Calcula e imprime el precio de venta de una obra de arte. 6 | Este precio se calcula incrementando el precio establecido por el 7 | dueño en un cierto porcentaje según la técnica empleada. 8 | """ 9 | 10 | precio = float(input('Ingrese el precio base: $')) 11 | tecnica = input('Ingrese la técnica usada: ') 12 | tecnica = tecnica.lower() 13 | if tecnica == 'óleo': 14 | porcentaje = 0.25 15 | elif tecnica == 'acuarela': 16 | porcentaje = 0.2 17 | elif tecnica == 'gouache': 18 | porcentaje = 0.18 19 | else: 20 | porcentaje = 0.1 21 | precio_venta = precio + precio * porcentaje 22 | print(f'\nPrecio de venta de la obra de arte = ${precio_venta:.2f}') -------------------------------------------------------------------------------- /Cap4/Programa 4_36.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.36 5 | Genera e imprime una secuencia de números con la forma: 6 | 7 | 1 8 | 1 2 1 9 | 1 2 3 2 1 10 | 1 2 3 4 3 2 1 11 | 1 2 3 4 5 4 3 2 1 12 | 1 2 3 4 5 6 5 4 3 2 1 13 | 1 2 3 4 5 6 7 6 5 4 3 2 1 14 | """ 15 | 16 | 17 | limite = int(input('\nIngrese un número entero positivo: ')) 18 | if limite <= 0: 19 | print('\nError en el dato.') 20 | else: 21 | for numero in range(1, limite + 1): 22 | for valor in range(1, numero + 1): 23 | print(valor, ' ', end = '') 24 | for valor in range(numero - 1, 0, -1): 25 | print(valor, ' ', end = '') 26 | print() # Provoca un salto de línea. -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 4_6 5 | Ciclo for con tuplas y uso del operador walrus. 6 | """ 7 | 8 | # Se define una tupla formada por números enteros. 9 | numeros = (5, 12, 4, 18, 11, 3, 24, 8, 5, 20) 10 | 11 | # Se itera sobre todos los elementos de la tupla. 12 | # Operador := válido a partir de Python 3.8. 13 | for num in numeros: 14 | if (cuadrado := num ** 2) > 100: # A la variable cuadrado le asigna el cuadrado de num. 15 | print(f'El cuadrado de {num} = {cuadrado} es mayor a 100.') 16 | 17 | # Equivalente a escribir: 18 | for num in numeros: 19 | cuadrado = num ** 2 20 | if cuadrado > 100: 21 | print(f'El cuadrado de {num} = {cuadrado} es mayor a 100.') 22 | 23 | -------------------------------------------------------------------------------- /Cap4/Programa 4_14.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 4.14 5 | Obtiene e imprime el total de divisores que tiene un número entero. 6 | """ 7 | 8 | numero = int(input('Ingrese un número entero positivo: ')) 9 | if numero > 0: 10 | cuenta_divisores = 1 # El 1 divide a todos los números. 11 | limite = numero // 2 + 1 12 | for divisor in range(2, limite): # Se empieza a partir de 2. 13 | if numero % divisor == 0: 14 | cuenta_divisores += 1 15 | if numero > 1: 16 | cuenta_divisores += 1 # Cuenta al mismo número como 1 de sus divisores. 17 | print(f'\nTotal de divisores de {numero} es = {cuenta_divisores}') 18 | else: 19 | print('\nSe espera un número positivo') -------------------------------------------------------------------------------- /Cap4/Programa 4_29.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.29 5 | Encuentra e imprime el mínimo común múltiplo (mcm) de dos 6 | números enteros positivos. 7 | """ 8 | 9 | numero1 = int(input('\nIngrese el primer número entero positivo: ')) 10 | numero2 = int(input('Ingrese el segundo número entero positivo: ')) 11 | if numero1 > 0 and numero2 > 0: 12 | if numero1 >= numero2: 13 | mcm = numero1 * 2 14 | numero = numero1 15 | else: 16 | mcm = numero2 * 2 17 | numero = numero2 18 | while mcm % numero1 != 0 or mcm % numero2 != 0: 19 | mcm += numero 20 | print(f'\nEl mcm de {numero1} y {numero2} es = {mcm}') 21 | else: 22 | print('Los datos ingresados no son números positivos.') -------------------------------------------------------------------------------- /Cap2/Programa 2_11.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 2.11 5 | Calcula e imprime el total de plántulas de lechuga que pueden 6 | plantarse en una huerta, considerando los espacios que debe haber 7 | entre cada planta y entre cada línea. 8 | """ 9 | 10 | metros_ancho = float(input('Ingrese total de metros de ancho de la huerta: ')) 11 | metros_largo = float(input('Ingrese total de metros de largo de la huerta: ')) 12 | total_lineas = metros_ancho / 0.3 # Se dejan 30 cm entre cada línea 13 | total_plant_por_linea = metros_largo / 0.25 # Se dejan 25 cm entre cada plántula 14 | total_plantulas = int(total_lineas * total_plant_por_linea) # Se convierte a entero 15 | print(f'\nTotal de plántulas que pueden plantarse en el huerto = {total_plantulas}') -------------------------------------------------------------------------------- /Cap5/Ejemplo 5_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 5_2 5 | Parámetros de tipos inmutables. 6 | """ 7 | 8 | # Parámetro numérico (inmutable). 9 | def f1(numero): 10 | numero = numero ** 2 11 | print("\nNúmero desde f1:", numero) 12 | 13 | # Parámetro cadena de caracteres (inmutable). 14 | def f2(cadena): 15 | cadena = cadena.upper() 16 | print("\nFrase desde f2:", cadena) 17 | 18 | # ======================================================== 19 | # Pruebas de las funciones. 20 | # ======================================================== 21 | numero = 5 22 | f1(numero) 23 | print("Número luego de llamar a f1:", numero) 24 | frase = 'hoy es un día soleado' 25 | f2(frase) 26 | print("Frase luego de llamar a f2:", frase) 27 | -------------------------------------------------------------------------------- /Cap5/Ejemplo 5_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 5_6 5 | Lista arbitraria de parámetros. 6 | """ 7 | 8 | def imprime(*args): 9 | """ Imprime los valores recibidos. 10 | 11 | Parámetro: 12 | *args: cero o varios valores. 13 | """ 14 | print('Esto recibí:', args) 15 | 16 | # ======================================================== 17 | # Pruebas de la función. 18 | # ======================================================== 19 | # No se pasan parámetros. 20 | imprime() 21 | # Se pasan 3 cadenas de caracteres. 22 | imprime('rojo', 'verde', 'azul') 23 | # Se pasan 4 números reales. 24 | imprime(12.50, 89.50, 30.20, 22.35) 25 | # Se pasan 4 datos de diferentes tipos. 26 | imprime(True, 16, -45.8, 'hola') 27 | 28 | -------------------------------------------------------------------------------- /Cap5/Ejemplo 5_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 5_5 5 | Documentación de funciones, tipo "docstring". 6 | """ 7 | 8 | def calcula_factorial(numero): 9 | """Calcula el factorial de un número. 10 | 11 | Parámetro: 12 | numero: es un número de tipo int y debe ser > 0. 13 | Regresa: 14 | El factorial del número recibido. 15 | """ 16 | factorial = 1 17 | for valor in range(2, numero + 1): 18 | factorial *= valor 19 | return factorial 20 | 21 | 22 | # Para consultar la documentación de la función. 23 | print(calcula_factorial.__doc__) 24 | 25 | # Ejemplo de uso de la función. 26 | n = int(input('Ingrese un número entero positivo: ')) 27 | print(f'El factorial de {n} es = {calcula_factorial(n)}') -------------------------------------------------------------------------------- /Cap3/Programa 3_15.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.15 5 | Dados el nivel y el sueldo de un trabajador, calcula el aumento 6 | que le corresponde -de acuerdo a su nivel- e imprime el nivel, 7 | sueldo anterior y nuevo sueldo. 8 | """ 9 | 10 | nivel = int(input('Ingrese el nivel del trabajador: 1..4: ')) 11 | sueldo = float(input('Ingrese el sueldo del trabajador: $')) 12 | if nivel == 1: 13 | nuevo_sueldo = sueldo * 1.12 14 | elif nivel == 2: 15 | nuevo_sueldo = sueldo * 1.08 16 | elif nivel == 3: 17 | nuevo_sueldo = sueldo * 1.05 18 | elif nivel == 4: 19 | nuevo_sueldo = sueldo * 1.038 20 | else: 21 | nuevo_sueldo = sueldo 22 | print('\nNivel:', nivel) 23 | print(f'Sueldo anterior = ${sueldo:.2f}\nNuevo sueldo = ${nuevo_sueldo:.2f}') -------------------------------------------------------------------------------- /Cap3/Programa 3_28.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.28 5 | Determina e imprime si un empleado es candidato o no para hacerse 6 | cargo de un puesto dentro de la empresa. 7 | """ 8 | 9 | clave = input('Ingrese clave del empleado: ') 10 | categoria = int(input('Ingrese categoría: ')) 11 | antiguedad = int(input('Ingrese antigüedad: ')) 12 | respuesta = False 13 | if categoria == 3 or categoria == 5: 14 | if antiguedad >= 5: 15 | respuesta = True 16 | elif categoria == 2 and antiguedad >= 10: 17 | respuesta = True 18 | if respuesta: 19 | resultado = 'reúne las características para el puesto.' 20 | else: 21 | resultado = 'no reúne las características para el puesto.' 22 | print(f'\nEl empleado con clave {clave} ' + resultado) 23 | -------------------------------------------------------------------------------- /Cap5/Ejemplo 5_9.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 5_9 5 | Uso de la instrucción with. 6 | """ 7 | 8 | # El archivo se cierra automáticamente. 9 | def escribe_archivo(archivo, *args): 10 | """ Crea un archivo y guarda en líneas diferentes cada uno 11 | de los valores recibidos por medio del parámetro args. 12 | 13 | Parámetro: 14 | archivo: de tipo str. Nombre con el que se creará el archivo. 15 | *args: parámetro de longitud variable. 16 | """ 17 | with open(archivo, 'w') as arch: 18 | for val in args: 19 | arch.write(str(val)) 20 | arch.write('\n') 21 | 22 | # Se prueba la función que utiliza el with. 23 | escribe_archivo('prueba_with', 'a', 'b', 'c', 'd', 'e', 'f', 'g') 24 | 25 | -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_1 5 | Impresiones en Python. 6 | """ 7 | 8 | edad = 83 9 | print("Hola otoño") 10 | print('Edad del abuelo: ', edad) 11 | # Por omisión separa con espacio en blanco. 12 | print("verde", "rojo", "azul") 13 | # Se establece como separador el - 14 | print("verde", "rojo", "azul", sep = "-") 15 | # Se establece como separador el --> 16 | print("verde", "rojo, amarillo o café", "se cae", sep = " --> ") 17 | # Por omisión termina con un salto de línea. 18 | print("dulce", "amargo", "ácido") 19 | # Se establece que, al terminar, no baje de renglón. 20 | print("Hola", end = "") 21 | # Se establece que, al terminar, no baje de renglón y escriba :) 22 | print('otoño, estación de los colores opacos', end = ":)") 23 | 24 | -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_7 5 | Lectura (ingreso) de datos por medio del teclado. 6 | """ 7 | 8 | print("\n¿Cómo te llamas? ") # Se solicita el nombre por medio de un print(). 9 | nombre = input() 10 | 11 | # Se solicita el lugar de residencia incluyendo un mensaje en el input(). 12 | ciudad = input("¿Dónde vives? ") 13 | 14 | # Se solicita la edad. En este caso será necesario convertir a 15 | # entero el dato ingresado. 16 | edad = int(input("¿Cuántos años tienes? ")) 17 | 18 | # Se solicita la altura en metros. Se convierte a real el dato ingresado. 19 | altura = float(input("¿Cuánto mides -en metros? ")) 20 | 21 | # Se muestran todos los datos leídos. 22 | print(f'\nLa persona de nombre {nombre} vive en {ciudad}.' 23 | f'\nTiene {edad} años y mide {altura} m') -------------------------------------------------------------------------------- /Cap4/Programa 4_39.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 4.39 5 | Encuentra e imprime todos los números deficientes comprendidos en el 6 | intervalo de 1 a un valor dado por el usuario. 7 | """ 8 | 9 | valor = int(input('\nIngrese hasta qué valor quiere analizar: ')) 10 | if valor <= 0: 11 | print('¡Error en el dato!'.upper()) 12 | else: 13 | print('\nLista de números deficientes:') 14 | # Se descarta el 1, no puede ser deficiente. 15 | for numero in range(2, valor + 1): 16 | suma_divisores = 1 # El 1 divide a todos. 17 | for divisor in range(2, numero // 2 + 1): 18 | if numero % divisor == 0: 19 | suma_divisores += divisor 20 | if suma_divisores < numero: 21 | print(f'El {numero} es un número deficiente.') -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 4_5 5 | Variante de solución del problema 4.20. 6 | Calcula e imprime la suma de los números contenidos en 7 | una cadena, los cuales deben estar separados por coma. 8 | """ 9 | 10 | cadena = input('Ingrese la cadena de caracteres: ') + ',' 11 | suma_numeros = 0 12 | for caracter in cadena: 13 | if caracter == ',': 14 | posicion = cadena.index(',') 15 | numero = cadena[0:posicion] # Se extrae el número que está antes de la coma. 16 | cadena = cadena[posicion + 1:] # Evita repetir el número extraído. 17 | try: 18 | suma_numeros += float(numero) 19 | except ValueError: 20 | pass # Si no es un número, no hay nada que hacer. 21 | print(f'\nLa suma de los números contenidos en la cadena es = {suma_numeros:.2f}') 22 | -------------------------------------------------------------------------------- /Cap3/Programa 3_26.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.26 5 | Calcula e imprime el total a pagar a un empleado, considerando 6 | sueldo más horas extras. Para el pago de las horas extras hay que 7 | tener en cuenta la categoría y el total de horas extras trabajadas. 8 | """ 9 | 10 | sueldo = float(input('Sueldo del empleado: $')) 11 | categoria = int(input('Categoría del empleado: ')) 12 | horas_extras = int(input('Número de horas extras: ')) 13 | if categoria == 1: 14 | precio_hora = 120 15 | elif categoria == 2: 16 | precio_hora = 150 17 | elif categoria == 3: 18 | precio_hora = 195 19 | elif categoria == 4: 20 | precio_hora = 245 21 | else: 22 | precio_hora = 0 23 | if horas_extras > 30: 24 | horas_extras = 30 25 | sueldo_neto = sueldo + horas_extras * precio_hora 26 | print(f'\nSueldo final: ${sueldo_neto:.2f}') -------------------------------------------------------------------------------- /Cap4/Programa 4_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.3 5 | Calcula e imprime la suma de los números pares y el promedio 6 | de los números impares. 7 | """ 8 | 9 | n = int(input('Ingrese la cantidad de números a procesar: ')) 10 | suma_pares = 0 11 | suma_impares = 0 12 | cuenta_impares = 0 13 | for i in range (1, n + 1): 14 | numero = int(input(f'Ingrese el número {i}: ')) 15 | if numero % 2 == 0: 16 | suma_pares += numero 17 | else: 18 | suma_impares += numero 19 | cuenta_impares += 1 20 | print('\nSuma de los números pares =', suma_pares) 21 | if cuenta_impares > 0: 22 | promedio = suma_impares / cuenta_impares 23 | print(f'Promedio de los números impares = {promedio:.2f}') 24 | else: 25 | print('\nNo es posible calcular el promedio de los números impares.') 26 | 27 | 28 | 29 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_2 5 | Variante de solución del problema 3.18 6 | 7 | Calcula e imprime el total a pagar por una llamada telefónica 8 | internacional, la cual se cobra de acuerdo a la región a la cual 9 | se llamó y a la duración de la misma. 10 | """ 11 | 12 | clave = int(input('Ingrese la clave del área geográfica: ')) 13 | duracion = int(input('Ingrese la duración en número de minutos: ')) 14 | if clave == 12: 15 | costo = duracion * 9 16 | elif clave == 15: 17 | costo = duracion * 8 18 | elif clave == 21: 19 | costo = duracion * 16 20 | elif clave == 23: 21 | costo = duracion * 19 22 | elif clave == 29: 23 | costo = duracion * 24 24 | else: 25 | costo = 0 26 | print('\n', '¡Clave incorrecta!'.center(40)) 27 | if costo > 0: 28 | print(f'\nTotal a pagar por la llamada = ${costo:.2f}') -------------------------------------------------------------------------------- /Cap3/Programa 3_21.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.21 5 | Dados 3 números enteros, los imprime en orden 6 | descendente (de mayor a menor). 7 | """ 8 | 9 | n1 = int(input('Ingrese el primer número entero: ')) 10 | n2 = int(input('Ingrese el segundo número entero: ')) 11 | n3 = int(input('Ingrese el tercer número entero: ')) 12 | print('\nNúmeros en orden decreciente: ', end = '') 13 | if n1 > n2: 14 | if n1 > n3: 15 | if n2 > n3: 16 | print(n1, n2, n3, sep = ', ') 17 | else: 18 | print(n1, n3, n2, sep = ', ') 19 | else: 20 | print(n3, n1, n2, sep = ', ') 21 | else: 22 | if n2 > n3: 23 | if n1 > n3: 24 | print(n2, n1, n3, sep = ', ') 25 | else: 26 | print(n2, n3, n1, sep = ', ') 27 | else: 28 | print(n3, n2, n1, sep = ', ') 29 | 30 | -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 4_2 5 | Solución del problema 4.1 sin usar ciclo. 6 | En este caso se emplea una variable por cada sueldo. 7 | """ 8 | 9 | sueldo1 = float(input('Ingrese el sueldo 1: $')) 10 | sueldo2 = float(input('Ingrese el sueldo 2: $')) 11 | sueldo3 = float(input('Ingrese el sueldo 3: $')) 12 | sueldo4 = float(input('Ingrese el sueldo 4: $')) 13 | sueldo5 = float(input('Ingrese el sueldo 5: $')) 14 | sueldo6 = float(input('Ingrese el sueldo 6: $')) 15 | sueldo7 = float(input('Ingrese el sueldo 7: $')) 16 | sueldo8 = float(input('Ingrese el sueldo 8: $')) 17 | sueldo9 = float(input('Ingrese el sueldo 9: $')) 18 | sueldo10 = float(input('Ingrese el sueldo 10: $')) 19 | nomina = sueldo1 + sueldo2 + sueldo3 + sueldo4 + sueldo5 + sueldo6 + sueldo7 + sueldo8 + sueldo9 + sueldo10 20 | print('\nLa nómina que debe pagarse es: $', nomina) -------------------------------------------------------------------------------- /Cap4/Programa 4_34.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.34 5 | Encuentra e imprime todos los números primos comprendidos 6 | en el intervalo de 1 a un valor dado por el usuario. 7 | """ 8 | 9 | valor = int(input('\nIngrese hasta qué valor quiere analizar: ')) 10 | if valor <= 0: 11 | print('\nError en el dato.') 12 | else: 13 | if valor >= 2: # Descarta el 1. 14 | print('\nEl número 2 es un número primo.') 15 | for numero in range(3, valor + 1, 2): # Descarta los pares. 16 | divisor = 3 17 | limite = numero // 2 18 | while divisor < limite and numero % divisor != 0: 19 | divisor += 2 20 | if divisor >= limite: 21 | print(f'El número {numero} es un número primo.') 22 | else: 23 | print('\nNo hay números primos.') 24 | -------------------------------------------------------------------------------- /Cap4/Programa 4_30.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 4.30 5 | Determina si un número es primo o no. 6 | """ 7 | 8 | numero = int(input('\nIngrese un número entero positivo: ')) 9 | if numero <= 0: 10 | print('\nError en el dato.') 11 | else: 12 | if numero == 2: 13 | primo = True 14 | else: 15 | primo = False 16 | # Descarta el 1 y todos los pares > 2. 17 | if numero > 2 and numero % 2 != 0: 18 | divisor = 3 19 | limite = numero // 2 20 | while divisor < limite and numero % divisor != 0: 21 | divisor += 2 22 | if divisor >= limite: 23 | primo = True 24 | if primo: 25 | print(f'\nEl número {numero} es un número primo.') 26 | else: 27 | print(f'\nEl número {numero} no es un número primo.') -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | """ 4 | @author: guardati 5 | Ejemplo 1_4 6 | Impresiones en Python usando f-string. 7 | """ 8 | 9 | valor = 'edad' 10 | edad = 83 11 | print(f'La {valor} del abuelo es {edad} años') 12 | 13 | valor = 'altura' 14 | altura = 1.72 15 | print(f'La {valor} del abuelo es {altura:.1f} m') # Da formato al número. 16 | 17 | nombre = 'Alberto' 18 | print(f'Mi abuelo se llama {nombre}.') 19 | 20 | # El !r provoca que el valor de nombre se escriba entre ''. 21 | print(f'Te dije que se llama {nombre!r}.') # Se verá 'Alberto'. 22 | 23 | # Con <10 se reservan 10 espacios para el valor de la variable. 24 | formato1 = f'{valor:<10} = {altura:.2f}' 25 | print(formato1) 26 | 27 | formato2 = f'{valor!r:<10} = {altura:.2f}' 28 | print(formato2) 29 | 30 | # Ejemplo combinando f-string con formato de cadenas. 31 | formato3 = f'{"peso".capitalize()} = {59.605:.2f}' 32 | print(formato3) 33 | -------------------------------------------------------------------------------- /Cap4/Programa 4_15.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 4.15 5 | Calcula e imprime la suma y el promedio de todos los números comprendidos 6 | entre dos números enteros que representan el límite inferior y el 7 | superior del intervalo de números que deben procesarse. 8 | """ 9 | 10 | entero1 = int(input('Ingrese el primer número entero: ')) 11 | entero2 = int(input('Ingrese el segundo número entero: ')) 12 | if entero1 <= entero2: # Garantizamos que, por lo menos, haya un número que sumar. 13 | suma = 0 14 | for numero in range(entero1, entero2 + 1): 15 | suma += numero 16 | total_numeros = entero2 - entero1 + 1 17 | promedio = suma / total_numeros 18 | print(f'\nLa suma de los números comprendidos entre {entero1} y {entero2}' 19 | f' es = {suma}') 20 | print(f'El promedio es = {promedio:.2f}') 21 | else: 22 | print('\nError en los datos.') -------------------------------------------------------------------------------- /Cap4/Programa 4_37.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.37 5 | Encuentra e imprime todos los números primos gemelos comprendidos 6 | en el intervalo de 1 a un valor dado por el usuario. 7 | """ 8 | 9 | valor = int(input('\nIngrese hasta qué valor quiere analizar: ')) 10 | if valor <= 0: 11 | print('¡Error en el dato!'.upper()) 12 | else: 13 | print('\nLista de pares de primos gemelos:') 14 | primo_anterior = 0 15 | # Descarta los pares y el número primo 2. 16 | for numero in range(3, valor + 1, 2): 17 | divisor = 3 18 | limite = numero // 2 19 | while divisor < limite and numero % divisor != 0: 20 | divisor += 2 21 | if divisor >= limite: # Demuestra que el número es primo. 22 | if numero - primo_anterior == 2: 23 | print(f'{primo_anterior} - {numero}'.center(30)) 24 | primo_anterior = numero 25 | -------------------------------------------------------------------------------- /Cap5/Programa 5_13.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.16 5 | Encuentra e imprime todos los números primos de, al menos, 2 dígitos cuyos 6 | espejos también sean números primos. El usuario debe ingresar los extremos 7 | del intervalo. 8 | Se dice que un número es el espejo de otro cuando está formado por los mismos 9 | dígitos, pero en orden inverso. 10 | """ 11 | import auxiliar 12 | 13 | liminf = int(input('\nIngrese límite inferior: ')) 14 | limsup = int(input('Ingrese límite superior: ')) 15 | if liminf > 9 and liminf < limsup: 16 | print(f'\nNúmeros primos y sus espejos primos: '.upper()) 17 | if liminf % 2 == 0: 18 | liminf += 1 19 | for num in range(liminf, limsup + 1, 2): 20 | if auxiliar.es_primo(num): 21 | espejo = auxiliar.genera_espejo(num) 22 | if auxiliar.es_primo(espejo): 23 | print(num, '-', espejo) 24 | else: 25 | print('\n¡Intervalo incorrecto!'.upper()) -------------------------------------------------------------------------------- /Cap2/Programa 2_10.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 2.10 5 | Calcula e imprime el total a pagar por alimento, a lo largo de un mes, 6 | en un refugio para perros en el cual viven perros de distinta edad y tamaño. 7 | Se considera que el mes tiene 30 días. 8 | """ 9 | 10 | precio_alim_ad = float(input('Ingrese el precio del alimento para adulto: $')) 11 | precio_alim_ca = float(input('Ingrese el precio del alimento para cachorro: $')) 12 | ''' 13 | Se multiplica por 30 para obtener el consumo en un mes y se divide 14 | por 1000 para expresar el consumo en kilos. 15 | ''' 16 | consumo_kg_adulto = (10 * 450 + 12 * 380) * 30 / 1000 17 | consumo_kg_cachorro = 6 * 230 * 30 / 1000 18 | costo_alim_ad = consumo_kg_adulto * precio_alim_ad 19 | costo_alim_ca = consumo_kg_cachorro * precio_alim_ca 20 | print(f'\nTotal a pagar por el alimento para perros adultos = ${costo_alim_ad:.2f}') 21 | print(f'Total a pagar por el alimento para perros cachorros = ${costo_alim_ca:.2f}') -------------------------------------------------------------------------------- /Cap5/Programa 5_12.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.15 5 | Obtiene e imprime todos los pares de números amigos comprendidos entre 6 | dos valores dados por el usuario. 7 | Dos números son amigos si la suma de los divisores del primero (sin incluirlo) 8 | es igual al segundo y, a su vez, la suma de los divisores del segundo 9 | (sin incluirlo) es igual al primero. 10 | """ 11 | import auxiliar 12 | 13 | liminf = int(input('\nIngrese límite inferior: ')) 14 | limsup = int(input('Ingrese límite superior: ')) 15 | if liminf > 0 and liminf < limsup: 16 | print(f'\nNúmeros amigos en el rango: {liminf} - {limsup}'.upper()) 17 | for num1 in range(liminf, limsup): 18 | for num2 in range(num1 + 1, limsup + 1): 19 | suma1 = auxiliar.suma_divisores(num1) 20 | suma2 = auxiliar.suma_divisores(num2) 21 | if suma1 == num2 and suma2 == num1: 22 | print(num1, '-', num2) 23 | else: 24 | print('\n¡Intervalo incorrecto!'.upper()) 25 | -------------------------------------------------------------------------------- /Cap3/Programa 3_13.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 3.13 5 | Dados el color, el aroma y el peso de una piña o ananá, imprime un mensaje 6 | indicando si la fruta está o no en condiciones para consumirse. 7 | El color y el aroma se expresan como cadenas de caracteres, mientras que 8 | el peso como valor booleano, está o no pesada. 9 | Los 3 datos se pudieron manejar por medio de otros tipos de datos. En este 10 | problema se decidió hacerlo así para practicar estos en particular. 11 | """ 12 | 13 | color = input('Ingrese el color de la fruta: ') 14 | aroma = input('Ingrese el aroma de la fruta: ') 15 | pesada = bool(input('Ingrese si la fruta está pesada (True/False): ')) 16 | # Se pasan a minúsculas para evitar inconsistencias cuando se comparen. 17 | color = color.lower() 18 | aroma = aroma.lower() 19 | if color == 'dorado' and aroma == 'suave' and pesada: 20 | print('\nLa fruta está madura. ¡Lista para comerse!') 21 | else: 22 | print('\nLa fruta no está madura o ya se pasó.') 23 | -------------------------------------------------------------------------------- /Cap3/Programa 3_24.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.24 5 | Calcula e imprime la retención del impuesto sobre la renta, así como 6 | el ingreso neto que cobrará un contribuyente. 7 | El impuesto sobre la renta se calcula de acuerdo a los ingresos y a la 8 | cantidad de dependientes económicos a cargo que tenga el contribuyente. 9 | """ 10 | 11 | ingreso = float(input('Proporcione el ingreso correspondiente: $')) 12 | num_dependientes = int(input('Ingrese el número de dependientes económicos: ')) 13 | if ingreso <= 20000: 14 | porcentaje = 0 15 | elif ingreso <= 40000: 16 | porcentaje = 0.15 17 | elif ingreso <= 70000: 18 | porcentaje = 0.25 19 | else: 20 | if ingreso <= 100000: 21 | porcentaje = 0.3 22 | else: 23 | porcentaje = 0.35 24 | if num_dependientes > 4: 25 | porcentaje -= 0.02 26 | retencion = ingreso * porcentaje 27 | ingreso_neto = ingreso - retencion 28 | print(f'\nRetención: ${retencion:.2f} \nIngreso neto: ${ingreso_neto:.2f}') 29 | -------------------------------------------------------------------------------- /Cap4/Programa 4_20.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.20 5 | Calcula e imprime la suma de los números contenidos en una cadena, 6 | los cuales deben estar separados por coma. 7 | """ 8 | 9 | cadena = input('Ingrese la cadena de caracteres: ') 10 | suma_numeros = 0 11 | for caracter in cadena: 12 | if caracter == ',': 13 | posicion = cadena.index(',') 14 | # Se extrae el número que está antes de la coma. 15 | numero = cadena[0:posicion] 16 | # Evita repetir el número extraído. 17 | cadena = cadena[posicion + 1:] 18 | try: 19 | suma_numeros += float(numero) 20 | except ValueError: 21 | pass # Si no es un número, no hay nada que hacer. 22 | # Intenta sumar el último número: no se detecta en el for 23 | # porque la cadena no termina con coma. 24 | try: 25 | suma_numeros += float(cadena) 26 | except ValueError: 27 | pass 28 | print(f'\nLa suma de los números contenidos en la cadena es = ' 29 | f'{suma_numeros:.2f}') 30 | -------------------------------------------------------------------------------- /Cap3/Programa 3_27.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.27 5 | Calcula e imprime un estimado del total a pagar en un hospital, en concepto de 6 | internación de un paciente. Para el cálculo se considera el tipo de enfermedad, 7 | la cantidad de días y la edad del paciente. 8 | """ 9 | 10 | edad = int(input('Edad del paciente: ')) 11 | tipo = int(input('Tipo de enfermedad (valor entre 1 y 4): ')) 12 | dias = int(input('Número estimado de días de internación: ')) 13 | if tipo == 1: 14 | costo_diario = 3150 15 | elif tipo == 2: 16 | costo_diario = 3980 17 | elif tipo == 3: 18 | costo_diario = 5500 19 | elif tipo == 4: 20 | costo_diario = 7150 21 | else: 22 | costo_diario = 0 23 | if costo_diario == 0: 24 | print('\nEl tipo de enfermedad ingresado es incorrecto'.upper()) 25 | else: 26 | costo_internacion = costo_diario * dias 27 | if edad < 16: 28 | costo_internacion *= 1.08 29 | elif edad > 70: 30 | costo_internacion *= 1.17 31 | print(f'\nCosto estimado a pagar: ${costo_internacion:.2f}') 32 | -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | 4 | @author: guardati 5 | Ejemplo 4_3 6 | Solución del problema 4.1 sin usar ciclo. 7 | En este caso se emplea una sola variable para leer el sueldo, 8 | lo cual implica que se debe leer y sumar 10 veces. 9 | """ 10 | 11 | nomina = 0 12 | sueldo = float(input('Ingrese el sueldo 1: $')) 13 | nomina += sueldo 14 | sueldo = float(input('Ingrese el sueldo 2: $')) 15 | nomina += sueldo 16 | sueldo = float(input('Ingrese el sueldo 3: $')) 17 | nomina += sueldo 18 | sueldo = float(input('Ingrese el sueldo 4: $')) 19 | nomina += sueldo 20 | sueldo = float(input('Ingrese el sueldo 5: $')) 21 | nomina += sueldo 22 | sueldo = float(input('Ingrese el sueldo 6: $')) 23 | nomina += sueldo 24 | sueldo = float(input('Ingrese el sueldo 7: $')) 25 | nomina += sueldo 26 | sueldo = float(input('Ingrese el sueldo 8: $')) 27 | nomina += sueldo 28 | sueldo = float(input('Ingrese el sueldo 9: $')) 29 | nomina += sueldo 30 | sueldo = float(input('Ingrese el sueldo 10: $')) 31 | nomina += sueldo 32 | print('\nLa nómina que debe pagarse es: $', nomina) 33 | -------------------------------------------------------------------------------- /Cap4/Programa 4_38.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.38 5 | En una cadena de caracteres cambia algunas letras de 6 | mayúscula a minúscula e imprime el texto modificado. 7 | """ 8 | 9 | texto = input('\nIngrese el texto a modificar: ') 10 | letra = input('Ingrese la letra que debe pasarse a minúsculas: ') 11 | bandera = False 12 | while letra != '': 13 | nuevo_texto = '' 14 | pos = texto.find(letra) 15 | while pos != -1: 16 | if pos > 0: 17 | nuevo_texto += texto[0:pos] + chr((ord(letra) + 32)) 18 | else: 19 | if len(nuevo_texto) == 0 or (nuevo_texto[0] == letra and not bandera): 20 | nuevo_texto += texto[0:pos + 1] 21 | bandera = True 22 | else: 23 | nuevo_texto += chr((ord(letra) + 32)) 24 | texto = texto[pos + 1:] 25 | pos = texto.find(letra) 26 | letra = input('Ingrese la letra que debe pasarse a minúsculas: ') 27 | nuevo_texto += texto 28 | texto = nuevo_texto 29 | print('\nTEXTO MODIFICADO:\n', texto.center(60)) 30 | -------------------------------------------------------------------------------- /Cap3/Programa 3_20.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 3.20 5 | Cacula e imprime el total a pagar en un hotel, de acuerdo al tipo de 6 | habitación ocupada y a la cantidad de días de hospedaje. 7 | """ 8 | 9 | dias_hospedaje = int(input('Ingrese el total de días de la estadía: ')) 10 | tipo_habitacion = input('Ingrese el tipo de habitación ocupada: ') 11 | tipo_habitacion = tipo_habitacion.upper() 12 | if tipo_habitacion == 'S': 13 | precio = 1500 14 | elif tipo_habitacion == 'D': 15 | precio = 2100 16 | elif tipo_habitacion == 'T': 17 | precio = 2700 18 | elif tipo_habitacion == 'F': 19 | precio = 3500 20 | else: 21 | precio = -1 # Si se ingresó un tipo equivocado de habitación. 22 | ''' Si precio es -1 se obtendrá un valor negativo el cual se imprimirá 23 | y deberá interpretarse como una alarma de que hubo un error en los datos. 24 | En otras secciones y capítulos se verán mejores alternativas para manejar 25 | este tipo de errores. ''' 26 | total_pagar = precio * dias_hospedaje 27 | print(f'\nEl total a pagar en el hotel = ${total_pagar:.2f}') -------------------------------------------------------------------------------- /Cap2/Programa 2_13.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.13 5 | Codifica una frase reemplazando las vocales por los números 1, 2 6 | 3, 4 o 5. Además, la primera mitad de la cadena pasará a ser la 7 | segunda mitad y viceversa y las letras consonantes deberán estar en mayúsculas. 8 | """ 9 | 10 | frase = input('Ingrese la frase a codificar: ') 11 | # Reemplaza las vocales por números enteros. 12 | frase_codificada = frase.replace('a', '1') 13 | frase_codificada = frase_codificada.replace('e', '3') 14 | frase_codificada = frase_codificada.replace('i', '5') 15 | frase_codificada = frase_codificada.replace('o', '7') 16 | frase_codificada = frase_codificada.replace('u', '9') 17 | mitad = len(frase_codificada) // 2 18 | # Extrae la primera mitad de la frase. 19 | primera_mitad = frase_codificada[0:mitad] 20 | # Extrae la segunda mitad de la frase. 21 | segunda_mitad = frase_codificada[mitad:] 22 | frase_codificada = segunda_mitad + primera_mitad 23 | frase_codificada = frase_codificada.upper() # Pasa a mayúsculas. 24 | print('\nFrase original:', frase) 25 | print('\nFrase codificada:', frase_codificada) -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | """ 4 | @author: guardati 5 | Ejemplo 4_1 6 | Ciclo for usando la función range(). 7 | """ 8 | 9 | # El valor por omisión para el tercer parámetro de range() es 1. 10 | for numero in range(1, 10): 11 | print(numero) # Imprime del 1 al 9. 12 | 13 | # El valor por omisión para el primer parámetro de range() es 0. 14 | for j in range(4): 15 | print(j) # Imprime del 0 al 3. 16 | 17 | cadena = '' # Cadena de caracteres vacía 18 | # Se usa _ cuando la variable de control no se necesita en el ciclo. 19 | for _ in range (10): 20 | cadena += '*' # Pega 10 * a la variable cadena. 21 | print(cadena) # Imprime ********** 22 | 23 | # En range() se especifica un incremento diferente de 1. 24 | for numero in range(1, 10, 2): 25 | print(numero) # Imprime: 1 3 5 7 y 9. 26 | 27 | ''' 28 | El tercer parámetro de range() es un incremento negativo o un decremento. 29 | En este caso, el valor inicial debe ser mayor que el final, para 30 | que el for se ejecute, al menos, 1 vez. 31 | ''' 32 | for numero in range(10, 1, -2): 33 | print(numero) # Imprime: 10 8 6 4 y 2. 34 | 35 | -------------------------------------------------------------------------------- /Cap2/Programa 2_14.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.14 5 | Modifica e imprime una cadena que contiene el nombre completo de 6 | una persona, dejándolo expresado de la siguiente manera: 7 | primer apellido segundo apellido, nombre. 8 | Vamos a suponer que el nombre y los apellidos no son compuestos y que se 9 | proporcionan separados por un solo espacio. Por ejemplo: 10 | Juan Pérez Pérez 11 | """ 12 | 13 | nombre_completo = input('Ingrese el nombre completo de la persona: ') 14 | # Primer espacio: separa el nombre del primer apellido. 15 | espacio = nombre_completo.find(' ') 16 | # Se extrae el nombre de la persona. 17 | nombre = nombre_completo[0:espacio] 18 | # Se pierde el nombre de pila. 19 | nombre_completo = nombre_completo[espacio+1:] 20 | # Segundo espacio: separa el primer apellido del segundo. 21 | espacio = nombre_completo.find(' ') 22 | # Se extrae el primer apellido. 23 | primer_apellido = nombre_completo[0:espacio] 24 | # Se pierde el primer apellido. 25 | segundo_apellido = nombre_completo[espacio+1:] 26 | nombre_completo = primer_apellido + ' ' + segundo_apellido + ', ' + nombre 27 | print(nombre_completo) -------------------------------------------------------------------------------- /Cap3/Programa 3_23.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.23 5 | Dados 3 números enteros, encuentra e imprime el mayor de los 3. 6 | Se considera que los datos pueden ser iguales entre sí. 7 | """ 8 | 9 | n1 = int(input('Ingrese el primer número entero: ')) 10 | n2 = int(input('Ingrese el segundo número entero: ')) 11 | n3 = int(input('Ingrese el tercer número entero: ')) 12 | if n1 > n2: 13 | if n1 > n3: 14 | print(f'\nEl mayor es: {n1} (el primer dato)') 15 | elif n1 == n3: 16 | print(f'\nLos mayores son: {n1} y {n3} (el primero y el tercero)') 17 | else: 18 | print(f'\nEl mayor es: {n3} (el tercer dato)') 19 | elif n1 == n2: 20 | if n1 > n3: 21 | print(f'\nLos mayores son: {n1} y {n2} (el primero y el segundo)') 22 | elif n1 == n3: 23 | print(f'\nLos mayores son: {n1} - {n2} y {n3} (los 3 son iguales)') 24 | else: 25 | print(f'\nEl mayor es: {n3} (el tercer dato)') 26 | elif n2 > n3: 27 | print(f'\nEl mayor es: {n2} (el segundo dato)') 28 | elif n2 == n3: 29 | print(f'\nLos mayores son: {n2} y {n3} (el segundo y el tercero)') 30 | else: 31 | print(f'\nEl mayor es: {n3} (el tercer dato)') 32 | -------------------------------------------------------------------------------- /Cap3/Programa 3_17.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.17 5 | Calcula e imprime el precio final de un automóvil. 6 | El mismo se determina considerando su precio base y un 7 | posible descuento y bono, los cuales dependen del modelo. 8 | Además del precio final, se debe imprimir el modelo y el precio base. 9 | """ 10 | 11 | modelo = input('Ingrese el modelo del automóvil: ') 12 | precio = float(input('Ingrese el precio base: $')) 13 | modelo_min = modelo.lower() # Para evitar inconsistencias al comparar. 14 | if modelo_min == 'serie 1': 15 | precio_final = precio * 0.97 - 20000 16 | elif modelo_min == 'serie 3' or modelo == 'serie 4': 17 | precio_final = precio * 0.95 - 35000 18 | elif modelo_min == 'serie 5': 19 | precio_final = precio * 0.95 - 60000 20 | elif modelo == 'x1': 21 | precio_final = precio * 0.95 - 30000 22 | elif modelo_min == 'x3': 23 | precio_final = precio * 0.93 - 50000 24 | elif modelo_min == 'x5': 25 | precio_final = precio * 0.91 - 70000 26 | else: 27 | precio_final = precio 28 | print('\nPara el modelo:', modelo.upper()) 29 | print(f'\nEl precio base es = ${precio:.2f} y ' 30 | f'el precio final es = ${precio_final:.2f}') -------------------------------------------------------------------------------- /Cap5/Programa 5_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.2 5 | """ 6 | 7 | def calcula_raiz_biseccion(numero, error): 8 | """ Obtiene la aproximación de la raíz cuadrada de un número 9 | por medio del método de la bisección. 10 | 11 | Parámetros: 12 | numero: es un número int o float, > 0. 13 | error: es un número float, > 0. 14 | Regresa: 15 | La aproximación de la raíz cuadrada del número con un error < error. 16 | """ 17 | inferior = 0 18 | superior = numero 19 | raiz = (inferior + superior) / 2 20 | while abs(raiz ** 2 - numero) >= error: 21 | if raiz ** 2 > numero: 22 | superior = raiz 23 | else: 24 | inferior = raiz 25 | raiz = (inferior + superior) / 2 26 | return raiz 27 | 28 | # ============================================================================= 29 | # Algunos usos de la función. 30 | # ============================================================================= 31 | raiz1 = calcula_raiz_biseccion(9, 0.1) 32 | raiz2 = calcula_raiz_biseccion(35.5, 0.001) 33 | print(f'\nRaíz de 9, con un error menor a 0.1, es = {raiz1:.4f}') 34 | print(f'Raíz de 35.5, con un error menor a 0.001, es = {raiz2:.5f}') -------------------------------------------------------------------------------- /Cap5/geometrico.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Módulo geometrico.py 5 | Agrupa varias funciones dedicadas al cálculo de operaciones realizadas con 6 | figuras geométricas. 7 | 8 | Funciones: 9 | -area_rectangulo: calcula el área de un rectángulo. 10 | -perimetro_rectangulo: calcula el perímetro de un rectángulo. 11 | -area_circulo: calcula el área de un círculo. 12 | -perimetro_circulo: calcula el perímetro de un círculo. 13 | """ 14 | 15 | pi = 3.1415926 # Asigna valor a la variable pi. 16 | 17 | def area_rectangulo(base, altura): 18 | """ Calcula y regresa el área de un rectángulo. 19 | 20 | Parámetro: 21 | - base: de tipo int o float > 0, es la base de un rectángulo. 22 | - altura: de tipo int o float > 0, es la altura de un rectángulo. 23 | Regresa: 24 | El área de un rectángulo, de tipo int o float (depende de los datos). 25 | """ 26 | return base * altura 27 | 28 | def area_circulo(radio): 29 | """ Calcula y regresa el área de un círculo. 30 | 31 | Parámetro: 32 | - radio: de tipo int o float > 0, es el radio de un círculo. 33 | Regresa: 34 | El área de un círculo, de tipo float. 35 | """ 36 | return pi * radio ** 2 37 | 38 | 39 | -------------------------------------------------------------------------------- /Cap2/Ejemplo 2_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 2_2 5 | Operaciones con números complejos. 6 | Cada complejo se expresa por medio de un par ordenado: a + bj, 7 | siendo a la parte real y b la parte imaginaria. 8 | """ 9 | 10 | z1 = complex(input('Ingrese un complejo: ')) 11 | z2 = z1 12 | print('\nEl valor de z2 es:', z2) 13 | 14 | # Otra forma de asignar un complejo. 15 | z3 = complex(2.5, -6.2) 16 | print('\nEl valor de z3 es:', z3) 17 | 18 | # Ejemplo de las operaciones de +, -, * y / entre complejos. 19 | print(f'\nSuma: {z1 + z2}') 20 | print(f'Resta: {z1 - z2}') 21 | print(f'Multiplicación: {z1 * z2:.2f}') 22 | print(f'División: {z1 / z2}') 23 | 24 | print('\nLa parte real es:', z1.real) 25 | print('La parte imaginaria es:', z1.imag) 26 | 27 | # Operaciones entre complejos y entre complejos con no complejos. 28 | z4 = z1 + 2.5 # Suma 2.5 a la parte real de z1. 29 | z5 = z1 + 2.5 + 3.2j # Suma a z1 el complejo (2.5 + 3.2j). 30 | # Suma 1.8 a la parte imaginaria de z1. 31 | z6 = z1 + 1.8j 32 | # Producto escalar: 4 por la parte real y 4 por la imaginaria. 33 | z7 = 4 * z1 34 | print('\nComplejos obtenidos:', z4, z5, z6, z7) 35 | 36 | # Se comparan las partes reales y las partes imaginarias entre sí. 37 | print('\n¿Los complejos son iguales?', z1 == z2) 38 | 39 | # Valor absoluto: |z1| = sqrt(z1.real**2 + z1.imag**2) 40 | print(f'\nEl valor absoluto es: {abs(z1):.3f}') -------------------------------------------------------------------------------- /Cap5/Programa 5_9.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.12 5 | """ 6 | 7 | def es_palindromo(secuencia): 8 | """ Determina si la secuencia es palíndromo. 9 | 10 | Parámetro: 11 | secuencia: cualquier tipo iterable 12 | Regresa: 13 | True si la secuencia es palíndromo, False en caso contrario. 14 | """ 15 | # Se convierte a str para usar el método replace y quitar 16 | # los posibles espacios en blanco de la secuencia. 17 | secuencia = str(secuencia) 18 | secuencia = secuencia.replace(' ', '') 19 | n = len(secuencia) 20 | izq = 0 21 | der = n - 1 22 | while izq <= der and secuencia[izq] == secuencia[der]: 23 | izq += 1 24 | der -= 1 25 | return izq > der 26 | 27 | # CP1: se proporcionan secuencias que son palíndromos. 28 | print('\nEvaluando palíndromos...') 29 | print(es_palindromo('neuquen')) 30 | print(es_palindromo('anita lava la tina')) 31 | print(es_palindromo('amigo no gima')) 32 | print(es_palindromo(1001001)) 33 | print(es_palindromo('yo dono rosas oro no doy')) 34 | print(es_palindromo(3526253)) 35 | 36 | # CP2: se proporcionan secuencias que no son palíndromos. 37 | print('\nEvaluando no palíndromos...') 38 | print(es_palindromo('el perro ladra toda la tarde')) 39 | print(es_palindromo('amigo no gima de esa manera')) 40 | print(es_palindromo(1101001)) 41 | print(es_palindromo(35248)) -------------------------------------------------------------------------------- /Cap3/Programa 3_29.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Solución del problema 3.29 5 | Calcula e imprime el costo de un paquete turístico de acuerdo 6 | con el destino, el nivel y la cantidad de días de duración. 7 | """ 8 | 9 | destino = input('Ingrese el tipo de destino (playa/colonial/arqueológica): ') 10 | nivel_paquete = input('Ingrese nivel de paquete (exclusivo/lujo/estándar): ') 11 | numero_dias = int(input('Ingrese los días de duración del viaje: ')) 12 | 13 | ''' Se asigna el valor del costo diario de acuerdo con el destino. Observe 14 | que,si el usuario se equivoca e ingresa un destino diferente a los 3 15 | previstos, el programa asignará el valor de $900, y calculará e imprimirá 16 | un resultado inconsistente. A pesar de que existen maneras de evitar 17 | este tipo de errores, en esta solución no se hace. ''' 18 | if destino == 'playa': 19 | costo_dia = 1200 20 | elif destino == 'colonial': 21 | costo_dia = 1000 22 | else: 23 | costo_dia = 900 24 | costo_paquete = costo_dia * numero_dias 25 | # Se aplica un recargo si el nivel es exxclusivo o lujo. 26 | if nivel_paquete == 'exclusivo': 27 | costo_paquete *= 1.3 28 | elif nivel_paquete == 'lujo': 29 | costo_paquete *= 1.1 30 | if numero_dias > 10: 31 | costo_paquete *= 0.92 # Se aplica el descuento del 8% para estadías > 10 días. 32 | print(f'\nEl costo del paquete elegido es ${costo_paquete:.2f}') 33 | 34 | -------------------------------------------------------------------------------- /Cap4/Programa 4_24.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.24 5 | Analiza un grupo de calificaciones y las clasifica de acuerdo a ciertos rangos 6 | dados. No se conoce el total de calificaciones que se ingresarán, por lo que 7 | al final se dará un valor negativo. 8 | Además, calcula e imprime el promedio de las calificaciones. 9 | """ 10 | 11 | suma_calificaciones = 0 12 | cuenta_calificaciones = 0 13 | rango1 = 0 14 | rango2 = 0 15 | rango3 = 0 16 | rango4 = 0 17 | calificacion = float(input('Ingrese una calificación: ')) 18 | while calificacion >= 0: 19 | suma_calificaciones += calificacion 20 | cuenta_calificaciones += 1 21 | if calificacion < 6: 22 | rango1 += 1 23 | elif calificacion < 8: 24 | rango2 += 1 25 | elif calificacion < 9: 26 | rango3 += 1 27 | else: 28 | rango4 += 1 29 | calificacion = float(input('Ingrese una calificación: ')) 30 | if cuenta_calificaciones > 0: 31 | promedio = suma_calificaciones / cuenta_calificaciones 32 | print(f'\nTotal de calificaciones entre 0 y 5.99: {rango1}') 33 | print(f'Total de calificaciones entre 6 y 7.99: {rango2}') 34 | print(f'Total de calificaciones entre 8 y 8.99: {rango3}') 35 | print(f'Total de calificaciones entre 9 y 10: {rango4}') 36 | print(f'\nPromedio de las calificaciones = {promedio:.2f}') 37 | else: 38 | print(f'\nNo se ingresaron datos.'.upper()) 39 | 40 | -------------------------------------------------------------------------------- /Cap5/Programa 5_8.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.11 5 | """ 6 | 7 | def estan_ordenadas(palabra): 8 | """ Determina si las letras de la palabra están ordenadas alfabéticamente. 9 | Parámetro: 10 | palabra: de tipo str. 11 | Regresa: 12 | True/False si las letras de la palabra tienen/o no orden alfabético. 13 | """ 14 | n = len(palabra) 15 | i = 0 16 | while i < n - 1 and palabra[i] <= palabra[i + 1]: 17 | i += 1 18 | return i == n - 1 19 | 20 | def cuenta_palabras(nombre): 21 | """ Cuenta y regresa el total de palabras que tienen las letras 22 | ordenadas alfabéticamente. Las palabras se leen de un archivo. 23 | Parámetro: 24 | nombre: de tipo str. Nombre del archivo. 25 | Regresa: 26 | El total de palabras que cumple con la condición. 27 | """ 28 | with open(nombre, 'r') as arch: 29 | contador = 0 30 | for pal in arch: 31 | pal = pal.strip() 32 | if estan_ordenadas(pal): 33 | contador += 1 34 | return contador 35 | # ------------------------------------------------------------------------- 36 | nombre = input('\nNombre del archivo que quiere analizar: ') 37 | try: 38 | print('\nCantidad de palabras con letras ordenadas:', cuenta_palabras(nombre)) 39 | except Exception: 40 | print('Problemas con el archivo.') 41 | 42 | -------------------------------------------------------------------------------- /Cap4/Programa 4_27.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.27 5 | Calcula e imprime el importe de cada venta, así como el total de localidades 6 | vendidas de cada uno de los 3 tipos y el total recaudado en un día. 7 | En esta solución se supone que siempre se ingresa alguno de los 3 tipos 8 | previstos de localidades. 9 | """ 10 | 11 | localidadesA = 0 12 | localidadesB = 0 13 | localidadesC = 0 14 | total_recaudado = 0 15 | tipo = input('\nTipo de localidad (A, B, C) o X para terminar: ').upper() 16 | cantidad = int(input('Ingrese la cantidad de boletos o -1 para terminar: ')) 17 | while tipo != 'X' and cantidad != -1: 18 | if tipo == 'A': 19 | localidadesA += cantidad 20 | venta = cantidad * 980 21 | elif tipo == 'B': 22 | localidadesB += cantidad 23 | venta = cantidad * 750 24 | else: 25 | localidadesC += cantidad 26 | venta = cantidad * 520 27 | print('\nTotal a pagar por los boletos: $', venta) 28 | total_recaudado += venta 29 | tipo = input('\nTipo de localidad (A, B, C) o X para terminar: ').upper() 30 | cantidad = int(input('Ingrese la cantidad de boletos o -1 para terminar: ')) 31 | total_boletos = localidadesA + localidadesB + localidadesC 32 | print(f'\nTotal de localidades por tipo: {localidadesA} - ' 33 | f'{localidadesB} - {localidadesC}') 34 | print(f'\nTotal de boletos: {total_boletos}, con una recaudación de:' 35 | f' ${total_recaudado:.2f}') -------------------------------------------------------------------------------- /Cap5/Programa 5_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Pruebas realizadas a las funciones pedidas en los problemas 5.6, 5 | 5.7 y 5.8. 6 | """ 7 | 8 | import archivos 9 | 10 | 11 | # CP1: escritura en archivo de varios números (problema 5.6). 12 | archivos.escribe_archivo('precios', 12.5, 8.3, 98.45, 10.45, 11, 24.30 ) 13 | 14 | # CP2: se usa el archivo creado para probar las 2 versiones de la 15 | # función de lectura de un archivo (problema 5.7). Se espera el mismo resultado. 16 | leido1 = archivos.lee1_archivo('precios') 17 | leido2 = archivos.lee2_archivo('precios') 18 | print(f'\nDatos leídos con la solución 1\n{leido1}') 19 | print(f'\nDatos leídos con la solución 2\n{leido2}') 20 | 21 | # CP3: se usa un archivo que contiene solo números. 22 | archivos.escribe_archivo('archivo1', 12.5, 5, 4, 0, 8.7, -2) 23 | print('Resultado de contar y sumar:', archivos.cuenta_y_suma('archivo1')) 24 | 25 | # CP4: se usa un archivo que contiene distintos tipos de datos (problema 5.8). 26 | archivos.escribe_archivo('archivo2', 12.5, 5, 'hola', 0, 8.7, -2, True) 27 | resultado = archivos.cuenta_y_suma('archivo2') 28 | print(f'\nHay {resultado[0]} números y su suma es {resultado[1]}') 29 | 30 | # CP5: se proporciona el nombre de un archivo que no existe (problema 5.8). 31 | try: 32 | print(archivos.cuenta_y_suma('archivo3')) 33 | except FileNotFoundError as error: 34 | print(f'\n{error}') 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /Cap4/Programa 4_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.4 5 | Calcula e imprime el promedio de las calificaciones de un grupo de n alumnos. 6 | Además, identifica la calificación más alta y la más baja del grupo y las 7 | imprime junto con la matrícula de los alumnos que las obtuvieron. 8 | """ 9 | 10 | total_alumnos = int(input('Ingrese la cantidad de alumnos: ')) 11 | suma_calif = 0 12 | # Al mayor se lo inicializa con un valor muy pequeño. 13 | calificacion_mayor = -1 14 | # Al menor se lo inicializa con un valor muy grande. 15 | calificacion_menor = 11 16 | for i in range(1, total_alumnos + 1): 17 | print(f'\nIngrese la matrícula y la calificación del alumno {i}:') 18 | matricula = int(input()) 19 | calificacion = float(input()) 20 | suma_calif += calificacion 21 | if calificacion > calificacion_mayor: 22 | calificacion_mayor = calificacion 23 | matricula_mayor = matricula 24 | if calificacion < calificacion_menor: 25 | calificacion_menor = calificacion 26 | matricula_menor = matricula 27 | if total_alumnos > 0: 28 | promedio = suma_calif / total_alumnos 29 | print(f'\nPromedio de calificaciones = {promedio:.2f}') 30 | print(f'Calificación mayor = {calificacion_mayor:.2f}, obtenida por el alumno con matrícula: {matricula_mayor}') 31 | print(f'Calificación menor = {calificacion_menor:.2f}, obtenida por el alumno con matrícula: {matricula_menor}') 32 | else: 33 | print('\nNo hay datos que procesar.') 34 | -------------------------------------------------------------------------------- /Cap5/Programa 5_10.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.13 5 | """ 6 | 7 | 8 | def convierte_a_binario(numero): 9 | """ Convierte un número entero positivo a binario. 10 | 11 | Parámetro: 12 | numero: de tipo int, > 0. 13 | Regresa: 14 | La notación binaria del número recibido. Es de tipo int. 15 | Lanza: 16 | ValueError: cuando el dato no es entero o > 0. 17 | """ 18 | if type(numero) == int and numero > 0: 19 | binario = 0 20 | potencia = 1 21 | while numero >= 2: 22 | digito = numero % 2 23 | numero = numero // 2 24 | binario = binario + digito * potencia 25 | potencia = potencia * 10 26 | binario = binario + numero * potencia 27 | return binario 28 | raise ValueError('El dato no es un número entero o no es positivo.') 29 | 30 | # CP1: se proporciona un número entero positivo. 31 | print('\nCP1 --> Notación binaria de 2:', convierte_a_binario(2)) 32 | # CP2: se proporciona un número entero positivo. 33 | print('CP2 --> Notación binaria de 254897:', convierte_a_binario(254897)) 34 | # CP3: se proporciona un número real. 35 | try: 36 | print('CP3 --> Notación binaria de 6.5:', convierte_a_binario(6.5)) 37 | except ValueError as error: 38 | print('CP3 -->', error) 39 | # CP4: se proporciona un número entero negativo. 40 | try: 41 | print('CP4 --> Notación binaria de -8:', convierte_a_binario(-8)) 42 | except ValueError as error: 43 | print('CP4 -->', error) 44 | -------------------------------------------------------------------------------- /Cap5/Programa 5_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.10 5 | """ 6 | 7 | def genera_reporte(arch_ent, arch_sal): 8 | """ Genera un reporte del año y sede de los últimos Juegos 9 | Olímpicos, de acuerdo con las especificaciones dadas 10 | (quitar datos duplicados y colocar mayúsculas). 11 | 12 | Parámetro: 13 | arch_ent: de tipo str. Indica el nombre del archivo que almacena 14 | los datos de los Juegos Olímpicos, con errores. 15 | arch_sal: de tipo str. Indica el nombre del archivo donde se 16 | guardará el reporte solicitado. 17 | Lanza: 18 | FileNotFoundError: si no se pudo abrir el archivo. 19 | """ 20 | try: 21 | lee = open(arch_ent, 'r') 22 | escribe = open(arch_sal, 'w') 23 | escribe.write('Últimos Juegos Olímpicos\n'.upper()) 24 | for juego in lee: 25 | posicion = juego.find(' ') 26 | anio = juego[0: posicion] 27 | juego = juego[posicion + 1:] 28 | posicion = juego.rfind(' ') 29 | ciudad = juego[0: posicion] 30 | escribe.write(anio + ' ---- ' + ciudad.title() + '\n') 31 | lee.close() 32 | escribe.close() 33 | except FileNotFoundError: 34 | raise FileNotFoundError('No se pudo abrir el archivo.'.upper()) 35 | 36 | # ========================================================================== 37 | # Se prueba la función. En este caso se creó un archivo con los 38 | # datos de las últimas 9 olimpíadas. 39 | # ========================================================================== 40 | genera_reporte('juegos', 'Reporte_olimpico') -------------------------------------------------------------------------------- /Cap5/Programa 5_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.3 5 | """ 6 | 7 | def lee_entero_positivo(mensaje): 8 | """ Lectura de un número entero positivo. 9 | 10 | Parámetro: 11 | mensaje: de tipo str. Es el mensaje que debe desplegarse en el input(). 12 | Regresa: 13 | Un número entero positivo. 14 | """ 15 | bandera = True 16 | while bandera: 17 | try: 18 | entero = int(input(mensaje)) 19 | if entero > 0: 20 | bandera = False 21 | else: 22 | print('¡el número debe ser > 0!'.upper()) 23 | except: 24 | print('solo se aceptan números enteros.'.upper()) 25 | return entero 26 | 27 | def dias_y_horas(numero): 28 | """ Calcula cuantos días y horas están comprendidos en el valor recibido. 29 | 30 | Parámetro: 31 | numero: es un número de tipo int y debe ser > 0. 32 | Regresa: 33 | Cantidad de días y horas comprendidos en el número recibido. 34 | """ 35 | dias = numero // 24 36 | horas = numero % 24 37 | return dias, horas 38 | 39 | # ======================================================== 40 | # Pruebas de las funciones. 41 | # ======================================================== 42 | retraso_recital = lee_entero_positivo('Total de horas de retraso del recital: ') 43 | dias, horas = dias_y_horas(retraso_recital) 44 | print(f'El recital se retrasó {dias} días y {horas} horas') 45 | 46 | prox_vuelo = lee_entero_positivo('¿Cuántas horas faltan para el próximo vuelo?: ') 47 | dias, horas = dias_y_horas(prox_vuelo) 48 | print(f'El próximo vuelo sale en {dias} días y {horas} horas') 49 | 50 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_3 5 | Ejemplos de algunas de las excepciones que maneja Python. 6 | Junto a cada caso se explica qué es lo que ocasiona el error 7 | y cuál es la excepción que se lanza. 8 | """ 9 | 10 | # Ejemplo de excepción: ValueError. 11 | numero = int(input('Ingrese un número entero: ')) 12 | ''' 13 | Si al ingresar el dato el usuario se equivoca e ingresa un número 14 | con decimales, por ejemplo 305.23, entonces se interrumpe la ejecución 15 | por el error ocurrido y Python lanza la excepción: 16 | ValueError: invalid literal for int() with base 10: '305.23' 17 | ''' 18 | 19 | # Ejemplo de excepción: NameError. 20 | resultado = variable * 5.2 21 | ''' 22 | En este caso, si se usa un IDE, se marcará una advertencia de que 23 | la variable está indefinida. Sin embargo, dejará ejecutar el programa 24 | pero, al ejecutarse, se lanzará la excepción: 25 | NameError: name 'variable' is not defined 26 | ''' 27 | 28 | # Ejemplo de excepción: IndexError. 29 | mes = 'mayo' 30 | print(mes[4]) 31 | ''' 32 | Se intenta imprimir el carácter que está en la posición 4 de 'mayo'. 33 | Pero teniendo en cuenta que la indexación de los caracteres se hace 34 | a partir de la posición 0, la posición 4 en 'mayo' no existe, está 35 | fuera del rango de la cadena y, por lo tanto, lanza la excepción: 36 | IndexError: string index out of range 37 | ''' 38 | 39 | # Ejemplo de excepción: TypeError. 40 | resultado = numero // 'algo' 41 | ''' 42 | En la operación se intenta dividir un número por una cadena de 43 | caracteres y, al ocurrir el error, se lanza la excepción: 44 | TypeError: unsupported operand type(s) for //: 'int' and 'str' 45 | ''' 46 | 47 | 48 | -------------------------------------------------------------------------------- /Cap5/Programa 5_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.4 5 | """ 6 | 7 | def lee_real(mensaje): 8 | """ Lectura de un número real. 9 | 10 | Parámetro: 11 | mensaje: tipo str. Se despliega en el input(). 12 | Regresa: 13 | Un número de tipo float. 14 | """ 15 | bandera = True 16 | while bandera: 17 | try: 18 | real = float(input(mensaje)) 19 | bandera = False 20 | except: 21 | print('solo se aceptan números reales.'.upper()) 22 | return real 23 | 24 | 25 | def calcula_distancia(punto1, punto2): 26 | """ Calcula la distancia entre dos puntos, dadas sus coordenadas. 27 | 28 | Parámetro: 29 | punto1: de tipo tuple, guarda las coordenadas del primer punto. 30 | punto2: de tipo tuple, guarda las coordenadas del segundo punto. 31 | Regresa: 32 | La distancia entre los puntos. Es de tipo float. 33 | """ 34 | distancia = ((punto2[0] - punto1[0]) ** 2 + (punto2[1] - punto1[1]) ** 2) ** 0.5 35 | return distancia 36 | 37 | #====================================================================== 38 | # Algunas pruebas de las funciones. 39 | #====================================================================== 40 | x1 = lee_real('Ingrese la coordenada x del primer punto: ') 41 | y1 = lee_real('Ingrese la coordenada y del primer punto: ') 42 | x2 = lee_real('Ingrese la coordenada x del segundo punto: ') 43 | y2 = lee_real('Ingrese la coordenada y del segundo punto: ') 44 | # Se forman las tuplas que representan a los puntos. 45 | punto1 = (x1, y1) 46 | punto2 = (x2, y2) 47 | distancia = calcula_distancia(punto1, punto2) 48 | print(f'\nLa distancia entre los puntos es = {distancia:.2f}') 49 | 50 | -------------------------------------------------------------------------------- /Cap5/Ejemplo 5_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 5_7 5 | Lanzamiento de excepciones desde una función. 6 | """ 7 | 8 | def calcula_promedio(*numeros): 9 | """ Calcula el promedio de los números proporcionados. 10 | 11 | Parámetro: 12 | *numeros: cero o varios números, int o float. 13 | Regresa: 14 | El promedio de los números. 15 | Lanza: 16 | ZeroDivisionError: cuando no se proporcionan datos. 17 | ValueError: cuando alguno de los datos proporcionados no es numérico. 18 | """ 19 | try: 20 | suma = 0 21 | for valor in numeros: 22 | suma += valor 23 | return suma / len(numeros) 24 | except ZeroDivisionError: 25 | raise ZeroDivisionError('No hay datos: división entre 0.') 26 | except TypeError: 27 | raise TypeError('Error en los datos: no son numéricos.') 28 | 29 | #======================================================== 30 | # Pruebas de la función. 31 | #======================================================== 32 | # CP1: no se proporcionan datos: división entre 0. 33 | try: 34 | promedio = calcula_promedio() 35 | print('\nCP1 --> El promedio es =', promedio) 36 | except Exception as error: 37 | print('\nCP1 -->', error) 38 | 39 | # CP2: se proporcionan datos no numéricos. 40 | try: 41 | promedio = calcula_promedio(4.5, 'hola', 23, -33) 42 | print('CP2 --> El promedio es =', promedio) 43 | except Exception as error: 44 | print('CP2 -->', error) 45 | 46 | # CP3: se proporcionan 2 números enteros. 47 | print('CP3 --> El promedio es =', calcula_promedio(4, 8)) 48 | # CP4: se proporcionan 8 números reales. 49 | prom = calcula_promedio(3.5, 8.2, -9.6, 12.2, 25.7, 48.7, -41.55, 39.33) 50 | print('CP4 --> El promedio es =', prom) 51 | -------------------------------------------------------------------------------- /Cap4/Programa 4_26.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.26 5 | Calcula el total de votos y porcentaje para cada uno de los 4 6 | candidatos, de acuerdo con una encuesta sobre intención de votos. 7 | """ 8 | 9 | votos_candidato1 = 0 10 | votos_candidato2 = 0 11 | votos_candidato3 = 0 12 | votos_candidato4 = 0 13 | voto = int(input('\nIngrese número del candidato (1, 2, 3, 4): ')) 14 | while voto != -1: 15 | if voto == 1: 16 | votos_candidato1 += 1 17 | elif voto == 2: 18 | votos_candidato2 += 1 19 | elif voto == 3: 20 | votos_candidato3 += 1 21 | elif voto == 4: 22 | votos_candidato4 += 1 23 | voto = int(input('Ingrese número del candidato al que votará (1, 2, 3, 4): ')) 24 | total_votos = votos_candidato1 + votos_candidato2 + votos_candidato3 + votos_candidato4 25 | if total_votos > 0: 26 | porcentaje_cand1 = votos_candidato1 / total_votos * 100 27 | porcentaje_cand2 = votos_candidato2 / total_votos * 100 28 | porcentaje_cand3 = votos_candidato3 / total_votos * 100 29 | porcentaje_cand4 = votos_candidato4 / total_votos * 100 30 | print(f'\nTotal de intenciones de votos para el candidato 1:' 31 | f' {votos_candidato1}') 32 | print(f'Representa un: {porcentaje_cand1:.2f}% del total.') 33 | print(f'\nTotal de intenciones de votos para el candidato 2:' 34 | f' {votos_candidato2}') 35 | print(f'Representa un: {porcentaje_cand2:.2f}% del total.') 36 | print(f'\nTotal de intenciones de votos para el candidato 3:' 37 | f' {votos_candidato3}') 38 | print(f'Representa un: {porcentaje_cand3:.2f}% del total.') 39 | print(f'\nTotal de intenciones de votos para el candidato 4:' 40 | f' {votos_candidato4}') 41 | print(f'Representa un: {porcentaje_cand4:.2f}% del total.') 42 | else: 43 | print('\nNo hay datos que analizar.') -------------------------------------------------------------------------------- /Cap5/Programa 5_15.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.18 5 | Determina si dos palabras son anagramas. 6 | """ 7 | 8 | def es_anagrama(pal1, pal2): 9 | """ Determina si dos palabras son anagramas. 10 | Parámetros: 11 | pal1: de tipo str. 12 | pal2: de tipo str. 13 | Regresa: 14 | True si son anagramas, False en caso contrario. 15 | """ 16 | n = len(pal1) 17 | if n == len(pal2): 18 | indice = 0 19 | anagrama = True 20 | while indice < n and anagrama: 21 | try: 22 | pos = pal2.index(pal1[indice]) 23 | pal2 = pal2[0: pos] + pal2[pos+1:] 24 | except: 25 | anagrama = False 26 | indice += 1 27 | else: 28 | anagrama = False 29 | return anagrama and len(pal2) == 0 30 | 31 | # ============================================================================= 32 | # Algunas pruebas de la función es_anagrama 33 | # ============================================================================= 34 | # CP1: se dan dos palabras que son anagramas. 35 | if es_anagrama('frase', 'fresa'): 36 | print('\nCP1: "frase y fresa" son anagramas.') 37 | else: 38 | print('\nCP1: "frase y fresa" no son anagramas.') 39 | # CP2: se dan dos palabras que no son anagramas. 40 | if es_anagrama('mar', 'arena'): 41 | print('CP2: "mar y arena" son anagramas.') 42 | else: 43 | print('CP2: "mar y arena" no son anagramas.') 44 | # CP3: se dan dos palabras que no son anagramas. 45 | if es_anagrama('aparta', 'raptar'): 46 | print('CP3: "aparta y raptar" son anagramas.') 47 | else: 48 | print('CP3: "aparta y raptar" no son anagramas.') 49 | # CP4: se dan dos cadenas vacías. 50 | if es_anagrama('', ''): 51 | print('CP4: dos cadenas vacías son anagramas.') 52 | else: 53 | print('CP4: dos cadenas vacías no son anagramas.') 54 | -------------------------------------------------------------------------------- /Cap5/Ejemplo 5_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 5_3 5 | Combinaciones de tipos de parámetros: posicionales, por omisión y de 6 | palabras claves. 7 | """ 8 | 9 | ''' 10 | Genera una cadena con el nombre completo de una persona, 11 | ordenado de dos formas diferentes, según uno de los parámetros. 12 | ''' 13 | def genera_nombre(nombre, apellido_paterno, apellido_materno, orden = False): 14 | if orden: 15 | nomb_comp = apellido_paterno + ' ' + apellido_materno + ', ' + nombre 16 | else: 17 | nomb_comp = nombre + ' ' + apellido_paterno + ' ' + apellido_materno 18 | return nomb_comp 19 | 20 | # Paso de parámetros posicionales. 21 | print('\nEjemplos de paso de parámetros posicionales:'.upper()) 22 | print(genera_nombre('Juan', 'Pérez', 'Dallia', True)) 23 | print(genera_nombre('Juan', 'Pérez', 'Dallia', False)) 24 | nombre = 'Irene' 25 | apellido_pat = 'Leno' 26 | apellido_mat = 'Arredondo' 27 | print(genera_nombre(nombre, apellido_pat, apellido_mat, True)) 28 | 29 | # Paso de parámetros por nombre. No importa el orden, solo los nombres. 30 | print('\nEjemplo de paso de parámetros por nombre:'.upper()) 31 | print(genera_nombre(nombre = 'Lucía', apellido_paterno = 'Larios', 32 | apellido_materno = 'Ruíz', orden = False)) 33 | print(genera_nombre(orden = True, apellido_paterno = 'Larios', 34 | nombre = 'Lucía', apellido_materno = 'Ruíz')) 35 | 36 | # Uso del valor por omisión del parámetro formal orden. 37 | print('\nParámetros por nombre y por omisión:'.upper()) 38 | print(genera_nombre(apellido_paterno = 'Pastore', nombre = 'Luis', 39 | apellido_materno = 'Genero')) 40 | 41 | ''' 42 | Uso combinado de parámetros posicionales y por nombre. Luego de un 43 | parámetro por nombre no se puede escribir uno posicional. 44 | ''' 45 | print(f'\nEjemplo de paso de parámetros posicionales seguidos de ' 46 | f'parámetros por nombre:'.upper()) 47 | print(genera_nombre('Pedro', 'Nardoni', apellido_materno = 'Lazo', orden = False)) 48 | -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 4.4 5 | Calcula e imprime el promedio de las calificaciones de un grupo de n alumnos. 6 | Además, obtiene la calificación más alta y la más baja del grupo y las 7 | imprime junto con la matrícula del alumno que las obtuvo. 8 | 9 | Solución alternativa del problema 4.4. 10 | Compare esta solución con la desarrollada por usted y con la del Programa 4_4. 11 | """ 12 | 13 | total_alumnos = int(input('Ingrese la cantidad de alumnos: ')) 14 | if total_alumnos > 0: 15 | print(f'\nIngrese la matrícula y la calificación del primer alumno:') 16 | matricula = int(input()) 17 | calificacion = float(input()) 18 | suma_calif = calificacion 19 | calificacion_mayor = calificacion # Al mayor se lo inicializa con la primer calificación. 20 | matricula_mayor = matricula # Se inicializa la matrícula con la primera leída. 21 | calificacion_menor = calificacion # Al menor se lo inicializa con la primer calificación. 22 | matricula_menor = matricula # Se inicializa la matrícula con la primera leída. 23 | for i in range(2, total_alumnos + 1): # Se leen total_alumnos - 1 en el ciclo 24 | print(f'\nIngrese la matrícula y la calificación del alumno {i}:') 25 | matricula = int(input()) 26 | calificacion = float(input()) 27 | suma_calif += calificacion 28 | if calificacion > calificacion_mayor: 29 | calificacion_mayor = calificacion 30 | matricula_mayor = matricula 31 | elif calificacion < calificacion_menor: 32 | calificacion_menor = calificacion 33 | matricula_menor = matricula 34 | promedio = suma_calif / total_alumnos 35 | print(f'\nPromedio de calificaciones = {promedio:.2f}') 36 | print(f'Calificación mayor = {calificacion_mayor:.2f}, obtenida por el alumno con matrícula: {matricula_mayor}') 37 | print(f'Calificación menor = {calificacion_menor:.2f}, obtenida por el alumno con matrícula: {matricula_menor}') 38 | else: 39 | print('\nNo hay datos que procesar.') 40 | -------------------------------------------------------------------------------- /Cap5/Ejemplo 5_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 5_1 5 | Funciones muy simples. 6 | """ 7 | 8 | ''' 9 | Función que genera un saludo personalizado. 10 | Recibe un nombre como parámetro. 11 | No regresa ningún resultado, por eso no aparece el return. 12 | ''' 13 | def saluda(nombre): 14 | print('\nHola', nombre) 15 | 16 | ''' 17 | Función que regresa el mayor de 2 números. 18 | Recibe dos números como parámetros. 19 | Regresa el mayor de los números. 20 | ''' 21 | def encuentra_mayor(numero1, numero2): 22 | if numero1 > numero2: 23 | mayor = numero1 24 | else: 25 | mayor = numero2 26 | return mayor 27 | 28 | ''' 29 | Función que lee y regresa un entero, asegurándose que el 30 | dato dado es un número entero. 31 | Recibe un mensaje como parámetro. 32 | Regresa el número entero leído. 33 | ''' 34 | def lee_entero(mensaje): 35 | bandera = True 36 | while bandera: 37 | try: 38 | entero = int(input(mensaje)) 39 | bandera = False 40 | except: 41 | print('solo se aceptan números enteros.'.upper()) 42 | return entero 43 | 44 | # ============================================================================= 45 | # Pruebas de las funciones. 46 | # ============================================================================= 47 | # Se llama a la función con el nombre de la persona a saludar. 48 | saluda('Juan') 49 | # Imprime el valor None, ya que la función no regresa un resultado. 50 | print(saluda('Antonio')) 51 | 52 | # Se proporcionan los datos que deben compararse. 53 | # El resultado se despliega junto al mensaje que está a la izquierda. 54 | precio1 = 25.3 55 | precio2 = 18.6 56 | print('\nEl mayor es:', encuentra_mayor(precio1, precio2)) 57 | 58 | # Se proporciona el mensaje que debe mostrarse cuando se pide el dato. 59 | # El resultado obtenido por la función se guarda en las variables. 60 | anio_construc_museo = lee_entero('¿En qué año fue construido el museo? ') 61 | anio_construc_estadio = lee_entero('¿En qué año fue construido el estadio? ') 62 | 63 | -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_3 5 | Impresiones en Python usando el método format(). 6 | """ 7 | 8 | edad = 83 9 | # Imprime el texto y el valor de la variable ocupando 5 espacios. 10 | print("Edad del abuelo: {0:5d}".format(edad)) # Argumento posicional. 11 | print("Edad del abuelo: {edad:5d}".format(edad = 88)) # Argumento nombrado. 12 | 13 | ''' 14 | Al dato indicado con el 0 lo sustituye el numero1 y al indicado con el 1, 15 | el numero2 multiplicado por 20. Es decir, primero se multiplica y el 16 | resultado es el que se imprime. Se reservan 10 espacios y el resultado 17 | se imprime justificado a derecha. 18 | ''' 19 | numero1 = 1258 20 | numero2 = 8920 21 | # Argumentos posicionales. 22 | print('{0:1d} {1:10d}'.format(numero1, numero2 * 20)) 23 | # Argumentos nombrados. 24 | print('{numero1:1d} {numero2:10d}'.format(numero1 = 1234, numero2 = 987)) 25 | precio = 2.23 26 | # Deja 3 decimales: completa con 0. 27 | print("El precio del pan es: ${0:.3f}".format(precio)) 28 | # Reserva 10 espacios para el número y justifica a derecha. 29 | print("El precio del pan es: ${0:10.3f}".format(precio)) 30 | print("El precio de la fruta es: ${fruta:.2f}".format(fruta = 12.5)) 31 | 32 | ''' 33 | En el primer ejemplo se usan argumentos nombrados, ya que entre {} 34 | se da el nombre del argumento que se incluirá en esa posición. 35 | En el segundo ejemplo se utilizan argumentos posicionales; 36 | es decir, se indica con un número si se debe reemplazar con el 37 | primer dato, el segundo, etc. 38 | ''' 39 | print('Este {herramienta} es de color {color}.'.format(herramienta = 'martillo', color = 'gris')) 40 | print('Este {0} es de color {1}.'.format('martillo', 'gris')) 41 | 42 | # Al usar dos veces {0} se utiliza la palabra martillo en ambas posiciones. 43 | print('Este {0} es de color {0}.'.format('martillo', 'gris')) 44 | 45 | ''' 46 | Ejemplo usando variables en lugar de constantes. 47 | En este caso solo se pueden usar argumentos posicionales. 48 | ''' 49 | animal1 = "gatos" 50 | animal2 = "perros" 51 | print('Existe la creencia de que los {0} y los {1} no pueden convivir.'.format(animal1, animal2)) 52 | -------------------------------------------------------------------------------- /Cap5/lecturas.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Módulo lecturas.py 5 | Solución del problema 5.5 6 | Agrupa varias funciones dedicadas a la lectura de datos, validando estos. 7 | 8 | Funciones: 9 | -lee_numero: lee y regresa un número (int o float). 10 | -lee_numero_positivo: lee y regresa un número (int o float) > 0. 11 | """ 12 | 13 | def lee_numero(tipo, mensaje): 14 | """ Lectura de un número entero o real, sin importar el signo. 15 | 16 | Parámetro: 17 | tipo: de tipo int o float. Indica qué tipo de número se debe leer. 18 | mensaje: de tipo str. Es el mensaje que se despliega en el input(). 19 | Regresa: 20 | Un número, de tipo int o float. 21 | """ 22 | bandera = True 23 | while bandera: 24 | try: 25 | numero = tipo(input(mensaje)) 26 | bandera = False 27 | except: 28 | print(f'solo se aceptan números de tipo {tipo}.'.upper()) 29 | return numero 30 | 31 | def lee_numero_positivo(tipo, mensaje): 32 | """ Lectura de un número entero o real positivo. 33 | 34 | Parámetro: 35 | tipo: de tipo int o float. Indica qué tipo de número se debe leer. 36 | mensaje: de tipo str. Es el mensaje que se despliega en el input(). 37 | Regresa: 38 | Un número positivo, de tipo int o float. 39 | """ 40 | bandera = True 41 | while bandera: 42 | try: 43 | numero = tipo(input(mensaje)) 44 | if numero > 0: 45 | bandera = False 46 | else: 47 | print('¡el número debe ser > 0!'.upper()) 48 | except: 49 | print(f'solo se aceptan números de tipo {tipo}.'.upper()) 50 | return numero 51 | 52 | # ======================================================== 53 | # Algunas pruebas de las funciones. 54 | # ======================================================== 55 | edad = lee_numero_positivo(int, 'Ingrese la edad del alumno: ') 56 | temperatura = lee_numero(float, 'Ingrese la temperatura actual: ') 57 | print(f'\nEl alumno tiene {edad} años') 58 | print(f'La temperatura del día de hoy es {temperatura} °C') 59 | -------------------------------------------------------------------------------- /Cap5/Programa 5_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.1 5 | """ 6 | 7 | def es_primo(numero): 8 | """ Determina si un número es primo o no. 9 | 10 | Parámetro: 11 | número: es de tipo int o float y > 0. 12 | Regresa: 13 | True si el número es primo o False en caso contrario. 14 | """ 15 | primo = False 16 | if numero == 2: 17 | primo = True 18 | else: 19 | # Descarta el 1 y todos los pares > 2. 20 | if numero > 2 and numero % 2 != 0: 21 | divisor = 3 22 | limite = numero // 2 23 | while divisor < limite and numero % divisor != 0: 24 | divisor += 2 25 | if divisor >= limite: 26 | primo = True 27 | return primo 28 | 29 | #======================================================== 30 | # Algunos usos de la función. 31 | #======================================================== 32 | 33 | # Determina si un número es o no primo (problema 4.30). 34 | dato = int(input('\nIngrese un número entero positivo: ')) 35 | if dato <= 0: 36 | print('\nError en el dato.') 37 | else: 38 | if es_primo(dato): 39 | print(f'El número {dato} sí es un número primo') 40 | else: 41 | print(f'El número {dato} no es un número primo') 42 | 43 | # Encuentra todos los primos hasta el valor dado (problema 4.34). 44 | valor = int(input('\nIngrese hasta qué valor quiere analizar: ')) 45 | if valor <= 0: 46 | print('\nError en el dato.') 47 | else: 48 | for numero in range(2, valor + 1): 49 | if es_primo(numero): 50 | print(f'El número {numero} sí es un número primo') 51 | 52 | # Encuentra todos los primos gemelos hasta el valor dado (problema 4.37). 53 | valor = int(input('\nIngrese hasta qué valor quiere encontrar primos gemelos: ')) 54 | if valor <= 0: 55 | print('\nError en el dato.') 56 | else: 57 | print('\nLista de pares de primos gemelos:') 58 | primo_anterior = 0 59 | for numero in range(3, valor + 1, 2): 60 | if es_primo(numero): 61 | if numero - primo_anterior == 2: 62 | print(f'{primo_anterior} - {numero}'.center(30)) 63 | primo_anterior = numero 64 | 65 | 66 | 67 | 68 | -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 4_7 5 | Algunos usos de las instrucciones break y continue. 6 | """ 7 | 8 | ''' 9 | El ciclo permite hacer tantas lecturas como sean necesarias para 10 | obtener un número mayor que 0. Observe que solo cuando se cumpla 11 | esta condición se ejecutará el break interrumpiendo el ciclo. 12 | ''' 13 | print('\nOpción 1: uso de break'.upper()) 14 | while True: 15 | numero = int(input('Ingrese un número entero positivo: ')) 16 | if numero > 0: 17 | break; 18 | 19 | print('\nOpción 2: sin usar break y usando una selección'.upper()) 20 | bandera = True 21 | while bandera: 22 | numero = int(input('Ingrese un número entero positivo: ')) 23 | if numero > 0: 24 | bandera = False 25 | 26 | print('\nOpción 3: sin usar break y usando doble lectura'.upper()) 27 | numero = int(input('Ingrese un número entero positivo: ')) 28 | while numero <= 0: 29 | numero = int(input('Ingrese un número entero positivo: ')) 30 | 31 | ''' 32 | Ejemplo del uso de las instrucciones continue y break. 33 | El continue se usa para no evaluar los números fuera de rango y los pares. 34 | El break se usa para interrumpir el ciclo solo cuando el usuario ya no quiera 35 | seguir buscando números primos mayores que 100. 36 | ''' 37 | print('\n\nOpción 1: uso de break y continue'.upper()) 38 | while True: 39 | numero = int(input('Ingrese un número entero positivo > 100: ')) 40 | # Descarta los fuera de rango y los pares. 41 | if numero <= 100 or numero % 2 == 0: 42 | continue # Inicia nuevamente el ciclo. 43 | divisor = 3 44 | limite = numero // 2 45 | while divisor <= limite and numero % divisor != 0: 46 | divisor += 2 47 | if divisor >= limite: 48 | print(f'El {numero} es un número primo') 49 | respuesta = input('Quiere evaluar otro número: SI/NO ').upper() 50 | if respuesta.upper() == 'NO': 51 | break # Interrumpe el ciclo. 52 | 53 | print('\n\nOpción 2: sin usar el break y continue'.upper()) 54 | respuesta = input('Quiere evaluar un número: SI/NO ').upper() 55 | while respuesta.upper() != 'NO': 56 | numero = int(input('Ingrese un número entero positivo > 100: ')) 57 | # Descarta los fuera de rango y los pares. 58 | if numero > 100 and numero % 2 != 0: 59 | divisor = 3 60 | limite = numero // 2 61 | while divisor <= limite and numero % divisor != 0: 62 | divisor += 2 63 | if divisor >= limite: 64 | print(f'El {numero} es un número primo') 65 | respuesta = input('Quiere evaluar otro número: SI/NO ').upper() 66 | 67 | -------------------------------------------------------------------------------- /Cap5/Programa 5_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 5.9 5 | """ 6 | import lecturas 7 | 8 | def guarda_calificaciones(nom_arch, total): 9 | """ Almacena las calificaciones leídas por terminal en un archivo de texto. 10 | En la primera línea guarda el total y cada calificación se escribe en una 11 | línea diferente. 12 | 13 | Parámetro: 14 | nom_arch: de tipo str. Indica el nombre del archivo que se creará. 15 | total: de tipo int. Indica el total de calificaciones a 16 | guardar en el archivo. 17 | """ 18 | arch_calif = open(nom_arch, 'w') # Se abre para escritura. 19 | arch_calif.write(str(total) + '\n') 20 | for i in range(1, total + 1): 21 | mensaje = 'Ingrese la calificación '+ str(i) + ': ' 22 | cal = lecturas.lee_numero_positivo(float, mensaje) 23 | # Para que quede una calificación por línea. 24 | arch_calif.write(str(cal) + '\n') 25 | arch_calif.close() 26 | 27 | def calcula_promedio(nom_arch): 28 | """ Calcula y regresa el promedio de los valores 29 | guardados en un archivo de texto. 30 | 31 | Parámetro: 32 | nom_arch: de tipo str. Indica el nombre del archivo 33 | del cual se leerán los datos. 34 | Regresa: 35 | El promedio de los datos almacenados en el archivo. De tipo float. 36 | Lanza: 37 | FileNotFoundError: cuando no se pudo abrir el archivo. 38 | ValueError: cuando hubo algún error en los datos. 39 | """ 40 | try: 41 | archivo = open(nom_arch, 'r') 42 | suma = 0 43 | contador = int(archivo.readline()) 44 | for _ in range(1, contador + 1): 45 | cal = float(archivo.readline()) 46 | suma += cal 47 | archivo.close() 48 | return suma / contador 49 | except FileNotFoundError: 50 | raise FileNotFoundError('No se pudo abrir el archivo.'.upper()) 51 | except (ValueError, ZeroDivisionError): 52 | raise ValueError('Error en los datos.'.upper()) 53 | 54 | #=============================================================== 55 | # Uso de las funciones para resolver el problema. 56 | #=============================================================== 57 | archivo = input('Nombre del archivo donde guardar las calificaciones: ') 58 | total = lecturas.lee_numero_positivo(int, '¿Cuántas calificaciones? ') 59 | guarda_calificaciones(archivo, total) 60 | 61 | # Importante si la creación del archivo se hizo en otro programa. 62 | archivo = input('Nombre del archivo de calificaciones: ') 63 | try: 64 | print(f"\nPromedio = {calcula_promedio(archivo):.2f}") 65 | except Exception as error: 66 | print(error) 67 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_4 5 | Manejo de excepciones. 6 | """ 7 | 8 | ''' 9 | Si el valor ingresado se puede convertir a entero, entonces se 10 | calcula y se despliega su cuadrado. En caso contrario se despliega 11 | un mensaje indicando que hubo un error. 12 | ''' 13 | try: 14 | numero = int(input('Ingrese un número entero: ')) 15 | print('El cuadrado del número es:', numero ** 2) 16 | except ValueError: 17 | print('\nError: el dato ingresado no se pudo convertir a entero.') 18 | 19 | ''' 20 | Si la cadena de caracteres tiene una longitud > a 0, entonces 21 | se muestra la inicial; es decir el carácter de la posición 0. 22 | En caso contrario se despliega un mensaje de error, ya que una 23 | cadena vacía no tiene un elemento en la posición 0. 24 | ''' 25 | nombre = input('Ingrese el nombre de la persona: ') 26 | try: 27 | print('La inicial es: ', nombre[0]) 28 | except IndexError: 29 | print('\nIngresó una cadena vacía. No hay inicial.') 30 | 31 | ''' 32 | Se intenta convertir a números reales a los datos ingresados y 33 | posteriormente dividirlos. Sin embargo puede suceder un error al 34 | convertirlos (si no son números) o al dividirlos (si el segundo es 0). 35 | En este caso las 2 excepciones que se manejan se escriben como una tupla. 36 | ''' 37 | numerador = input('Ingrese el numerador: ') 38 | denominador = input('Ingrese el denominador: ') 39 | try: 40 | numero1 = float(numerador) 41 | numero2 = float(denominador) 42 | resultado = numero1 / numero2 43 | print(f'\nEl resultado de la división es: {resultado:.2f}') 44 | except (ValueError, ZeroDivisionError): 45 | print('\nDato no numérico o el denominador es un cero.') 46 | 47 | ''' 48 | Otra manera de escribir el bloque except es como se muestra más abajo. 49 | Así se puede ser más explícito al indicar qué hacer en caso de error, 50 | especialmente si se requieren acciones diferentes según la excepción 51 | ocurrida. 52 | ''' 53 | try: 54 | numero1 = float(numerador) 55 | numero2 = float(denominador) 56 | resultado = numero1 / numero2 57 | print(f'\nEl resultado de la división es: {resultado:.2f}') 58 | except ValueError: 59 | print('\nAlguno de los datos no es un número.') 60 | except ZeroDivisionError: 61 | print('\nEl denominador es un cero.') 62 | 63 | ''' 64 | Cuando no interese precisar el tipo de excepción, el bloque del 65 | except se puede quedar vacío. 66 | ''' 67 | try: 68 | numero1 = float(numerador) 69 | numero2 = float(denominador) 70 | resultado = numero1 / numero2 71 | print(f'\nEl resultado de la división es: {resultado:.2f}') 72 | except: 73 | print('\nUn error ha ocurrido.'.upper()) 74 | -------------------------------------------------------------------------------- /Cap5/archivos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Módulo archivos.py 5 | Agrupa varias funciones auxiliares en el manejo de archivos. 6 | 7 | Funciones: 8 | escribe_archivo: escribe en un archivo los elementos recibidos. 9 | lee1_archivo: regresa el contenido de un archivo de texto. 10 | lee2_archivo: regresa el contenido de un archivo de texto. 11 | cuenta_y_suma: regresa cuantos números hay en un archivo y la suma de estos. 12 | """ 13 | 14 | # Solución del problema 5.6 15 | def escribe_archivo(arch, *args): 16 | """ Crea un archivo y guarda en líneas diferentes cada 17 | uno de los valores recibidos por medio del parámetro args. 18 | 19 | Parámetro: 20 | arch: de tipo str. Nombre con el que se creará el archivo. 21 | *args: parámetro de longitud variable. 22 | """ 23 | arch = open(arch, 'w') 24 | for val in args: 25 | arch.write(str(val)) 26 | arch.write('\n') 27 | arch.close() 28 | 29 | # Solución del problema 5.7 - alternativa 1 30 | def lee1_archivo(arch): 31 | """ Regresa el contenido del archivo llamado arch. 32 | 33 | Parámetro: 34 | arch: de tipo str. Nombre del archivo que debe leerse. 35 | regresa: 36 | El contenido del archivo con formato de str. 37 | Lanza: 38 | FileNotFoundError: cuando no se puede abrir el archivo. 39 | """ 40 | try: 41 | lee = open(arch, 'r') 42 | linea = lee.read(); # Se lee todo el contenido del archivo. 43 | lee.close() 44 | return linea 45 | except FileNotFoundError: 46 | raise FileNotFoundError('No se pudo abrir el archivo.'.upper()) 47 | 48 | # Solución del problema 5.7 - alternativa 2 49 | def lee2_archivo(arch): 50 | try: 51 | lee = open(arch, 'r') 52 | cadena = '' 53 | for val in lee: # Itera sobre el archivo. 54 | cadena += val 55 | lee.close() 56 | return cadena 57 | except FileNotFoundError: 58 | raise FileNotFoundError('No se pudo abrir el archivo.'.upper()) 59 | 60 | # Solución del problema 5.8 61 | def cuenta_y_suma(arch): 62 | """ Regresa total de números guardados en un archivo y la suma de estos. 63 | 64 | Parámetro: 65 | arch: de tipo str. Nombre del archivo que debe leerse. 66 | Regresa: 67 | El total de números leídos y su suma. Es de tipo tuple. 68 | Lanza: 69 | FileNotFoundError: cuando no se pudo abrir el archivo. 70 | """ 71 | try: 72 | lee = open(arch, 'r') 73 | suma = 0 74 | cuenta = 0 75 | for val in lee: # Itera sobre el archivo. 76 | try: 77 | suma += float(val) # El dato es un número: se +. 78 | cuenta += 1 79 | except: # No es número: se pasa al siguiente dato. 80 | continue 81 | lee.close() 82 | return (cuenta, suma) 83 | except FileNotFoundError: 84 | raise FileNotFoundError('No se pudo abrir el archivo.'.upper()) 85 | -------------------------------------------------------------------------------- /Cap2/Ejemplo 2_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 2_3 5 | Tuplas: creación y algunos ejemplos de usos. 6 | """ 7 | 8 | vacia = () # Tupla vacía. 9 | numeros = (1, 2, 3) # Formada por 3 números. 10 | # Formada por 3 cadenas. 11 | saludos = ('Buenos días', 'Buenos tardes', 'Buenas noches') 12 | # Formada por datos de distintos tipos. 13 | mezcla = ('rojo', 4, True, -16.5) 14 | fecha = 31, 'enero', 2020 # Define una fecha. No se usaron (). 15 | 16 | print('\nEjemplos de tuplas:'.upper()) 17 | print(vacia) 18 | print(numeros) 19 | print(mezcla) 20 | print(fecha) 21 | 22 | # Tuplas de un solo elemento: requieren una coma luego del elemento. 23 | elem_con_coma = ('hola',) # Para que se considere una tupla. 24 | elem_sin_coma = ('hola') # Al faltarle la coma, se considera una cadena. 25 | # Imprime: 26 | print('\nIncluyendo la coma anónima:', type(elem_con_coma)) 27 | # Imprime: 28 | print('No incluyendo la coma anónima:', type(elem_sin_coma)) 29 | 30 | # Funciones de tuplas. 31 | # Cantidad de elementos de la tupla. 32 | print('\nLa longitud de la tupla es:', len(mezcla)) 33 | # Cuenta cuántas veces está el 4 en la tupla. 34 | print(f'El 4 está {mezcla.count(4)} vez (veces) en: {mezcla}') 35 | # Regresa la posición del valor True en la tupla. 36 | print('El valor True está en la posición:', mezcla.index(True)) 37 | #print(mezcla.index(17)) # Da un ValueError 38 | 39 | # Concatena tuplas con el operador +. 40 | conca = numeros + mezcla 41 | print('\nResultado de la concatenación de las tuplas:', conca) 42 | 43 | # Repite tuplas con el operador *. 44 | repite = numeros * 3 45 | print('\nLa tupla repetida 3 veces es:', repite) 46 | 47 | # Acceso a elementos de la tupla por medio de un índice. 48 | print('\nEl cuarto elemento es:', conca[3]) # Enumera a partir de 0. 49 | print('\nEl último elemento es:', mezcla[-1]) # Inicia desde el final. 50 | #print(vacia[1]) # Da IndexError: tuple index out of range 51 | 52 | # Se pueden subdividir (slice) como las cadenas. 53 | parte = mezcla[0:2] 54 | print('\nLa tupla formada por los 2 primeros elementos es:', parte) 55 | 56 | # Desempaquetar valores de una tupla. Exige conocer la longitud de la tupla. 57 | dia, mes, anio = fecha 58 | print(f'\nLuego de desempaquetar: día = {dia}, mes = {mes} y año = {anio}') 59 | manana, tarde, noche = saludos 60 | print(f'\nA la mañana decimos: "{manana}", a la tarde: "{tarde}" y ' 61 | f'a la noche: "{noche}"') 62 | # Da: ValueError: too many values to unpack (expected 2) 63 | #val1, val2 = mezcla 64 | 65 | # Anidar tuplas: 2 cadenas y una tupla. 66 | datos_completos = 'Silvia', 'Guardati', fecha 67 | print('\nAnidando 2 cadenas y 1 tupla:', datos_completos) 68 | # Anidar tuplas: 2 tuplas. 69 | sal_fecha = (saludos, fecha) 70 | print('\nAnidando 2 tuplas:', sal_fecha) 71 | 72 | # Comparación de tuplas. 73 | # Da True: los 3 primeros elementos coinciden, pero repite tiene más. 74 | print('\n¿Menor?', numeros < repite) 75 | # Da True: 'hola' es mayor que el primer elemento de saludos: 76 | # minúsculas > mayúsculas. 77 | print('\n¿Mayor?', elem_con_coma > saludos) 78 | 79 | # Genera una tupla a partir de una cadena de caracteres. 80 | letras = tuple('lagarto') 81 | print('\nLa tupla formada a partir de lagarto es:', letras) 82 | -------------------------------------------------------------------------------- /Cap5/auxiliar.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Módulo auxuliar.py 5 | Agrupa varias funciones desarrolladas para algunos problemas 6 | del capítulo 5, para facilitar el reuso de estas. 7 | 8 | Funciones: 9 | es_primo: determina si un número es o no primo. 10 | es_palindromo: determina si una secuencia es o no palíndromo. 11 | convierte_a_binario: obtiene la notación en binario de un 12 | número entero positivo. 13 | suma_divisores: obtiene la suma de los divisores de un número 14 | entero positivo. 15 | genera_espejo: obtiene y regresa e número espejo del número recibido. 16 | calcula_edad: calcula y regresa la edad de acuerdo con la fecha de 17 | nacimiento y la fecha actual. 18 | """ 19 | 20 | import time 21 | 22 | def es_primo(numero): 23 | """ Determina si un número es primo o no. 24 | 25 | Parámetro: 26 | número: es de tipo int o float y > 0. 27 | Regresa: 28 | True si el número es primo, False en caso contrario. 29 | """ 30 | primo = False 31 | if numero == 2: 32 | primo = True 33 | else: 34 | # Descarta el 1 y todos los pares > 2. 35 | if numero > 2 and numero % 2 != 0: 36 | divisor = 3 37 | limite = numero // 2 38 | while divisor < limite and numero % divisor != 0: 39 | divisor += 2 40 | if divisor >= limite: 41 | primo = True 42 | return primo 43 | 44 | def es_palindromo(secuencia): 45 | """ Determina si la secuencia es palíndromo. 46 | 47 | Parámetro: 48 | secuencia: cualquier tipo iterable 49 | Regresa: 50 | True si la secuencia es palíndromo, False si no. 51 | """ 52 | # Se convierte a str para usar el método replace y quitar 53 | # los posibles espacios en blanco de la secuencia. 54 | secuencia = str(secuencia) 55 | secuencia = secuencia.replace(' ', '') 56 | n = len(secuencia) 57 | izq = 0 58 | der = n - 1 59 | while izq <= der and secuencia[izq] == secuencia[der]: 60 | izq += 1 61 | der -= 1 62 | return izq > der 63 | 64 | 65 | def convierte_a_binario(numero): 66 | """ Convierte un número entero positivo a binario. 67 | 68 | Parámetro: 69 | numero: de tipo int, > 0. 70 | Regresa: 71 | La representación binaria del número. Es de tipo int. 72 | Lanza: 73 | ValueError: cuando el dato no es entero o > 0. 74 | """ 75 | if type(numero) == int and numero > 0: 76 | binario = 0 77 | potencia = 1 78 | while numero >= 2: 79 | digito = numero % 2 80 | numero = numero // 2 81 | binario = binario + digito * potencia 82 | potencia = potencia * 10 83 | binario = binario + numero * potencia 84 | return binario 85 | raise ValueError('El dato no es un número entero o no es positivo.') 86 | 87 | def suma_divisores(numero): 88 | """ Calcula la suma de los divisores de un número, sin 89 | incluir al mismo número. 90 | 91 | Parámetro: 92 | numero: de tipo int, > 0. 93 | Regresa: 94 | La suma de los divisores del número. Es de tipo int. 95 | Lanza: 96 | ValueError: cuando el dato no es entero o > 0. 97 | """ 98 | if type(numero) == int and numero > 0: 99 | suma = 0 100 | limite = numero // 2 101 | for num in range(1, limite + 1): 102 | if numero % num == 0: 103 | suma += num 104 | return suma 105 | raise ValueError('El dato no es un número entero o no es positivo.') 106 | 107 | def genera_espejo(numero): 108 | """ Genera el número espejo del número recibido. 109 | 110 | Parámetro: 111 | numero: de tipo int, > 0. 112 | Regresa: 113 | Un número de tipo int que es el espejo del número recibido. 114 | Lanza: 115 | ValueError: cuando el dato no es entero o no es > 0. 116 | """ 117 | if type(numero) == int and numero > 0: 118 | espejo = 0 119 | temporal = numero 120 | while temporal > 0: 121 | digito = temporal % 10 122 | espejo = espejo * 10 + digito 123 | temporal = temporal // 10 124 | return espejo 125 | raise ValueError('El dato no es un número entero o no es positivo.') 126 | 127 | def calcula_edad(fecha_nac): 128 | """ Calcula la edad, en años cumplidos, dada la fecha 129 | de nacimiento. 130 | 131 | Parámetro: 132 | fecha_nac: de tipo tuple, almacena la fecha de 133 | nacimiento con el formato (dd, mm, aaaa). 134 | Regresa: 135 | La edad que es de tipo int. 136 | """ 137 | dia_nac = fecha_nac[0] 138 | mes_nac = fecha_nac[1] 139 | anio_nac = fecha_nac[2] 140 | fecha_act = time.localtime() 141 | dia_act = fecha_act[2] 142 | mes_act = fecha_act[1] 143 | anio_act = fecha_act[0] 144 | edad = 0 145 | if anio_act > anio_nac: 146 | edad = anio_act - anio_nac - 1 147 | if mes_act > mes_nac: 148 | edad += 1 149 | elif mes_act == mes_nac and dia_act > dia_nac: 150 | edad += 1 151 | return edad 152 | -------------------------------------------------------------------------------- /Cap2/Ejemplo 2_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 2_1 5 | Manejo de cadenas de caracteres. 6 | """ 7 | 8 | # Asignación de cadenas que ocupan una sola línea. 9 | cadena1 = 'enero' 10 | cadena2 = "febrero" 11 | 12 | # Asignación de cadenas que ocupan más de una línea. 13 | cadena3 = '''Esto es un ejemplo de una cadena muy larga que ocupa más 14 | de una línea. En estos casos se requiere usar tres comillas dobles o 15 | tres comillas simples. Fin del ejemplo.''' 16 | cadena4 = """Esto es un ejemplo de una cadena muy larga que ocupa más 17 | de una línea. En estos casos se requiere usar tres comillas dobles o 18 | tres comillas simples. Fin del ejemplo.""" 19 | 20 | # Para incluir " en la cadena se deben usar las simples para encerrar la cadena. 21 | cadena5 = '¿Por qué siempre saludas haciendo gestos "feos"?' 22 | 23 | # Para incluir ' en la cadena se debe preceder por el caracter \. 24 | cadena6 = 'Juan dijo: "Creo que Mc\'Gregor es un buen hombre."' 25 | 26 | # Para concatenar o unir dos cadenas se usa el operador +. 27 | cadena7 = cadena1 + cadena2 28 | cadena7 = cadena1 + ' ' + cadena2 # Deja un espacio entre las dos cadenas. 29 | 30 | # Para repetir una cadena se usa el operador *. 31 | cadena8 = 3 * 'agua' 32 | print(cadena8) 33 | cadena8 = 3 * 'agua ' 34 | print(cadena8) 35 | cadena8 = 3 * 'agua' + ' ' 36 | print(cadena8) 37 | cadena8 = 3 * ('agua' + ' ') 38 | print(cadena8) 39 | 40 | # Indexación de cadenas. 41 | print(cadena1[0]) # Imprime el primer carácter de la cadena. 42 | print(cadena1[-1]) # Imprime el último carácter de la cadena. 43 | 44 | # Slicing (con positivos). 45 | print(cadena1[0:3]) # Imprime ene. 46 | print(cadena1[:4]) # Valor inicial por omisión: 0. Imprime ener. 47 | print(cadena1[3:]) # Valor final por omisión: la longitud. Imprime ro. 48 | print(cadena1[:]) # Toma del 0 a la longitud -1. Imprime enero. 49 | print(cadena1[::2]) # Igual anterior, tomando de 2 en 2. Imprime eeo. 50 | 51 | # Slicing (con negativos). 52 | cadena2 = 'ABCDEFGHIJKLMNOP' 53 | # Subcadena formada por el último caracter. 54 | print(cadena2[-1:]) # Imprime P. 55 | # Subcadena formada por toda la cadena en orden inverso. 56 | print(cadena2[::-1]) # Imprime PONMLKJIHGFEDCBA. 57 | # Igual a la anterior pero excluye los últimos 9 caracteres. 58 | print(cadena2[-10::-1]) # Imprime GFEDCBA. 59 | # Subcadena formada por los últimos 4 caracteres, en orden inverso. 60 | print(cadena2[:-5:-1]) # Imprime PONM. 61 | 62 | # Ejemplo del uso de algunos de los métodos de cadenas. 63 | cadena9 = 'hoy está lloviendo' 64 | 65 | # Método capitalize: convierte a mayúscula la primera letra. 66 | print(cadena9.capitalize()) 67 | 68 | ''' Método para centrar, justificar a izquierda y justificar a derecha. 69 | El entero indica la cantidad de espacios reservados para la cadena y, 70 | por lo tanto, se centra o justifica de acuerdo a esos espacios.''' 71 | print(cadena9.center(30)) # Centra la cadena con respeto a 30 espacios. 72 | print(cadena9.ljust(30)) # Justifica a izquierda la cadena con respeto a 30 espacios. 73 | print(cadena9.rjust(30)) # Justifica a derecha la cadena con respeto a 30 espacios. 74 | 75 | # El segundo parámetro indica el carácter con cual se completan los n espacios. 76 | print(cadena9.center(30, '*')) 77 | print(cadena9.ljust(30, '*')) 78 | print(cadena9.rjust(30, '*')) 79 | 80 | # Regresa el total de veces que una cadena está en otra cadena. 81 | print(f'Total de veces que aparece la palabra "comillas" es = {cadena3.count("comillas")}') 82 | 83 | 84 | ''' Busca la cadena recibida en la cadena que llama al método y 85 | regresa la posición de esta. Si no la encuentra regresa -1. ''' 86 | print(cadena3.find('comillas')) # Busca de izquierda a derecha. 87 | print(cadena3.rfind('comillas')) # Busca de derecha a izquierda. 88 | 89 | ''' Busca la cadena recibida en la cadena que llama al método y 90 | regresa la posición de esta. 91 | Si no la encuentra lanza el error: ValueError: substring not found.''' 92 | print(cadena3.index('comillas')) # Busca de izquierda a derecha. 93 | print(cadena3.rindex('comillas')) # Busca de derecha a izquierda. 94 | 95 | ''' Métodos que ayudan a comprobar la naturaleza de los datos almacenados en 96 | la cadena. Se presentan solo algunos de los que tiene Python.''' 97 | print(cadena1.isalpha()) # Imprime True ya que cadena1 es alfabética. 98 | print(cadena1.isdigit()) # Imprime False ya que cadena1 no está formada por dígitos. 99 | print('205'.isalpha()) # Imprime False ya que la cadena no es alfabética. 100 | print('205'.isdigit()) # Imprime True ya que la cadena está formada por dígitos. 101 | 102 | # Determina si las letras de la cadena son solo minúsculas. 103 | print('esto es un ejemplo'.islower()) # Regresa True. 104 | 105 | # Determina si las letras de la cadena son solo mayúsculas. 106 | print('esto es un ejemplo'.isupper()) # Regresa False. 107 | print('JUJUY'.isupper()) # Regresa True. 108 | 109 | # Determina si la cadena está formada solo por espacios. 110 | print(cadena1.isspace()) # Regresa False. 111 | print(' '.isspace()) # Regresa True. 112 | 113 | # Regresa el total de caracteres que forman la cadena (la longitud). 114 | print('La longitud de la cadena es = ', len(cadena4)) 115 | print(len('')) # Regresa 0, es una cadena vacía. 116 | 117 | # Convierte todas las letras de la cadena a minúsculas. 118 | print('JUJUY'.lower()) 119 | 120 | # Convierte todas las letras de la cadena a mayúsculas. 121 | print(cadena1.upper()) 122 | 123 | # Reemplaza a la cad1 por la cad2, si está y todas sus ocurrencias. 124 | print(cadena1.replace('e', '*')) # Imprime *n*ro. 125 | print(cadena1.replace('p', '*')) # Imprime enero. 126 | 127 | # Determina si una cadena empieza/termina con una subcadena. 128 | print(cadena8.startswith('agua')) # Regresa True. 129 | print(cadena8.endswith('agua')) # Regresa False porque termina agua y un espacio 130 | cadena8 = cadena8[0:len(cadena8) - 1] # Se recorta la cadena8, suprimiendo el espacio. 131 | print(cadena8.endswith('agua')) # Regresa True. 132 | 133 | # Reemplaza mayúsculas por minúsculas y viceversa. 134 | print('Esto es UNa mezcla horrible de MayúSCulas Y minúSCULAS'.swapcase()) 135 | 136 | # Escribe la primera letra de cada palabra en mayúsculas. 137 | print('las venas abiertas de américa latina'.title()) --------------------------------------------------------------------------------