From 37c145ff2e2e8f070d3a1e2fbdc826fd3dc16375 Mon Sep 17 00:00:00 2001 From: dcsibon Date: Wed, 23 Oct 2024 16:08:10 +0200 Subject: [PATCH] =?UTF-8?q?Pr=C3=A1cticas=20resueltas=20del=20a=C3=B1o=20p?= =?UTF-8?q?asado?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- otros/__init__.py | 1 + pruebas/__init__.py | 1 + src/Pract2_1/__init__.py | 0 src/Pract2_1/ej2_1_01.py | 55 ++++++++++++++ src/Pract2_1/ej2_1_10.py | 119 +++++++++++++++++++++++++++++ src/Pract2_2/__init__.py | 0 src/Pract2_2/ej2_2_01.py | 27 +++++++ src/Pract2_2/ej2_2_03.py | 53 +++++++++++++ src/Pract2_2/ej2_2_04.py | 27 +++++++ src/Pract2_2/ej2_2_05.py | 51 +++++++++++++ src/Pract2_2/ej2_2_08.py | 63 ++++++++++++++++ src/Pract2_2/ej2_2_13.py | 31 ++++++++ src/Pract2_2/ej2_2_15.py | 34 +++++++++ src/Pract2_2/ej2_2_18.py | 40 ++++++++++ src/Pract2_2/ej2_2_19.py | 57 ++++++++++++++ src/Pract2_2/piramideSumas1.py | 132 +++++++++++++++++++++++++++++++++ src/Pract2_3/__init__.py | 0 src/Pract2_3/actividad01.py | 74 ++++++++++++++++++ src/Pract2_3/burbuja.py | 25 +++++++ 19 files changed, 790 insertions(+) create mode 100644 otros/__init__.py create mode 100644 pruebas/__init__.py create mode 100644 src/Pract2_1/__init__.py create mode 100644 src/Pract2_1/ej2_1_01.py create mode 100644 src/Pract2_1/ej2_1_10.py create mode 100644 src/Pract2_2/__init__.py create mode 100644 src/Pract2_2/ej2_2_01.py create mode 100644 src/Pract2_2/ej2_2_03.py create mode 100644 src/Pract2_2/ej2_2_04.py create mode 100644 src/Pract2_2/ej2_2_05.py create mode 100644 src/Pract2_2/ej2_2_08.py create mode 100644 src/Pract2_2/ej2_2_13.py create mode 100644 src/Pract2_2/ej2_2_15.py create mode 100644 src/Pract2_2/ej2_2_18.py create mode 100644 src/Pract2_2/ej2_2_19.py create mode 100644 src/Pract2_2/piramideSumas1.py create mode 100644 src/Pract2_3/__init__.py create mode 100644 src/Pract2_3/actividad01.py create mode 100644 src/Pract2_3/burbuja.py diff --git a/otros/__init__.py b/otros/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/otros/__init__.py @@ -0,0 +1 @@ + diff --git a/pruebas/__init__.py b/pruebas/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/pruebas/__init__.py @@ -0,0 +1 @@ + diff --git a/src/Pract2_1/__init__.py b/src/Pract2_1/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/Pract2_1/ej2_1_01.py b/src/Pract2_1/ej2_1_01.py new file mode 100644 index 0000000..629e880 --- /dev/null +++ b/src/Pract2_1/ej2_1_01.py @@ -0,0 +1,55 @@ +""" +Ejercicio 2.1.1 + +Escribir un programa que pregunte al usuario su edad y muestre por pantalla si es mayor de edad o no. +""" + +def pedirEdad(): + """ + Pedir la edad y comprobar que se trata de un número entero entre 1 y 125. + + Retorna + ------- + int + un entero con el valor de la edad introducida por consola. + """ + salir = False + while not salir: + entrada = input("Introduzca su edad: ") + + if entrada.isnumeric() and 0 < int(entrada) <= 125: + salir = True + else: + print("***Error*** edad introducida no válida.") + + edad = int(entrada) + + return edad + + +def mayorEdad(edad): + """ + Comprobar si la edad corresponde a una persona mayor de edad o no. + + Retorna + ------- + bool + True es mayor de edad / False no es mayor de edad. + """ + if edad >= 18: + return True + else: + return False + + +def main(): + edad = pedirEdad() + + if mayorEdad(edad): + print("Eres mayor de edad.") + else: + print("No eres mayor de edad.") + + +if __name__ == "__main__": + main() diff --git a/src/Pract2_1/ej2_1_10.py b/src/Pract2_1/ej2_1_10.py new file mode 100644 index 0000000..5b4d454 --- /dev/null +++ b/src/Pract2_1/ej2_1_10.py @@ -0,0 +1,119 @@ +""" +Ejercicio 2.1.10 + +La pizzería Bella Napoli ofrece pizzas vegetarianas y no vegetarianas a sus clientes. Los ingredientes para cada tipo de pizza aparecen a continuación. + + - Ingredientes vegetarianos: Pimiento y tofu. + - Ingredientes no vegetarianos: Peperoni, Jamón y Salmón. + +Escribir un programa que pregunte al usuario si quiere una pizza vegetariana o no, y en función de su respuesta le muestre un menú con los ingredientes disponibles para que elija. Solo se puede eligir un ingrediente además de la mozzarella y el tomate que están en todas la pizzas. Al final se debe mostrar por pantalla si la pizza elegida es vegetariana o no y todos los ingredientes que lleva. +""" + +import os + + +def preguntarTipoPizza(): + """ + Pedir el tipo de la pizza. + + Retorna + ------- + int un entero con el valor del tipo de pizza => 1: vegetariana / 2: no vegetariana + """ + tipo = -1 + while tipo != 1 and tipo != 2: + tipo = pedirNumero("Elija el tipo de pizza (1. vegetariana / 2. NO vegetariana) => ", 1, 2) + if tipo == -1: + print("**ERROR** tipo de pizza no válido...") + + return tipo + + +def obtenerListaIngredientes(tipo): + """ + Obtener los ingredientes según el tipo de pizza. + + Params + ---------- + int tipo de pizza => 1 = vegetariana / 2 = no vegetariana + + Retorna + ------- + str una cadena de caracteres con los ingredientes de cada pizza. + """ + if tipo == 1: + # pizza vegetariana + lista = ["pimiento", "tofu"] + elif tipo == 2: + # pizza no vegetariana + lista = ["peperoni", "salmón", "jamón"] + else: + # error, pizza no válida + lista = [] + return lista + + +def muestraIngredientes(listaIngredientes): + resultadoPantalla = "" + cont = 1 + for ingrediente in listaIngredientes: + resultadoPantalla += str(cont) + " - " + ingrediente + "\n" + cont += 1 + return resultadoPantalla + + +def eligeIngrediente(listaIngredientes): + print("\nIngredientes disponibles para esta pizza") + print("----------------------------------------") + print(muestraIngredientes(listaIngredientes)) + + ingredienteExtra = -1 + while ingredienteExtra == -1: + ingredienteExtra = pedirNumero("Elige el ingrediente extra de tu pizza: ", 1, len(listaIngredientes)) + if ingredienteExtra == -1: + print("**Error** elige un número válido de la lista...") + return ingredienteExtra + + +def pedirNumero(mensaje, min, max): + entrada = input(mensaje) + if entrada.isnumeric() and min <= int(entrada) <= max: + return int(entrada) + else: + return -1 + + +def mostrarPizza(tipo, listaIngredientes, ingrediente): + frase = "\nHas elegido una pizza " + if tipo == 1: + frase += "vegetariana con tomate, mozzarella y " + else: + frase += "no vegetariana con tomate, mozzarella y " + frase += listaIngredientes[ingrediente - 1] + ".\n" + return frase + + +def borrarConsola(): + if os.name == "posix": + os.system ("clear") + elif os.name == "ce" or os.name == "nt" or os.name == "dos": + os.system ("cls") + + +def main(): + borrarConsola() + + print("\nBienvenido a la pizzería Bella Napoli...\n") + + tipo = preguntarTipoPizza() + + listaIngredientes = obtenerListaIngredientes(tipo) + + if len(listaIngredientes) > 0: + ingrediente = eligeIngrediente(listaIngredientes) + + print(mostrarPizza(tipo, listaIngredientes, ingrediente)) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/Pract2_2/__init__.py b/src/Pract2_2/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/Pract2_2/ej2_2_01.py b/src/Pract2_2/ej2_2_01.py new file mode 100644 index 0000000..6df9c1f --- /dev/null +++ b/src/Pract2_2/ej2_2_01.py @@ -0,0 +1,27 @@ +""" +Ejercicio 2.2.1 +Escribir un programa que pida al usuario una palabra y la muestre por pantalla 10 veces. +""" + +import os + +def repetirPalabra(palabra): + for i in range(1, 10): + palabra += palabra + "\n" + + +def borrarConsola(): + if os.name == "posix": + os.system ("clear") + elif os.name == "ce" or os.name == "nt" or os.name == "dos": + os.system ("cls") + + +def main(): + borrarConsola() + palabra = input("Introduzca una palabra: ").replace(" ", "") + print(repetirPalabra(palabra)) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/Pract2_2/ej2_2_03.py b/src/Pract2_2/ej2_2_03.py new file mode 100644 index 0000000..6fd990c --- /dev/null +++ b/src/Pract2_2/ej2_2_03.py @@ -0,0 +1,53 @@ +""" +Ejercicio 2.2.3 +Escribir un programa que pida al usuario un número entero positivo y muestre por pantalla todos los números impares desde 1 hasta ese número separados por comas. +""" + +import os + +def comprobarNumero(entrada): + return entrada.isnumeric() and int(entrada) > 0 + + +def pedirNumeroEnteroPositivo(mensaje: str): + entrada = input(mensaje).replace(" ", "") + + while not comprobarNumero(entrada): + entrada = input("**ERROR**, vuelva a intentarlo\n" + mensaje).replace(" ", "") + + #Retornamos el número entero positivo introducido + return int(entrada) + + +def crearSerie(numero): + serie = "" + for i in range(1, numero, 2): + serie += str(i) + if i < numero - 1: + serie += ", " + return serie + + +def esPar(numero): + return numero % 2 == 0 + + +def borrarConsola(): + if os.name == "posix": + os.system ("clear") + elif os.name == "ce" or os.name == "nt" or os.name == "dos": + os.system ("cls") + + +def main(): + borrarConsola() + numero = pedirNumeroEnteroPositivo("Introduzca un entero positivo: ") + + if not esPar(numero): + numero += 1 + + print(crearSerie(numero)) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/Pract2_2/ej2_2_04.py b/src/Pract2_2/ej2_2_04.py new file mode 100644 index 0000000..7b6f5ff --- /dev/null +++ b/src/Pract2_2/ej2_2_04.py @@ -0,0 +1,27 @@ +""" +Ejercicio 2.2.4 +Escribir un programa que pida al usuario un número entero positivo y muestre por pantalla la cuenta atrás desde ese número hasta cero separados por comas. +""" + +import os +from ej2_23 import pedirNumeroEnteroPositivo, borrarConsola + + +def crearSerie(numero): + serie = "" + for i in range(numero, -1, -1): + serie += str(i) + if i > 0: + serie += ", " + return serie + + +def main(): + borrarConsola() + numero = pedirNumeroEnteroPositivo("Introduzca un entero positivo: ") + + print(crearSerie(numero)) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/Pract2_2/ej2_2_05.py b/src/Pract2_2/ej2_2_05.py new file mode 100644 index 0000000..5c8e230 --- /dev/null +++ b/src/Pract2_2/ej2_2_05.py @@ -0,0 +1,51 @@ +""" +Ejercicio 2.2.5 +Escribir un programa que pregunte al usuario una cantidad a invertir, el interés anual y el número de años, y muestre por pantalla el capital obtenido en la inversión cada año que dura la inversión. +# Formula para calcular El capital tras un año. + amount *= 1 + interest / 100 +# En donde: +# - amount: Cantidad a invertir +# - interest: Interes porcentual anual +""" + +from EjerciciosU2.Pract2_2.ej2_2_03 import borrarConsola, pedirNumeroEnteroPositivo + + +def comprobarFloat(entrada: str): + return entrada.count(".") <= 1 and entrada.replace(".", "").isnumeric() + + +def pedirNumeroFloat(mensaje: str): + entrada = input(mensaje).replace(" ", "") + + while not comprobarFloat(entrada): + entrada = input("**ERROR**, entrada no válida\n" + mensaje).replace(" ", "") + + #Retornamos el número introducido convertido a float + return float(entrada) + + +def rendimientoCapital(capital: float, interes: float, annios: int): + + rendimientoAnual = "" + cont = 1 + + while cont <= annios: + capital *= 1 + interes / 100 + rendimientoAnual += "Año {:>2} => {:.2f}\n".format(cont, capital) + cont += 1 + + return rendimientoAnual + +def main(): + borrarConsola() + + capital = pedirNumeroFloat("Introduzca el capital invertido: ") + interes = pedirNumeroFloat("Introduzca el interés del fondo: ") + annios = pedirNumeroEnteroPositivo("Introduzca el número de años a invertir: ") + + print(rendimientoCapital(capital, interes, annios)) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/Pract2_2/ej2_2_08.py b/src/Pract2_2/ej2_2_08.py new file mode 100644 index 0000000..0f8cb1c --- /dev/null +++ b/src/Pract2_2/ej2_2_08.py @@ -0,0 +1,63 @@ +""" +Ejercicio 2.2.8 +Escribir un programa que pida al usuario un número entero y muestre por pantalla un triángulo rectángulo como el de más abajo. + +1 +3 1 +5 3 1 +7 5 3 1 +9 7 5 3 1 +""" + +import os +from ej2_23 import borrarConsola, esPar + + +def comprobarNumero(entrada): + return entrada.replace("-", "").isnumeric() + + +def pedirNumeroEntero(mensaje: str): + entrada = input(mensaje).replace(" ", "") + + while not comprobarNumero(entrada): + entrada = input("**ERROR**, vuelva a intentarlo\n" + mensaje).replace(" ", "") + + return int(entrada) + + +def construirFila(numero, fin, signo): + fila = "" + for i in range(numero, fin, -2): + fila += str(i * signo) + " " + + return fila + + +def construirTriangulo(numero): + if numero > 0: + signo = 1 + else: + signo = -1 + + if esPar(numero): + inicio = 0 + else: + inicio = 1 + + numero = abs(numero) + + triangulo = "" + for i in range(inicio, numero + 1, 2): + triangulo += construirFila(i, inicio - 1, signo) + "\n" + + return triangulo + +def main(): + borrarConsola() + numero = pedirNumeroEntero("Introduzca un número entero: ") + print(construirTriangulo(numero)) + + +if __name__ == "__main__": + main() diff --git a/src/Pract2_2/ej2_2_13.py b/src/Pract2_2/ej2_2_13.py new file mode 100644 index 0000000..9d6f2d1 --- /dev/null +++ b/src/Pract2_2/ej2_2_13.py @@ -0,0 +1,31 @@ +""" +Ejercicio 2.2.13 +Escribir un programa que muestre el eco de todo lo que el usuario introduzca hasta que el usuario escriba “salir” que terminará. +""" + +import os +from ej2_23 import borrarConsola + + +def ecoConsola(entrada: str): + if entrada.strip().lower() == "salir": + return True + else: + return False + + +def main(): + borrarConsola() + + print("Soy el eco.. háblame o escribe salir:") + + salir = False + while not salir: + entrada = input() + salir = ecoConsola(entrada) + if not salir: + print(entrada) + + +if __name__ == "__main__": + main() diff --git a/src/Pract2_2/ej2_2_15.py b/src/Pract2_2/ej2_2_15.py new file mode 100644 index 0000000..56c8272 --- /dev/null +++ b/src/Pract2_2/ej2_2_15.py @@ -0,0 +1,34 @@ +""" +Ejercicio 2.2.15 +Leer números enteros de teclado, hasta que el usuario ingrese el 0. Finalmente, mostrar la sumatoria de todos los números positivos ingresados. +""" + +from ej2_23 import borrarConsola + + +def leeNumero(): + numero = int(input()) + if numero >= 0: + return numero + else: + return -1 + + +def main(): + borrarConsola() + + print("Introduzca números...") + + total = 0 + while True: + numero = leeNumero() + if numero > 0: + total += numero + elif numero == 0: + break + + print(f"\n{total}\n") + + +if __name__ == "__main__": + main() diff --git a/src/Pract2_2/ej2_2_18.py b/src/Pract2_2/ej2_2_18.py new file mode 100644 index 0000000..1928af9 --- /dev/null +++ b/src/Pract2_2/ej2_2_18.py @@ -0,0 +1,40 @@ +""" +Ejercicio 2.2.18 +Solicitar al usuario que ingrese números enteros positivos y, por cada uno, imprimir la suma de los dígitos que lo componen. La condición de corte es que se ingrese el número -1. Al finalizar, mostrar cuántos de los números ingresados por el usuario fueron números pares. +""" + +from ej2_23 import borrarConsola, esPar +from ej2_28 import pedirNumeroEntero + + +def sumarDigitos(numero): + suma = 0 + + entrada = str(numero) + for i in range(0, len(entrada)): + suma += int(entrada[i]) + + return suma + + +def main(): + borrarConsola() + + totalNumerosPares = 0 + + print("Introduzca números enteros positivos...") + + while True: + numero = pedirNumeroEntero("") + if numero >= -1: + if numero == -1: + break + elif esPar(numero): + totalNumerosPares += 1 + print(f"La suma de sus dígitos es {sumarDigitos(numero)}") + + print(f"\nTotal de números pares => {totalNumerosPares}\n") + + +if __name__ == "__main__": + main() diff --git a/src/Pract2_2/ej2_2_19.py b/src/Pract2_2/ej2_2_19.py new file mode 100644 index 0000000..ac4507d --- /dev/null +++ b/src/Pract2_2/ej2_2_19.py @@ -0,0 +1,57 @@ +""" +Ejercicio 2.2.19 +Mostrar un menú con tres opciones: 1 - Introduzca una nota, 2 - Imprimir listado, 3 - Finalizar programa. A continuación, el usuario debe poder seleccionar una opción (1, 2 ó 3). Si elige una opción incorrecta, informarle del error. El menú se debe volver a mostrar luego de ejecutada cada opción, permitiendo volver a elegir. Si elige las opciones 1 ó 2 se imprimirá un texto. Si elige la opción 3, se interrumpirá la impresión del menú y el programa finalizará. +""" + +from ej2_2_03 import borrarConsola + + +def mostrarMenu(): + print("MENÚ\n----") + print("1 - Introduzca una nota\n2 - Imprimir listado\n3 - Finalizar programa") + print("Seleccione una opción => ", end="") + + +def comprobarOpcionValida(entrada): + if entrada.isnumeric() and 1 <= int(entrada) <= 3: + return True + else: + return False + + +def imprimirListado(notas): + print("Listado de notas") + print("----------------") + print(notas) + + +def leerNota(listado): + nota = input("Introduzca una nota: ") + listado += nota + "\n" + return listado + + +def main(): + listado = "" + + while True: + borrarConsola() + mostrarMenu() + opcion = input("") + + if comprobarOpcionValida(opcion): + if opcion == '1': + borrarConsola() + listado = leerNota(listado) + elif opcion == '2': + borrarConsola() + imprimirListado(listado) + else: + print("Programa finalizado.") + break + + input("\nPulse para continuar...") + + +if __name__ == "__main__": + main() diff --git a/src/Pract2_2/piramideSumas1.py b/src/Pract2_2/piramideSumas1.py new file mode 100644 index 0000000..4834b74 --- /dev/null +++ b/src/Pract2_2/piramideSumas1.py @@ -0,0 +1,132 @@ + +import os + + +def borrarConsola(): + """ + Limpia la consola + """ + if os.name == "posix": + os.system ("clear") + elif os.name == "ce" or os.name == "nt" or os.name == "dos": + os.system ("cls") + + +def generarFila(num, res): + """ + Crea una fila de la pirámide de sumas + + Parámetros + ---------- + int + un número por el que empezar la serie de la fila + str + la cadena de caracteres que acumulará todas las filas de la pirámide + + Retorna + ------- + str + la cadena de caracteres de la pirámide con la fila acumulada como otra línea + """ + total = 0 + res += str(num) + " => " + str(num) + " " + + for i in range(num - 1, -1, -1): + res += f"+ {i} " + total += i + + if num != 0: + res += f"= {total}" + res += "\n" + + return res + + +def piramide(num: int): + """ + Crea una pirámide de sumas de un número + + Parámetros + ---------- + int + un número, que será el valor máximo de la pirámide de sumas + + Retorna + ------- + str + la cadena de caracteres con la pirámide de sumas + """ + res = "" + + while num >= 0: + res = generarFila(num, res) + num -= 1 + + return res + + +def main(): + + repetir = True + while repetir: + borrarConsola() + + num = int(input("Introduzca un número: ")) + + while abs(num) > 100: + num = int(input("**Error** Introduzca un número entre -100 y 100: ")) + + print("\nSu pirámide de sumas es la siguiente:\n" + piramide(abs(num))) + + repetir = input("¿Quiere hacer otra pirámide? (s/n) ").replace(" ", "").upper()[0:1] == "S" + + +if __name__ == "__main__": + main() + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/Pract2_3/__init__.py b/src/Pract2_3/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/Pract2_3/actividad01.py b/src/Pract2_3/actividad01.py new file mode 100644 index 0000000..b28dfeb --- /dev/null +++ b/src/Pract2_3/actividad01.py @@ -0,0 +1,74 @@ +""" +Actividad 1: + Escribe un programa que capture la excepción división entre cero. Tendrá que mostar el mensaje del error capturado. +""" + +def dividir(num1: float, num2: float = 1) -> float: + """Realiza la división de dos números + + Args: + num1 (float): número que vamos a dividir. + num2 (float): número que será el divisor. + (por defecto es 1) + + Returns: + float: división redondeada a 2 decimales o None si se genera una excepción. + """ + + # Inicializar a None para no retornar un número si se produjo un error + resultado = None + + resultado = num1 / num2 + + resultado = round(resultado, 2) + + return resultado + + +def pedirNumero(msj: str) -> float: + """Solicita un número + + Args: + msj (str): mensaje que se muestra en consola para solicitar el número. + + Returns: + float: número introducido por el usuario. + """ + + # Inicializar a None para no retornar un número si se produjo un error + numero = None + + try: + numero = float(input(msj)) + except: + print("**Error** Número introducido no válido") + + return numero + + +def main(): + + dividendo = pedirNumero("Introduzca el dividendo: ") + + # Para continuar comprobamos que se retornó un número en el dividendo + if dividendo != None: + divisor = pedirNumero("Introduzca el divisor: ") + + # Para continuar comprobamos que se retornó un número en el divisor + if divisor != None: + # Capturo la excepción fuera del método para comprobar la excepción en el test + try: + resultado = dividir(dividendo, divisor) + except ZeroDivisionError: + print("**Error** No es posible realizar la división por cero.") + except: + print("**Error** Se produjo un error y no es posible realizar la división.") + + # Solo mostrar el resultado si se retornó un número + # Sino ya habrá mostrado un mensaje de error anteriormente + if resultado != None: + print(f"El resultado es {resultado}") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/Pract2_3/burbuja.py b/src/Pract2_3/burbuja.py new file mode 100644 index 0000000..95f1cae --- /dev/null +++ b/src/Pract2_3/burbuja.py @@ -0,0 +1,25 @@ + + + +def ordenar(lista: list): + + return lista + + +def prueba1(): + print(saludo) + + +def main(): + f = 7 + prueba1() + """a = [8, 3, 1, 19, 14] + + listaOrdenada = ordenar(a) +""" + mapa = [["0" for _ in range(5)] for i in range(5)] + +saludo = "hola" + +if __name__ == "__main__": + main()