diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d5f8f72 --- /dev/null +++ b/.gitignore @@ -0,0 +1,199 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py +.env +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# UV +# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +#uv.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/latest/usage/project/#working-with-version-control +.pdm.toml +.pdm-python +.pdm-build/ + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +# Ruff stuff: +.ruff_cache/ + +# PyPI configuration file +.pypirc + + + +```plaintext +# Entorno virtual +.venv/ + +# Archivos de configuración de VS Code +.vscode/ + +# Archivos de caché de Python +__pycache__/ +*.pyc +*.pyo + +# Base de datos local +db.sqlite3 + +# Archivos de entorno +.env + +# Archivos de logs +*.log + +.vscode/ \ No newline at end of file diff --git a/10 PYTHON/000_temp.py b/10 PYTHON/000_temp.py index 8b13789..8cb4e25 100644 --- a/10 PYTHON/000_temp.py +++ b/10 PYTHON/000_temp.py @@ -1 +1,49 @@ +# Se definen unos cuantos clientes +clientes = [ + {'Nombre': 'Hector', + 'Apellidos': 'Costa Guzman', + 'dni' : '11111111A' + }, + {'Nombre' : 'Juan', + 'Apellidos' : 'González Márquez', + 'dni' : '22222222B' + } +] +# Se crea una función que muestra un cliente en una lista apartir del DNI + +def mostrar_cliente(clientes, dni): + for c in clientes: + if (dni == c ['dni']): + print(f"{c}\n") + return + + print('Cliente no encontrado') + + +# Se crea una función que borra un cliente en una lista apartir del DNI + +def borrar_cliente(clientes, dni): + for i,c in enumerate(clientes): + if (dni == c ['dni']): + del(clientes[i]) + print(str(c), "> Borrado") + return + + print("Cliente no encontrado") + +# Utilización del codigo estructurado + +print("----Listado de clientes----") +print(clientes) + +print("\n---Ver clientes por DNI---") +mostrar_cliente(clientes, '11111111A') +mostrar_cliente(clientes, '22222222B') + +print("\n-----Borrar clientes por DNI----") +borrar_cliente(clientes, '22222222V') +borrar_cliente(clientes, '22222222B') + +print("\n-----Listado de clientes----") +print(clientes) \ No newline at end of file diff --git a/10 PYTHON/001_Variables.py b/10 PYTHON/001_Variables.py index f96ca20..1d6ff84 100644 --- a/10 PYTHON/001_Variables.py +++ b/10 PYTHON/001_Variables.py @@ -3,7 +3,7 @@ # Lo ideal es declara e inicializar siempre las variables. # ----------------------------------------------------------- -# Declaración de variable numérica entera: +# Declaración de variable numérica entera: n_edad = 47 # Declaración de variable numérica de coma flotante: @@ -36,7 +36,7 @@ # Cuando se valida una condición , Python devuelve True o False: print(10 > 9) print(10 == 9) -print(10 < 9) +print(10 < 9, "\n") # Declaración múltiple # En una sola instrucción, estamos declarando tres variables: a, b y c, y asignándoles un valor concreto a cada una. @@ -56,3 +56,10 @@ print(type(NUMEROPI)) print(type(is_verdadero)) print(type(is_casado)) + +s_nombre_usuario = input("Intorduce tu nombre: ") + +print("Bienvenido", s_nombre_usuario) + +n_edad = int(input("Introduce tu edad: ")) +print(s_nombre_usuario.capitalize(), "el proximo año tendras: ", n_edad + 1, "años") diff --git a/10 PYTHON/002_Operadores.py b/10 PYTHON/002_Operadores.py index bf6d41f..f86cc36 100644 --- a/10 PYTHON/002_Operadores.py +++ b/10 PYTHON/002_Operadores.py @@ -5,7 +5,7 @@ n_numerador = 85 n_denominador = 9 -n_resto = n_numerador%n_denominador +n_resto = n_numerador % n_denominador print("El resto de dividir" , n_numerador , "entre" , n_denominador , "es" , n_resto) diff --git a/10 PYTHON/003_print.py b/10 PYTHON/003_print.py index dea156a..4259d60 100644 --- a/10 PYTHON/003_print.py +++ b/10 PYTHON/003_print.py @@ -9,6 +9,28 @@ print("El resultado de sumar" , n_numero_1, "y" , n_numero_2 , "es" , (n_numero_1+n_numero_2)) #Si concatenamos int y strings usando el signo + nos puede dar problemas. -print("El resultado de sumar " + n_numero_1 + " y " + n_numero_2 + " es " + (n_numero_1+n_numero_2)) +#print("El resultado de sumar ", n_numero_1, " y ", n_numero_2, " es " + (n_numero_1 + n_numero_2)) -print("El resultado de sumar" + " " + " os numeros") \ No newline at end of file +print("El resultado de sumar" + " " + " os numeros") + +edad = 20 + +if edad >= 18: + + print("Adulto") + +else: + + print("Menor") + +print(len("hola")) # cuenta el numero de caracteres contenidos en la cadena +print(10//3) # Division entera, realiza una aproximación al entero mas cercano + +for i in range(3): + print(i) + +print("python".upper()) + +print(5+3.2) + +print(5%2) \ No newline at end of file diff --git a/10 PYTHON/004_Input.py b/10 PYTHON/004_Input.py index 645d762..1d3f29f 100644 --- a/10 PYTHON/004_Input.py +++ b/10 PYTHON/004_Input.py @@ -1,4 +1,4 @@ -s_nombreIntroducido = input("Introduzca su nombre: ") +s_nombreIntroducido = input("Introduce tu nombre: ") print("Bienvenido", s_nombreIntroducido) @@ -8,6 +8,6 @@ por lo que, si necesitamos operar matemáticamente con números, tendremos que hacer un casting: """ -s_edad = int(input("Introduzca su edad: ")) +s_edad = int(input("Introduce tu edad: ")) -print("El año que viene tendrá usted ", s_edad + 1, "años") +print("El año que viene tu tendras ", s_edad + 1, "años") diff --git a/10 PYTHON/008_if_elif_else.py b/10 PYTHON/008_if_elif_else.py index ba94e70..55f1e5c 100644 --- a/10 PYTHON/008_if_elif_else.py +++ b/10 PYTHON/008_if_elif_else.py @@ -4,10 +4,11 @@ notaIn=int(input("Introduzca nota:")) -if notaIn<5: - calificacion="Suspenso" -else: calificacion="Aprobado" - +if notaIn < 5: + calificacion = "Suspenso" +else: + calificacion = "Aprobado" + print(calificacion) # IF no sólo evalúa un boleano, también si una variable contiene información diff --git a/10 PYTHON/009_Ejercicios_Condicionales_10.py b/10 PYTHON/009_Ejercicios_Condicionales_10.py index 1f15234..b921135 100644 --- a/10 PYTHON/009_Ejercicios_Condicionales_10.py +++ b/10 PYTHON/009_Ejercicios_Condicionales_10.py @@ -4,6 +4,10 @@ # Si la compra es mayor a $100, el descuento es del 10%. Si es mayor a $500, # el descuento es del 20%. Crea un programa que calcule el total a pagar # después del descuento. +# crear bloque de try-except para evitar que se generen errores en el programa +# Trabajar en el tratamiento de errores +# ! No en python +# != diferente compra = float(input("Introduce el total de la compra: $")) if compra > 500: diff --git a/10 PYTHON/009_Ejercicios_Condicionales_3.py b/10 PYTHON/009_Ejercicios_Condicionales_3.py index 12aae82..84e98e1 100644 --- a/10 PYTHON/009_Ejercicios_Condicionales_3.py +++ b/10 PYTHON/009_Ejercicios_Condicionales_3.py @@ -4,13 +4,19 @@ # Si la calificación es mayor o igual a 90, imprime "Excelente", si es mayor # o igual a 70 y menor que 90, imprime "Bueno", si es mayor o igual a 50 y # menor que 70, imprime "Suficiente", y si es menor que 50, imprime "Insuficiente". +#mejorar el condicional para que valide el tipo de dato, que no introduzca negativos, +# que no ingrese numeros mayores de 100 calificacion = float(input("Ingresa tu calificación (0-100): ")) if calificacion >= 90: - print("Excelente") + calificacion = "aprovado" + print("Tu promedio a sido:", calificacion.capitalize()) elif calificacion >= 70: - print("Bueno") + calificacion = "bueno" + print("Tu promedio a sido:", calificacion.capitalize()) elif calificacion >= 50: - print("Suficiente") + calificacion = "suficiente" + print("Tu calificacion a sido:", calificacion.capitalize()) else: - print("Insuficiente") + calificacion = "insuficiente" + print("Tu calificacion a sido:", calificacion.capitalize()) diff --git a/10 PYTHON/009_Ejercicios_Condicionales_4.py b/10 PYTHON/009_Ejercicios_Condicionales_4.py index 9c8caaa..dc031a7 100644 --- a/10 PYTHON/009_Ejercicios_Condicionales_4.py +++ b/10 PYTHON/009_Ejercicios_Condicionales_4.py @@ -3,6 +3,9 @@ # Un almacén da un descuento del 15% si la compra del cliente supera los 1000 Euros. # Escribe un programa que pida el total de la compra y calcule el descuento # (si aplica) y el total a pagar. +#Optimizar y agregar condicionales, para verificar que no ponga valores negativos, valores vacios +#que sean numeros, que no sea 0, volver a preguntar, hacer un bucle +# Isnotanumber # Solicita al usuario que ingrese el total de la compra total_compra = float(input("Ingresa el total de la compra: $")) diff --git a/10 PYTHON/009_Ejercicios_Condicionales_5.py b/10 PYTHON/009_Ejercicios_Condicionales_5.py index 3b598e4..443d9d6 100644 --- a/10 PYTHON/009_Ejercicios_Condicionales_5.py +++ b/10 PYTHON/009_Ejercicios_Condicionales_5.py @@ -3,6 +3,8 @@ # Escribe un programa que pida al usuario un número del 1 al 7 y muestre el día # de la semana correspondiente. Si el número no está en ese rango, debe # indicar que el número es inválido. +# crear un bucle para que se le informe al usuario todas las fallas de datos introducidos +# Enfocar el codigo para que sea entendible pensando en que el usuario seria un "niño" numero = int(input("Ingresa un número del 1 al 7: ")) if numero == 1: diff --git a/10 PYTHON/009_Ejercicios_Condicionales_6.py b/10 PYTHON/009_Ejercicios_Condicionales_6.py index 627553e..41331ba 100644 --- a/10 PYTHON/009_Ejercicios_Condicionales_6.py +++ b/10 PYTHON/009_Ejercicios_Condicionales_6.py @@ -6,6 +6,7 @@ # Adolescente: De 13 a 19 años. # Adulto: De 20 a 64 años. # Adulto mayor: 65 años o más. +# Se emplean condicionales anidados edad = int(input("Introduce tu edad: ")) if edad < 13: diff --git a/10 PYTHON/009_Operador ternario.py b/10 PYTHON/009_Operador ternario.py index e8e3c26..ba9ff17 100644 --- a/10 PYTHON/009_Operador ternario.py +++ b/10 PYTHON/009_Operador ternario.py @@ -13,7 +13,15 @@ num = 12 if num % 2 == 0: - print="Par" -else: print="Impar" + print("Par") +else: + print("Impar") +# Implementación de operador condicional +ls_nombre = str(input("Ingresa tu nombre: ")).title() +ln_edad = 34 if (ls_nombre == "javier") else 17 +print(f"{ls_nombre} tu edad es: {ln_edad}") + +ls_tiempo = str(input("¿Llueve o hace sol? ")) +print("vamos", "a la piscina" if (ls_tiempo == "sol") else " al cine") diff --git a/10 PYTHON/010_For.py b/10 PYTHON/010_For.py index e65bd53..c595812 100644 --- a/10 PYTHON/010_For.py +++ b/10 PYTHON/010_For.py @@ -15,17 +15,19 @@ # Repite el print tantas veces como caracteres hay en el string -# Evaluamos si un mail contiene el caracter @ - for i in "frase": print("Hola", end=" ") +# Evaluamos si un mail contiene el caracter @ crear una validación en 2 pasos para el mail + miEmail=input("Introduce email") -email=False +email = False for i in miEmail: if i=="@": email=True -if email==True: #Se puede simplificar if email: + +# Se utiliza la expresion simplificada if email: que es lo mismo que if email == True: +if email: # De esta forma se evita la redundancia print("El email es correcto") else: print("EL mail no es correcto") diff --git a/10 PYTHON/011_While.py b/10 PYTHON/011_While.py index 84923a4..bca3484 100644 --- a/10 PYTHON/011_While.py +++ b/10 PYTHON/011_While.py @@ -6,8 +6,8 @@ edad = 0 while edad < 18: - edad=edad+1 -print("Tienes "+str(edad)) + edad = edad+1 + print("Tienes "+str(edad)) # Pregunta la edad mientras sea negativa @@ -21,18 +21,18 @@ # Calcula la raiz cuadrada de un número. Tenemos tres intentos y el número no puede ser negativo. -import math; -intentos=0; +import math +intentos=0 num = int(input("Introduce numero: ")) -while num<0: - intentos=intentos+1 +while num < 0: + intentos = intentos+1 print("Incorrecto") num=int(input("Introduce numero: ")) if intentos==2: print("Demasiados intentos") - break; + break if intentos<2: intentos=intentos+1 diff --git a/10 PYTHON/012_Ejercicios_Bucles_1.py b/10 PYTHON/012_Ejercicios_Bucles_1.py index bbec015..448c1bb 100644 --- a/10 PYTHON/012_Ejercicios_Bucles_1.py +++ b/10 PYTHON/012_Ejercicios_Bucles_1.py @@ -4,11 +4,44 @@ # Escribe un programa que sume todos los números enteros del 1 al 100 usando un bucle for. suma = 0 + for numero in range(1, 101): suma += numero print("La suma de los números del 1 al 100 es:", suma) +a = 31 +b = a // 2 +# División entera. P. ej. 13 // 2 == 6 +while b > 1: + if a % b == 0: # % es el operador resto. P. ej. 10 % 5 == 0 + print(f"{b} es factor de {a}") + break + + else: + print(f'{a} es primo') + b -= 1 + +print ('\nFuera del Bucle.') + +a = 5 + +while a: + print(a, end=' ') + if a == 2: # Se usa 'if' en lugar de una comparación suelta + break + a -=1 # Se reduce a para evitar un bucle infinito + +print('\n fuera del bucle') +print(f"valor de a: {a}") + +nl_b = 7 +while bool(nl_b): + nl_b -= 1 + if nl_b % 2 == 0: # se verifican los numeros pares + continue # se evitan los numeros pares segun la sentencia del if + print(nl_b, end= ' ') +print("fuera del bucle") diff --git a/10 PYTHON/012_Ejercicios_Bucles_2.py b/10 PYTHON/012_Ejercicios_Bucles_2.py index 0d7ee40..13dd457 100644 --- a/10 PYTHON/012_Ejercicios_Bucles_2.py +++ b/10 PYTHON/012_Ejercicios_Bucles_2.py @@ -10,6 +10,21 @@ print("Cuadrados de los números del 1 al 10:", cuadrados) - - +""" + ejemplo, donde se evalua si un número es primo o no dentro de un bucle while +""" + +ln_a = 89 +ln_b = ln_a // 2 # se realiza division entera (se lleva a cabo redondeo de factores) +print(ln_b) + +while ln_b > 1: + if ln_a % ln_b == 0: # se usa el operador de resto o residuo + print(f"{ln_b} es factor de {ln_a}") + break + ln_b -= 1 +else: + print(f"\n{ln_a} es primo") + +print("\nfuera del bucle") diff --git a/10 PYTHON/012_Ejercicios_Bucles_3.py b/10 PYTHON/012_Ejercicios_Bucles_3.py index 0088de8..8fe738f 100644 --- a/10 PYTHON/012_Ejercicios_Bucles_3.py +++ b/10 PYTHON/012_Ejercicios_Bucles_3.py @@ -13,5 +13,6 @@ print(f"La letra 'a' aparece {contador} veces en la palabra {texto}.") - +for s in ['Me', 'Gusta', 'Python!']: + print(s, end=' ') diff --git a/10 PYTHON/012_Ejercicios_Bucles_4.py b/10 PYTHON/012_Ejercicios_Bucles_4.py index 7a288f1..1441ec3 100644 --- a/10 PYTHON/012_Ejercicios_Bucles_4.py +++ b/10 PYTHON/012_Ejercicios_Bucles_4.py @@ -12,4 +12,10 @@ print(f"{numero} x {i} = {resultado}") +# programa que compara los valores de dos listas, mostrando el valor maximo en cada comparación +lista_1a = [10, 20, 30, 40] +lista_1b = [5, 25, 50, 10] +for a,b in zip(lista_1a, lista_1b): + m = max(a,b) # al utilizar la expresión max: esta devuelve el valor maximo entre a y b + print(m, end = ' ') \ No newline at end of file diff --git a/10 PYTHON/012_Ejercicios_Bucles_5.py b/10 PYTHON/012_Ejercicios_Bucles_5.py index 12a6f48..8b6cae5 100644 --- a/10 PYTHON/012_Ejercicios_Bucles_5.py +++ b/10 PYTHON/012_Ejercicios_Bucles_5.py @@ -1,8 +1,53 @@ +# recorrer un diccionario con u bucle for +keys = ['nombre', 'apellido', 'edad'] +values = ['fran', 'guiza', '34'] +base = dict(zip(keys, values)) # creacion de un diccionario +"""En cada iteración del ejemplo le estamos pasando la clave (k) del diccionario y el valor del diccionario correspondiente a esa clave (d[k]) +""" +for k in base: # se declara la variable k para recorrer el diccionario + info = '{}: {}'.format(k, base[k]) # dentro del for se inicializa una nueva variable que recorre el diccionario # Texto formateado con claves y valores + print(info) +# Asignacion en tuplas +l_a, l_b = (3, 4) # asignacion de valores dentro de una tupla +l_t = [(1,2), (3,4), (5,6)] # declaracion de una lista de tuplas +for x, y in l_t: # for para recorrer la lista de tuplas asignando los valores contenidos a dos variables (desempaquetado en tuplas) + print(x + y, end= ' '"\n") +# navegar en un diccionarios con el desempaquetado de tuplas +for k, v in base.items(): # devuelve la tupla con clave valor, en cada iteración del for + print(f"{k}: {v}") + +for k in base.keys(): # Recorre el diccionario, pero solo busca dentro de la lista keys + print(k, end = ' ') + +for v in base.values(): # Recorre el diccionario pero solo va a la lista de valores + print(v, end = ' ') + + +# Obtener claves +claves = base.keys() # dict_keys(['nombre', 'apellido', 'edad']) +print(claves, "\n") + +# Obtener valores +valores = base.values()# dict_values(['Guido', 'van Rossum', 60]) +print(valores, "\n") + +# Obtener items (pares clave-valor) +pares = base.items() # dict_items([('nombre', 'Guido'), ('apellido', 'van Rossum'), ('edad', 60)]) +print(pares, "\n") + +# Si necesitas convertirlos a listas +lista_claves = list(claves) +lista_valores = list(valores) +lista_pares = list(pares) + +print(lista_claves, "\n") # ['nombre', 'apellido', 'edad'] +print(lista_valores, "\n") # ['Guido', 'van Rossum', 60] +print(lista_pares, "\n") # [('nombre', 'Guido'), ('apellido', 'van Rossum'), ('edad', 60)] diff --git a/10 PYTHON/012_Ejercicios_Bucles_6.py b/10 PYTHON/012_Ejercicios_Bucles_6.py index 39d880d..798f101 100644 --- a/10 PYTHON/012_Ejercicios_Bucles_6.py +++ b/10 PYTHON/012_Ejercicios_Bucles_6.py @@ -1,14 +1,54 @@ - +import random # Escribe un script que cuente desde 1 hasta un número n proporcionado por # el usuario, imprimiendo cada número. +letras = list('abcdefghijklmnopqrstuvwyz') + +l_1 = letras[:8] # Creacion de sublistas +l_2 = letras[8:16] +l_3 = letras[16:] + +random.shuffle(l_1) # se mezclan las franjas de las listas de manera aleatoria +random.shuffle(l_2) +random.shuffle(l_3) + +""" + Haciendo uso de zip aprovechamos la ventaja que presenta este metodo ya que es mas legible + evita la preocupación de que todas las listas tengan la misma longitud + """ +for a, b, c in zip(l_1, l_2, l_3): # se recorren las 3 sublistas que han sido mezcladas, el recorrido se realiza de manera simultanea + print(a + b + c, end=' ') # se muestra en pantalla una letra de cada lista en cada iteración + +print(" ") n = int(input("Introduce un número hasta el que contar: ")) contador = 1 while True: + if contador == n: + break print(contador) contador += 1 +print(n) + + +letras = list('iabcdiefghijklimnopqrst') # se crea una lista con una cantidad de letras +vocales = 'aeiou' # declaracion e incialicion de una variable con las vocales + +random.shuffle(letras) # uso del random para mezclar la lista +print(' '.join(letras)) # se imprime la lista mezclada, agragando un espacio entre cada caracter + +""" +En este ejemplo buscamos las posiciones de las vocales en un abecedario desordenado. Para ello +usamos la función enumerate, que nos pide una secuencia y nos devuelve la misma secuencia +asociada a sus índices: + """ +for i, letra in enumerate(letras): # dentro del for se hace uso de 2 variables para recorrer la lista, ademas de usar el metodo enumerate + if letra in vocales: # la variable letra recorre las vocales + print(f"{letra} en la posición {i}") # al imprimir la variable i se usa para numerar la posicion +abcde = sorted(letras[:5]) # el enumerate se puede usar envuelto en un list() o recorrerlo con un for +list(enumerate(abcde)) # de esta forma devuelve una secuencia con sus indices +list(enumerate(abcde, 10)) # es posible indicarle en que indice empieza diff --git a/10 PYTHON/012_Ejercicios_Bucles_8.py b/10 PYTHON/012_Ejercicios_Bucles_8.py index 656a460..cee28cc 100644 --- a/10 PYTHON/012_Ejercicios_Bucles_8.py +++ b/10 PYTHON/012_Ejercicios_Bucles_8.py @@ -10,7 +10,3 @@ numero = int(input("Introduce un número (5 para detener): ")) print("¡Número 5 encontrado!") - - - - diff --git a/10 PYTHON/012_Ejercicios_Bucles_9.py b/10 PYTHON/012_Ejercicios_Bucles_9.py index 68abcbe..47a3b81 100644 --- a/10 PYTHON/012_Ejercicios_Bucles_9.py +++ b/10 PYTHON/012_Ejercicios_Bucles_9.py @@ -1,6 +1,5 @@ - - - +import sys +import math # Escribe un script que solicite al usuario su edad y asegúrate de que el @@ -13,5 +12,51 @@ edad = int(input("Introduce tu edad nuevamente: ")) print("Edad válida introducida:", edad) - - +""" +The program: +Your program must determine in which category belongs a given integer. The possible integers are named intervals that are also given. +The intervals do not overlap. +The integer always belongs to a category. + +INPUT: +Line 1: X the integer to categorize. +Line 2: N an integer for the number of categories. +Next N lines: Two integers F and T for the inclusive bounds of the interval, followed by a word category, its name. + +OUTPUT: +The name of the category with the interval that contains X. + +CONSTRAINTS: +0 < N < 100 +-1000 ≤ F ≤ T ≤ 1000 +F ≤ X ≤ T + +EXAMPLE: +Input +10 +3 +-1000 -1 negative +0 0 null +1 1000 positive +Output +positive + +""" + +# Auto-generated code below aims at helping you parse +# the standard input according to the problem statement. + +x = int(input()) +n = int(input()) +for i in range(n): + inputs = input().split() + f = int(inputs[0]) + t = int(inputs[1]) + category = inputs[2] + + if x <0: + n = "negative" + elif x == 0: + n = "null" + elif x > 0: + n = "positivo" \ No newline at end of file diff --git a/10 PYTHON/012_Listas.py b/10 PYTHON/012_Listas.py index 1696194..ea88ac9 100644 --- a/10 PYTHON/012_Listas.py +++ b/10 PYTHON/012_Listas.py @@ -1,15 +1,15 @@ - +# la información sobre los metodos de las listas se encuenta en el documento del tema 6 parte 3 = Estructura de datos # LISTAS """ La lista es un tipo de colección ordenada y modificable. Es decir, una secuencia de valores de cualquier tipo, ordenados y de tamaño variable. -Se escriben entre corchetes. [] +Se escriben entre corchetes []. """ miLista=["Angel", 43, 667767250] -miLista2 = [22, True, "una lista", [1, 2]] +mi_Lista02 = [22, True, "una lista", [1, 2]] # MÉTODOS DE LAS LISTAS @@ -18,12 +18,38 @@ print(miLista) # Acceder a los elementos de una lista +""" + Podemos acceder a cada uno de los elementos de la lista escribiendo el nombre de la lista e indicando el + índice del elemento entre corchetes. +""" miLista = [22, True, "una cadena", [1, 2]] print(miLista[0]) +# Aceder a una lista dentro de otra lista +""" + [][] primero para indicar a qué posición de la lista exterior queremos acceder, y el + segundo para seleccionar el elemento de la lista interior +""" miLista = [[1,2] , [3,4] , [5,6]] -miVar = miLista[1,1] -print(miVar) +miVar = miLista[1][1] +print(miVar) # tiene un valor de 4 + +# Modificación de valores dento de una lista +mi_lista = [22, True] +mi_lista [0] = 99 +print(mi_lista[0]) +print(f"la lista nueva es: {mi_lista[:]}") # [:] con esta expresión se imprime toda la lista + + +# Operaciones con listas + +print(miLista == mi_lista) # False + +print(mi_lista in miLista) # False + +print(mi_lista == [[1,2] , [3,4] , [5,6]]) # Salida True + +print(mi_lista is [[1,2] , [3,4] , [5,6]]) # False / se recomienda el uso de operadores para hacer comparaciones # Función con una lista como parámetro @@ -35,3 +61,54 @@ def miFunccion(listaFrutas): miFunccion(frutas) +la = [1, 2, 3, 4, 5] +lb = list('abcde') +lc = list('ABCDE') + +zlist = list(zip(la, lb, lc)) # soporta cualquier número # zip # de argumentos posicionales zlist +a, b, c = zip(*zlist) # El * en zip desempaqueta lista de tuplas +print(la, lb, lc, sep = '\n') # Seperador por defecto es espacio +print(la, lb) + +# incluir una función en una lista + +lista_funcion = [0, 2, miFunccion,"fran"] +print(lista_funcion[2]) + + +mi_Lista01 = ["Angel", "Maria", "Manolo", "Antonio", "Pepe"] +mi_Lista02 = ["Maria", 2, 5.56, True] # Se puede mezclar diferentes elementos + +print (mi_Lista01[1]) # Para un elemento en concreto, se empieza a contar desde la posición cero. +print (mi_Lista02[0:2]) # Empezando desde cero incluido hasta el dos sin incluir, esto es, “Angel y María”. + +mi_Lista01.append("javier") # Agrega un elemento a la final de la lista +print(mi_Lista01[:]) + +mi_Lista02.clear() # borra los elementos de la lista +print(mi_Lista02[:]) + +mi_Lista02 = mi_Lista01.copy() # copia una lista de la otra +print(mi_Lista01[:]) +print(mi_Lista02[:]) + +print(mi_Lista01.count("javier")) # retorna la cantidad de veces que se encuentra un elemento + +mi_Lista02.extend(mi_Lista01) # Añade los elementos de una lista a otra. +print(mi_Lista02[:]) + +print(mi_Lista02.index("javier")) # Devuelve el índice del primer elemento cuyo valor es el especificado. + +mi_Lista01.insert(2, "edelmira") # Añade un elemento en la posición especificada. +print(mi_Lista01[:]) + +print(mi_Lista01.pop(4)) # Borra el elemento en la posición especificada y devuelve el elemento eliminado. + +mi_Lista01.remove("Pepe") # Elimina el elemento con el valor especificado +print(mi_Lista01) + +mi_Lista01.sort(reverse=True) +print(mi_Lista01) +mi_Lista01.sort() +print("🎕",mi_Lista01) + diff --git a/10 PYTHON/012_listas_01.py b/10 PYTHON/012_listas_01.py new file mode 100644 index 0000000..99b67f1 --- /dev/null +++ b/10 PYTHON/012_listas_01.py @@ -0,0 +1,67 @@ +from pathlib import Path +import pickle + +lista_1 = list() # creacion de lista vacia + +def abrir_archivo():# abrir archivo + global lista_1 # declarar lista_1 como variable global + file_name = input("introduce el nombre del archivo: ")# se solicita nombre de archivo + +#comprobacion de archivo existente + path = Path(file_name) + + if path.is_file(): #Abre el archivo en modo lectura + input_file = open(file_name, 'rb') # se crea una variable asignandole el archivo + lista_1 = pickle.load(input_file) + input_file.close() # se cierra el archivo + else: + print("archivo no encontrado, crearemos una lista vacia") + +abrir_archivo() +print(lista_1) + +def crear_lista(): + while True: + n_usuario = input("Ingresa un valor (o escribe 'salir' para terminar): ") + + if n_usuario.lower() == "salir": # Convertimos a minúsculas para evitar errores + break # Sale del bucle si el usuario escribe 'salir' + + if n_usuario.isnumeric(): # comprobacion del numero + num = int(n_usuario) + lista_1.append(num) # se agrega a la lista despues de comprobarlo + print(f"numero {num} agregado exitosamente") + + else: + print("has ingresado un valor no mumerico") # en caso de que no sea un número + + +crear_lista() # Llamamos a la función antes de guardar +print(lista_1) + +li_1 = lista_1.__iter__() +li_1.__next__() +next(li_1) +next(li_1) + +li_2 = iter(lista_1) +next(li_2) + +def guardar(): + guardar = input("deseas guardar la lista: (si) o (no)").lower() + + if guardar == "si": #Metodo usado para guardar un archivo tipo lista + output = open('mi_lista.pkl', 'wb') # Abre un archivo en modo escritura binaria ('wb') + pickle.dump(lista_1, output) # Guarda el objeto 'lista_1' en el archivo usando pickle + output.close() # Cierra el archivo + print("lista guardado con exito") +guardar() +""" +if guardar == "si": + with open('mi_lista.pkl', 'wb') as output: # Usamos "with open" para manejar archivos mejor + pickle.dump(lista_1, output) + print("Lista guardada con éxito.") +✔ Se usa with open(...) para manejar el archivo de manera más segura y evitar olvidar cerrarlo. +""" + + diff --git a/10 PYTHON/013_Tuplas.py b/10 PYTHON/013_Tuplas.py index 68c9be5..21542b4 100644 --- a/10 PYTHON/013_Tuplas.py +++ b/10 PYTHON/013_Tuplas.py @@ -86,8 +86,72 @@ print(num3) +this_tuple = ("platano", "pera", "manzana", "fresa", "cherry", "orange", "kiwi", "melon", "mango") +print(f"Aqui muestro el elemento en la posicion 1: {this_tuple[1]}") +print(f"En esta linea se puede ver el ultimo elemento: {this_tuple[-1]}") +print(f"En esta linea se puede ver el pen-ultimo elemento: {this_tuple[-2]}") +print(f"Aqui se muestra un rango en la tupla: {this_tuple[2:5]}") # Al especificar un rango, el valor de retorno será una nueva tupla con los elementos especificados. +print(f"Rango con indices negativos: {this_tuple[-4:-1]}") +# Modificando datos en una tupla, se debe convertir en una lista y luego convertir la lista en tupla / Directamente no se pueden modificar u agregar elementos +tupla_x = ("apple", "banana", "cherry") # Declaración de una tupla +print(f"tupla sin modificación: {tupla_x}") +lista_y = list(tupla_x) # se convierte la tupla en una lista +lista_y[1] = "Kiwi" # a la lista se le modifica los datos deseados +tupla_x = tuple(lista_y) # se convierte la lista en una tupla +print(f"Tupla modificada: {tupla_x}") +# Recorrer una tupla + +print("se recorre una tupla: ") +for x in this_tuple: # Puedes recorrer los elementos de la tupla utilizando un bucle for. + print(x) + +# comprobar si existe el articulo en una tupla + +if "platano" in this_tuple: + print("si 'platano' esta declarado en esta tupla") +else: + print("platano no encontrado") + +# longitud de una tupla +print(f"Aqui se mide la longitud de la tupla: {len(this_tuple)}") + +# #Tupla unitaria. Hay que poner al final "," +tupla_01 = ("manzana",) +print(type(tupla_01)) # se verifica el tipo de dato contenido + +""" + Las tuplas no se pueden cambiar, por lo que no puedes eliminar elementos de él, pero puedes + eliminarlas por completo haciendo uso de la expresión del +""" +del tupla_01 + +# unir dos tuplas + +tupla_02 = ("a", "b", "c") +tupla_03 = (1, 2, 3) + +tupla_04 = tupla_02 + tupla_03 +print(f"Muestra el resultado de unir dos tuplas: {tupla_04}") + +# Uso del contructor tuple() + +this_tuple_1 = tuple(("apple", "banana", "cherry")) # note the double round-brackets +print(this_tuple_1) + +# empaquetado de tupla, no se recomienda, es posible definir una tupla sin el uso de paréntesis +miTupla = "Angel", 4, 5.345, True, 4 + +#Desempaquetado de tupla. Permite asignar todos los elementos de una tupla a diferentes variables: +miTupla = ("Angel", 4, 5.345, True, 4) +nombre, num1, num2, valor1, num3 = miTupla + +print(nombre) +print(num1) +print(num2) +print(valor1) +print(num3) \ No newline at end of file diff --git a/10 PYTHON/014_Diccionarios.py b/10 PYTHON/014_Diccionarios.py index 400cf2c..d442104 100644 --- a/10 PYTHON/014_Diccionarios.py +++ b/10 PYTHON/014_Diccionarios.py @@ -26,6 +26,7 @@ "Amélie": "Jean-Pierre Jeunet"} peliculas["Love Actually"] +peliculas["Kill Bill"] # Reasignar valores a un diccionario @@ -36,6 +37,7 @@ miDiccionario3={"nombre":"Jordan", "Equipo":"Bulls", "Anillos":[1991, 1992, 1993, 1996, 1997, 1998]} print(miDiccionario3["Anillos"]) +print(miDiccionario3["nombre"], "Obtuvo anillos en los años: ", miDiccionario3["Anillos"]) # Quitar valores de un diccionario @@ -172,5 +174,5 @@ } print(myfamily["child1"]) - +print(myfamily) diff --git a/10 PYTHON/014_diccionarios_01.py b/10 PYTHON/014_diccionarios_01.py new file mode 100644 index 0000000..1215a6d --- /dev/null +++ b/10 PYTHON/014_diccionarios_01.py @@ -0,0 +1,114 @@ +""" programa que pide al usuario su documento para verificar su edad + en caso de que no se encuentre en el diccionario pide la edad para agregrar su + información +""" +# importacion de librerias +import pickle +from pathlib import Path + +docu = {} # creacion de un diccionario vacio +# la información contenida en las "" es la posicion dentro del diccionario y lo que viene despues es su valor + +def abrir_archivo(): + global docu # declarar docu como variable global + file_name = input("introduce el nombre del archivo: ")# se solicita nombre de archivo + + path = Path(file_name) #comprobacion de archivo existente + + if path.is_file(): #Abre el archivo en modo lectura + input_file = open(file_name, 'rb') # se crea una variable asignandole el archivo + docu = pickle.load(input_file) + input_file.close() # se cierra el archivo + else: + print("archivo no encontrado, crearemos un diccionario vacio") + +abrir_archivo() +print(docu) + +document_number = input("introduce tu documento de identidad: ") + +if document_number in docu: #comprueba que el dato introducido este en el diccionario + print(f"\n la edad de {document_number} es: {docu[document_number]}") + +else: + edad = input("Documento no encontrado, introduce tu edad: ") + if edad.isnumeric(): # se verifica que sea un numero valido (solo aplica para positivos) + num = int(edad) + docu[document_number] = num # se añade al diccionario los valores introducidos por el usuario + print("añadido al diccionario") + else: + print("edad no valida") + +print("\n", docu) + +guardar = input("deseas guardar el diccionario:") + +if guardar == "si": #Metodo usado para guardar un archivo tipo diccionario + output = open('midic.pkl', 'wb') # Abre un archivo en modo escritura binaria ('wb') + pickle.dump(docu, output) # Guarda el objeto 'docu' en el archivo usando pickle + output.close() # Cierra el archivo + print("diccionario guardado con exito") +else: + document_number = input("introduce tu documento de identidad: ") + +# Ingreso de datos por consola para asginarlos a un diccionario + +nombre_usu = input("Introduce tu nombre: ") +apellido_usu = input("introduce tu apellido: ") +pais_usu = input("Cual es tu pais: ") +ciudad_usu = input("Ingresa tu ciudad: ") + +# Creación de un diccionario +dic_01 = { + "Nombre": nombre_usu, + "Apellido": apellido_usu, + "Pais":pais_usu, + "Ciudad": ciudad_usu +} +print(dic_01) + +# Otra forma de definir diccionarios con la funcion dict() +dic_02 = dict( + Nombre="Santiago", + Apellido="Hernandez", + Pais="España", + Ciudad="Madrid" +) +print(dic_02) + +dic_03 = dic_02.copy() +print(dic_03) + +dic_03.clear() +print(f"Este diccionario esta vacio: {dic_03}") + +# Los metodos que se usan en el diccionario estan especificados en el archivo de estuctura de datos + +# Devuelve un diccionario con las claves y valores especificados +print(f"muestra los apellidos: {dic_01.fromkeys("Apellido")}") + +# Devuelve el valor de una clave +print(f"muestra el nombre contenido en el diccionario: {dic_01.get("Nombre")}") + +# Devuelve una lista que contiene una tupla por cada par clave-valor +print(f"mostrar el diccionario como tupla: {dic_01.items()}") + +# Devuelve una lista que contiene las claves del diccionario +print(f"Muestra una lista que contiene el diccionario: {dic_01.keys()}") + +# Borra el elemento con la clave especificada +dic_01.pop("Apellido") +print(dic_01) + +# Borra el último par clave-valor insertado +dic_02.popitem() +print(dic_02) + +# Devuelve el valor de la clave especificada. Si no existe, inserta la clave con el valor especificado. +print(f"muestra el valor de nombre: {dic_02.setdefault("Apellido")}") + +# Actualiza el diccionario con el par clave-valor que se especifique +dic_01.update(Apellido = "Diaz") + +# Devuelve una lista con los valores del diccionario +print(f"Muestra el diccionario: {dic_01.values()}") \ No newline at end of file diff --git a/10 PYTHON/015_Sets.py b/10 PYTHON/015_Sets.py index 3caa709..b12c7f2 100644 --- a/10 PYTHON/015_Sets.py +++ b/10 PYTHON/015_Sets.py @@ -4,10 +4,10 @@ # SETs, conjuntos """ -Un conjunto es una colección de elementos únicos que no está ordenada ni indexada, -por lo que no puede estar seguro de en qué orden aparecerán los elementos. -En Python, los conjuntos se escriben entre llaves. -Una vez que se crea un conjunto, no puede cambiar sus elementos, pero puede agregar nuevos elementos. + Un conjunto es una colección de elementos únicos que no está ordenada ni indexada, + por lo que no puede estar seguro de en qué orden aparecerán los elementos. + En Python, los conjuntos se escriben entre llaves. + Una vez que se crea un conjunto, no puede cambiar sus elementos, pero puede agregar nuevos elementos. """ # Declaración: @@ -115,9 +115,9 @@ miSet = {"manzana", "banana", "cereza"} -del miSet +# del miSet En esta linea usando del se elimina el diccionario -print(miSet) +print(f"{miSet}") # Unión de conjuntos # El método union() devuelve un nuevo conjunto con todos los elementos de ambos conjuntos: diff --git a/10 PYTHON/016_Funcion_Algoritmo_Busqueda_Binaria.py b/10 PYTHON/016_Funcion_Algoritmo_Busqueda_Binaria.py new file mode 100644 index 0000000..a541fa7 --- /dev/null +++ b/10 PYTHON/016_Funcion_Algoritmo_Busqueda_Binaria.py @@ -0,0 +1,27 @@ +# Busqueda binaria: / siempre es mejor hacer uso de la busqueda binaria, evitar el uso de busqueda lineal por optmización en el tiempo de ejecución +""" + Importante recalcar que para la solución de búsqueda binaria es necesario tener la lista + ordenada, por lo que usamos la función sorted() para ordenarla. +""" + +def importar_lista(archivo): + lista = [] + with open(archivo) as tf: + lines = tf.read().split('","') + for line in lines: + lista.append(line) + return lista + +def buscar(lista, nombre_buscado): + tamano_de_lista = len(lista) # haciendo uso de la función sorted se organiza la lista en orden alfabetico + inicio = 0 + fin=tamano_de_lista-1 + while inicio <= fin: + medio=(inicio + fin)//2 + if lista[medio] == nombre_buscado: + return medio + elif lista[medio] < nombre_buscado: + inicio=medio+1 + elif lista[medio] > nombre_buscado: + fin = medio-1 + return -1 \ No newline at end of file diff --git a/10 PYTHON/016_Funcion_Algoritmo_Busqueda_lineal.py b/10 PYTHON/016_Funcion_Algoritmo_Busqueda_lineal.py new file mode 100644 index 0000000..5893f20 --- /dev/null +++ b/10 PYTHON/016_Funcion_Algoritmo_Busqueda_lineal.py @@ -0,0 +1,52 @@ + +import pickle +# Busqueda lineal + +def buscar(lista, nombre_buscado): + tamano_lista = len(lista) + for actual in range(0, tamano_lista): + if(lista[actual] == nombre_buscado): + return actual + return -1 + +def main(): + # Cargar la lista desde el archivo .pkl + with open('mi_lista.pkl', 'rb') as archivo: + importa_lista = pickle.load(archivo) + + lista_de_alumnos = sorted(importa_lista) + posicion_del_alumno = buscar(lista_de_alumnos, "12") + + if posicion_del_alumno != -1: + print(f"Alumno(a) {lista_de_alumnos} está en la posicion {posicion_del_alumno}") + else: + print("Alumno no encontrado") + +if __name__ == "__main__": + main() + +# Se inserta un archivo importado + +def importar_lista(archivo): + lista = [] + with open(archivo) as tf: + lines = tf.read().split('","') + for line in lines: + lista.append(line) + return lista + +def buscar_1(lista, nombre_buscado): + tamano_de_lista = len(lista) + for actual in range(0,tamano_de_lista): + if (lista[actual] == nombre_buscado): + return actual + return -1 + +def main(): + lista_de_alumnos = sorted(importa_lista('../data/lista_aluno s')) + posicion_del_alumno = buscar(lista_de_alumnos, "Wanessa") + print("Alumno(a) {} está en la posicion {}".format(lista_de_alumnos[posicion_del_alumno], posicion_del_alumno)) + +if __name__ == "__main__": + main() + diff --git a/10 PYTHON/016_funcion_multiplicada.py b/10 PYTHON/016_funcion_multiplicada.py new file mode 100644 index 0000000..481519e --- /dev/null +++ b/10 PYTHON/016_funcion_multiplicada.py @@ -0,0 +1,120 @@ +import numpy as np +import time +import math + +# función con múltiples parámetros con una sentencia de retorno + +numer_1 = int(input("ingresa el primer: ")) +numer_2 = int(input("Ingresa otro valor: ")) + +def multiplica(val1: int, val2: int): + resultado = val1 * val2 + return resultado + +print(multiplica(numer_1, numer_2)) # se llama la función y se le asignan los valores necesarios para que se ejecute la función + + +# lista con 10 millones de números +x = list(np.random.randint(low=1, high=500000, size= 10000000)) + +# Complejidad Constante O(k) Constant Time +def constante(x: list) -> list: + return x + +# Medir el tiempo de ejecución + +start_time = time.time() +constante(x) +end_time = time.time() + +print(f"Tiempo de ejecución Complejidad Constante O(k) : {end_time - start_time} segundos") + +# Complejidad O(n) Linear Time +def iterador_normal(x:list) -> list: + contador = len(x) + while(contador > 0): + contador -= 1 + return x + +# Medir el tiempo de ejecucion +start_time = time.time() +iterador_normal(x) +end_time = time.time() + +print(f"Tiempo de ejecución Complejidad O(n): {end_time - start_time} segundos") + +# Complejidad O(n2) Quadratic Time +def iterador_anidado(x:list) -> list: + contador_externo = len(x)//1000 + contador_interno = len(x)//1000 + + while(contador_externo > 0): + contador_externo -= 1 + + for i in range(contador_interno): + i + return x + +# Medir el tiempo de ejecucion +start_time = time.time() +iterador_anidado(x) +end_time = time.time() + +print(f"Tiempo de ejecución Complejidad O(n2) Quadratic: {end_time - start_time} segundos") + +# Complejidad O(log(n)) Logarithmic Time +def iterador_multiplicado(x:list) -> list: + iterador = len(x) + incremento = 1 + while(iterador > 0): + iterador -= incremento + incremento *= (incremento + 1) + + return x + +# Medir el tiempo de ejecucion +start_time = time.time() +iterador_multiplicado(x) +end_time = time.time() + +print(f"Tiempo de ejecución Complejidad O(log(n)) Logarithmic : {end_time - start_time} segundos") + +# Complejidad O(log(log(n))) Logarithmic from Logarithmic Time +def iterador_incremento_exponencial(x:list) -> list: + iterador = len(x) + incremento = 1 + while(iterador > 0): + iterador -= pow(incremento, 2) + incremento += 1 + return x + +# Medir el tiempo de ejecucion +start_time = time.time() +iterador_incremento_exponencial(x) +end_time = time.time() + +print(f"Tiempo de ejecución Complejidad O(log(log(n))) Logarithmic from Logarithmic: {end_time - start_time} segundos") + +# Cálculo de la complejidad Algorítmica del Ejemplo / 'La Complejidad es n*n*n, n cubo' +y = list(np.random.randint(low=1,high=500000, size=999)) + +def calculo_bit_o_ejemplo(y:list) -> str: + iterador = -len(y) # k + incremento = 1 # k + q_list = y # k + + while(iterador < 0): # log(n) + iterador /= incremento # k + incremento += 1 # k + for p in y: # n + for q in y: # n -> n * n + for r in y: # n -> n * n * n + r + return "La Complejidad es n*n*n, n cubo" + +# Medir el tiempo de ejecucion +start_time = time.time() +calculo_bit_o_ejemplo(y) +end_time = time.time() + +print(f"Tiempo de ejecución Cálculo de la complejidad Algorítmica del Ejemplo: {end_time - start_time} segundos") diff --git a/10 PYTHON/016_funciones.py b/10 PYTHON/016_funciones.py index daf7018..31e39c3 100644 --- a/10 PYTHON/016_funciones.py +++ b/10 PYTHON/016_funciones.py @@ -4,7 +4,7 @@ # ------------------------------------- # Definición de una función. Importante la identación: -def my_funcion(): +def my_funcion(): # sintaxis basica de la declaración de una función print("Estamos ejecutando la función.") # Llamada a la función. En otra parte de mi código, llamamos a la función para que se ejecute: @@ -12,26 +12,22 @@ def my_funcion(): my_funcion() # ------------------------------------- +num1 = int(input()) +num2 = int(input()) +def suma(num1, num2): + print("\n","suma =", num1 + num2) -def suma(): - num1 = 3 - num2 = 5 - print("suma =", num1+num2) - -suma() +suma(num1 = int(input("ingresa el valor inicial: ")), num2 = int(input("ingresa el siguiente valor: "))) # Otra opción: def suma(): - num1 = 3 - num2 = 5 + num1 = float(input("ingresa el valor inicial: ")) + num2 = float(input("ingresa el valor adicional: ")) resultado = num1 + num2 return resultado - - - -print(suma()) +print("El resultado es: ", suma()) # ------------------------------------- #El bloque de código que ejecutará la función incluye todas las declaraciones con indentación @@ -209,10 +205,14 @@ def sumar(a, b): # --------------------------- # función con múltiples parámetros con una sentencia de retorno +numer_1 = int(input("ingresa el primer: ")) +numer_2 = int(input("Ingresa otro valor: ")) + def multiplica(val1, val2): - return val1 * val2 + resultado = val1 * val2 + return resultado -multiplica(3, 5) # muestra 15 en la consola +multiplica(numer_1, numer_2) # muestra 15 en la consola #--------------------------------------- @@ -243,7 +243,7 @@ def sumar(a:int = 0, b:int = 0) -> int: #def sumar(a = 0, b = 0): return a + b - resultado = sumar() +resultado = sumar() #print(f'Resultado sumar: {resultado}') print(f'Resultado sumar: {sumar(45, 654)}') #uanque le hemos dicho el tipo de los parámetros no estamos obligados a cumplirlo. @@ -391,11 +391,6 @@ def fahrenheit_celsius(fahrenheit): print(f'{fahrenheit} F a C: {resultado:0.2f}') - - - - - - def suma(num1, num2): - print("suma= ", num1+num2) \ No newline at end of file + print("suma= ", num1+num2) + diff --git a/10 PYTHON/funciones.py b/10 PYTHON/016_funciones_1.py similarity index 99% rename from 10 PYTHON/funciones.py rename to 10 PYTHON/016_funciones_1.py index daf7018..9624aae 100644 --- a/10 PYTHON/funciones.py +++ b/10 PYTHON/016_funciones_1.py @@ -5,7 +5,7 @@ # Definición de una función. Importante la identación: def my_funcion(): - print("Estamos ejecutando la función.") + print("Estamos ejecutando la función.") # Llamada a la función. En otra parte de mi código, llamamos a la función para que se ejecute: @@ -28,9 +28,6 @@ def suma(): resultado = num1 + num2 return resultado - - - print(suma()) # ------------------------------------- @@ -243,7 +240,7 @@ def sumar(a:int = 0, b:int = 0) -> int: #def sumar(a = 0, b = 0): return a + b - resultado = sumar() +resultado = sumar() #print(f'Resultado sumar: {resultado}') print(f'Resultado sumar: {sumar(45, 654)}') #uanque le hemos dicho el tipo de los parámetros no estamos obligados a cumplirlo. diff --git a/10 PYTHON/016_funciones_excepciones.py b/10 PYTHON/016_funciones_excepciones.py new file mode 100644 index 0000000..b5c627d --- /dev/null +++ b/10 PYTHON/016_funciones_excepciones.py @@ -0,0 +1,99 @@ +def indexador(objeto, indice): + return objeto[indice] + +# print(indexador('Python', 4)) + +try: + indexador('Python', 10) +except IndexError: # se realiza la capatrua del Indexerror + print("has puesto un indice muy grande") +finally: # Esta expresión se usa para asegurar el cierre de de un fichero o una conexión + print('Esto se ejecuta incluso cuando salta la excepción') + +print("Estamos fuera del try-catch") + +try: + indexador('Python', 'h') + # para evitar que el flujo del programa se dentenga es recomndable usar el bloque except +except (IndexError, TypeError): + print("Error") + # El uso de finally solo asegura que el codigo de su bloque se ejecute, pero impide que el flujo del programa se detenga +finally: # Esta expresión se usa para asegurar el cierre de de un fichero o una conexión + print('Esto se ejecuta incluso cuando salta la excepción') + +print("Estamos fuera del try-catch") + + # Captura todos los errores. No recomendado. +""" + try: + indexador('Python', 'h') + except: + print('Error.') + + print('Hemos salido del try-catch') +""" + +try: + indexador('Python', 'h') +except IndexError: + print("Error de indice") +except TypeError: + print("El indice tiene que ser un número") +finally: # Esta expresión se usa para asegurar el cierre de de un fichero o una conexión + print('Esto se ejecuta incluso cuando salta la excepción') + +print("Estamos fuera del try-catch") + +try: + raise IndexError('Excepción lanzada manualmente') +except IndexError as e: # # Aquí `e` es la variable que almacena la excepción capturada + print(f'He capturado mi propia excepción: {e}') + + +""" +ex_a = 10 +ex_b = 21 +la sentencia assert: + su uso es muy útil para detectar errores en + depuración, pero no se recomienda el uso de assert en producción. +# assert(ex_a > ex_b), 'A tiene que ser mayor que B' # si se cumple la condición no salta el error +# print("Continua el ciclo del programa normal, se ha cumplido la condicion") +""" + +class miPropiaExcepcion(Exception): # Esta clase hereda de la clase raiz Exception + + def __init__(self, valor): + self.valor = valor + + def __str__(self): # define como hay que representar una clase si se la quiere mostrar como un string (una cadena de texto) + return str(self.valor) + +#raise (miPropiaExcepcion("Mensaje de error")) + +def indexado(objeto, indice): + return objeto[indice] +""" + En este caso, indexador produce una excepción, que capturamos en el bloque except, por lo que ejecutamos el código dentro de ese bloque. +Luego, ejecutamos el código finally y, tras ello, como ejecutamos el código fuera de nuestro bloque try/except/finally. +""" +try: + indexador('Python', 10) +except IndexError: + print('Capturamos la excepción') +finally: + print('Esto se ejecuta incluso cuando salta la excepción') +print('Se ejecutará este print?') + +def divide(x, y): + try: + resultado = x/y + except ZeroDivisionError: + print("No se pude dividir por cero") + else: + print(f"El resultado es:{resultado} ") + finally: + print('Ejecutamoss el finally') + +divide(4,12) + +divide(4,0) \ No newline at end of file diff --git a/10 PYTHON/016_iteradores.py b/10 PYTHON/016_iteradores.py new file mode 100644 index 0000000..876e808 --- /dev/null +++ b/10 PYTHON/016_iteradores.py @@ -0,0 +1,35 @@ +class Repetidor(): # Definir la clase sin argumentos en la cabecera. + + def __init__(self, veces, item): + self.veces = veces # Número de repeticiones + self.item = item # Elemento a repetir + self.counter = 0 # Contador de iteraciones + + def __iter__(self): + return self # Un iterador debe devolverse a sí mismo + + def __next__(self): + if self.counter == self.veces: + raise StopIteration('Iterador consumido') # Indica que el iterador terminó + + self.counter += 1 + return self.item # Devuelve el valor repetido + +# Prueba del iterador +repetidor = Repetidor(3, "Python") + +for item in repetidor: + print(item) + + +class Repetidor_1(): + + def __init__(self, veces, *items): + self.veces = veces + self.items = items + + def __iter__(self): + return iter(self.items * self.veces) # Devuelve iterador de la lista + +for r in Repetidor_1(3, 'a', 'b', 'c'): + print(r, end=' ') \ No newline at end of file diff --git a/10 PYTHON/017_-Algoritmos_Insertion_Sort.py b/10 PYTHON/017_-Algoritmos_Insertion_Sort.py new file mode 100644 index 0000000..c1e769c --- /dev/null +++ b/10 PYTHON/017_-Algoritmos_Insertion_Sort.py @@ -0,0 +1,49 @@ +import time + +""" + La clasificación es una de las funciones más utilizadas en programación. Y si no usamos el + algoritmo correcto llevará tiempo extra completar la clasificación. +""" + +# Insertion Sort / No es recomendable para clasificar matrices grandes. + +""" + Ordena un array usando el algoritmo de inserción. + Parámetros: + arr: Lista a ordenar. + n: Longitud de la lista. +""" +def insertion_sort(arr, n): + for i in range(1, n): + """ + Itera desde el segundo elemento (i = 1) hasta el último elemento del array. En cada iteración, + posicion_actual es la posición del elemento actual, y posicion_elemento es el valor de ese elemento. + """ + posicion_actual = i # posición actual y elemento + posicion_elemento = arr[i] ## iterar hasta llega al primer elemento o + +# el elemento actual es más pequeño que el elemento anterior + """ + Compara el elemento actual con los elementos anteriores. Si el elemento actual es menor + que el elemento anterior, mueve el elemento anterior una posición hacia la derecha. + Repite este proceso hasta que el elemento actual esté en la posición correcta. + """ + while posicion_actual > 0 and posicion_elemento < arr[posicion_actual -1]: ## actualizar el elemento actual con el elemento anterior + arr[posicion_actual] = arr[posicion_actual -1] ## moviéndose a la posición anterior + posicion_actual -=1 ## actualizar el elemento de posición actual + arr[posicion_actual] = posicion_elemento + +if __name__ == "__main__": + #inicializacion del array + arr = [3, 4, 7, 8, 1, 9, 5, 2, 6,11,23] + print(f"Lista sin ordenar: {arr}") + insertion_sort(arr, len(arr)) + + print(f"Lista ordeana: {arr}") + + # Medir el tiempo de ejecucion +start_time = time.time() +insertion_sort(arr, len(arr)) +end_time = time.time() + +print(f"Tiempo de ejecución Cálculo de la complejidad Algorítmica del Ejemplo: {end_time - start_time} segundos") \ No newline at end of file diff --git a/10 PYTHON/017_Algoritmo_Bubble_sort.py b/10 PYTHON/017_Algoritmo_Bubble_sort.py new file mode 100644 index 0000000..92512a6 --- /dev/null +++ b/10 PYTHON/017_Algoritmo_Bubble_sort.py @@ -0,0 +1,31 @@ +import time + +""" + La clasificación de burbujas es un algoritmo simple. Intercambia los elementos adyacentes en cada + iteración repetidamente hasta que se ordena la matriz dada. +""" + +def bublle_sort(arr, n): + for i in range(n): + # Iterando de 0 a n-i-1 ya que los últimos i elementos ya están ordenados + for j in range(n - i -1): + # Comprobando el siguiente elemento + if arr[j] > arr[j +1 ]: + # Intercambiando los elementos adyacentes + arr[j], arr[j +1] = arr[j +1], arr[j] + +if __name__ == "__main__": + # Inicialización del array + arr = [12,34,54,6,7,2,90,87,5] + print(f"lista sin ordenar: {arr}") + + bublle_sort(arr, len(arr)) + print(f"Lista ordenada: {arr}") + + +# Medir el tiempo de ejecucion +start_time = time.time() +bublle_sort(arr, len(arr)) +end_time = time.time() + +print(f"Tiempo de ejecución Cálculo de la complejidad Algorítmica del Ejemplo: {end_time - start_time} segundos") \ No newline at end of file diff --git a/10 PYTHON/017_Algoritmo_Merge_sort.py b/10 PYTHON/017_Algoritmo_Merge_sort.py new file mode 100644 index 0000000..1252eef --- /dev/null +++ b/10 PYTHON/017_Algoritmo_Merge_sort.py @@ -0,0 +1,97 @@ +import time + +def merge(arr, left_index, mid_index, right_index): + """ + Función para fusionar dos sub-matrices ordenadas. + :param arr: Matriz original. + :param left_index: Índice inicial de la sub-matriz izquierda. + :param mid_index: Índice medio de la matriz. + :param right_index: Índice final de la sub-matriz derecha. + """ + # Crear copias de las sub-matrices izquierda y derecha + left_array = arr[left_index:mid_index + 1] + right_array = arr[mid_index + 1:right_index + 1] + + print(f"Matriz izquierda: {left_array}") + print(f"Matriz derecha: {right_array}") + + # Obtener las longitudes de las sub-matrices + left_array_length = len(left_array) + right_array_length = len(right_array) + + # Índices para iterar sobre las sub-matrices + i = 0 # Índice para la sub-matriz izquierda + j = 0 # Índice para la sub-matriz derecha + + # Índice para reemplazar elementos en la matriz original + k = left_index + + # Comparar elementos de ambas sub-matrices y fusionarlos en orden + while i < left_array_length and j < right_array_length: + if left_array[i] <= right_array[j]: + arr[k] = left_array[i] # El elemento de la izquierda es menor o igual + i += 1 + else: + arr[k] = right_array[j] # El elemento de la derecha es menor + j += 1 + k += 1 + + # Mostrar el estado actual de la matriz + print(f"Matriz actualizada: {arr}") + + # Agregar los elementos restantes de la sub-matriz izquierda (si los hay) + while i < left_array_length: + arr[k] = left_array[i] + i += 1 + k += 1 + print(f"Matriz actualizada: {arr}") + + # Agregar los elementos restantes de la sub-matriz derecha (si los hay) + while j < right_array_length: + arr[k] = right_array[j] + j += 1 + k += 1 + print(f"Matriz actualizada: {arr}") + + +def merge_sort(arr, left_index, right_index): + """ + Función recursiva para ordenar una matriz usando Merge Sort. + :param arr: Matriz original. + :param left_index: Índice inicial de la sub-matriz. + :param right_index: Índice final de la sub-matriz. + """ + # Caso base: si la sub-matriz tiene un solo elemento, ya está ordenada + if left_index >= right_index: + return + + # Calcular el índice medio + mid_index = (left_index + right_index) // 2 + + print(f"Dividiendo: {arr[left_index:right_index + 1]}") + + # Llamadas recursivas para dividir la matriz en mitades + merge_sort(arr, left_index, mid_index) # Ordenar la mitad izquierda + merge_sort(arr, mid_index + 1, right_index) # Ordenar la mitad derecha + + # Fusionar las dos mitades ordenadas + merge(arr, left_index, mid_index, right_index) + + +if __name__ == "__main__": + # Inicialización de la matriz + arr = [3, 4, 5, 6, 39, 23, 434, 56, 7, 9, 0, 86, 22, 12, 34] + print(f"Matriz sin ordenar: {arr}") + + # Llamar a merge_sort para ordenar toda la matriz + merge_sort(arr, 0, len(arr) - 1) + + print(f"Matriz ordenada: {arr}") + + + # Medir el tiempo de ejecucion +start_time = time.time() +merge_sort(arr, 0, len(arr) -1) +end_time = time.time() + +print(f"Tiempo de ejecución Cálculo de la complejidad Algorítmica del Ejemplo: {end_time - start_time} segundos") \ No newline at end of file diff --git a/10 PYTHON/017_Algoritmo_Selection_Sort.py b/10 PYTHON/017_Algoritmo_Selection_Sort.py new file mode 100644 index 0000000..a74f658 --- /dev/null +++ b/10 PYTHON/017_Algoritmo_Selection_Sort.py @@ -0,0 +1,31 @@ +import time +# implementación del algoritmo selection sort + +def selection_sort(arr, n): + for i in range(n): # Itera sobre cada elemento del array. + #En cada iteración, asume que el elemento actual (arr[i]) es el mínimo. + # para almacenar el índice del elemento minimo + min_element_index = i + for j in range(i + 1, n): # Compara el elemento actual con los elementos restantes del array. + # comprobando y reemplazando el indice minimo del elemento + if arr[j] < arr[min_element_index]: + min_element_index = j + # Intercambiando el elemento actual con el elemento minimo + arr[i], arr[min_element_index] = arr[min_element_index], arr[i] + +if __name__ == "__main__": + # Inicialización del array + arr = [3,4,5,67,42,4,6,78,2,1,0] + print(f"lista sin ordenar: {arr}") + selection_sort(arr, len(arr)) + + #imprimiendo el arry + print(f"lista ordeana: {arr}") + + + # Medir el tiempo de ejecucion +start_time = time.time() +selection_sort(arr, len(arr)) +end_time = time.time() + +print(f"Tiempo de ejecución Cálculo de la complejidad Algorítmica del Ejemplo: {end_time - start_time} segundos") \ No newline at end of file diff --git a/10 PYTHON/017_Algoritmos_01.py b/10 PYTHON/017_Algoritmos_01.py new file mode 100644 index 0000000..1e8390d --- /dev/null +++ b/10 PYTHON/017_Algoritmos_01.py @@ -0,0 +1,114 @@ + + +""" + A la idea del tiempo la llamaremos complejidad temporal y a la de recursos + del sistema la llamaremos complejidad espacial. +""" + +def codigo_1 (number): + a=0 + + for j in range(1, number +1): + a += a + j + + for k in range(number, 0, -1): # Instrucciones = 3n+1 + a -= 1 + a *=2 + return a + +def codigo_2(): # F(x) = 3 + a = 0 + a -= 1 + a *= 2 + +def codigo_3(number): # F(x) = n2+1 + a = 0 + + for j in range(1, number + 1): + for k in range(1, number + 1): + a += a + (k * j) + + return a + +# codigo para encontrat el primer numero par de la lista + +def codigo_4(array): + for k in range(len(array)): + if(array[k] % 2 == 0): + return k + + return None + +# Constante O(1) / Es la más sencilla y siempre presenta un tiempo de ejecución constante. + +def constante(): + x=50 + + x + return x + +# Lineal O(x) / El tiempo crece linealmente mientras crece los datos + +def lineal(number): + result = 0 + for x in range(0, number): + +result + + return result + +# Polinómico O(xc), c > 0 / Son los algoritmos más comunes +""" + Cuando c es 2 se le llama cuadrático, cuando es 3 se le llama cúbico, y + en general, polinómico. Cuando n es muy grande suelen ser muy complicados. Estos algoritmos suelen + tener bucles anidados. Si tienen 2 bucles anidados sería un cuadrático. +""" + +def polinomico(number): + x = 0 + for i in range(1, number): + for j in range(1, number): + x += i + j + + for i in range(1, number): + for j in range(1, number): + for k in range(1, number): + x += i * j * k + return x + +# Logarítmico O(log x) no suelen ser muchos + +""" + Estos algoritmos indican que el tiempo es menor que el tamaño de los datos de + entrada. No importa indicar la base del logaritmo. Un ejemplo es una búsqueda dicotómica. +""" +""" + Este algoritmo busca un elemento en un array ordenado dividiendo el array en 2 mitades, identifica + en cuál de las mitades se encuentra, luego divide esa parte en 2 mitades iguales y busca nuevamente hasta + encontrar el elemento, es un algoritmo recursivo: +""" + +def bin(a, x, low, high): # # Definimos una función llamada 'bin' que recibe una lista 'a', un valor 'x' a buscar y dos índices: 'low' y 'high'. + ans = -1 # Inicializamos la variable 'ans' con -1, indicando que aún no hemos encontrado el valor. + if low == high: # Caso base: si low es igual a high, significa que el rango ya se ha reducido al mínimo. + ans = -1 # En ese caso, devolvemos -1, indicando que no se encontró el valor. + else: + mid = (low + ((high-low)//2)) # Calculamos la posición media entre 'low' y 'high'. + if x < a[mid]: # Si el valor 'x' es menor que el valor en la posición 'mid'... + ans = bin(a, x, low, mid) # ...hacemos una llamada recursiva en la mitad izquierda (low hasta mid). + elif x > a[mid]: # Si el valor 'x' es mayor que 'a[mid]'... + ans = bin(a, x, mid+1, high) # ...hacemos la llamada recursiva en la mitad derecha (mid+1 hasta high). + else: # Si encontramos que 'x' es igual a 'a[mid]'... + ans = mid # ...entonces hemos encontrado la posición, y guardamos el índice 'mid' en 'ans'. + return ans # Finalmente, devolvemos 'ans', que será el índice donde se encontró 'x' o -1 si no se encontró. + +# Exponencial: O(Cx) +""" + Es una de las peores complejidades algorítmicas. Sube demasiado a medida que crece los datos de +entrada. Puede verse en la Figura como crece una función de este tipo. Un ejemplo de este código es la +solución de Fibonacci, el cual genera bucles 2 recursividades en cada ejecución. Ejemplo: +""" +def exponencial(n): + if n==1 or n==2: + return 1 + return exponencial(n-1) + exponencial(n-2) + + diff --git a/10 PYTHON/018_Modulos.py b/10 PYTHON/018_Modulos.py index e3c0880..ebd6ee3 100644 --- a/10 PYTHON/018_Modulos.py +++ b/10 PYTHON/018_Modulos.py @@ -2,9 +2,9 @@ # Módulos """ -Para llamar a una función que tengamos en un módulo tenemos que importarla y luego -usar la nomenclatura del punto: -Suponiendo que en un módulo funciones.py tenemos la siguiente función suma: + Para llamar a una función que tengamos en un módulo tenemos que importarla y luego + usar la nomenclatura del punto: + Suponiendo que en un módulo funciones.py tenemos la siguiente función suma: """ def suma(num1, num2): print("suma= ", num1+num2) diff --git a/10 PYTHON/019_POO_1.py b/10 PYTHON/019_POO_1.py index 3788610..47fb913 100644 --- a/10 PYTHON/019_POO_1.py +++ b/10 PYTHON/019_POO_1.py @@ -8,23 +8,32 @@ class Coche: # Declaración de atributos - largo = 250 - ancho = 120 - ruedas = 4 - peso = 900 - color = "rojo" - is_enMarcha = False + def __init__(self): # Por buenas practicas es recomendado hacer uso del constructor + self.largo = 250 + self.ancho = 120 + self.ruedas = 4 + self.peso = 900 + self.color = "rojo" + self.is_enMarcha = False # Declaración de métodos - def arrancar(self): # self hace referencia a la instancia de clase. + def arrancar(self): # self hace referencia a la instancia de clase. / en otros lenguajes de programacion se conoce como this self.is_enMarcha = True # Es como si pusiésemos miCoche.is_enMarcha = True def estado(self): - if (self.is_enMarcha == True): + if self.is_enMarcha: return "El coche está arrancado" else: return "El coche está parado" + def cambiar_color(self): + if self.color: + nuevo_color = input("Ingresa el color deseado: ") + self.color = nuevo_color + print("se ha cambiado el color") + return + + # Declaración de una instancia de clase, objeto de clase o ejemplar de clase. miCoche = Coche() miCoche2 = Coche() @@ -33,10 +42,14 @@ def estado(self): print("El largo del coche es de" , miCoche.largo, "cm.") miCoche.arrancar() print(miCoche.estado()) -print(miCoche.color) +print(miCoche.color) # Cuanndo se accede a un atributo se diferencia porque no lleva () en el llamado +miCoche2.cambiar_color() +print(f"El color del coche 2 es: {miCoche2.color}") # Acceso a un método de la clase Coche. Nomenclatura del punto. -print("El coche está arrancado:" , miCoche.arrancar()) +print("El coche está arrancado:" , miCoche.arrancar()) +print(f"El coche 1: {miCoche.estado()}") +print(f"El coche 2: {miCoche2.estado()}") #Modificamos el valor de una propiedad miCoche2.ruedas = 10 diff --git a/10 PYTHON/019_POO_1b.py b/10 PYTHON/019_POO_1b.py index 53b15e0..7396153 100644 --- a/10 PYTHON/019_POO_1b.py +++ b/10 PYTHON/019_POO_1b.py @@ -4,7 +4,7 @@ class Usuario: # Declaración de atributos nombre = "Angel" - __edad = 47 + __edad = 47 # Se realiza encapsulación de la variable y se deja de forma privada, no es posible modificarla sin hacer uso del metodo setter login = "admin" password = "1234" email = "angel@loquesea.com" @@ -20,31 +20,29 @@ def resumen(self): # self hace referencia a la instancia de clase. f'Email: {self.email}\n' f'Teléfono: {self.telefono}') - def cambiaEdad(self): + + def cambiar_Edad(self): edadIntroducida = int(input("Introduce edad entre 18-100:")) if 18 < edadIntroducida < 100: - #if edadIntroducida<18 or edadIntroducida>100: - - + #if edadIntroducida < 18 and edadIntroducida > 100: self.__edad = edadIntroducida print("Edad introducida correcta") return else: print("La edad introducida no es correcta.") - self.cambiaEdad() + self.cambiar_Edad() # Uso de recursividad return "" - def muestraEdad(self): print('La edad del usuario es:', self.__edad, 'años.') - return "" + administrador = Usuario() administrador.resumen() -print(administrador.cambiaEdad()) +print(administrador.cambiar_Edad()) print(administrador.muestraEdad()) print(administrador.__edad) #error diff --git a/10 PYTHON/020_POO_volumenCubo.py b/10 PYTHON/020_POO_volumenCubo.py index b4458ce..a3d3e33 100644 --- a/10 PYTHON/020_POO_volumenCubo.py +++ b/10 PYTHON/020_POO_volumenCubo.py @@ -8,13 +8,15 @@ def __init__(self, ancho, alto, profundo): def calcular_volumen(self): return self.ancho * self.alto * self.profundo - + ancho = int(input('Proporciona el ancho: ')) alto = int(input('Proporciona el alto: ')) profundo = int(input('Proprociona lo profundo: ')) cubo1 = Cubo(ancho, alto, profundo) + + cubo2 = Cubo(ancho, alto, profundo) cubo3 = Cubo(ancho, alto, profundo) diff --git "a/10 PYTHON/021_POO_Ecapsulaci\303\263n.py" "b/10 PYTHON/021_POO_Ecapsulaci\303\263n.py" index 80e1f82..e7c3be8 100644 --- "a/10 PYTHON/021_POO_Ecapsulaci\303\263n.py" +++ "b/10 PYTHON/021_POO_Ecapsulaci\303\263n.py" @@ -4,11 +4,16 @@ # POO # CREACIÓN DE UNA CLASE +""" + Los atributos siempre se declaran privados, por seguridad y funcionalidad, por norma general cada atributo debe tener un getter y un setter + los metodos y funciones publicas con getter +""" + class Coche(): # Método constructor - def __init__(self): + def __init__(self,): self.__largo = 250 self.__ancho = 120 self.__ruedas = 4 @@ -18,17 +23,43 @@ def __init__(self): # Declaración de métodos def arrancar(self): # self hace referencia a la instancia de clase. - self.is_enMarcha = True # Es como si pusiésemos miCoche.is_enMarcha = True + self.__is_enMarcha = True # Es como si pusiésemos miCoche.is_enMarcha = True def estado(self): - if (self.is_enMarcha == True): + if self.__is_enMarcha: return "El coche está arrancado" else: return "El coche está parado" + + @property + def color(self): + return self.__color + + @color.setter + def color(self): + if self.__color: + color_nuevo = input("ingresa el nuevo color: ") + self.__color = color_nuevo + print("se ha cambiado el color!") + return + + + def ver_peso(self): + print(f"El peso del coche es: {self.__peso}") + + def ver_largo(self): + print(f"El largo del coche es: {self.__largo}") + + def ver_ancho(self): + print(f"El ancho del coche es: {self.__ancho}") + # Declaración de una instancia de clase, objeto de clase o ejemplar de clase. miCoche = Coche() -miCoche.__ruedas = 9 -print("Mi coche tiene",miCoche.__ruedas, "ruedas.") -help(Coche) \ No newline at end of file +miCoche.ver_ancho() +print(f"el color de coche es {miCoche.color}") +miCoche.ver_largo() +miCoche.ver_peso() +miCoche.color +print(f"El nuevo color es: {miCoche.color}") diff --git "a/10 PYTHON/021_POO_Ecapsulaci\303\263n2.py" "b/10 PYTHON/021_POO_Ecapsulaci\303\263n2.py" index e2bbdf8..22ff489 100644 --- "a/10 PYTHON/021_POO_Ecapsulaci\303\263n2.py" +++ "b/10 PYTHON/021_POO_Ecapsulaci\303\263n2.py" @@ -1,6 +1,10 @@ # POO # CREACIÓN DE UNA CLASE +""" + Los atributos siempre se declaran privados, por seguridad y funcionalidad, por norma general cada atributo debe tener un getter y un setter + los metodos y funciones publicas +""" class Coche: @@ -18,7 +22,7 @@ def arrancar(self): # self hace referencia a la instancia de clase. self.is_enMarcha = True # Es como si pusiésemos miCoche.is_enMarcha = True def estado(self): - if (self.is_enMarcha == True): + if self.is_enMarcha: return "El coche está arrancado" else: return "El coche está parado" diff --git "a/10 PYTHON/021_POO_Ecapsulaci\303\263n3.py" "b/10 PYTHON/021_POO_Ecapsulaci\303\263n3.py" index 8bb62d0..a3b470a 100644 --- "a/10 PYTHON/021_POO_Ecapsulaci\303\263n3.py" +++ "b/10 PYTHON/021_POO_Ecapsulaci\303\263n3.py" @@ -1,6 +1,15 @@ # POO # CREACIÓN DE UNA CLASE +""" + Los atributos siempre se declaran privados, por seguridad y funcionalidad, por norma general cada atributo debe tener un getter y un setter + los metodos y funciones publicas +""" + +""" + Un decorador es una función que se le añade a otra función, se crea una función inicial dentro de la clase + y luego se le realiza la llamada +""" class Persona: def __init__(self, nombre, apellido, edad): @@ -8,12 +17,12 @@ def __init__(self, nombre, apellido, edad): self.apellido = apellido self.edad = edad - @property + @property # Metodo getter def nombre(self): print('Llamando método get nombre') return self._nombre - @nombre.setter + @nombre.setter # Metodo setter def nombre(self, nombre): print('Llamando método set nombre') self._nombre = nombre @@ -23,7 +32,6 @@ def mostrar_detalle(self): #Sin decoradores - #def mostrar_detalle(self): # print(f'Persona: {self.nombre()} {self.apellido} {self.edad}') diff --git "a/10 PYTHON/021_POO_Ecapsulaci\303\263n5.py" "b/10 PYTHON/021_POO_Ecapsulaci\303\263n5.py" index 117f65f..246b56c 100644 --- "a/10 PYTHON/021_POO_Ecapsulaci\303\263n5.py" +++ "b/10 PYTHON/021_POO_Ecapsulaci\303\263n5.py" @@ -1,35 +1,35 @@ class Persona: def __init__(self, nombre, apellido, edad): - self._nombre = nombre - self._apellido = apellido - self._edad = edad + self.__nombre = nombre + self.__apellido = apellido + self.__edad = edad @property def nombre(self): - return self._nombre + return self.__nombre @nombre.setter def nombre(self, nombre): - self._nombre = nombre + self.__nombre = nombre @property def apellido(self): - return self._apellido + return self.__apellido @apellido.setter def apellido(self, apellido): - self._apellido = apellido + self.__apellido = apellido @property def edad(self): - return self._edad + return self.__edad @edad.setter def edad(self, edad): - self._edad = edad + self.__edad = edad def mostrar_detalle(self): - print(f'Persona: {self._nombre} {self._apellido} {self._edad}') + print(f'Persona: {self.__nombre} {self.__apellido} {self.__edad}') persona1 = Persona('Juan', 'Perez', 28) diff --git a/10 PYTHON/023_POO_Herencia_1.py b/10 PYTHON/023_POO_Herencia_1.py index 90ebcf1..b1f4327 100644 --- a/10 PYTHON/023_POO_Herencia_1.py +++ b/10 PYTHON/023_POO_Herencia_1.py @@ -6,8 +6,8 @@ def __init__(self, nombre, edad): self.edad = edad -# Definición de la clase hija que hereda de la clase padre. -class Empleado(Persona): +# Definición de la clase hija que hereda de la clase padre. +class Empleado(Persona): # la herencia se hace efectiva poniendo por parametro en la clase hijo la calse padre def __init__(self, nombre, edad, sueldo): super().__init__(nombre, edad) #Nos permite acceder a los métodos del padre self.sueldo = sueldo diff --git a/10 PYTHON/023_POO_Herencia_2.py b/10 PYTHON/023_POO_Herencia_2.py index 9334e53..11c1128 100644 --- a/10 PYTHON/023_POO_Herencia_2.py +++ b/10 PYTHON/023_POO_Herencia_2.py @@ -10,7 +10,7 @@ def __init__(self, nombre, edad, lugar): def descripcion(self): - print("El nombre es ", self.nombre, ", tiene ", self.edad, " anyos", " y es de ", self.lugar) + print(f"El nombre es: {self.nombre} tiene {self.edad} años y es de {self.lugar}") # Para personalizar el constructor del padre de acuerdo a las necesidades del hijo se usa super(): @@ -22,8 +22,8 @@ def __init__(self, salario, antiguedad, nombre_emp, edad_emp, lugar_epm): self.antiguedad=antiguedad def descripcion(self): - super().descripcion() - print("Salario: ", self.salario, ", antiguedad: ", self.antiguedad) + super().descripcion() # usando super() se pueden heredar metodos + print(f"Salario: {self.salario} antiguedad: {self.antiguedad}") Angel=Persona("Angel", 43, "Malaga") Angel.descripcion() @@ -31,3 +31,9 @@ def descripcion(self): Empleado1=Empleado(2000, 2017, "Manolo", 33, "Madrid") Empleado1.descripcion() +usuario = Persona(nombre = input("ingresa tu nombre: "), edad = input("Ingresa tu edad: "), lugar= input("Ingresa tu ubicacion: ")) + +usuario2 = Empleado(salario = input("ingresa tu salario: "), antiguedad = input("Desde cuando trabajas aqui: ")) + +usuario.descripcion() +usuario2.descripcion() \ No newline at end of file diff --git a/10 PYTHON/024_POO_EjercicioHerencia.py b/10 PYTHON/024_POO_EjercicioHerencia.py index 53fb419..32b581b 100644 --- a/10 PYTHON/024_POO_EjercicioHerencia.py +++ b/10 PYTHON/024_POO_EjercicioHerencia.py @@ -46,12 +46,12 @@ def __str__(self): # Creamos un objeto de la clase Vehiculo vehiculo = Vehiculo('Rojo', 4) -print(vehiculo) +print(f"el vehiculo tiene: {vehiculo}") # Creamos un objeto de la clase hija Coche coche = Coche('Azul', 4, 150) -print(coche) +print(f"El coche tiene: {coche}") # Creamos un objeto de la clase hija Bicicleta bicicleta = Bicicleta('Blanca', 2, 'Urbano') -print(bicicleta) +print(f"La bicicleta tiene: {bicicleta}") diff --git a/10 PYTHON/031_POO_Herencia_13.py b/10 PYTHON/031_POO_Herencia_13.py index b28b04f..dc63a3d 100644 --- a/10 PYTHON/031_POO_Herencia_13.py +++ b/10 PYTHON/031_POO_Herencia_13.py @@ -1,3 +1,61 @@ +#Creacion de uan estructura para los clientes: +class Cliente: + + def __init__(self, dni, nombre, apellidos): + self.dni = dni + self.nombre = nombre + self.apellidos = apellidos + + def __str__(self): + return(f"{self.nombre} {self.apellidos}") + +# creacion de la estructura para las empresas + +class Empresa: + def __init__(self, clientes=[]): + self.clientes = clientes + + def mostrar_clientes(self, dni = None): + for c in self.clientes: + if c.dni == dni: + print(c) + return + print("Cliente no encontrado") + + def borrar_cliente(self, dni = None): + for i,c in enumerate(self.clientes): + if c.dni == dni: + del(self.clientes[i]) + print(str(c), "> Borrado") + print("Cliente no encontrado") + +# Utilización de las estructuras +# creacion de clientes + +hector = Cliente(dni = "11111111A", nombre = "hector", apellidos ="Costa Guzman") +juan = Cliente(dni = "22222222B", nombre = "juan", apellidos = "Gonzalez Marquez") + +# creacion de objetos con la clase empresa +empresa = Empresa(clientes=[hector, juan]) + +# Mostrar los clientes en un listado +print("==LISTADO DE CLIENTES==") +print(str(empresa.clientes)) + +print("\n==MOSTRAR CLIENTES POR DNI==") +# Consulto clientes por DNI +empresa.mostrar_clientes("11111111A") +empresa.mostrar_clientes("11111111Z") + +print("\n==BORRAR CLIENTES POR DNI==") +# Borro un cliente por DNI +empresa.borrar_cliente("22222222V") +empresa.borrar_cliente("22222222B") + + +# Muestro de nuevo todos los clientes +print("\n==LISTADO DE CLIENTES==") +print(empresa.clientes) diff --git a/10 PYTHON/031_POO_Herencia_14.py b/10 PYTHON/031_POO_Herencia_14.py index fd40910..2d55c6a 100644 --- a/10 PYTHON/031_POO_Herencia_14.py +++ b/10 PYTHON/031_POO_Herencia_14.py @@ -1,4 +1,41 @@ +class Usuario(): + def __init__(self): + self.nombre = input("ingresa tu nombre: ") + self.edad = int(input("ingresa tu edad: ")) + self.login = input("Ingresa tu usuario: ") + self.passsword = input("Elige tu contraseña: ") + self.email = input("Facilita tu email: ") + self.telefono = int(input("Ingresa tu telefono: ")) + def __del__(self): + print("Acabas de eliminar un usuario") + def resumen(self): + print(f"\nlos datos del usuario son:\n Nombre: {self.nombre}\n Edad: {self.edad}\n Login: {self.login}\n Password: {self.passsword}\n Email: {self.email}\n Telefono: {self.telefono}") + + def cambiar_edad(self): + edad_introducida = int(input("introduce tu edad: ")) + if 18 < edad_introducida < 100: + self.edad = edad_introducida + print("Edad introducidad correcta") + return "" + else: + print("La edad introducida no es correcta") + self.cambiar_edad + return "" + + def muestra_edad(self): + print(f"La edad del usuario es: {self.edad} años") + return "" + + +administrador = Usuario() +administrador.resumen() + +administrador.cambiar_edad() +administrador.muestra_edad() + +del administrador + diff --git a/10 PYTHON/031_POO_Herencia_16.py b/10 PYTHON/031_POO_Herencia_16.py index fd40910..485e7f7 100644 --- a/10 PYTHON/031_POO_Herencia_16.py +++ b/10 PYTHON/031_POO_Herencia_16.py @@ -1,4 +1,58 @@ +# Creación de la clase padre +class Padre(): + def __init__(self, ojos, cejas): + # Definicion de los atributos en el constructor de la clase + self.ojos = ojos + self.cejas = cejas +# Creacion de la clase hijo que hereda de la clase padre +class Hijo(Padre): + # Definicion de los atributos en el constructor + def __init__(self, ojos, cejas, cara): + # se sobreescriben los atributos + self.ojos = ojos + self.cejas = cejas + self.cara = cara # se especifica el nuevo atributo +tomas = Hijo('Marrones', 'Negras', 'Larga') # se instancia o se crea un objeto de la clase hijo +print(tomas.ojos, tomas.cejas, tomas.cara) +# Mismo ejemplo llamando al constructor de la clase madre: +#Creacion de la clase padre +class Madre(object): + def __init__(self, ojos, cejas): + # Definicion de los atributos + self.ojos = ojos + self.cejas = cejas + +# Creacion de la clase hija que hereda de la clase madre +class Hija(Madre): + # Creacion del constructor de la clase especificando los atributos + def __init__(self, ojos, cejas, cara): + # Especificacion de la clase y llamado a su construtor mas los atributos + Padre.__init__(self, ojos, cejas) # Este metodo se utiliza en caso de herencia multiple + self.cara = cara #Especificamos el nuevo atributo para Hija + +mile = Hija('azules', 'negras', 'Larga') +print(mile.ojos, mile.cejas, mile.cara) + +# Utilizando super(). De esta forma es casi el mismo codigo, pero no se hace necesario especificar la clase padre + +# creación de la clase abuelo +class Abuelo(object): + def __init__(self, ojos, cejas): + #Definimos los Atributos + self.ojos = ojos + self.cejas = cejas + +# Clase que hereda de la clase padre (abuelo) +class Nieto(Abuelo): + #creamos el constructor de la clase especificando atributos + def __init__(self, ojos, cejas, cara): + #Solicitamos a super llamar de la clase padre esos atributos + super().__init__(ojos, cejas) + self.cara = cara # Especificacion del nuevo atributo + +miguel = Nieto('verdes', 'negras', 'redonda') +print(miguel.ojos, miguel.cejas, miguel.cara) diff --git a/10 PYTHON/031_POO_Herencia_17.py b/10 PYTHON/031_POO_Herencia_17.py index fd40910..26b4d82 100644 --- a/10 PYTHON/031_POO_Herencia_17.py +++ b/10 PYTHON/031_POO_Herencia_17.py @@ -1,4 +1,224 @@ +""" + La clase empleado contiene un constructor para inicializar sus atributos + Los datos utilizados son: nombre completo, cedula y teléfono. + Cada atributo de la clase cuenta con sus respectivos get y set. +""" +class Empleado: + def __init__(self, nombre, cedula, telefono): + self.__nombre = nombre + self.__cedula = cedula + self.__telefono = telefono + + def set_nombre(self, nombre): + self.__nombre = nombre + + def get_nombre(self): + return self.__nombre + + def set_cedula(self, cedula): + self.__cedula = cedula + + def get_cedula(self): + return self.__cedula + def set_telefono(self, telefono): + self.__telefono = telefono + + def get_telefono(self): + return self.__telefono +""" + Clase de empleado por tiempo definido Esta clase hereda de la clase empleado. + Los nuevos atributos son: + Número de plaza + Salario base + Duración de contrato en meses + Además, cuenta con un método que calcula el salario total El empleado recibe un aumento del 2% sobre su salario base. +""" +class EmpleadoDefinido(Empleado): + def __init__(self, nombre, cedula, telefono, nPlaza, salarioBase, duracion_contrato): + #constructor de la clase empleado + super().__init__(nombre, cedula, telefono) + #Nuevos atributos + self.__nPlaza = nPlaza + self.__salarioBase = salarioBase + self.__duracion_contrato = duracion_contrato + + def set_nPlaza(self, nPlaza): + self.__nPlaza = nPlaza + + def get_nPlaza(self): + return self.__nPlaza + + def set_salarioBase(self, salarioBase): + self.__salarioBase = salarioBase + + def get_salarioBase(self): + return self.__salarioBase + + def set_duracion_contrato(self, duracion_contrato): + self.__duracion_contrato = duracion_contrato + + def get_duracion_contrato(self): + return self.__duracion_contrato + + #calcula el salario total + def calcularSalarioTotal(self): + return self.__salarioBase + (self.__salarioBase * 0.02) + +""" + Clase de empleado por tiempo indefinido Esta clase hereda de la clase empleado. + Los nuevos atributos son: + Número de plaza + Salario base + Categoría (1, 2, 3) + Además, cuenta con un método que calcula el salario total. + Los empleados recieben un aumento de acuerdo a su categoría: + Categoría 1: 3% + Categoría 2: 5% + Categoría 3: 8% +""" + +class EmpleadoIndefinido(Empleado): + def __init__(self, nombre, cedula, telefono, nPlaza, salarioBase, categoria): + #constructor de la clase empleado + super().__init__(nombre, cedula, telefono) + #Nuevos atributos + self.__nPlaza = nPlaza + self.__salarioBase = salarioBase + self.__categoria = categoria + + def set_nPlaza(self, nPlaza): + self.__nPlaza = nPlaza + + def get_nPlaza(self): + return self.__nPlaza + + def set_salarioBase(self, salarioBase): + self.__salarioBase = salarioBase + + def get_salarioBase(self): + return self.__salarioBase + + def set_categoria(self, categoria): + self.__categoria = categoria + + def get_categoria(self): + return self.__categoria + + #calcula el salario total + def calcularSalarioTotal(self): + if self.__categoria == 1: + return self.__salarioBase + (self.__salarioBase * 0.03) + elif self.__categoria == 2: + return self.__salarioBase + (self.__salarioBase * 0.05) + elif self.__categoria == 3: + return self.__salarioBase + (self.__salarioBase * 0.08) + else: + return self.__salarioBase + +""" + Empleado subcontratado Esta clase hereda de la clase empleado. + El nuevo atributo es: + Empresa responsable +""" + +class EmpleadoSubcontratado(Empleado): + def __init__(self, nombre, cedula, telefono, empresaResponsable): + super().__init__(nombre, cedula, telefono) + self.__empresaResponsable = empresaResponsable + + def set_empresaResponsable(self, empresa): + self.__empresaResponsable = empresa + + def get_empresaResponsable(self): + return self.__empresaResponsable + + +""" + Ejecución del código + La siguiente celda ejecuta las clases creadas anteriormente. Ejecuta 8 tipos de empleados + desglosados de la siguiente manera: + 2 contratados + 4 indefinidos + 2 subcontratados +""" + +#Empleados subcontratados +subContratado1 = EmpleadoSubcontratado("Roberto Flores Morales", 123456789, 88888888, "Coca-Cola") +subContratado2 = EmpleadoSubcontratado("Ana Mora Cruz", 223446789, 77777777, "Pepsi") + +print("*** Empleados subcontratados ***") +print("\n****Empleado 1****") +print("Nombre: " + subContratado1.get_nombre() + +"\nCédula: " + str(subContratado1.get_cedula()) + +"\nTeléfono: " + str(subContratado1.get_telefono()) + +"\nEmpresa responsable: " + subContratado1.get_empresaResponsable()) + +print("\n****Empleado 2****") +print("Nombre: " + subContratado2.get_nombre() + +"\nCédula: " + str(subContratado2.get_cedula()) + +"\nTeléfono: " + str(subContratado2.get_telefono()) + +"\nEmpresa responsable: " + subContratado2.get_empresaResponsable()) + +#Empleados por tiempo definido +empleadoD = EmpleadoDefinido("Jeff Muñoz Castro", 345687324, 66666666, 3, 500000, 3) +empleadoD2 = EmpleadoDefinido("María Gonzáles Pérez", 983456783, 99999999, 6, 450000, 2) + +print("\n*** Empleados de tiempo definido ***") +print("\n****Empleado 1****") +print("Nombre: " + empleadoD.get_nombre() + +"\nCédula: " + str(empleadoD.get_cedula()) + +"\nTeléfono: " + str(empleadoD.get_telefono()) + +"\nNúmero de plaza: " + str(empleadoD.get_nPlaza()) + +"\nDuracion contrato: " + str(empleadoD.get_duracion_contrato()) + " meses" + +"\nSalario total: " + str(empleadoD.calcularSalarioTotal())) + +print("\n****Empleado 2****") +print("Nombre: " + empleadoD2.get_nombre() + +"\nCédula: " + str(empleadoD2.get_cedula()) + +"\nTeléfono: " + str(empleadoD2.get_telefono()) + +"\nNúmero de plaza: " + str(empleadoD2.get_nPlaza()) + +"\nDuración contrato " + str(empleadoD2.get_duracion_contrato()) + " meses" + +"\nSalario total: " + str(empleadoD2.calcularSalarioTotal())) + +#empleados por tiempo indefinido +empleadoI = EmpleadoIndefinido("Roberto Rojas Salazar", 434565432, 22222222, 4, 350000,1) +empleadoI2 = EmpleadoIndefinido("Rebeca Suárez Tapia", 897456274, 33445533, 7, 510000, 2) +empleadoI3 = EmpleadoIndefinido("Sara Vega Montes", 989734567, 65786590, 19, 475000, 3) +empleadoI4 = EmpleadoIndefinido("Luis Sánchez Castillo", 546378763, 23546543, 23, 560000, 1) + +print("\n*** Empleados de tiempo indefinido ***") +print("\n****Empleado 1****") +print("Nombre: " + empleadoI.get_nombre() + +"\nCédula: " + str(empleadoI.get_cedula()) + +"\nTeléfono: " + str(empleadoI.get_telefono()) + +"\nNúmero de plaza: " + str(empleadoI.get_nPlaza()) + +"\nCategoría: " + str(empleadoI.get_categoria()) + +"\nSalario total: " + str(empleadoI.calcularSalarioTotal())) + +print("\n****Empleado 2****") +print("Nombre: " + empleadoI2.get_nombre() + +"\nCédula: " + str(empleadoI2.get_cedula()) + +"\nTeléfono: " + str(empleadoI2.get_telefono()) + +"\nNúmero de plaza: " + str(empleadoI2.get_nPlaza()) + +"\nCategoría: " + str(empleadoI2.get_categoria()) + +"\nSalario total: " + str(empleadoI2.calcularSalarioTotal())) + +print("\n****Empleado 3****") +print("Nombre: " + empleadoI3.get_nombre() + +"\nCédula: " + str(empleadoI3.get_cedula()) + +"\nTeléfono: " + str(empleadoI3.get_telefono()) + +"\nNúmero de plaza: " + str(empleadoI3.get_nPlaza()) + +"\nCategoría: " + str(empleadoI3.get_categoria()) + +"\nSalario total: " + str(empleadoI3.calcularSalarioTotal())) + +print("\n****Empleado 4****") +print("Nombre: " + empleadoI4.get_nombre() + +"\nCédula: " + str(empleadoI4.get_cedula()) + +"\nTeléfono: " + str(empleadoI4.get_telefono()) + +"\nNúmero de plaza: " + str(empleadoI4.get_nPlaza()) + +"\nCategoría: " + str(empleadoI4.get_categoria()) + +"\nSalario total: " + str(empleadoI4.calcularSalarioTotal())) \ No newline at end of file diff --git a/10 PYTHON/032_POO_Encapsulacion_07.py b/10 PYTHON/032_POO_Encapsulacion_07.py index 597f00c..8a116f9 100644 --- a/10 PYTHON/032_POO_Encapsulacion_07.py +++ b/10 PYTHON/032_POO_Encapsulacion_07.py @@ -21,6 +21,7 @@ def set_color(self, nuevo_color): self.__color = nuevo_color else: print("Color no válido. Por favor, elija entre 'blanco', 'negro' o 'rojo'.") + # Crear una instancia de Zapatilla con un color inicial válido mi_zapatilla = Zapatilla("blanco") diff --git a/10 PYTHON/032_POO_Encapsulacion_09.py b/10 PYTHON/032_POO_Encapsulacion_09.py index 1645325..2112c74 100644 --- a/10 PYTHON/032_POO_Encapsulacion_09.py +++ b/10 PYTHON/032_POO_Encapsulacion_09.py @@ -11,6 +11,10 @@ def __init__(self, titular, saldo): def saldo(self): return self.__saldo + @property + def titular(self): + return self.__titular + @saldo.setter def saldo(self, monto): if monto >= 0: diff --git a/10 PYTHON/Ejercicios_basicos.py b/10 PYTHON/Ejercicios_basicos.py new file mode 100644 index 0000000..eed55c1 --- /dev/null +++ b/10 PYTHON/Ejercicios_basicos.py @@ -0,0 +1,196 @@ +from random import shuffle + +# 1. Dados dos números, escriba un código Python para encontrar el mínimo de estos dos números + +n_a = 4 +n_b = 7 + +def minimun(n_a, n_b): + if n_a < n_b: + return n_a + else: + return n_b + +print(minimun(n_a, n_b)) + +# 2. Invertir palabras de una cadena dada. + +def rev_sentence(sentence): + words = sentence.split(' ') # : convierte la frase en una lista de palabras. + rev_sentence = ' '.join(reversed(words)) # revierte el orden de la lista. / join --> une las palabras de nuevo separadas por espacios. + return rev_sentence + +if __name__ == "__main__": + sentencia = "Codigo de practica de prueba de geeks" + print(sentencia) + print(rev_sentence(sentencia)) + +# 3. Realizar una suma de los elementos de una tupla + +test_tup = (7, 8, 9 ,10 ,7, 8) +print("La tupla origina es:", str(test_tup)) + +res = sum(list(test_tup)) # usando la función predefinida sum y convirtiendo la tupla en una lista es posible sumarla y asignar ese valor a una variable +print("El resultado de la suma de la tupla es:", str(res)) # se imprime el resultado usando el metodo str + +# 4. Escriba un código que calcule una lista de números proporcionados. + +def sum_list(num_list): + if len(num_list) == 1: # CASO BASE + return num_list[0] # # Si la lista tiene solo un elemento, devuelve ese elemento + else: + # Caso recursivo: suma el primer número + la suma del resto de la lista + return num_list[0] + sum_list(num_list[1:]) + +print(sum_list([3,5,6,7,9])) + +# 5. Escriba un código que desordene al azar una lista. / en este ejm hace falta importar el modulo shuffle de la clase random + +l_x = ['Skyrin', 'pertenece', 'a', 'los', 'Nórdicos'] +print(l_x) +shuffle(l_x) +print(l_x) + +# 6. Escriba un código que pueda contar todas las palabras mayúsculas de un archivo. +archivo = "short.zen.txt" +# Aquí abres un archivo que debe estar en la variable archivo +# (deberías haber definido archivo = "archivo.txt" antes o pasar el nombre del archivo). +with open(archivo) as fh: # se encarga de abrir y cerrar automáticamente el archivo. / + # fh es el "file handle" o la variable que representa el archivo abierto. + count = 0 # Inicializas una variable count que va a contar la cantidad de letras mayúsculas encontradas. + text = fh.read() # Lee todo el contenido del archivo como un string completo y lo almacena en text. + +for character in text: # Aquí se recorre carácter por carácter todo el texto del archivo. + if character.isupper(): # Verifica si el carácter es una letra mayúscula (A-Z). + count += 1 # Si es mayúscula, incrementas el contador en 1. + +print(f"El número de letras con mayúsculas en el archivo es: {count}") +print(archivo) + +# 7. ¿Si la lista 1 es [4, 6, 8, 1, 0, 3], que sería la lista 1 [-1]? + +li_7 = [4, 6, 8, 1, 0, 3] + +print(li_7[-1]) + +# 8. Escriba un programa para producir la serie Fibonacci en Python. + +n_fi =int(input("intruduce el valor de 'n': ")) +first = 0 +second = 1 +sum = 0 +count = 0 +print("secuencia de fibonacci: ") + +while(count <= n_fi): # Bucle que se ejecuta hasta que count llegue a n_fi + print(sum) # Imprime el número actual en la secuencia + count += 1 # Incrementa el contador + first = second # Mueve el valor de 'second' a 'first' + second = sum # Mueve el valor de 'sum' a 'second' + sum = first + second # Calcula el siguiente número de la secuencia + +# Version en la que se incluye un condicional y se deja mas legible el codigo + +n_fi = int(input("Introduce el valor de 'n': ")) + +first = 0 +second = 1 +count = 0 + +print("Secuencia de Fibonacci:") + +if n_fi <= 0: + print("Por favor, introduce un número positivo.") +elif n_fi == 1: + print(first) +else: + while count < n_fi: + print(first) + next_term = first + second + first = second + second = next_term + count += 1 + +# 9. Escriba un programa en Python para comprobar si un número es primo. + +def isprimo(n_nump): + if n_nump <= 1: + return False + elif n_nump == 2: + return True + else: + for i in range(2, int(n_nump ** 0.5) + 1): # se itera hasta la raíz cuadrada de n_nump. + if n_nump % i == 0: + return False + return True + +def app(): + n_user = int(input("escribe un número: ")) + + if isprimo(n_user): + print("El numero es primo!!") + else: + print('El numero no es primo!!') + +if __name__ == '__main__': + app() + +# 10. Escribir un programa en Python para comprobar si un número es capicúa. +# Es decir, si se lee igual de derecha a izquierda que de izquierda a derecha. + +n_ca = input("introduce un número: ") +n_cb = n_ca[::-1] # es una forma en Python de invertir una cadena de texto. + +if n_ca == n_cb: + print("has ingresado un numero capicúa") +else: + print("El número ingresado no es capicúa") + +# 11. Escribir un algoritmo de ordenación para un conjunto de datos numéricos en Python. + +n_lista = ['1', '3','6','8','9'] # Se crea una lista de strings (cada número está entre comillas, por lo tanto son textos) +n_lista = [int(i) for i in n_lista] # Se convierte cada string de la lista en un entero usando una comprensión de lista. +# Ahora la lista será [1, 3, 6, 8, 9] pero como números. +n_lista.sort() # Se ordena la lista de forma ascendente. En este caso ya estaba ordenada, pero asegura el orden. +print(f"lista ordenada de manera ascendente: {n_lista}") +n_lista.sort(reverse=True) # ordene de manera descendente añadiendo el parámetro reverse=True +print(f"Lasta ordenanda de manera descendente: {n_lista}") +n_lista_ordenada = sorted(n_lista) # sorted(): Es similar a sort(), pero devuelve una nueva lista ordenada sin modificar la original. +print(f"Nueva lista creada desde la anterior: {n_lista_ordenada}") + +# sort() con key: Puedes pasarle una función al parámetro key para ordenar según un criterio específico. +n_lista.sort(key=lambda x: abs(x)) # el parámetro key. Le estás diciendo a Python: “ordena cada elemento de la lista usando como criterio el resultado de la función abs(x)”. +# abs(x): es la función abs() de Python que devuelve el valor absoluto de x. +""" + lambda x: abs(x): es una función anónima (lambda) que toma cada elemento x y devuelve abs(x) + Cuando quieres ordenar por valor absoluto y no por el valor original (por ejemplo, cuando tienes números negativos). +""" +print(f"lista ordenada con valores absolutos {n_lista}") + + +# El código es inválido porque en Python raise y except no funcionan con strings, sino con clases de excepción +""" +try: + if '1' != 1: + raise "algún error" # No puedes lanzar un string, debes lanzar una excepción como raise ValueError("algún error") o raise Exception("algún error"). + else: + print("no se ha producido algún error") +except "algún error": # debe capturar una clase de excepción o una instancia, no un string. Debe ser algo como except ValueError as e: + print("Se ha producido algún error") +""" + +# Version valida de código + +try: + if '1' != 1: + raise ValueError("algún error") + else: + print("no se ha producido algún error") +except ValueError as e: + print(f"Se ha producido algún error: {e}") + +# 14. ¿Como se puede acceder al último índice de una lista? + +n_lis_ind = [12,23,56,78,9] +print(f"se imprime el ultimo elemento de la lista: {n_lis_ind[-1]}") +print(f"imprime el primer elemento de la lista: {n_lis_ind[0]}") \ No newline at end of file diff --git a/10 PYTHON/__pycache__/bin_to_dec.cpython-313.pyc b/10 PYTHON/__pycache__/bin_to_dec.cpython-313.pyc new file mode 100644 index 0000000..47c63fb Binary files /dev/null and b/10 PYTHON/__pycache__/bin_to_dec.cpython-313.pyc differ diff --git a/10 PYTHON/__pycache__/camel.cpython-313.pyc b/10 PYTHON/__pycache__/camel.cpython-313.pyc new file mode 100644 index 0000000..dbfd18a Binary files /dev/null and b/10 PYTHON/__pycache__/camel.cpython-313.pyc differ diff --git a/10 PYTHON/__pycache__/funcion_area.cpython-313.pyc b/10 PYTHON/__pycache__/funcion_area.cpython-313.pyc new file mode 100644 index 0000000..70e450d Binary files /dev/null and b/10 PYTHON/__pycache__/funcion_area.cpython-313.pyc differ diff --git a/10 PYTHON/__pycache__/recycling.cpython-313.pyc b/10 PYTHON/__pycache__/recycling.cpython-313.pyc new file mode 100644 index 0000000..a2dce90 Binary files /dev/null and b/10 PYTHON/__pycache__/recycling.cpython-313.pyc differ diff --git a/10 PYTHON/bin_to_dec.py b/10 PYTHON/bin_to_dec.py new file mode 100644 index 0000000..3d3f29e --- /dev/null +++ b/10 PYTHON/bin_to_dec.py @@ -0,0 +1,17 @@ +""" +Convierte cadenas binarias a sus equivalentes decimales. +Lanzar ValueError si binary_str contiene caracteres distintos de 0 y 1 +""" +def decimal(binary_str): + + remove_0_and_1 = binary_str.replace('0', '').replace('1', '') + if len(remove_0_and_1) > 0: + raise ValueError('La cadena binaria de entrada solo puede contener 0 y 1') + place = 1 # Posición + dec = 0 +# El valor decimal + for bit in binary_str[::-1]: # Bucle desde el final de la cadena hasta el principio + if (bit == '1'): # Si el dígito es un 1, agregue el valor posicional. Si es 0, ignorar. + dec += place + place *= 2 # Multiplique la posición por 2 para el siguiente valor de posición + return dec \ No newline at end of file diff --git a/10 PYTHON/camel.py b/10 PYTHON/camel.py new file mode 100644 index 0000000..770ad48 --- /dev/null +++ b/10 PYTHON/camel.py @@ -0,0 +1,33 @@ +import re +""" Convierta la palabra para que tenga la primera letra en mayúscula, el resto en +minúsculas""" + +def capitalize(word): + return word[0:1].upper() + word[1:].lower() + # Los segmentos no producen errores de tipo "index out of bounds". +#Así que esto todavía funciona en cadenas vacías y cadenas de longitud 1 +"""convierte una palabra a minúsculas""" +def lowercase(word): + + return word.lower() + +def camel_case(sentence): + remove_multiple_spaces = re.sub(r'\s+', ' ', sentence) # Reemplaza cualquier grupo de espacios en blanco con un solo espacio + remove_surrounding_space = remove_multiple_spaces.strip() # elimina cualquier espacio en blanco restante + words = remove_surrounding_space.split(' ') # Segmenta por espacios + first_word = lowercase(words[0]) # Pasa a minúsculas la primera palabra + # Escribe con mayúscula la segunda palabra y las siguientes y las pone en una nueva lista. + capitalized_words = [ capitalize(word) for word in words[ 1: ] ] + # Reúne todas las palabras en una lista + camel_cased_words = [first_word] + capitalized_words + # Vuelve a juntar las palabras + camel_cased_sentance = ''.join(camel_cased_words) + return camel_cased_sentance + +def main(): + sentence = input('Introduzca la frase: ') + camelcased = camel_case(sentence) + print(camelcased) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/10 PYTHON/funcion_area.py b/10 PYTHON/funcion_area.py new file mode 100644 index 0000000..0680f53 --- /dev/null +++ b/10 PYTHON/funcion_area.py @@ -0,0 +1,19 @@ +from math import pi + +def area(r): + # Verificamos los tipos correctos + if type(r) not in [float, int]: + raise TypeError("solo números enteros o de coma flotante") + + # Verificamos los valores negativos + if r < 0: + raise ValueError("No se permiten valores negativos") + + areaC = pi*(r**2) + return areaC + +valores = [1, 3, 0, -1, -3, 2+3j, True, 'hola'] + +for v in valores: + areaCalculada = area(v) + print(f'Para el valor {v} el área es {areaCalculada}') \ No newline at end of file diff --git a/10 PYTHON/recycling.py b/10 PYTHON/recycling.py new file mode 100644 index 0000000..666a16d --- /dev/null +++ b/10 PYTHON/recycling.py @@ -0,0 +1,78 @@ +from collections import namedtuple + +CrateData = namedtuple('CrateData', ['houses', 'crates']) + +def max_recycling(crates): + """Returns the index with the largest value in the list and the number of crates for that house. + Raises ValueError if list is empty.""" + if crates is None or len(crates) == 0: + raise ValueError('A list with at least one element is required') + max_houses = [] + max_crates = crates[0] + for crate in crates: + if crate > max_crates: + max_crates = crate + + for house, crates in zip (range(len(crates)), crates): + if crates == max_crates: + max_houses.append(house) + return CrateData(max_houses, max_crates) + +def min_recycling(crates): + """Returns the smallest value in the list and a list of house number (list indexes) with that value. + Raises ValueError if list is None or empty.""" + if crates is None or len(crates) == 0: + raise ValueError('A list with at least one element is required') + min_houses = [] + min_crates = crates[0] + + for crate in crates: + if crate < min_crates: + min_crates = crate + + for house, crates in zip (range(len(crates)), crates): + if crates == min_crates: + min_houses.append(house) + return CrateData(min_houses, min_crates) + +def total_crates(crates): + """ Return the total of all the values in the crates list""" + total = 0 + for crate in crates: + total += crate + return total + +def get_crate_quantities(houses): + """ Ask user for number of crates for each house""" + crates = [] + for house in range(houses): + crates.append(positive_int_input('Enter crates for house {}'.format(house))) + return crates + +def positive_int_input(question): + """ Valdiate user enters a positive integer """ + while True: + try: + integer = int(input(question + ' ')) + if integer >= 0: + return integer + else: + print('Please enter a positive integer.') + except ValueError: + print('Please enter a positive integer.') + +def main(): + print('Recycling truck program') + houses = positive_int_input('How many houses?') + crates = get_crate_quantities(houses) + maximums = max_recycling(crates) + minimums = min_recycling(crates) + total = total_crates(crates) + print('The total number of crates set out on the street is {}'.format(total)) + print('The max number of crates from any house is {}'.format(maximums.crates)) + print('The house(s) with the most recycling is {}'.format(maximums.houses)) + print('The min number of crates from any house is {}'.format(minimums.crates)) + print('The house(s) with the least recycling is {}'.format(minimums.houses)) + +if __name__ == '__main__': + main() diff --git a/10 PYTHON/test_bin_to_dec.py b/10 PYTHON/test_bin_to_dec.py new file mode 100644 index 0000000..436a8c7 --- /dev/null +++ b/10 PYTHON/test_bin_to_dec.py @@ -0,0 +1,38 @@ +import unittest +import bin_to_dec + +class TestBinaryToDecimal(unittest.TestCase): + def test_binario_decimal_con_entradas_validas(self): +# El método bin de Python hace la conversión de binario a decimal +# Los bucles son útiles: testeamos un rango de números + for d in range(100): + binary = bin(d) # En formato '0b10101' + binary = binary[2:] # Quitar la inicial '0b' + dec_output = bin_to_dec.decimal(binary) + self.assertEqual(d, dec_output) + # Testeamos algunos números más grandes + test_vals = [4000, 4001, 4002, 1024, 1099511627776, 1099511627777, 1099511627775] + for d in test_vals: + binary = bin(d) # En formato '0b10101' + binary = binary[2:] # Quitar la inicial '0b' + dec_output = bin_to_dec.decimal(binary) + self.assertEqual(d, dec_output) + + # Test con strings + test_bin_str = [ '101010', '1111', '000111', '0', '1'] + expected_dec = [ 42, 15, 7, 0, 1] + for binary_input, expected_dec_output in zip( test_bin_str, expected_dec) : + dec = bin_to_dec.decimal(binary_input) + self.assertEqual(dec, expected_dec_output) + + def test_binario_decimal_con_entradas_invalidas(self): + # Testeamos que se genere un error con cadenas que no estén compuestas por 0 y 1. + valid = '010101' + valid2 = '1111111' + invalid = [ '123456', '101010012', 'abc', '@#$%$%^%^&'] + for invalid_input in invalid: + with self.assertRaises(ValueError): + bin_to_dec.decimal(invalid_input) + +if __name__ == '__main__': + unittest.main() \ No newline at end of file diff --git a/10 PYTHON/test_camel.py b/10 PYTHON/test_camel.py new file mode 100644 index 0000000..76c0b62 --- /dev/null +++ b/10 PYTHON/test_camel.py @@ -0,0 +1,109 @@ +import unittest +from unittest.mock import patch +import camel + +class TestCamelCase(unittest.TestCase): + def test_capitalize(self): + input_words = ['abc', 'ABC', 'aBC', 'ABc'] + capitalized = 'Abc' + + for word in input_words: + self.assertEqual(capitalized, camel.capitalize(word)) + + def test_lower(self): + # this isn't really needed, since we can assume that Python's library functions work correctly :) + input_words = ['abc', 'ABC', 'aBC', 'ABc'] + lower = 'abc' + for word in input_words: + self.assertEqual(lower, camel.lowercase(word)) + + def test_camel_case_single_words(self): + input_and_expected_outputs = { + 'hello' : 'hello', + 'Hello' : 'hello', + 'Thisisaverylongwordlalalalalalalalalalala': + 'thisisaverylongwordlalalalalalalalalalala', + 'a': 'a' + } + + for input_val, output_val in input_and_expected_outputs.items(): + self.assertEqual(output_val, camel.camel_case(input_val)) + + + def test_camel_case_uppercase(self): + input_and_expected_outputs = { + 'HELLO': 'hello', + 'Hello': 'hello', + 'HeLLo wORlD': 'helloWorld' + } + + for input_val, output_val in input_and_expected_outputs.items(): + self.assertEqual(output_val, camel.camel_case(input_val)) + + def test_camel_case_lowercase(self): + input_and_expected_outputs = { + 'hello': 'hello', + 'hELLO': 'hello', + 'heLLo WORlD': 'helloWorld' + } + for input_val, output_val in input_and_expected_outputs.items(): + self.assertEqual(output_val, camel.camel_case(input_val)) + + def test_camel_case_empty_strings(self): + input_and_expected_outputs = { + '': '', + ' ': '', + } + for input_val, output_val in input_and_expected_outputs.items(): + self.assertEqual(output_val, camel.camel_case(input_val)) + + def test_camel_case_many_words(self): + input_and_expected_outputs = { + 'two words': 'twoWords', + 'this is a sentence': 'thisIsASentence', + 'Here is a long sentence with many words' : + 'hereIsALongSentenceWithManyWords', + } + for input_val, output_val in input_and_expected_outputs.items(): + self.assertEqual(output_val, camel.camel_case(input_val)) + + def test_camel_case_extra_spaces(self): + input_and_expected_outputs = { + ' Spaces Before': 'spacesBefore', + 'Spaces after' : 'spacesAfter', + ' spaces Every where ' : 'spacesEveryWhere', + '\tThere is a \t tab here': 'thereIsATabHere', + '\nThere is a \n newline here': 'thereIsANewlineHere', + 'There is a newline here\n': 'thereIsANewlineHere', + '\nThere is a newline here\n': 'thereIsANewlineHere', + } + for input_val, output_val in input_and_expected_outputs.items(): + self.assertEqual(output_val, camel.camel_case(input_val)) + + def test_camel_case_emojis(self): + input_and_expected_outputs = { + '👽🌎🌺': '👽🌎🌺', + '👽 🌎🌺🐑🌳🌵🐬': '👽🌎🌺🐑🌳🌵🐬' + } + for input_val, output_val in input_and_expected_outputs.items(): + self.assertEqual(output_val, camel.camel_case(input_val)) + + def test_camel_case_international(self): + input_and_expected_outputs = { + '你叫 什么 名字': '你叫什么名字', + 'Write a résumé': 'writeARésumé', + 'Über die Brücke': 'überDieBrücke', + 'Fahre über die Brücke': 'fahreÜberDieBrücke', + } + for input_val, output_val in input_and_expected_outputs.items(): + self.assertEqual(output_val, camel.camel_case(input_val)) + + def test_input_and_output(self): + # Patch the input. Using with context manager automatically takes care of unpatching. + with patch('builtins.input', return_value='This IS another SENTenCE'): + # And, patch the output + with patch('builtins.print') as mock_print: + camel.main() + mock_print.assert_called_with('thisIsAnotherSentence') +if __name__ == '__main__': + unittest.main() \ No newline at end of file diff --git a/10 PYTHON/test_funcion_area.py b/10 PYTHON/test_funcion_area.py new file mode 100644 index 0000000..44e8176 --- /dev/null +++ b/10 PYTHON/test_funcion_area.py @@ -0,0 +1,32 @@ +import unittest +from funcion_area import area +from math import pi + +class TestArea(unittest.TestCase): + + def test_area(self): + print('-----Test valores de resultado conocido----') + self.assertAlmostEqual(area(1),pi) + self.assertAlmostEqual(area(0),0) + self.assertAlmostEqual(area(3),pi*(3**2)) + +# Test de valores negativos + def test_negativos(self): + print('-----Test de valores negativos------') + #Indicamos el tipo de excepción, la función y el valor esperado. + self.assertRaises(ValueError, area, -1) + +# test de tipos no compatibles + # Verificamos si el tipo de los parametros es correcto + # El tipo de excepción debe ser de TypeError + # Se realiza una prueba para que cada tipo conocido no valido + + def test_tipos(self): + print('-----Test de tipos no compatibles-----') + """Test that the area function raises TypeError for incompatible input types.""" + # Boolean values like True are not valid inputs for the area function, as it expects a numeric type. + self.assertRaises(TypeError, area, True) + self.assertRaises(TypeError, area, 'hola') + # Complex numbers are not valid inputs for the area function because the area of a circle is defined only for real numbers. + self.assertRaises(TypeError, area, 2+3j) + \ No newline at end of file diff --git a/10 PYTHON/test_recycling.py b/10 PYTHON/test_recycling.py new file mode 100644 index 0000000..411abf3 --- /dev/null +++ b/10 PYTHON/test_recycling.py @@ -0,0 +1,68 @@ +import unittest +from unittest.mock import Mock, patch +import recycling + +class TestRecycling(unittest.TestCase): + + def test_max_values(self): + # More than one house with the same max value + example_data = [1, 3, 5, 0, 2, 6, 3, 6] + max_data = recycling.max_recycling(example_data) + self.assertEqual(max_data.crates, 6) + self.assertEqual(max_data.houses, [5, 7]) + # Single max value + example_data = [1, 3, 9, 0, 2, 3, 3, 6] + max_data = recycling.max_recycling(example_data) + self.assertEqual(max_data.crates, 9) + self.assertEqual(max_data.houses, [2]) + + def test_min_values(self): + # More than one joint min value + example_data = [1, 0, 3, 5, 0, 2, 6] + min_data = recycling.min_recycling(example_data) + self.assertEqual(min_data.crates, 0) + self.assertEqual(min_data.houses, [1, 4]) + + # Single min value + example_data = [1, 3, 5, 0, 2, 6] + min_data = recycling.min_recycling(example_data) + self.assertEqual(min_data.crates, 0) + self.assertEqual(min_data.houses, [3]) + + def test_total(self): + example_data = [1, 3, 5, 0, 2, 6] + self.assertEqual(recycling.total_crates(example_data), 17) + + def test_get_crate_quantities(self): + """ + Create a patch to replace the built in input function with a mock. + The mock is called mock_input, and we can change the way it behaves, e.g. provide + our desired return values. So when the code calls input(), instead of + calling the built-in input function, it will call the mock_input mock function, + which doesn't do anything except for returning the values provided in the + list of side_effect values - the first time it is called, it returns the first + side_effect value (1), second time it will return the second value, (3) etc... + """ + example_data = [1, 3, 5, 0, 2, 6] + with patch('builtins.input', side_effect=example_data) as mock_input: + self.assertEqual(recycling.get_crate_quantities(6), example_data) + + def test_int_input(self): + # Test with some invalid input + # Put a valid input at the end or the function will never return + with patch('builtins.input', side_effect=['-2', '-1000', 'abc', '123abc', '3']) as mock_input: + self.assertEqual(recycling.positive_int_input('example question'), 3) + #Ultimately, should return the valid value at the end of the list. + with patch('builtins.input', side_effect=[ '0', '13', '1', '100000000']) as mock_input: + self.assertEqual(recycling.positive_int_input('example question'), 0) + self.assertEqual(recycling.positive_int_input('example question'), 13) + self.assertEqual(recycling.positive_int_input('example question'), 1) + self.assertEqual(recycling.positive_int_input('example question'), 100000000) + + def test_main(self): + with patch('builtins.input', side_effect=['4', '1', '3', '2', '3']) as mock_input: + recycling.input = mock_input + recycling.main() # verify program doesn't crash :) Could also test that it's printing correct data with a mock print function. + +if __name__ == '__main__': + unittest.main() diff --git a/Ejercicios de clase/001_Herramientas.txt b/Ejercicios de clase/001_Herramientas.txt new file mode 100644 index 0000000..cbd9f2b --- /dev/null +++ b/Ejercicios de clase/001_Herramientas.txt @@ -0,0 +1,14 @@ +Para codificar online: + + - https://pythonsandbox.com/ + - https://vscode.dev/?vscode-lang=es-es + +IDEs: + - https://code.visualstudio.com/ + - https://www.jetbrains.com/pycharm/ + +Plug-ins de Visual Studio: + - Python + - Python debugger + - Pylance + - Jupiter \ No newline at end of file diff --git a/Ejercicios de clase/005_Variables.py b/Ejercicios de clase/005_Variables.py new file mode 100644 index 0000000..3c3a56a --- /dev/null +++ b/Ejercicios de clase/005_Variables.py @@ -0,0 +1,58 @@ +# VARIABLES + +# Lo ideal es declara e inicializar siempre las variables. +# ----------------------------------------------------------- + +# Declaración de variable numérica entera: +n_edad = 47 + +# Declaración de variable numérica de coma flotante: +n_numero = -23.5245 + +# Declaración de variable de tipo string: +s_nombre = 'Manolo es "amigo" mío' + +# Declaración de variable de tipo string en varias líneas: +s_textoLargo = """Esto es un mensaje +...con tres saltos +...de linea""" + +# Sobreescribimos el valor de la variable s_edad y ahora la ponemos como string: +s_edad = "47" + +# Declaración de constante: +NUMEROPI = 3.14159 + +# Declaración de un boolean +is_verdadero = True +is_casado = False + +# True = 1 y False = 0 +True == 1 +False == 0 + +print(True + 2) + +# Cuando se valida una condición , Python devuelve True o False: +print(10 > 9) +print(10 == 9) +print(10 < 9) + +# Declaración múltiple +# En una sola instrucción, estamos declarando tres variables: a, b y c, y asignándoles un valor concreto a cada una. + +a, b, c = 'string', 15, True + +# Sería como poner: +a = 'string' +b = 15 +c = True + +# Para verificar el tipo de cualquier objeto en Python, usamos la función type() : + +print(type(n_edad)) +print(type(n_numero)) +print(type(s_nombre)) +print(type(NUMEROPI)) +print(type(is_verdadero)) +print(type(is_casado)) diff --git a/Ejercicios de clase/010_variables.py b/Ejercicios de clase/010_variables.py new file mode 100644 index 0000000..8bebd4e --- /dev/null +++ b/Ejercicios de clase/010_variables.py @@ -0,0 +1,73 @@ +## +# 04 - Variables +# Las variables sirven para guardar datos en memoria. +# Python es un lenguaje de tipado dinámico y de tipado fuerte. +### + +from os import system +if system("clear") != 0: system("cls") + +# Para asignar una variable solo hace falta poner el nombre de la variable y asignarle un valor +my_name = "midudev" +print(my_name) # Imprime el valor de la variable my_name + +age = 32 +print(age) # Imprime el valor de la variable age) + +# Reasignar un nuevo valor a una variable existente +age = 39 +print(age) # Ahora la variable age tiene el valor 39 + +# Tipado dinámico: el tipo de dato se determine en tiempo de ejecución +# No es necesario declarar explícitamente el tipo de variable +name = "midudev" +print(type(name)) # Muestra el tipo de dato de la variable name (str) + +name = 32 +print(type(name)) # Ahora la variable tiene un número entero (int) + +# Tipado fuerte: Python no realiza conversione de tipo automáticas +# Esto generará un error porque no se puede sumar un número con una cadena +# print(10 + "2") # ❌ TypeError: unsupported operand type(s) for +: 'int' and 'str' + +# f-string (literal de cadena de formato) +# desde la versión Python 3.6 +print(f"Hola {my_name}, tengo {age + 5} años") + +# No recomendada forma de asignar variables +name, age, city = "midudev", 32, "Bogotá" + +# Convenciones de nombres de variables +mi_nombre_de_variable = "ok" # snake_case +nombre = "ok" + +miNombreDeVariable = "no-recomendado" # camelCase +MiNombreDeVariable = "no-recomendado" # PascalCase +minombredevariable = "no-recomendado" # todojunto + +mi_nombre_de_variable_123 = "ok" + +MI_CONSTANTE = 3.14 # UPPER_CASE -> constantes + +# Nombres NO válidos de variables (esto generaría errores) +# 123123_variable = "ko" # ❌ No puede comenzar con un número +# mi-variable = "ko" # ❌ No puede contener guiones (-), usa guion bajo (_) +# mi variable = "ko" # ❌ No puede contener espacios +# True = False # ❌ No puedes sobrescribir palabras reservadas + +# Palabras reservadas en Python (no se pueden usar como nombres de variables) + +# ['False', 'None', 'True', 'and', 'as', 'assert', +# 'async', 'await', 'break', 'class', 'continue', +# 'def', 'del', 'elif', 'else', 'except', 'finally', +# 'for', 'from', 'global', 'if', 'import', 'in', 'is', +# 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', +# 'return', 'try', 'while', 'with', 'yield'] + +# Anotaciones de tipo (opcional, para mayor claridad en el código) +is_user_logged_in: bool = True # Indica que la variable es un booleano +print(is_user_logged_in) + +name: str = "midudev" # Indica que la variable es una cadena de texto +print(name) + diff --git a/Ejercicios de clase/015_types.py b/Ejercicios de clase/015_types.py new file mode 100644 index 0000000..98cff26 --- /dev/null +++ b/Ejercicios de clase/015_types.py @@ -0,0 +1,41 @@ +### +# 02 - types() +# Python tiene varios tipos de datos +# int, float, complex, str, bool, NoneType, list, tuple, dict, range, set... +### + +from os import system +if system("clear") != 0: system("cls") + +""" +El comando `type()` devuelve el tipo de un objeto en Python +""" +print("int:") # Enteros (números sin parte decimal) +print(type(10)) # Número entero positivo +print(type(0)) # El número cero también es un entero +print(type(-5)) # Número entero negativo +print(type(7238424723784278934789239874)) # Python permite enteros de gran tamaño + +print("float:") # Números decimales (de punto flotante) +print(type(3.14)) # Número con punto decimal +print(type(1.0)) # También es considerado un float, aunque sea un número entero con punto decimal +print(type(1e3)) # Notación científica (equivalente a 1000.0) + +print("complex:") # Números complejos (con parte real e imaginaria) +print(type(1 + 2j)) # Un número complejo en Python (1 es la parte real, 2j es la parte imaginaria) + +print("str:") # Cadenas de texto (strings) +print(type("Hola")) # Un string con texto +print(type("")) # Un string vacío +print(type("123")) # Aunque parezca un número, está entre comillas, por lo que es un string +print(type(""" + Multilinea +""")) # Un string que abarca varias líneas usando triple comillas + +print("bool:") # Valores booleanos (True o False) +print(type(True)) # Valor booleano verdadero +print(type(False)) # Valor booleano falso +print(type(1 < 2)) # Comparación que devuelve un booleano (True) + +print("NoneType:") # Representa la ausencia de valor +print(type(None)) # `None` es un tipo especial en Python que representa "sin valor" o "nulo" \ No newline at end of file diff --git a/Ejercicios de clase/020_Casting.py b/Ejercicios de clase/020_Casting.py new file mode 100644 index 0000000..12da0e6 --- /dev/null +++ b/Ejercicios de clase/020_Casting.py @@ -0,0 +1,43 @@ + +# Forzado de tipo Enteros: +x = int(1) # x Valdrá 1 +y = int(2.8) # y Valdrá 2 +z = int("3") # z Valdrá 3 + +# Forzado de tipo Float: +x = float(1) # x Valdrá 1.0 +y = float(2.8) # y Valdrá 2.8 +z = float("3") # z Valdrá 3.0 +w = float("4.2") # w Valdrá 4.2 + +# Forzado de tipo string: +x = str("s1") # x Valdrá 's1' +y = str(2) # y Valdrá '2' +z = str(3.0) # z Valdrá '3.0' + +# CASTING. Reconversión de tipos: +# Casting de int a float: +n_numero = 13 +n_numero_2 = float(n_numero) + +# Casting de float a int: +n_numero_3 = 24.876 +n_numero_4 = int(n_numero_3) + +# Casting de string a int +s_texto = "13" +n_numero_5 = int(s_texto) + +# Casting de int a string +n_numero_6 = 27 +s_texto_2 = str(n_numero_6) + + +print(n_numero_2) +print(type(n_numero_2)) +print(n_numero_4) +print(type(n_numero_4)) +print(n_numero_5) +print(type(n_numero_5)) +print(s_texto_2) +print(type(s_texto_2)) diff --git a/Ejercicios de clase/025_cast.py b/Ejercicios de clase/025_cast.py new file mode 100644 index 0000000..696145b --- /dev/null +++ b/Ejercicios de clase/025_cast.py @@ -0,0 +1,37 @@ +### +# 03 - casting de types +# Transformar un tipo de un valor a otro +### + +from os import system +if system("clear") != 0: system("cls") + +print("Conversión de tipos") + +# Convertir una cadena que contiene un número a un entero y sumarlo con otro entero +print(2 + int("100")) # Convierte "100" a entero y suma 2. Resultado: 102 + +# Convertir un entero a cadena para concatenarlo con otra cadena +print("100" + str(2)) # Convierte el número 2 a cadena y lo concatena. Resultado: "1002" + +# Convertir una cadena con un número decimal a tipo float +print(type(float("3.1416"))) # Convierte "3.1416" a float y muestra su tipo. Resultado: + +# Convertir un número decimal a entero (se trunca la parte decimal) +print(int(3.1416)) # Convierte 3.1416 a 3 eliminando la parte decimal. Resultado: 3 + +# Evaluar valores numéricos como booleanos +print(bool(3)) # Cualquier número distinto de 0 es True. Resultado: True +print(bool(0)) # 0 es False. Resultado: False +print(bool(-1)) # Números negativos también son True. Resultado: True + +# Evaluar cadenas como booleanos +print(bool("")) # Una cadena vacía es False. Resultado: False +print(bool(" ")) # Una cadena con espacios es True. Resultado: True +print(bool("False")) # Una cadena con texto, aunque sea "False", es True. Resultado: True + +# Redondear un número decimal +print(round(2.51)) # Redondea 2.51 al entero más cercano. Resultado: 3 + +# Este genera un error y se comenta para evitar conflicto en la ejecución +# print(int("Hola mundo")) # ❌ Esto generaría un ValueError porque "Hola mundo" no es un número \ No newline at end of file diff --git a/Ejercicios de clase/030_Comentarios.py b/Ejercicios de clase/030_Comentarios.py new file mode 100644 index 0000000..e3e19b9 --- /dev/null +++ b/Ejercicios de clase/030_Comentarios.py @@ -0,0 +1,21 @@ + +# Los comentarios son anotaciones que pondremos en nuestro código que el programa no va a tener en cuenta. +# Existen dos tipos de comentarios: + +# Esto es un comentario de una línea + +"""Esto es un comentario +que me va a ocupar +varias líneas""" + +# En el caso de las funciones podemos meter docstrings: + +def suma(a, b): + """Esta función suma dos números + :param a: Primer número + :param b: Segundo número + :return: La suma de a y b + """ + return a + b + +suma(1,5) \ No newline at end of file diff --git a/Ejercicios de clase/035_Operadores.py b/Ejercicios de clase/035_Operadores.py new file mode 100644 index 0000000..1410923 --- /dev/null +++ b/Ejercicios de clase/035_Operadores.py @@ -0,0 +1,39 @@ + + + +# Módulo. Nos devuelve el resto de una división: + +n_numerador = 85 +n_denominador = 9 +n_resto = n_numerador % n_denominador +print("El resto de dividir" , n_numerador , "entre" , n_denominador , "es" , n_resto) + + +# == Igual que... +# No confundir con el operador de asignación = +# Con = le damos un valor a una variable. Con == comprobamos si dos objetos son iguales. + +n_numero1 = 34 +s_texto1 = "34" +n_numero1 == s_texto1 + + +n_numero2 = 34 +n_numero3 = 34 +n_numero2 == n_numero3 + +# != Diferente que... + +n_numero4 = 34 +n_numero5 = 34 +n_numero4 != n_numero5 + +# += Suma e incremento + +n_numero6 = 34 +n_numero6 += 1 #Sería como poner: n_numero6 = n_numero6 +1 +print(n_numero6) + + + + diff --git a/Ejercicios de clase/040_Metodos_Strings.py b/Ejercicios de clase/040_Metodos_Strings.py new file mode 100644 index 0000000..deed385 --- /dev/null +++ b/Ejercicios de clase/040_Metodos_Strings.py @@ -0,0 +1,27 @@ + +# find() retorna la posición de la primera similitud de la substring + +cadenaDeTexto = "Es peor cometer una injusticia que padecerla porque quien la comete se convierte en injusto y quien la padece no." +print(cadenaDeTexto.find('quien')) + +# Devolvería: 52 + +# ---------------------------------------------------------------- + +# rfind() retorna la última posición de la similitud de la substring. + +cadenaDeTexto = "Es peor cometer una injusticia que padecerla porque quien la comete se convierte en injusto y quien la padece no." +print(cadenaDeTexto.rfind('quien')) + +# Devolvería: 94 +# Si, el substring no es encontrado retorna -1. +# ---------------------------------------------------------------- + +# replace. Devuelve una cadena donde un valor especificado se reemplaza con un valor especificado + +miString = "Esto es bonito. Esto es bueno." +newString = miString.replace("es" ,"FUE") +print(newString) + +# Devolvería: Esto FUE bonito. Esto FUE bueno. +# ---------------------------------------------------------------- diff --git a/Ejercicios de clase/045_print.py b/Ejercicios de clase/045_print.py new file mode 100644 index 0000000..b5e3b09 --- /dev/null +++ b/Ejercicios de clase/045_print.py @@ -0,0 +1,13 @@ + +#Salida de directa de datos +print("En esta ocasión hemos imprimido por pantalla este string") + + +#Salida de datos calculados +n_numero_1 = 4 +n_numero_2 = 6 +print("El resultado de sumar" , n_numero_1, "y" , n_numero_2 , "es" , (n_numero_1+n_numero_2)) + +#Si concatenamos int y strings usando el signo + nos puede dar problemas. +print("El resultado de sumar " + n_numero_1 + " y " + n_numero_2 + " es " + (n_numero_1+n_numero_2)) + diff --git a/Ejercicios de clase/050_print.py b/Ejercicios de clase/050_print.py new file mode 100644 index 0000000..09a4faa --- /dev/null +++ b/Ejercicios de clase/050_print.py @@ -0,0 +1,48 @@ +### +# 01 - print() +# El módulo print() es el módulo que nos permite imprimir en consola +# Sirve para mostrar información en consola y te va a acompañar +# TODA TU VIDA. Desde hoy hasta el fin de los tiempos +### + +# Podemos importar módulos de Python para usarlos en nuestros programas. +# En este caso, importamos el módulo "os" que nos da acceso a funciones +# relacionadas con el sistema operativo +from os import system + +# system() nos permite ejecutar un comando en la terminal. +# En este caso, lo hacemos para limpiar la pantalla tanto +# en MacOS/Linux usando "clear" como en Windows con "cls" +if system("clear") != 0: system("cls") + +# Este es un ejemplo básico de cómo imprimir un texto en consola +print("¡Hola, Twitch!") + +# También puedes usar comillas simples para imprimir texto +print('Esto también funciona con una comilla') + +# Puedes imprimir múltiples elementos separados por un espacio +print("Python", "es", "genial") + +# El parámetro 'sep' permite definir cómo se separan los elementos impresos +print("Python", "es", "brutal", sep = "-") + +# El parámetro 'end' define lo que se imprime al final de la línea +print("Esto se imprime", end = "\n") # Aquí, el 'end' tiene un salto de línea explícito +print("en una línea") # Esto se imprime en la línea siguiente + +# También se pueden imprimir números directamente +print(42) + +# Ejemplo de cómo imprimir el símbolo de pulgadas (") +# Si usamos comillas dobles dentro de un string con comillas dobles, se produce un error: +# print("Esto es una "pulgada"") # ❌ Esto generaría un error de sintaxis + +# ✅ Solución 1: Usar comillas simples para encerrar la cadena +print('Esto es una "pulgada" dentro de un string con comillas simples') + +# ✅ Solución 2: Usar el carácter de escape \ para incluir comillas dobles dentro de un string con comillas dobles +print("Esto es una \"pulgada\" dentro de un string con comillas dobles") + +# ✅ Solución 3: Usar triple comillas para definir el string +print("""Esto es una "pulgada" dentro de un string con triple comillas""") \ No newline at end of file diff --git a/Ejercicios de clase/055_Input.py b/Ejercicios de clase/055_Input.py new file mode 100644 index 0000000..2243f94 --- /dev/null +++ b/Ejercicios de clase/055_Input.py @@ -0,0 +1,16 @@ + + + +s_nombreIntroducido = input("Introduzca su nombre: ") + +print("Bienvenido", s_nombreIntroducido) + +# ------------------------------------- + +""" IMPORTANTE: Todo lo introducido por input() se considera string, aunque sea un número, +por lo que, si necesitamos operar matemáticamente con números, tendremos que hacer un casting: +""" + +n_edad = input("Introduzca su edad: ") + +print("El año que viene tendrá usted ", n_edad + 1, "años") diff --git a/Ejercicios de clase/060_input.py b/Ejercicios de clase/060_input.py new file mode 100644 index 0000000..1c115ee --- /dev/null +++ b/Ejercicios de clase/060_input.py @@ -0,0 +1,26 @@ +### +# 05 - Entrada de usuario (input()) - Versión simplificada +# La función input() permite obtener datos del usuario a través de la consola. +### + +from os import system +if system("clear") != 0: system("cls") + +# Para obtener datos del usuario se usa la función input() +# La función input() recibe un mensaje que se muestra al usuario +# y devuelve el valor introducido por el usuario +nombre = input("Hola, ¿cómo te llamas?\n") +print(f"Hola {nombre}, encantado de conocerte") + +# Ten en cuenta que la función input() devuelve un string +# Así que si queremos obtener un número se debe convertir el string a un número +age = input("¿Cuántos años tienes?\n") +age = int(age) +print(f"Tienes {age} años") + +# La función input() también puede devolver múltiples valores +# Para hacerlo, el usuario debe separar los valores con una coma +print("Obtener múltiples valores a la vez") +country, city = input("¿En qué país y ciudad vives?\n").split() + +print(f"Vives en {country}, {city}") \ No newline at end of file diff --git a/Ejercicios de clase/065_Metodos_Strings.py b/Ejercicios de clase/065_Metodos_Strings.py new file mode 100644 index 0000000..04efe6d --- /dev/null +++ b/Ejercicios de clase/065_Metodos_Strings.py @@ -0,0 +1,82 @@ + +# TRABAJAR CON STRINGS +"""Los strings son secuencias de caracteres de texto. +Todos los objetos en Python se engloban en dos categorías: mutables o inmutables. +Los tipos básicos mutables son las listas, los diccionarios y los sets. +Los tipos básicos inmutables son los números, los strings y las tuplas. +Los objetos mutables pueden ser cambiados en el mismo objeto, mientras que los inmutables no. +""" +# Para concatenar textos se hace con “+” o simplemente con una coma. +# Si ponemos coma nos pone entre los textos un espacio, con + no lo hace. + +print("Esta frase" , "termina aquí.") +print("Esta frase " + "termina aquí.") + +# Contatenación y multiplicación de strings +a = "uno" +b = "dos" +c = a + b # c es "unodos" +c = a * 3 # c es "unounouno" + + +#---------------------------------------------- + +# MÉTODOS DE LOS STRINGS: + +# lower(): Convierte en minúsculas un string. +s_texto1 = "ESTE TEXTO ESTÁ INICIALMENTE EN MAYÚSCULAS" +print(s_texto1.lower()) + +# capitalize(): Pone la primera letra en mayúscula. +s_texto2 = "este texto no tenía la primera letra en mayúsculas" +print(s_texto2.capitalize()) + + +# count(): Cuenta cuantas veces aparece una letra o una cadena de caracteres. +s_texto3 = "Vamos a ver cuántas veces aparece la letra c" +print(s_texto3.count('c')) + +# find(): Representa el índice o la posición en el cual aparece un carácter o un grupo de caracteres. Si aparece varias veces me dice sólo el primero. +s_texto4 = "Vamos a ver en qué posición aparece primero la letra e" +print(s_texto4.find('e')) + +# rfind(): Igual que find() pero contando desde atrás. +s_texto5 = "Vamos a ver en qué posición aparece la palabra desde, contando desde atrás" +print(s_texto5.rfind('desde')) + +# isdigit(): Devuelve un boolean, nos dice si el valor introducido es un string. Tiene que ser un valor introducido entre comillas o dará error. +s_texto6 = "6" +print(s_texto6.isdigit()) + +# isalum(): Devuelve un boolean, Devuelve verdadero si todos los caracteres de la cadena son numéricos y hay al menos un carácter. En caso contrario, devuelve falso. +s_texto7 = "9857654gf7" +print(s_texto7.isalnum()) + +# isalpha(): Devuelve un boolean, comprueba si hay sólo letras. Los espacios no cuentan. +s_texto8 = "Holamundo" +print(s_texto8.isalpha()) + +# split(): Separa por palabras utilizando espacios. Crea una lista. +s_texto9 = "Vamos a separar esta frase por los espacios" +print(s_texto9.split()) + +# Podemos usar otro carácter como separador, por ejemplo una coma: +s_texto10 = "Esta sería la primera parte,y esta la segunda" +print(s_texto10.split(",")) + +# strip(): Borra los espacios sobrantes al principio y al final. +s_texto11 = " En este texto había espacios al principio y al final " +print(s_texto11.strip()) + +# replace(): Cambia una palabra o una letra por otra. +s_texto12 = "Vamos reemplazar la palabra casa" +print(s_texto12.replace("casa", "hogar")) + +# Te invito a que inspecciones el resto de funciones predefinidas para los strings en: +# https://www.freecodecamp.org/espanol/news/metodos-de-string-de-python-explicados-con-ejemplo/ + + + + + + diff --git a/Ejercicios de clase/070_Metodos_Stringsb.py b/Ejercicios de clase/070_Metodos_Stringsb.py new file mode 100644 index 0000000..deed385 --- /dev/null +++ b/Ejercicios de clase/070_Metodos_Stringsb.py @@ -0,0 +1,27 @@ + +# find() retorna la posición de la primera similitud de la substring + +cadenaDeTexto = "Es peor cometer una injusticia que padecerla porque quien la comete se convierte en injusto y quien la padece no." +print(cadenaDeTexto.find('quien')) + +# Devolvería: 52 + +# ---------------------------------------------------------------- + +# rfind() retorna la última posición de la similitud de la substring. + +cadenaDeTexto = "Es peor cometer una injusticia que padecerla porque quien la comete se convierte en injusto y quien la padece no." +print(cadenaDeTexto.rfind('quien')) + +# Devolvería: 94 +# Si, el substring no es encontrado retorna -1. +# ---------------------------------------------------------------- + +# replace. Devuelve una cadena donde un valor especificado se reemplaza con un valor especificado + +miString = "Esto es bonito. Esto es bueno." +newString = miString.replace("es" ,"FUE") +print(newString) + +# Devolvería: Esto FUE bonito. Esto FUE bueno. +# ---------------------------------------------------------------- diff --git a/Ejercicios de clase/075_Operadores.py b/Ejercicios de clase/075_Operadores.py new file mode 100644 index 0000000..f8a70f5 --- /dev/null +++ b/Ejercicios de clase/075_Operadores.py @@ -0,0 +1,39 @@ + + + +# Módulo. Nos devuelve el resto de una división: + +n_numerador = 85 +n_denominador = 9 +n_resto = n_numerador%n_denominador +print("El resto de dividir" , n_numerador , "entre" , n_denominador , "es" , n_resto) + + +# == Igual que... +# No confundir con el operador de asignación = +# Con = le damos un valor a una variable. Con == comprobamos si dos objetos son iguales. + +n_numero1 = 34 +s_texto1 = "34" +n_numero1 == s_texto1 + + +n_numero2 = 34 +n_numero3 = 34 +n_numero2 == n_numero3 + +# != Diferente que... + +n_numero4 = 34 +n_numero5 = 34 +n_numero4 != n_numero5 + +# += Suma e incremento + +n_numero6 = 34 +n_numero6 += 1 #Sería como poner: n_numero6 = n_numero6 +1 +print(n_numero6) + + + + diff --git a/Ejercicios de clase/080_Operadores_logicos.py b/Ejercicios de clase/080_Operadores_logicos.py new file mode 100644 index 0000000..7d87a12 --- /dev/null +++ b/Ejercicios de clase/080_Operadores_logicos.py @@ -0,0 +1,35 @@ + + +a = True +b = False +resultado = a and b +# print(resultado) + +resultado = a or b +# print(resultado) + +resultado = not a +print(resultado) + +#---------------------------------- +# Sintaxis simplificada para varios operadores lógicos +edad = input('Introduce tu edad: ') + + +#veintes = edad >= 20 and edad < 30 +#print(veintes) +#treintas = edad >= 30 and edad <40 +#print(treintas) + +if ( 20 <= edad < 30) or (30 <= edad <40): + print('Dentro de rango (20\'s) o (30\'s)') +# if veintes: +# print('Dentro de los 20\'s') +# elif treintas: +# print('Dentro de los 30\'s') +# else: +# print('Fuera de rango') +else: + print("No está dentro de los 20's ni 30's") + + diff --git a/Ejercicios de clase/085_Objetos_mutables_inmutables.py b/Ejercicios de clase/085_Objetos_mutables_inmutables.py new file mode 100644 index 0000000..13ce8e5 --- /dev/null +++ b/Ejercicios de clase/085_Objetos_mutables_inmutables.py @@ -0,0 +1,40 @@ + + + + +# Obtener la dirección de memoria de una variable + +a = 65 +print("La dirección de memoria es" , id(a)) + +# Obtener la dirección de memoria de una variable que apunta a otra + +miNumero = 65 +miNumero2 = miNumero +print("La dirección de memoria es" , id(miNumero)) +print("La dirección de memoria es" , id(miNumero2)) + +# Si cambio la variable, realmente creo una copia en otra dirección de memoria: + +a = 65 +print("La dirección de memoria es" , id(a)) +a+=2 +print("La dirección de memoria es" , id(a)) + +# Obtener la dirección de memoria de una tupla +a = (1, 2, 3, 4, 5) +print("La dirección de memoria es" , id(a)) + +# Obtener la dirección de memoria de una lista + +a = [1, 2, 3, 4, 5] +print("La dirección de memoria es" , id(a)) + +# Obtener la dirección de memoria de un diccionario +a = {'a': 1, 'b': 2} +print(a) +print("La dirección de memoria es" , id(a)) + +a["c"] = 3 +print(a) +print("La dirección de memoria es" , id(a)) \ No newline at end of file diff --git a/Ejercicios de clase/090_if_elif_else.py b/Ejercicios de clase/090_if_elif_else.py new file mode 100644 index 0000000..d0200d0 --- /dev/null +++ b/Ejercicios de clase/090_if_elif_else.py @@ -0,0 +1,129 @@ + + +# # Programa que pide una nota por consola y valora si el alumno ha aprobado o no. + +# notaIn=int(input("Introduzca nota:")) + +# if notaIn<5: +# calificacion="Suspenso" +# else: calificacion="Aprobado" + +# print(calificacion) + +# # IF no sólo evalúa un boleano, también si una variable contiene información + +# variable = 19 + +# if variable: +# print("Contiene información") +# else: +# print("No contiene información") + + +# #En este ejemplo sí evalúa un boleano + +# variable = 19 + +# if variable == True: +# print("Contiene información") +# else: +# print("No contiene información") + +# # Programa que pide una edad por consola y valora si el usuario es mayor de edad o no. + +edad=int(input("Introduce edad: ")) + +if edad<18: + print("No puedes pasar") +elif edad>100: + print("Edad incorrecta") +else: + print("Adelante") + +# Programa que pide una nota por consola y valora las posibles calificaciones del alumno. + +nota=int(input("Introduce tu nota: ")) + +if nota<5: + print("Suspenso") +elif nota<7: + print("Aprobado") +elif nota<9: + print("Notable") +else: + print("Sobresaliente") + + + +# IF abreviado +n_num1 = 5 +n_num2 = 10 +if n_num1 > n_num2: print(n_num1 , "es mayor que" , n_num2) + +# IF...ELSE abreviado +a = 2 +b = 330 +print("A") if a > b else print("B") + +# Se pueden concatenar operadores de comparación: + +edad=117 +if 00 and edad<100 + print("Edad correcta") +else: + print("Edad incorrecta") + + # Otro ejemplo de operadores de comparación concatenados + +salarioPresidente = int(input("Introduce salario presidente: ")) +print("El salario del presidente es de" , salarioPresidente) + +salarioDirector = int(input("Introduce salario Director: ")) +print("El salario del director es de" , salarioDirector) + +salarioJefe = int(input("Introduce salario jefe: ")) +print("El salario del jefe es de" , salarioJefe) + +salarioOperario = int(input("Introduce salario operario: ")) +print("El salario del operario es de" , salarioOperario) + +if salarioOperario20 or numHermanos<2 or notaMedia<=5: + print("NO eres candidato a la beca") +else: + print("Sí eres candidato a la beca") + +# Operador IN + +opcion = input("ELige opcion: opcion1, opcion2, opcion3, opcion4: ") +pasoMinusculas = opcion.lower() +if pasoMinusculas in("opcion1", "opcion2", "opcion3", "opcion4"): + print("Opción válida: " + pasoMinusculas) +else: + print("Opción inválida: " + pasoMinusculas) + + # If anidados. Queremos comprar un coche. Necesitamos ser mayores de edad y tener 20000€ + +n_edad = int(input("Introduzca su edad: ")) +n_dinero = int(input("Introduzca presupuesto: ")) + +if n_edad < 18: + print("No tienes la edad suficiente para conducir.") +else: + if n_dinero < 20000: + print("Tienes la edad pero no el dinero para comprar el coche.") + else: + print("Puedes comprar el coche.") + + + + diff --git a/Ejercicios de clase/095_if.py b/Ejercicios de clase/095_if.py new file mode 100644 index 0000000..e3f85cf --- /dev/null +++ b/Ejercicios de clase/095_if.py @@ -0,0 +1,157 @@ +### +# 01 - Sentencias condicionales (if, elif, else) +# Permiten ejecutar bloques de código solo si se cumplen ciertas condiciones. +### + +from os import system +if system("clear") != 0: system("cls") + +print("\n Sentencia simple condicional") +# Podemos usar la palabra clave "if" para ejecutar un bloque de código +# solo si se cumple una condición. +edad = 18 +if edad >= 18: + print("Eres mayor de edad") + print("¡Felicidades!") + +# Si no se cumple la condición, no se ejecuta el bloque de código +edad = 15 +if edad >= 18: + print("Eres mayor de edad") + print("¡Felicidades!") + +# Podemos usar el comando "else" para ejecutar un bloque de código +# si no se cumple la condición anterior del if +print("\n Sentencia condicional con else") +edad = 15 +if edad >= 18: + print("Eres mayor de edad") +else: + print("Eres menor de edad") + +print("\n Sentencia condicional con elif") +nota = 5 + +# Además de usar "if" y "else", podemos usar "elif" para determinar +# múltiples condiciones, ten en cuenta que sólo se ejecutará el primer bloque +# de código que cumpla la condición (o la del else, si está presente) +if nota >= 9: + print("¡Sobresaliente!") +elif nota >= 7: + print("Notable!") +elif nota >= 5: + print("¡Aprobado!") +else: + print("¡No está calificado!") + +print("\n Condiciones múltiples") +edad = 16 +tiene_carnet = True + +# Los operadores lógicos en Python son: +# and: True si ambos operandos son verdaderos +# or: True si al menos uno de los operandos es verdadero +# En JavaScript: +# && sería and +# || sería or + +# En el caso que seas mayor de edad y tengas carnet... +# entonces podrás conducir +if edad >= 18 and tiene_carnet: + print("Puedes conducir 🚗") +else: + print("POLICIA 🚔!!!1!!!") + +# En un pueblo de Isla Margarita son más laxos y +# te dejan conducir si eres mayor de edad O tienes carnet +if edad >= 18 or tiene_carnet: + print("Puedes conducir en la Isla Margarita 🚗") +else: + print("Paga al policía y te deja conducir!!!") + +# También tenemos el operador lógico "not" +# que nos permite negar una condición +es_fin_de_semana = False +# JavaScript -> ! +if not es_fin_de_semana: + print("¡midu, venga que hay que streamear!") + +# Podemos anidar condicionales, uno dentro del otro +# para determinar múltiples condiciones aunque +# siempre intentaremos evitar esto para simplificar +print("\n Anidar condicionales") +edad = 20 +tiene_dinero = True + +if edad >= 18: + if tiene_dinero: + print("Puedes ir a la discoteca") + else: + print("Quédate en casa") +else: + print("No puedes entrar a la disco") + +# Más fácil sería: +# if edad < 18: +# print("No puedes entrar a la disco") +# elif tiene_dinero: +# print("Puedes ir a la discoteca") +# else: +# print("Quédate en casa") + +# Ten en cuenta que hay valores que al usarlos como condiciones +# en Python son evaluados como verdaderos o falsos +# por ejemplo, el número 5, es True +numero = 5 +if numero: # True + print("El número no es cero") + +# Pero el número 0 se evalúa como False +numero = 0 +if numero: # False + print("Aquí no entrará nunca") + +# También el valor vacío "" se evalúa como False +nombre = "" +if nombre: + print("El nombre no es vacío") + +# ¡Ten cuidado con no confundir la asignación = con la comparación ==! +numero = 3 # asignación +es_el_tres = numero == 3 # comparación + +if es_el_tres: + print("El número es 3") + +# A veces podemos crear condicionales en una sola línea usando +# las ternarias, es una forma concisa de un if-else en una línea de código +print("\nLa condición ternaria:") +# [código si cumple la condición] if [condicion] else [codigo si no cumple] + +edad = 17 +mensaje = "Es mayor de edad" if edad >= 18 else "Es menor de edad" +print(mensaje) + +### +# EJERCICIOS +### + +# Ejercicio 1: Determinar el mayor de dos números +# Pide al usuario que introduzca dos números y muestra un mensaje +# indicando cuál es mayor o si son iguales + +# Ejercicio 2: Calculadora simple +# Pide al usuario dos números y una operación (+, -, *, /) +# Realiza la operación y muestra el resultado (maneja la división entre zero) + +# Ejercicio 3: Año bisiesto +# Pide al usuario que introduzca un año y determina si es bisiesto. +# Un año es bisiesto si es divisible por 4, excepto si es divisible por 100 pero no por 400. + +# Ejercicio 4: Categorizar edades +# Pide al usuario que introduzca una edad y la clasifique en: +# - Bebé (0-2 años) +# - Niño (3-12 años) +# - Adolescente (13-17 años) +# - Adulto (18-64 años) +# - Adulto mayor (65 años o más) \ No newline at end of file diff --git a/Ejercicios de clase/100_Ejercicios_Condicionales_1.py b/Ejercicios de clase/100_Ejercicios_Condicionales_1.py new file mode 100644 index 0000000..6c6372e --- /dev/null +++ b/Ejercicios de clase/100_Ejercicios_Condicionales_1.py @@ -0,0 +1,14 @@ + + +# Escribe un programa que pregunte al usuario su edad y muestre por pantalla +# si es mayor de edad o no. + +edad = int(input("Ingresa tu edad: ")) + + +if edad >= 18: + print("Eres mayor de edad.") + +else: + print("No eres mayor de edad.") + diff --git a/Ejercicios de clase/105_Ejercicios_Condicionales_2.py b/Ejercicios de clase/105_Ejercicios_Condicionales_2.py new file mode 100644 index 0000000..f7c855f --- /dev/null +++ b/Ejercicios de clase/105_Ejercicios_Condicionales_2.py @@ -0,0 +1,12 @@ + + +# Solicita dos números al usuario y determina cuál de los dos es mayor o si son iguales. + +numero1 = int(input("Ingresa el primer número: ")) +numero2 = int(input("Ingresa el segundo número: ")) +if numero1 > numero2: + print("El primer número es mayor.") +elif numero1 < numero2: + print("El segundo número es mayor.") +else: + print("Ambos números son iguales.") diff --git a/Ejercicios de clase/110_Ejercicios_Condicionales_3.py b/Ejercicios de clase/110_Ejercicios_Condicionales_3.py new file mode 100644 index 0000000..2d36d85 --- /dev/null +++ b/Ejercicios de clase/110_Ejercicios_Condicionales_3.py @@ -0,0 +1,16 @@ + + +# Escribe un script que solicite una calificación al usuario (0 - 100). +# Si la calificación es mayor o igual a 90, imprime "Excelente", si es mayor +# o igual a 70 y menor que 90, imprime "Bueno", si es mayor o igual a 50 y +# menor que 70, imprime "Suficiente", y si es menor que 50, imprime "Insuficiente". + +calificacion = float(input("Ingresa tu calificación (0-100): ")) +if calificacion >= 90: + print("Excelente") +elif calificacion >= 70: + print("Bueno") +elif calificacion >= 50: + print("Suficiente") +else: + print("Insuficiente") diff --git a/Ejercicios de clase/115_Ejercicios_Condicionales_4.py b/Ejercicios de clase/115_Ejercicios_Condicionales_4.py new file mode 100644 index 0000000..b869b40 --- /dev/null +++ b/Ejercicios de clase/115_Ejercicios_Condicionales_4.py @@ -0,0 +1,26 @@ + + +# Un almacén da un descuento del 15% si la compra del cliente supera los 1000 Euros. +# Escribe un programa que pida el total de la compra y calcule el descuento +# (si aplica) y el total a pagar. + +# Solicita al usuario que ingrese el total de la compra +total_compra = float(input("Ingresa el total de la compra: $")) + +# Verifica si el total de la compra supera los 1000 dólares +if total_compra > 1000: + # Calcula el descuento + descuento = total_compra * 0.15 + # Redondea el descuento a dos decimales + descuento_redondeado = round(descuento, 2) + # Calcula el total final aplicando el descuento redondeado + total_final = total_compra - descuento_redondeado + # Redondea el total final a pagar a dos decimales + total_final_redondeado = round(total_final, 2) + # Imprime el total final a pagar y el descuento aplicado + print(f"Se aplicó un descuento de ${descuento_redondeado}, total a pagar: ${total_final_redondeado}") +else: + # Si no se aplica descuento, el total a pagar es el mismo que el total de la compra + # Redondea el total de la compra a dos decimales + total_compra_redondeado = round(total_compra, 2) + print(f"No se aplicó descuento, total a pagar: ${total_compra_redondeado}") diff --git a/Ejercicios de clase/120_Ejercicios_Condicionales_5.py b/Ejercicios de clase/120_Ejercicios_Condicionales_5.py new file mode 100644 index 0000000..888ae52 --- /dev/null +++ b/Ejercicios de clase/120_Ejercicios_Condicionales_5.py @@ -0,0 +1,23 @@ + + +# Escribe un programa que pida al usuario un número del 1 al 7 y muestre el día +# de la semana correspondiente. Si el número no está en ese rango, debe +# indicar que el número es inválido. + +numero = int(input("Ingresa un número del 1 al 7: ")) +if numero == 1: + print("Lunes") +elif numero == 2: + print("Martes") +elif numero == 3: + print("Miércoles") +elif numero == 4: + print("Jueves") +elif numero == 5: + print("Viernes") +elif numero == 6: + print("Sábado") +elif numero == 7: + print("Domingo") +else: + print("Número inválido") diff --git a/Ejercicios de clase/125_Ejercicios_Condicionales_6.py b/Ejercicios de clase/125_Ejercicios_Condicionales_6.py new file mode 100644 index 0000000..44e6566 --- /dev/null +++ b/Ejercicios de clase/125_Ejercicios_Condicionales_6.py @@ -0,0 +1,20 @@ + + +# Escribe un programa que pida la edad del usuario y clasifique a las personas en diferentes categorías (niño, adolescente, adulto, adulto mayor). Supón los siguientes rangos de edad: + +# Niño: Menos de 13 años. +# Adolescente: De 13 a 19 años. +# Adulto: De 20 a 64 años. +# Adulto mayor: 65 años o más. + +edad = int(input("Introduce tu edad: ")) +if edad < 13: + print("Eres un niño.") +else: + if edad < 20: + print("Eres un adolescente.") + else: + if edad < 65: + print("Eres un adulto.") + else: + print("Eres un adulto mayor.") diff --git a/Ejercicios de clase/130_Ejercicios_Condicionales_7.py b/Ejercicios de clase/130_Ejercicios_Condicionales_7.py new file mode 100644 index 0000000..51e1c20 --- /dev/null +++ b/Ejercicios de clase/130_Ejercicios_Condicionales_7.py @@ -0,0 +1,20 @@ + + +# Desarrolla un programa que solicite la calificación de un examen (0 a 100) +# y devuelva el rango de desempeño basado en la puntuación: insuficiente, +# suficiente, bien, muy bien, o excelente. + +calificacion = int(input("Introduce la calificación del examen (0-100): ")) +if calificacion < 60: + print("Insuficiente") +else: + if calificacion < 70: + print("Suficiente") + else: + if calificacion < 80: + print("Bien") + else: + if calificacion < 90: + print("Muy bien") + else: + print("Excelente") diff --git a/Ejercicios de clase/135_Ejercicios_Condicionales_8.py b/Ejercicios de clase/135_Ejercicios_Condicionales_8.py new file mode 100644 index 0000000..4d2b812 --- /dev/null +++ b/Ejercicios de clase/135_Ejercicios_Condicionales_8.py @@ -0,0 +1,17 @@ + + +# Escribe un programa que sugiera qué ponerse basado en la temperatura actual +# (en grados Celsius) que el usuario introduce. Considera: + +# Menos de 10°C: Abrigo y bufanda. +# De 10°C a 20°C: Suéter ligero. +# Más de 20°C: Camiseta. + +temperatura = float(input("¿Cuál es la temperatura actual en grados Celsius? ")) +if temperatura < 10: + print("Deberías usar abrigo y bufanda.") +else: + if temperatura <= 20: + print("Un suéter ligero sería adecuado.") + else: + print("Es un buen día para llevar camiseta.") diff --git a/Ejercicios de clase/140_Ejercicios_Condicionales_9.py b/Ejercicios de clase/140_Ejercicios_Condicionales_9.py new file mode 100644 index 0000000..6a0f290 --- /dev/null +++ b/Ejercicios de clase/140_Ejercicios_Condicionales_9.py @@ -0,0 +1,13 @@ + + +# Programa un sistema que categorice los ingresos anuales de una persona +# como 'bajo', 'medio' o 'alto'. Define tú mismo los límites de cada categoría. + +ingresos = float(input("Introduce tus ingresos anuales: ")) +if ingresos < 20000: + print("Tus ingresos son bajos.") +else: + if ingresos < 50000: + print("Tus ingresos son medios.") + else: + print("Tus ingresos son altos.") diff --git a/Ejercicios de clase/145_Ejercicios_Condicionales_10.py b/Ejercicios de clase/145_Ejercicios_Condicionales_10.py new file mode 100644 index 0000000..47e0ae0 --- /dev/null +++ b/Ejercicios de clase/145_Ejercicios_Condicionales_10.py @@ -0,0 +1,17 @@ + + +# Una tienda ofrece descuentos basados en el total de compra. +# Si la compra es mayor a $100, el descuento es del 10%. Si es mayor a $500, +# el descuento es del 20%. Crea un programa que calcule el total a pagar +# después del descuento. + +compra = float(input("Introduce el total de la compra: $")) +if compra > 500: + total = compra * 0.8 + print(f"El total después del descuento es: ${total:.2f}") +else: + if compra > 100: + total = compra * 0.9 + print(f"El total después del descuento es: ${total:.2f}") + else: + print(f"No hay descuento. El total es: ${compra:.2f}") diff --git a/Ejercicios de clase/150_Ejercicios_Condicionales_11.py b/Ejercicios de clase/150_Ejercicios_Condicionales_11.py new file mode 100644 index 0000000..61b312a --- /dev/null +++ b/Ejercicios de clase/150_Ejercicios_Condicionales_11.py @@ -0,0 +1,14 @@ + +# Solicitar la edad y el dinero al usuario +edad = int(input("Introduce tu edad: ")) +dinero = float(input("Introduce la cantidad de dinero que tienes: ")) + +# Verificar las condiciones para comprar el coche +if edad >= 18 and dinero >= 20000: + print("¡Felicidades! Puedes comprar el coche.") +elif edad >= 18 and dinero < 20000: + print("Tienes la edad suficiente, pero no tienes suficiente dinero para comprar el coche.") +elif edad < 18 and dinero >= 20000: + print("Tienes suficiente dinero, pero no tienes la edad suficiente para comprar el coche.") +else: + print("No tienes ni la edad suficiente ni el dinero necesario para comprar el coche.") diff --git a/Ejercicios de clase/155_Ejercicios_Condicionales_12.py b/Ejercicios de clase/155_Ejercicios_Condicionales_12.py new file mode 100644 index 0000000..e873e57 --- /dev/null +++ b/Ejercicios de clase/155_Ejercicios_Condicionales_12.py @@ -0,0 +1,33 @@ +# Crea un número aleatorio entre 1 y 100, y el usuario debe adivinarlo. +# El programa le indica si el número ingresado es mayor o menor que el número secreto + + +import random + +# Generar un número aleatorio entre 1 y 100 +numero_secreto = random.randint(1, 100) +intentos = 0 + +print("¡Bienvenido al juego de adivinar el número!") +print("He elegido un número entre 1 y 100. ¡A ver si puedes adivinarlo!") + +while True: + # Pedir al usuario que ingrese un número + guess = input("Introduce tu intento: ") + + # Verificar si la entrada es un número + if guess.isdigit(): + guess = int(guess) + intentos += 1 + else: + print("Por favor, introduce un número válido.") + continue + + # Comparar el número ingresado con el número secreto + if guess < numero_secreto: + print("El número secreto es mayor que", guess) + elif guess > numero_secreto: + print("El número secreto es menor que", guess) + else: + print(f"¡Felicidades! ¡Adivinaste el número en {intentos} intentos!") + break \ No newline at end of file diff --git a/Ejercicios de clase/160_Operador condicional.py b/Ejercicios de clase/160_Operador condicional.py new file mode 100644 index 0000000..82cee99 --- /dev/null +++ b/Ejercicios de clase/160_Operador condicional.py @@ -0,0 +1,11 @@ + + +# Operador condicional + +nombre = "Pedro" +edad = 30 if nombre == "Pedro" else 15 +print(edad) + +tiempo = "lluvia" +print("Vamos", "a la piscina" if tiempo == "sol" else "al cine") + diff --git a/Ejercicios de clase/165_Operador ternario.py b/Ejercicios de clase/165_Operador ternario.py new file mode 100644 index 0000000..f6c3622 --- /dev/null +++ b/Ejercicios de clase/165_Operador ternario.py @@ -0,0 +1,19 @@ + + +# Operador ternario + +num = 12 + +var = "par" if (num % 2 == 0) else "impar" + +print(var) + +# Sería como escribir + +num = 12 + +if num % 2 == 0: + print="Par" +else: print="Impar" + + diff --git a/Ejercicios de clase/170_For.py b/Ejercicios de clase/170_For.py new file mode 100644 index 0000000..bf6e8d5 --- /dev/null +++ b/Ejercicios de clase/170_For.py @@ -0,0 +1,133 @@ + + +# El bucle for + +# Ejecuta el print dos veces + +for i in [1,10]: + print("Hola") + + +# Imprime el contenido del diccionario + +for i in ["primavera", "verano", "otoño", "invierno"]: + print(i) + +# Repite el print tantas veces como caracteres hay en el string + +for i in "frase": + print("Hola", end=" ") + +# Evaluamos si un mail contiene el caracter @ + + +miEmail=input("Introduce email") +email=False +for i in miEmail: + if i=="@": + email=True +if email==True: #Se puede simplificar if email: + print("El email es correcto") +else: + print("EL mail no es correcto") + +# Podemos unir valores de texto con valores de variable a la hora de imprimir: + +for i in range(5): + print(f"Valor de la variable {i}") + +for i in range(5,10): + print(f"Valor de la variable {i}") + +# Podemos poner un tercer argumento con el que especificamos de cuanto en cuanto va el conteo: + +for i in range(5,10,2): + print(f"Valor de la variable {i}") + + +# validar un mail en función de si tiene @ simplemente recorriendo la logitud del string: + +valido=False +email=input("Introduce tu email: ") + +for i in range(len(email)): + if email[i]=="@": + valido=True + +if valido: + print("Email correcto") +else: + print("Email incorrecto") + +# Las cadenas son objetos iterables, contienen una secuencia de caracteres: + +for x in "banana": + print(x) + +# Con la instrucción break podemos detener el ciclo antes de que haya pasado por todos los elementos: +# Salga del bucle cuando x es "banana" + +frutas = ["manzana", "banana", "cereza"] +for x in frutas: + print(x) + if x == "banana": + break + +# Salga del bucle cuando x es "banana", pero esta vez el corte se produce antes de la impresión: + +frutas = ["manzana", "banana", "cereza"] +for x in frutas: + if x == "banana": + break + print(x) + +# Con la instrucción continue podemos detener la iteración actual del ciclo y continuar con la siguiente: +# En este caso no me imprimiría "banana" + +frutas = ["manzana", "banana", "cereza"] +for x in frutas: + if x == "banana": + continue + print(x) + + +# Para recorrer un conjunto de código un número específico de veces, podemos usar la función range () + +for x in range(6): + print(x) + +# Función range con parámetro de inicio incrementado por defecto en 1. + +for x in range(2, 6): + print(x) + +# Función range con parámetro de inicio incrementado en 3. + +for x in range(2, 30, 3): + print(x) + +# Bucle for anidado +# Imprime cada color para cada fruta: + +color = ["verde", "amarilla", "roja"] +frutas = ["manzana", "banana", "cereza"] + +for x in frutas: + for y in color: + print(x, y) + + +# Los bucles for no pueden estar vacíos. +# Si por alguna razón tenemos un bucle for sin contenido, usaremos la instrucción pass para evitar un error. + +for x in [0, 1, 2]: + pass + +# Un bucle for también puede tener una cláusula else. +# La cláusula else se ejecutará cuando el iterador emita una excepción +# debido a que no quedan más elementos. + +for i in ["azu1", "rojo", "verde"]: + print(i) +else: + print("El bucle ya no tiene más elementos") \ No newline at end of file diff --git a/Ejercicios de clase/175_loop_for.py b/Ejercicios de clase/175_loop_for.py new file mode 100644 index 0000000..a2602b6 --- /dev/null +++ b/Ejercicios de clase/175_loop_for.py @@ -0,0 +1,93 @@ +### +# 02 - Bucles (for) +# Permiten ejecutar un bloque de código repetidamente mientras ITERA un iterable o una lista +### + +from os import system +if system("clear") != 0: system("cls") + +print("\nBucle for:") + +# Iterar una lista +frutas = ["manzana", "pera", "mandarina"] +for fruta in frutas: + print(fruta) + +# Iterar sobre cualquier cosa que sea iterable +cadena = "midudev" +for caracter in cadena: + print(caracter) + +# enumerate() +frutas = ["manzana", "pera", "mandarina"] +for idx, value in enumerate(frutas): + print(f"El índice es {idx} y la fruta es {value}") + +# bucles anidados +letras = ["A", "B", "C"] +numeros = [1, 2, 3] + +for letra in letras: + for numero in numeros: + print(f"{letra}{numero}") + + +# break +print("\nbreak:") +animales = ["perro", "gato", "raton", "loro", "pez", "canario"] +for idx, animal in enumerate(animales): + print(animal) + if animal == "loro": + print(f"El loro está escondido en el índice {idx}") + break + +# continue +print("\ncontinue:") +animales = ["perro", "gato", "raton", "loro", "pez", "canario"] +for idx, animal in enumerate(animales): + if animal == "loro": continue + + print(animal) + +# Comprensión de listas (list comprehension) +animales = ["perro", "gato", "raton", "loro", "pez", "canario"] +animales_mayus = [animal.upper() for animal in animales] +print(animales_mayus) + +# Muestra los números pares de una lista +pares = [num for num in [1, 2, 3, 4, 5, 6] if num % 2 == 0] +print(pares) + +### +# EJERCICIOS (for) +### + +# Ejercicio 1: Imprimir números pares +# Imprime todos los números pares del 2 al 20 (inclusive) usando un bucle for. +print("\nEjercicio 1:") + +# Ejercicio 2: Calcular la media de una lista +# Dada la siguiente lista de números: +# numeros = [10, 20, 30, 40, 50] +# Calcula la media de los números usando un bucle for. +print("\nEjercicio 2:") + +# Ejercicio 3: Buscar el máximo de una lista +# Dada la siguiente lista de números: +# numeros = [15, 5, 25, 10, 20] +# Encuentra el número máximo en la lista usando un bucle for. +print("\nEjercicio 3:") + +# Ejercicio 4: Filtrar cadenas por longitud +# Dada la siguiente lista de palabras: +# palabras = ["casa", "arbol", "sol", "elefante", "luna"] +# Crea una nueva lista que contenga solo las palabras con más de 5 letras +# usando un bucle for y list comprehension. +print("\nEjercicio 4:") + +# Ejercicio 5: Contar palabras que empiezan con una letra +# Dada la siguiente lista de palabras: +# palabras = ["casa", "arbol", "sol", "elefante", "luna", "coche"] +# Pide al usuario que introduzca una letra. +# Cuenta cuántas palabras en la lista empiezan con esa letra (sin diferenciar mayúsculas/minúsculas). +print("\nEjercicio 5:") \ No newline at end of file diff --git a/Ejercicios de clase/180_Ejercicio_For_01.py b/Ejercicios de clase/180_Ejercicio_For_01.py new file mode 100644 index 0000000..483a095 --- /dev/null +++ b/Ejercicios de clase/180_Ejercicio_For_01.py @@ -0,0 +1,7 @@ + + +# Escribe un programa que imprima los números del 1 al 10 utilizando un bucle for. + + +for i in range(1, 11): + print(i) \ No newline at end of file diff --git a/Ejercicios de clase/185_Ejercicio_For_02.py b/Ejercicios de clase/185_Ejercicio_For_02.py new file mode 100644 index 0000000..748555a --- /dev/null +++ b/Ejercicios de clase/185_Ejercicio_For_02.py @@ -0,0 +1,10 @@ + + +# Escribe un programa que solicite al usuario un número entero positivo y luego +# imprima la tabla de multiplicar de ese número del 1 al 10. + + +numero = int(input("Introduce un número entero positivo: ")) + +for i in range(1, 11): + print(f"{numero} x {i} = {numero * i}") \ No newline at end of file diff --git a/Ejercicios de clase/190_Ejercicio_For_03.py b/Ejercicios de clase/190_Ejercicio_For_03.py new file mode 100644 index 0000000..d50d4f7 --- /dev/null +++ b/Ejercicios de clase/190_Ejercicio_For_03.py @@ -0,0 +1,18 @@ + + +# Escribe un programa que solicite al usuario una cadena de texto y luego imprima cada +# carácter de la cadena junto con su frecuencia (cuántas veces aparece en la cadena). +# Utiliza un diccionario para almacenar las frecuencias. + + +cadena = input("Introduce una cadena de texto: ") +frecuencias = {} + +for caracter in cadena: + if caracter in frecuencias: + frecuencias[caracter] += 1 + else: + frecuencias[caracter] = 1 + +for caracter, frecuencia in frecuencias.items(): + print(f"'{caracter}': {frecuencia} veces") \ No newline at end of file diff --git a/Ejercicios de clase/195_While.py b/Ejercicios de clase/195_While.py new file mode 100644 index 0000000..333e4ce --- /dev/null +++ b/Ejercicios de clase/195_While.py @@ -0,0 +1,58 @@ + + +# WHILE + +# Imprime edad cuando el contador llegue a 18 + +edad = 0 +while edad < 18: + edad=edad+1 +print("Tienes "+str(edad)) + +# Pregunta la edad mientras sea negativa + +edad=int(input("Introduce edad: ")) + +while edad<0: + print("Edad incorrecta") + edad=int(input("Introduce edad: ")) + +print("tu edad es: "+str(edad)) + +# Calcula la raiz cuadrada de un número. Tenemos tres intentos y el número no puede ser negativo. + +import math; +intentos=0; +num = int(input("Introduce numero: ")) + +while num<0: + intentos=intentos+1 + print("Incorrecto") + num=int(input("Introduce numero: ")) + + if intentos==2: + print("Demasiados intentos") + break; + +if intentos<2: + intentos=intentos+1 + solucion=math.sqrt(num) + print("la raiz cuadrada de "+str(num)+ " es: "+str(solucion)) + +# Bucle while con un if anidado y un break +# Salga del bucle cuando num sea 3: + +num = 1 +while num < 6: + print(num) + if num == 3: + break + num += 1 + + + + + + + + diff --git a/Ejercicios de clase/200_loop_while.py b/Ejercicios de clase/200_loop_while.py new file mode 100644 index 0000000..993a856 --- /dev/null +++ b/Ejercicios de clase/200_loop_while.py @@ -0,0 +1,113 @@ +### +# 01 - Bucles (while) +# Permiten ejecutar un bloque de código repetidamente mientras se cumpla una condición +### + +from os import system +if system("clear") != 0: system("cls") + +print("\n Bucle while:") + +# Bucle con una simple condición +contador = 0 + +while contador <= 5: + print(contador) + contador += 1 # es super importante para evitar un bucle infinito + +# utilizando la palabra break, para romper el bucle +print("\n Bucle while con break:") +contador = 0 + +while True: + print(contador) + contador += 1 + if contador == 5: + break # sale del bucle + +# continue, que lo hace es saltar esa iteración en concreto +# y continuar con el bucle +print("\n Bucle con continue") +contador = 0 +while contador < 10: + contador += 1 + + if contador % 2 == 0: + continue + + print(contador) + +# else, esta condición cuando se ejecuta? +print("\n Bucle while con else:") +contador = 0 +while contador < 5: + print(contador) + contador += 1 +else: + print("El bucle ha terminado") + +# else, esta condición cuando se ejecuta? +print("\n Bucle while con else:") +contador = 0 +while contador < 5: + print(contador) + contador += 1 +else: + print("El bucle ha terminado") + +# pedirle al usuario un número que tiene +# que ser positivo si no, no le dejamos en paz +numero = -1 +while numero < 0: + numero = int(input("Escribe un número positivo: ")) + if numero < 0: + print("El número debe ser positivo. Intenta otra vez, majo o maja.") + +print(f"El número que has introducido es {numero}") + +numero = -1 +while numero < 0: + try: + numero = int(input("Escribe un número positivo: ")) + if numero < 0: + print("El número debe ser positivo. Intenta otra vez, majo o maja.") + except: + print("Lo que introduces debe ser un número, que si no peta!") + +print(f"El número que has introducido es {numero}") + +### +# EJERCICIOS (while) +### + +# Ejercicio 1: Cuenta atrás +# Imprime los números del 10 al 1 usando un bucle while. +print("\nEjercicio 1:") + +# Ejercicio 2: Suma de números pares (while) +# Calcula la suma de los números pares entre 1 y 20 (inclusive) usando un bucle while. +print("\nEjercicio 2:") + +# Ejercicio 3: Factorial de un número +# Pide al usuario que introduzca un número entero positivo. +# Calcula su factorial usando un bucle while. +# El factorial de un número entero positivo es el producto de todos los números del 1 al ese número. Por ejemplo, el factorial de 5 +# 5! = 5 x 4 x 3 x 2 x 1 = 120. +print("\nEjercicio 3:") + +# Ejercicio 4: Validación de contraseña +# Pide al usuario que introduzca una contraseña. +# La contraseña debe tener al menos 8 caracteres. +# Usa un bucle while para seguir pidiendo la contraseña hasta que cumpla con los requisitos. +# Si la contraseña es válida, imprime "Contraseña válida". +print("\nEjercicio 4:") + +# Ejercicio 5: Tabla de multiplicar +# Pide al usuario que introduzca un número. +# Imprime la tabla de multiplicar de ese número (del 1 al 10) usando un bucle while. +print("\nEjercicio 5:") + +# Ejercicio 6: Números primos hasta N +# Pide al usuario que introduzca un número entero positivo N. +# Imprime todos los números primos menores o iguales que N usando un bucle while. +print("\nEjercicio 6:") \ No newline at end of file diff --git a/Ejercicios de clase/205_Match-case.py b/Ejercicios de clase/205_Match-case.py new file mode 100644 index 0000000..2655d1a --- /dev/null +++ b/Ejercicios de clase/205_Match-case.py @@ -0,0 +1,19 @@ + +# En Python, no existe una estructura de switch-case como en otros lenguajes de programación +# (por ejemplo, en C, Java o JavaScript). Sin embargo, a partir de Python 3.10, se introdujo +# una estructura similar llamada match-case, que permite realizar comparaciones de patrones +# de manera similar a un switch-case. + +def operacion(opcion): + match opcion: + case 1: + return "Opción 1 seleccionada" + case 2: + return "Opción 2 seleccionada" + case 3: + return "Opción 3 seleccionada" + case _: + return "Opción no válida" + +print(operacion(2)) # Salida: "Opción 2 seleccionada" +print(operacion(4)) # Salida: "Opción no válida" \ No newline at end of file diff --git a/Ejercicios de clase/210_Ejercicios_Bucles_1.py b/Ejercicios de clase/210_Ejercicios_Bucles_1.py new file mode 100644 index 0000000..1fafb09 --- /dev/null +++ b/Ejercicios de clase/210_Ejercicios_Bucles_1.py @@ -0,0 +1,13 @@ + + + +# Escribe un programa que sume todos los números enteros del 1 al 100 usando un bucle for. + +suma = 0 +for numero in range(1, 101, 2): + print(numero) + + + + + diff --git a/Ejercicios de clase/215_Ejercicios_Bucles_2.py b/Ejercicios de clase/215_Ejercicios_Bucles_2.py new file mode 100644 index 0000000..41dc75e --- /dev/null +++ b/Ejercicios de clase/215_Ejercicios_Bucles_2.py @@ -0,0 +1,15 @@ + + + +# Utiliza un bucle for para generar e imprimir la lista de los cuadrados +# de los primeros 10 números enteros (1 al 10). + +cuadrados = [] +for numero in range(1, 11): + cuadrados.append(numero ** 2) +print("Cuadrados de los números del 1 al 10:", cuadrados) + + + + + diff --git a/Ejercicios de clase/220_Ejercicios_Bucles_3.py b/Ejercicios de clase/220_Ejercicios_Bucles_3.py new file mode 100644 index 0000000..0ae1180 --- /dev/null +++ b/Ejercicios de clase/220_Ejercicios_Bucles_3.py @@ -0,0 +1,17 @@ + + + + +# Dado un string, utiliza un bucle for para contar cuántas veces aparece la +# letra 'a' en el string. + +texto = "banana" +contador = 0 +for caracter in texto: + if caracter == 'a': + contador += 1 +print(f"La letra 'a' aparece {contador} veces en la palabra {texto}.") + + + + diff --git a/Ejercicios de clase/225_Ejercicios_Bucles_4.py b/Ejercicios de clase/225_Ejercicios_Bucles_4.py new file mode 100644 index 0000000..32e418e --- /dev/null +++ b/Ejercicios de clase/225_Ejercicios_Bucles_4.py @@ -0,0 +1,15 @@ + + + + + +# Escribe un programa que imprima la tabla de multiplicar del número 7, +# desde el 7x1 hasta el 7x10, usando un bucle for. + +numero = 7 +for i in range(1, 11): + resultado = numero * i + print(f"{numero} x {i} = {resultado}") + + + diff --git a/Ejercicios de clase/230_Ejercicios_Bucles_5.py b/Ejercicios de clase/230_Ejercicios_Bucles_5.py new file mode 100644 index 0000000..a510dc3 --- /dev/null +++ b/Ejercicios de clase/230_Ejercicios_Bucles_5.py @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/Ejercicios de clase/235_Ejercicios_Bucles_6.py b/Ejercicios de clase/235_Ejercicios_Bucles_6.py new file mode 100644 index 0000000..7c16f11 --- /dev/null +++ b/Ejercicios de clase/235_Ejercicios_Bucles_6.py @@ -0,0 +1,14 @@ + + +# Escribe un script que cuente desde 1 hasta un número n proporcionado por +# el usuario, imprimiendo cada número. + + +n = int(input("Introduce un número hasta el que contar: ")) +contador = 1 +while True: + print(contador) + contador += 1 + + + diff --git a/Ejercicios de clase/236_challenge_fantastic_four.py b/Ejercicios de clase/236_challenge_fantastic_four.py new file mode 100644 index 0000000..40fff32 --- /dev/null +++ b/Ejercicios de clase/236_challenge_fantastic_four.py @@ -0,0 +1,42 @@ +""" +¿Está en Equilibrio la Alianza entre Reed Richards y Johnny Storm? + +En el universo de los 4 Fantásticos, la unión y el equilibrio entre los poderes es fundamental para enfrentar cualquier desafío. En este problema, nos centraremos en dos de sus miembros: + +Reed Richards (Mr. Fantastic), representado por la letra R. +Johnny Storm (La Antorcha Humana), representado por la letra J. + +Objetivo: + +Crea una función en Python que reciba una cadena de texto. Esta función debe contar cuántas veces aparece la letra R (para Reed Richards) y cuántas veces aparece la letra J (para Johnny Storm) en la cadena. + +- Si la cantidad de R y la cantidad de J son iguales, se considera que la alianza entre la mente y el fuego está en equilibrio y la función debe retornar True. +- Si las cantidades no son iguales, la función debe retornar False. +- En el caso de que no aparezca ninguna de las dos letras en la cadena, se entiende que el equilibrio se mantiene (0 = 0), por lo que la función debe retornar True. +""" + +from os import system +if system("clear") != 0: system("cls") + +text = "RRRRJJJjjjrrr" + +def check_is_balanced(text): + text = text.upper() + + # contar facilmente el número de veces que aparece una letra + count_r = text.count("R") # Reed Richards + count_j = text.count("J") # Johnny Storm + + print(f"count_r: {count_r} count_j: {count_j}") + + # if count_r == count_j: + # return True + # else: + # return False + + return count_r == count_j + +print(check_is_balanced("RRJJ")) +print(check_is_balanced("RRRRJJ")) +print(check_is_balanced("RRJJJJJJ")) +print(check_is_balanced("awwwaqAQAQA")) \ No newline at end of file diff --git a/Ejercicios de clase/240_Ejercicios_Bucles_7.py b/Ejercicios de clase/240_Ejercicios_Bucles_7.py new file mode 100644 index 0000000..5c53fab --- /dev/null +++ b/Ejercicios de clase/240_Ejercicios_Bucles_7.py @@ -0,0 +1,19 @@ + + + +# Creeros intra un programa que sume númoducidos por el usuario hasta que el +# usuario introduzca 0. Al final, el programa debe mostrar la suma total. + +suma = 0 +numero = int(input("Introduce un número (0 para terminar): ")) + +while numero != 0: + suma += numero + numero = int(input("Introduce otro número (0 para terminar): ")) + +print("La suma total es:", suma) + + + + + diff --git a/Ejercicios de clase/245_Ejercicios_Bucles_8.py b/Ejercicios de clase/245_Ejercicios_Bucles_8.py new file mode 100644 index 0000000..0faa15d --- /dev/null +++ b/Ejercicios de clase/245_Ejercicios_Bucles_8.py @@ -0,0 +1,16 @@ + + + +# Implementa un programa que le pida al usuario introducir números hasta que +# introduzca el número 5. Cuando eso ocurra, el programa debe imprimir un +# mensaje indicando que se encontró el número 5 + +numero = int(input("Introduce un número (5 para detener): ")) +while numero != 5: + numero = int(input("Introduce un número (5 para detener): ")) +print("¡Número 5 encontrado!") + + + + + diff --git a/Ejercicios de clase/250_Ejercicios_Bucles_9.py b/Ejercicios de clase/250_Ejercicios_Bucles_9.py new file mode 100644 index 0000000..353e3bc --- /dev/null +++ b/Ejercicios de clase/250_Ejercicios_Bucles_9.py @@ -0,0 +1,17 @@ + + + + + +# Escribe un script que solicite al usuario su edad y asegúrate de que el +# número proporcionado esté entre 1 y 100. Si el número está fuera de ese rango, +# pídele que lo introduzca nuevamente. + +edad = int(input("Introduce tu edad (entre 1 y 100): ")) +while edad < 1 or edad > 100: + print("Error: la edad debe estar entre 1 y 100.") + edad = int(input("Introduce tu edad nuevamente: ")) +print("Edad válida introducida:", edad) + + + diff --git a/Ejercicios de clase/255_Ejercicios_Bucles_10_break.py b/Ejercicios de clase/255_Ejercicios_Bucles_10_break.py new file mode 100644 index 0000000..819b479 --- /dev/null +++ b/Ejercicios de clase/255_Ejercicios_Bucles_10_break.py @@ -0,0 +1,22 @@ + + + + + +# Escribe un programa que pida al usuario que ingrese números. +# El programa debe seguir pidiendo números hasta que el usuario ingrese el número 0. +# En ese momento, el programa debe detenerse y mostrar la suma de todos los números ingresados. + + +suma = 0 + +while True: + numero = int(input("Introduce un número (0 para terminar): ")) + if numero == 0: + break # Salir del bucle si el número es 0 + suma += numero + +print(f"La suma de todos los números ingresados es: {suma}") + + + diff --git a/Ejercicios de clase/260_Ejercicios_Bucles_10_continue.py b/Ejercicios de clase/260_Ejercicios_Bucles_10_continue.py new file mode 100644 index 0000000..61c9449 --- /dev/null +++ b/Ejercicios de clase/260_Ejercicios_Bucles_10_continue.py @@ -0,0 +1,26 @@ + + + + + +# Escribe un programa que pida al usuario que ingrese números. +# Si el número ingresado es negativo, el programa debe ignorarlo y pedir otro número. +# Si el número es positivo, el programa debe sumarlo. +# El programa debe detenerse cuando el usuario ingrese 0 y mostrar la suma de todos +# los números positivos ingresados. + +suma = 0 + +while True: + numero = int(input("Introduce un número (0 para terminar): ")) + if numero == 0: + break # Salir del bucle si el número es 0 + if numero < 0: + print("Número negativo ignorado.") + continue # Saltar a la siguiente iteración si el número es negativo + suma += numero + +print(f"La suma de todos los números positivos ingresados es: {suma}") + + + diff --git a/Ejercicios de clase/265_range.py b/Ejercicios de clase/265_range.py new file mode 100644 index 0000000..a096207 --- /dev/null +++ b/Ejercicios de clase/265_range.py @@ -0,0 +1,67 @@ +### +# 03 - range() +# Permite crear una secuencia de números. Puede ser útil para for, pero no solo para eso +### + +from os import system +if system("clear") != 0: system("cls") + +print("\nrange():") + +# Generado una secuencia de números del 0 al 9 +for num in range(10): + print(num) + +# range(inicio, fin) +for num in range(5, 10): + print(num) + +# range(inicio, fin, paso) +for num in range(0, 1000, 5): + print(num) + +for num in range(-5, 0): + print(num) + +for num in range(10, 0, -1): + print(num) + +for num in range(0, 444): + print(num) + +nums = range(10) +list_of_nums = list(nums) +print(list_of_nums) + +# seria para hacerlo cinco veces +for _ in range(5): + print("hacer cinco veces algo") + +### +# EJERCICIOS (range) +### + +# Ejercicio 1: Imprimir números del 1 al 10 +# Imprime los números del 1 al 10 (inclusive) usando un bucle for y range(). +print("\nEjercicio 1:") + +# Ejercicio 2: Imprimir números impares del 1 al 20 +# Imprime todos los números impares entre 1 y 20 (inclusive) usando un bucle for y range(). +print("\nEjercicio 2:") + +# Ejercicio 3: Imprimir múltiplos de 5 +# Imprime los múltiplos de 5 desde 5 hasta 50 (inclusive) usando un bucle for y range(). +print("\nEjercicio 3:") + +# Ejercicio 4: Imprimir números en orden inverso +# Imprime los números del 10 al 1 (inclusive) en orden inverso usando un bucle for y range(). +print("\nEjercicio 4:") + +# Ejercicio 5: Suma de números en un rango +# Calcula la suma de los números del 1 al 100 (inclusive) usando un bucle for y range(). +print("\nEjercicio 5:") + +# Ejercicio 6: Tabla de multiplicar +# Pide al usuario que introduzca un número. +# Imprime la tabla de multiplicar de ese número (del 1 al 10) usando un bucle for y range(). +print("\nEjercicio 6:") \ No newline at end of file diff --git a/Ejercicios de clase/270_Listas.py b/Ejercicios de clase/270_Listas.py new file mode 100644 index 0000000..2e51a5a --- /dev/null +++ b/Ejercicios de clase/270_Listas.py @@ -0,0 +1,37 @@ + + +# LISTAS + +""" +La lista es un tipo de colección ordenada y modificable. +Es decir, una secuencia de valores de cualquier tipo, ordenados y de tamaño variable. +Se escriben entre corchetes. [] +""" + +miLista=["Angel", 43, 667767250] +miLista2 = [22, True, "una lista", [1, 2]] + +# MÉTODOS DE LAS LISTAS + +# Hacer una lista de una cadena +miLista = list("PYTHON") +print(miLista) + +# Acceder a los elementos de una lista +miLista = [22, True, "una cadena", [1, 2]] +print(miLista[0]) + +miLista = [[1,2] , [3,4] , [5,6]] +miVar = miLista[1,1] +print(miVar) + +# Función con una lista como parámetro + +def miFunccion(listaFrutas): + for x in listaFrutas: + print(x) + +frutas = ["Manzana", "banana", "cereza"] + +miFunccion(frutas) + diff --git a/Ejercicios de clase/275_list.py b/Ejercicios de clase/275_list.py new file mode 100644 index 0000000..02ddb17 --- /dev/null +++ b/Ejercicios de clase/275_list.py @@ -0,0 +1,99 @@ +### +# 03 - Listas +# Secuencias mutables de elementos. +# Pueden contener elementos de diferentes tipos. +### + +from os import system +if system("clear") != 0: system("cls") + +# Creación de listas +print("\nCrear listas") +lista1 = [1, 2, 3, 4, 5] # lista de enteros +lista2 = ["manzanas", "peras", "plátanos"] # lista de cadenas +lista3 = [1, "hola", 3.14, True] # lista de tipos mixtos + +lista_vacia = [] +lista_de_listas = [[1, 2], ['calcetin', 4]] +matrix = [[1, 2], [2, 3], [4, 5]] + +print(lista1) +print(lista2) +print(lista3) +print(lista_vacia) +print(lista_de_listas) +print(matrix) + +# Acceso a elementos por índice +print("\nAcceso a elementos por índice") +print(lista2[0]) # manzanas +print(lista2[1]) # peras +print(lista2[-1]) # plátanos +print(lista2[-2]) # peras + +print(lista_de_listas[1][0]) + +# Slicing (rebanado) de listas +lista1 = [1, 2, 3, 4, 5] +print(lista1[1:4]) # [2, 3, 4] +print(lista1[:3]) # [1, 2, 3] +print(lista1[3:]) # [4, 5] +print(lista1[:]) # [1, 2, 3, 4, 5] + +# El tercer parámetro es el paso (step) +lista1 = [1, 2, 3, 4, 5, 6, 7, 8] +print(lista1[::2]) # para devolver índices pares +print(lista1[::-1]) # para devolver índices inversos + +# Modificar una lista +lista1[0] = 20 +print(lista1) + +# Añadir elementos a una lista +lista1 = [1, 2, 3] + +# forma larga y menos eficiente +lista1 = lista1 + [4, 5, 6] +print(lista1) + +# forma corta y más eficiente +lista1 += [7, 8, 9] +print(lista1) + +# Recuperar longitud de una lista +print("Longitud de la lista", len(lista1)) + +### +# EJERCICIOS +### + +# Ejercicio 1: El mensaje secreto +# Dada la siguiente lista: +# mensaje = ["C", "o", "d", "i", "g", "o", " ", "s", "e", "c", "r", "e", "t", "o"] +# Utilizando slicing y concatenación, crea una nueva lista que contenga solo el mensaje "secreto". + +# Ejercicio 2: Intercambio de posiciones +# Dada la siguiente lista: +# numeros = [10, 20, 30, 40, 50] +# Intercambia la primera y la última posición utilizando solo asignación por índice. + +# Ejercicio 3: El sándwich de listas +# Dadas las siguientes listas: +# pan = ["pan arriba"] +# ingredientes = ["jamón", "queso", "tomate"] +# pan_abajo = ["pan abajo"] +# Crea una lista llamada sandwich que contenga el pan de arriba, los ingredientes y el pan de abajo, en ese orden. + +# Ejercicio 4: Duplicando la lista +# Dada una lista: +# lista = [1, 2, 3] +# Crea una nueva lista que contenga los elementos de la lista original duplicados. +# Ejemplo: [1, 2, 3] -> [1, 2, 3, 1, 2, 3] + +# Ejercicio 5: Extrayendo el centro +# Dada una lista con un número impar de elementos, extrae el elemento que se encuentra en el centro de la lista utilizando slicing. +# Ejemplo: lista = [10, 20, 30, 40, 50] -> El centro es 30 + +# Ejercicio 6: Reversa parcial +# Dada una lista, invierte solo la primera mitad de la lista (utilizando slicing y concatenación). +# Ejemplo: lista = [1, 2, 3, 4, 5, 6] -> Resultado: [3, 2, 1, 4, 5, 6] diff --git a/Ejercicios de clase/280_list_methods.py b/Ejercicios de clase/280_list_methods.py new file mode 100644 index 0000000..541ae11 --- /dev/null +++ b/Ejercicios de clase/280_list_methods.py @@ -0,0 +1,114 @@ +### +# 04 - Listas Métodos +# Los métodos más importantes para trabajar con listas +### + +from os import system +if system("clear") != 0: system("cls") + +# Creamos una lista con valores +lista1 = ['a', 'b', 'c', 'd'] + +# Añadir o insertar elementos a la lista +lista1.append('e') # Añade un elemento al final +print(lista1) + +lista1.insert(1, '@') # Inserta un elemento en la posición que le indiquemos como primer argumento +print(lista1) + +lista1.extend(['😃', '😍']) # Agrega elementos al final de la lista +print(lista1) + +# Eliminar elementos de la lista +lista1.remove('@') # Eliminar la primera aparición de la cadena de texto @ +print(lista1) + +ultimo = lista1.pop() # Eliminar el último elemento de la lista y además te lo devuelve +print(ultimo) +print(lista1) + +lista1.pop(1) # Eliminar el segundo elemento de la lista (es el índice 1) +print(lista1) + +# Eliminar por lo bestia un índice +del lista1[-1] +print(lista1) + +lista1.clear() # Eliminar todos los elementos de la lista +print(lista1) + +# Eliminar un rango de elementos +lista1 = ['🐼', '🐨', '🐶', '😿', '🐹'] +del lista1[1:3] # eliminamos los elementos del índice 1 al 3 (no incluye el índice 3) +print(lista1) + +# Más métodos útiles +print('Ordenar listas modificando la original') +numbers = [3, 10, 2, 8, 99, 101] +numbers.sort() +print(numbers) + +print('Ordenar listas creando una nueva lista') +numbers = [3, 10, 2, 8, 99, 101] +sorted_numbers = sorted(numbers) +print(sorted_numbers) + +print("Ordenar una lista de cadenas de texto (todo minúscula)") +frutas = ['manzana', 'pera', 'limón', 'manzana', 'pera', 'limón'] +sorted_frutas = sorted(frutas) +print(sorted_frutas) + +print("Ordenar una lista de cadenas de texto (mezclas mayúscula y minúscula)") +frutas = ['manzana', 'Pera', 'Limón', 'manzana', 'pera', 'limón'] +frutas.sort(key=str.lower) +print(frutas) + +# Más cositas útiles +animals = ['🐶', '🐼', '🐨', '🐶'] +print(len(animals)) # Tamaño de la listas -> 4 +print(animals.count('🐶')) # Cuantas veces aparece el elemento '🐶' -> 2 +print('🐼' in animals) # Comprueba si hay un '🐼' en la lista -> True +print('🐹' in animals) # -> False + +### +# EJERCICIOS +# Usa siempre que puedas los métodos que has aprendido +### + +# Ejercicio 1: Añadir y modificar elementos +# Crea una lista con los números del 1 al 5. +# Añade el número 6 al final usando append(). +# Inserta el número 10 en la posición 2 usando insert(). +# Modifica el primer elemento de la lista para que sea 0. + +# Ejercicio 2: Combinar y limpiar listas +# Crea dos listas: +# lista_a = [1, 2, 3] +# lista_b = [4, 5, 6, 1, 2] +# Extiende lista_a con lista_b usando extend(). +# Elimina la primera aparición del número 1 en lista_a usando remove(). +# Elimina el elemento en el índice 3 de lista_a usando pop(). Imprime el elemento eliminado. +# Limpia completamente lista_b usando clear(). + +# Ejercicio 3: Slicing y eliminación con del +# Crea una lista con los números del 1 al 10. +# Utiliza slicing y del para eliminar los elementos desde el índice 2 hasta el 5 (sin incluir el 5). +# Imprime la lista resultante. + +# Ejercicio 4: Ordenar y contar +# Crea una lista con los siguientes números: [5, 2, 8, 1, 9, 4, 2]. +# Ordena la lista de forma ascendente usando sort(). +# Cuenta cuántas veces aparece el número 2 en la lista usando count(). +# Comprueba si el número 7 está en la lista usando in. + +# Ejercicio 5: Copia vs. Referencia +# Crea una lista llamada original con los números [1, 2, 3]. +# Crea una copia de la lista original llamada copia_1 usando slicing. +# Crea otra copia llamada copia_2 usando copy(). +# Crea una referencia a la lista original llamada referencia. +# Modifica el primer elemento de la lista referencia a 10. +# Imprime las cuatro listas (original, copia_1, copia_2, referencia) y observa los cambios. + +# Ejercicio 6: Ordenar strings sin diferenciar mayúsculas y minúsculas. +# Crea una lista con las siguientes cadenas: ["Manzana", "pera", "BANANA", "naranja"]. +# Ordena la lista sin diferenciar entre mayúsculas y minúsculas. \ No newline at end of file diff --git a/Ejercicios de clase/281_list_comprehensions.py b/Ejercicios de clase/281_list_comprehensions.py new file mode 100644 index 0000000..d985a57 --- /dev/null +++ b/Ejercicios de clase/281_list_comprehensions.py @@ -0,0 +1,80 @@ +### +# Comprensión de Listas +### + +# Es una forma concisa de crear listas a partir de otras listas, rangos, +# o cualquier iterable, usando una sintaxis parecida a una expresión matemática. + +# Sintaxis básica + +# [expresión for variable in iterable] + +# Ejemplo básico: +# Crear una lista con los cuadrados de los números del 0 al 9 +# Sin comprensión de listas: + +cuadrados = [] + +for x in range(1, 6): + cuadrados.append(x**2) + +print(cuadrados) # → [1, 4, 9, 16, 25] + +# Con comprensión de listas: +cuadrados = [x**2 for x in range(10)] +print(cuadrados) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] + +# Listas por comprensión con condición +# Puedes agregar una condición para filtrar elementos: +# [expresion for elemento in iterable if condicion] + +# Ejemplo con condición: +# Cuadrados de solo los números pares del 0 al 9 + +cuadrados_pares = [x**2 for x in range(10) if x % 2 == 0] +print(cuadrados_pares) # [0, 4, 16, 36, 64] + +# Listas por comprensión con condición else +# Cuando necesitas un else, la sintaxis cambia: +# [expresion_if if condicion else expresion_else for elemento in iterable] + +# Ejemplo con if-else: +# Clasificar números como "par" o "impar" + +clasificacion = ["par" if x % 2 == 0 else "impar" for x in range(5)] +print(clasificacion) # ['par', 'impar', 'par', 'impar', 'par'] + +# Listas por comprensión anidadas +# Puedes anidar múltiples bucles for: + +# Ejemplo de anidamiento: +# Producto cartesiano de dos listas + +colores = ['rojo', 'verde'] +tallas = ['S', 'M', 'L'] +combinaciones = [(color, talla) for color in colores for talla in tallas] +print(combinaciones) +# [('rojo', 'S'), ('rojo', 'M'), ('rojo', 'L'), +# ('verde', 'S'), ('verde', 'M'), ('verde', 'L')] + +# Ejemplos avanzados +# 1. Aplanar una matriz: +matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] +plana = [num for fila in matriz for num in fila] +print(plana) # [1, 2, 3, 4, 5, 6, 7, 8, 9] + +# 2. Extraer vocales de una cadena: +cadena = "Listas por Comprensión en Python" +vocales = [c for c in cadena.lower() if c in 'aeiouáéíóú'] +print(vocales) # ['i', 'a', 'o', 'o', 'e', 'ió', 'e', 'o'] + +# 3. Convertir temperaturas: +celsius = [0, 10, 20, 30, 40] +fahrenheit = [(temp * 9/5) + 32 for temp in celsius] +print(fahrenheit) # [32.0, 50.0, 68.0, 86.0, 104.0] + +# 4. Lista de listas por comprensión: +# Crear una matriz 3x3 con ceros excepto en la diagonal +matriz_identidad = [[1 if i == j else 0 for j in range(3)] for i in range(3)] +print(matriz_identidad) +# [[1, 0, 0], [0, 1, 0], [0, 0, 1]] diff --git a/Ejercicios de clase/285_Tuplas.py b/Ejercicios de clase/285_Tuplas.py new file mode 100644 index 0000000..ba3ea4e --- /dev/null +++ b/Ejercicios de clase/285_Tuplas.py @@ -0,0 +1,93 @@ + + + +# TUPLAS + +"""Una tupla es una colección ordenada e inmutable. +En Python, las tuplas se escriben entre paréntesis. +""" + +# Declaración de una tupla + +miTupla = ("manzana", "banana", "cereza") +print(miTupla[1]) + +# Otra forma de declararla + +miTupla = tuple(("manzana", "banana", "cereza")) +print(miTupla) + + +# Indexación Negativa + +miTupla = ("manzana", "banana", "cereza") +print(miTupla[-1]) + +# Rango de índices +# Devuelve el tercer, cuarto y quinto elemento: + +miTupla = ("manzana", "banana", "cereza", "naranja", "kiwi", "melon", "mango") +print(miTupla[2:5]) + +# Convierta la tupla en una lista para poder cambiarla: + +miTupla = ("manzana", "banana", "cereza") +miLista = list(miTupla) +miLista[1] = "kiwi" +miTupla = tuple(miLista) + +print(miTupla) + +# Recorrer una tupla + +miTupla = ("manzana", "banana", "cereza") +for x in miTupla: + print(x) + +# Comprobar si existe un elemento +# Compruebe si "manzana" está presente en la tupla: + +miTupla = ("manzana", "banana", "cereza") +if "manzana" in miTupla: + print("Sí, 'manzana' está en la tupla.") + +# Otra forma, simplemente con un boolean + +print("manzana" in miTupla) + +# Longitud de la tupla + +miTupla = ("manzana", "banana", "cereza") +print(len(miTupla)) + + +# Unir dos tuplas + +tupla1 = ("a", "b" , "c") +tupla2 = (1, 2, 3) + +tupla3 = tupla1 + tupla2 +print(tupla3) + +# Cuantas veces se encuentra el elemento 4 en miTupla? + +miTupla = ("manzana", "banana", "cereza" , "manzana") +print(miTupla.count("manzana")) + +# Desempaquetdo de tupla + +miTupla=("Angel", 4, 5.345, True, 4) +nombre, num1, num2, valor1, num3=miTupla + +print(nombre) +print(num1) +print(num2) +print(valor1) +print(num3) + + + + + + + diff --git a/Ejercicios de clase/290_Diccionarios.py b/Ejercicios de clase/290_Diccionarios.py new file mode 100644 index 0000000..e3caa21 --- /dev/null +++ b/Ejercicios de clase/290_Diccionarios.py @@ -0,0 +1,176 @@ + + + +# DICCIONARIOS + +"""Los diccionarios, también llamados matrices asociativas, deben su nombre a que son +colecciones que relacionan una clave y un valor. +Un diccionario es una colección desordenada, modificable e indexada. +En Python, los diccionarios se escriben entre llaves y tienen claves y valores. +""" + +# Declaración de un diccionario + +miDiccionario = { + "brand": "Ford", + "model": "Mustang", + "year": 1964 +} +print(miDiccionario) + + +# A los valores almacenados en un diccionario se accede por su clave + +peliculas = {"Love Actually": "Richard Curtis", +"Kill Bill": "Tarantino", +"Amélie": "Jean-Pierre Jeunet"} + +peliculas["Love Actually"] + +# Reasignar valores a un diccionario + +peliculas["Kill Bill"] = "Quentin Tarantino" +print(peliculas) + +# Usar una tupla dentro de un diccionario: + +miDiccionario3={"nombre":"Jordan", "Equipo":"Bulls", "Anillos":[1991, 1992, 1993, 1996, 1997, 1998]} +print(miDiccionario3["Anillos"]) + +# Quitar valores de un diccionario + +peliculas = {"Love Actually": "Richard Curtis", +"Kill Bill": "Tarantino", +"Amélie": "Jean-Pierre Jeunet"} + +peliculas.pop("Love Actually") + +print(peliculas) + +# Crear un diccionario a partir de dos listas: + +lista_claves=["nombre", "edad"] +lista_valores=["Angel", 43] +diccionario = dict(zip(lista_claves , lista_valores)) +print(diccionario) + +# Para comprobar si una clave está en el diccionario: + +"nombre" in diccionario #Devuelve true o false + + +# Imprima las claves del diccionario: + +peliculas = {"Love Actually": "Richard Curtis", +"Kill Bill": "Tarantino", +"Amélie": "Jean-Pierre Jeunet"} +for x in peliculas: + print(peliculas[x]) + +# Longitud de un diccionario: + +peliculas = {"Love Actually": "Richard Curtis", +"Kill Bill": "Tarantino", +"Amélie": "Jean-Pierre Jeunet"} + +print(len(peliculas)) + +# Agregar elementos a un diccionario: + +miDiccionario = { + "brand": "Ford", + "model": "Mustang", + "year": 1964 +} +miDiccionario["color"] = "red" +print(miDiccionario) + +# Eliminar el último elemento insertado: + +miDiccionario = { + "brand": "Ford", + "model": "Mustang", + "year": 1964 +} +miDiccionario.popitem() +print(miDiccionario) + + +# La palabra clave del elimina el elemento con el nombre de clave especificado: + +miDiccionario = { + "brand": "Ford", + "model": "Mustang", + "year": 1964 +} +del miDiccionario["model"] +print(miDiccionario) + + +# La palabra clave del también puede eliminar completamente el diccionario: + +miDiccionario = { + "brand": "Ford", + "model": "Mustang", + "year": 1964 +} +del miDiccionario +print(miDiccionario) + +# La palabra clave clear() vacía el diccionario: + +miDiccionario = { + "brand": "Ford", + "model": "Mustang", + "year": 1964 +} +miDiccionario.clear() +print(miDiccionario) + + + +# Copiar un diccionario + +miDiccionario = { + "brand": "Ford", + "model": "Mustang", + "year": 1964 +} +midict = miDiccionario.copy() +print(midict) + + +# Otra forma de copiar un diccionario + +miDiccionario = { + "brand": "Ford", + "model": "Mustang", + "year": 1964 +} +midict = dict(miDiccionario) +print(midict) + +# Diccionarios anidados + +child1 = { + "name" : "Emil", + "year" : 2004 +} +child2 = { + "name" : "Tobias", + "year" : 2007 +} +child3 = { + "name" : "Linus", + "year" : 2011 +} + +myfamily = { + "child1" : child1, + "child2" : child2, + "child3" : child3 +} + +print(myfamily["child1"]) + + diff --git a/Ejercicios de clase/295_Sets.py b/Ejercicios de clase/295_Sets.py new file mode 100644 index 0000000..5a6981a --- /dev/null +++ b/Ejercicios de clase/295_Sets.py @@ -0,0 +1,163 @@ + + + +# SETs, conjuntos + +""" +Un conjunto es una colección de elementos únicos que no está ordenada ni indexada, +por lo que no puede estar seguro de en qué orden aparecerán los elementos. +En Python, los conjuntos se escriben entre llaves. +Una vez que se crea un conjunto, no puede cambiar sus elementos, pero puede agregar nuevos elementos. +""" + +# Declaración: + +mi_conjunto = {"Angel", "Sara", "Pilar"} +mi_conjunto2 = {"Angel", "Manolo", "Juan"} + +# Otra forma de declararlo + +mi_conjunto3 = set(("Angel", "Sara", "Pilar")) +print(mi_conjunto3) + + +# Para añadir un nuevo elemento: + +mi_conjunto.add("Antonio") + +# Para añadir varios elementos: + +mi_conjunto.update({"Fran", "María"}) + +# Unión de colecciones. Si hay algún valor repetido sólo aparecerá una vez. + +union= mi_conjunto | mi_conjunto2 + +# Intersección de conjuntos: + +interseccion= mi_conjunto & mi_conjunto2 + +# Nos crea otro conjunto con los valores que estaban duplicados en ambos conjuntos. +# En nuestro caso sólo Angel. + +# Diferencia de conjuntos. Nos crea otro conjunto con los elementos que no están duplicados. + +diferencia= mi_conjunto - mi_conjunto2 + +# Para comprobar si un elemento está en un conjunto: + +"Angel" in mi_conjunto # Devuelve true o false + +# Recorra el conjunto e imprima los valores: + +miSet = {"manzana", "banana", "cereza"} + +for x in miSet: + print(x) + +""" +No puede acceder a los elementos de un conjunto haciendo referencia a un índice, +ya que los conjuntos no están ordenados, los elementos no tienen índice. +""" + +# Obtenga la cantidad de elementos en un conjunto: + +miSet = {"manzana", "banana", "cereza"} + +print(len(miSet)) + +# Elimine "banana" utilizando el método remove() : + +miSet = {"manzana", "banana", "cereza"} + +miSet.remove("banana") + +print(miSet) + +# Elimine "banana" utilizando el método discard() : + +miSet = {"manzana", "banana", "cereza"} + +miSet.discard("banana") + +print(miSet) + +""" +Si el elemento a eliminar no existe, remove() generará un error. +Si el elemento a eliminar no existe, discard() NO generará un error. +""" + +# Elimine el último elemento utilizando el método pop() : +"""También puede usar el método pop() para eliminar un elemento, +pero este método eliminará el último elemento. +Recuerde que los conjuntos no están ordenados, +por lo que no sabrá qué elemento se elimina. +""" + +miSet = {"manzana", "banana", "cereza", "cereza"} +print(miSet) + +x = miSet.pop() + +print(x) + +print(miSet) + +# El método clear() vacía el conjunto: + +miSet = {"manzana", "banana", "cereza"} + +miSet.clear() + +print(miSet) + +# La palabra clave del borrará completamente el conjunto: + +miSet = {"manzana", "banana", "cereza"} + +del miSet + +print(miSet) + +# Unión de conjuntos +# El método union() devuelve un nuevo conjunto con todos los elementos de ambos conjuntos: + +set1 = {"a", "b" , "c"} +set2 = {1, 2, 3} + +set3 = set1.union(set2) +print(set3) + +# El método update() inserta los elementos en set2 en set1: + +set1 = {"a", "b" , "c"} +set2 = {1, 2, 3} + +set1.update(set2) +print(set1) + +# Tanto union() como update() excluirán cualquier elemento duplicado. + + +# Uso de SET para eliminar elementos duplicados de un ARRAY: +# Array con elementos duplicados +array_con_duplicados = [1, 2, 2, 3, 4, 4, 5, 6, 6] + +# Convertir el array en un set para eliminar duplicados +array_sin_duplicados = list(set(array_con_duplicados)) + +print("Array original:", array_con_duplicados) +print("Array sin duplicados:", array_sin_duplicados) + + + + + + + + + + + + + diff --git a/Ejercicios de clase/296_Funcion_ZIP.py b/Ejercicios de clase/296_Funcion_ZIP.py new file mode 100644 index 0000000..a939507 --- /dev/null +++ b/Ejercicios de clase/296_Funcion_ZIP.py @@ -0,0 +1,80 @@ + + + +# zip() toma dos o más iterables (listas, tuplas, strings, etc.) y los +# combina elemento a elemento, devolviendo un iterador de tuplas. + +# 📌 Sintaxis + +# zip(iterable1, iterable2, ...) + +✅ Ejemplo básico + +nombres = ["Ana", "Luis", "Carlos"] +edades = [30, 25, 40] + +combinado = zip(nombres, edades) + +print(list(combinado)) +# → [('Ana', 30), ('Luis', 25), ('Carlos', 40)] + +# 🧪 ¿Qué pasa si las listas tienen distinto tamaño? + +nombres = ["Ana", "Luis"] +edades = [30, 25, 40] # una edad extra + +print(list(zip(nombres, edades))) +# → [('Ana', 30), ('Luis', 25)] + +# 👉 zip() se detiene cuando la lista más corta termina + +# 🛠️ Usos típicos de zip() +# 1. Recorrer dos listas a la vez + +for nombre, edad in zip(nombres, edades): + print(f"{nombre} tiene {edad} años") + +# 2. Crear un diccionario desde dos listas + +keys = ["nombre", "edad", "ciudad"] +values = ["Ángel", 32, "Málaga"] + +diccionario = dict(zip(keys, values)) +print(diccionario) +# → {'nombre': 'Ángel', 'edad': 32, 'ciudad': 'Málaga'} + +# 3. Desempaquetar (unzip) una lista de tuplas + +pares = [("a", 1), ("b", 2), ("c", 3)] + +letras, numeros = zip(*pares) + +print(letras) # → ('a', 'b', 'c') +print(numeros) # → (1, 2, 3) + +# 🧠 El * sirve para "desempaquetar" listas o tuplas. + +# 4. Sumar elementos de dos listas + +a = [1, 2, 3] +b = [4, 5, 6] + +suma = [x + y for x, y in zip(a, b)] +print(suma) # → [5, 7, 9] + +# 5. Juntar tres listas + +nombres = ["Ana", "Luis", "Carlos"] +edades = [30, 25, 40] +ciudades = ["Madrid", "Sevilla", "Málaga"] + +for nombre, edad, ciudad in zip(nombres, edades, ciudades): + print(f"{nombre}, {edad} años, vive en {ciudad}") + +# 🧠 zip() devuelve un iterador, no una lista +# Eso significa que si haces: + +z = zip([1, 2], [3, 4]) +print(z) # → + +# Tienes que convertirlo con list() o recorrerlo con un bucle para ver su contenido. \ No newline at end of file diff --git a/Ejercicios de clase/300_funciones.py b/Ejercicios de clase/300_funciones.py new file mode 100644 index 0000000..9885bc1 --- /dev/null +++ b/Ejercicios de clase/300_funciones.py @@ -0,0 +1,401 @@ + +# ------------------------------------- +# FUNCIONES +# ------------------------------------- + +# Definición de una función. Importante la identación: +def my_funcion(): + print("Estamos ejecutando la función.") + +# Llamada a la función. En otra parte de mi código, llamamos a la función para que se ejecute: + +my_funcion() + +# ------------------------------------- + + +def suma(): + num1 = 3 + num2 = 5 + print("suma =", num1+num2) + +suma() + +# Otra opción: +def suma(): + num1 = 3 + num2 = 5 + resultado = num1 + num2 + return resultado + + + + +print(suma()) + +# ------------------------------------- +#El bloque de código que ejecutará la función incluye todas las declaraciones con indentación +# dentro de la función. + +def miFunción(): + print('this will print') + print('so will this') + +x = 7 +# la asignación de x no es parte de la función ya que no está indentada + +#--------------------------------------- +#Las variables definidas dentro de una función solo existen dentro del ámbito de esa función. + + +def duplica(num): + x = num * 2 + return x + +print(x) # error - x no está definida +print(duplica(4)) # muestra 8 + +#--------------------------------------- + +#Si la definición de una función incluye parámetros, debe proporcionar el mismo número +# de parámetros cuando llame a la función. +def multiplica(arg1, arg2): + return arg1 * arg2 + +#print(multiplica(3)) # TypeError: multiplica() utiliza exactamente 2 argumentos (0 proporcionados) + +print(multiplica('a', 5)) # 'aaaaa' mostrado en la consola + +#print(multiplica('a', 'b')) # TypeError: Python no puede multiplicar dos strings + +#--------------------------------------- +#Puedes pasar los parámetros en el orden que desees, utilizando el nombre del parámetro. +def suma(a, b): + return a + b + +result = suma(b=2, a=3) +print(result) +# result = 4 + +#--------------------------------------- + +#También podríamos pasar varios valores que retornar a return. +def f(x, y): + return x * 2, y * 2 + +a, b = f(1, 2) + +""" Sin embargo, esto no quiere decir que las funciones Python puedan de-volver varios valores, + lo que ocurre en realidad es que Python crea una tupla al vuelo cuyos elementos + son los valores a retornar, y esta única variable es la que se devuelve.""" + + + + +# ------------------------------------- +# función con un parámetro +# ------------------------------------- + +# Declaración de una función + +def miFuncion(num1, num2): + return(num1+num2) + + +# Llamada a la función + +print(miFuncion(2, 3)) + + +# ------------------------------------- +def holaConNombre(name): + print("Hola " + name + "!") + +holaConNombre("Angel") # llamada a la función, 'Hola Angel!' se muestra en la consola +# ------------------------------------- + + +#--------------------------------------- +# Funcion con parametro por defecto +#--------------------------------------- + +def imprimir(precio, iva = 1.21): + print(precio * iva) + +imprimir(300, 1.08) + +# Funciones con argumentos variables +# Me crea una tupla de nombre "otros" + +def varios(param1, param2, *otros): + for val in otros: + print (val) + +varios(1, 2) +varios(1, 2, 3) +varios(1, 2, 3, 4) + + +""" +También se puede preceder el nombre del último parámetro con **, +en cuyo caso en lugar de una tupla se utilizaría un diccionario. +Las claves de este diccionario serían los nombres de los parámetros +indicados al llamar a la función y los valores del diccionario, +los valores asociados a estos parámetros. +""" + +def varios(param1, param2, **otros): + for i in otros.items(): + print (i) + +varios(1, 2, tercero = 3) + +# --------------------------- +#--------------------------------------- +#ARGUMENTOS VARIABLES EN FUNCIONES. EL ARGUMENTO CON * SERÁ UNA TUPLA +# PYTHON NO TIENE SOBRECARGA DE FUNCIONES +#--------------------------------------- +def listarNombres(*nombres): + for nombre in nombres: + print(nombre) + +listarNombres('Juan', 'Karla', 'María', 'Ernesto') +listarNombres('Laura', 'Carlos') + +#--------------------------------------- +# hACER LO MISMO PERO PASANDO DICCIONARIOS COMO ARGUMENTOS. KWARGS + +def listarTerminos(**KWARGS): + for clave, valor in KWARGS.items(): + print(f'{clave}: {valor}') + +listarTerminos(IDE='Integrated Developement Environment', PK='Primary Key') +listarTerminos(DBMS='Database Management System') + + +#--------------------------------------- + +def mi_funcion(nombre, apellido): + print('saludos desde mi función') + print(f'Nombre: {nombre}, Apellido: {apellido}') + # Sería como imprimir así: + print('Nombre:', nombre, 'Apellido:', apellido) + +mi_funcion('Juan', 'Perez') +mi_funcion('Karla','Lara') + +#--------------------------------------- +# RETURN +#--------------------------------------- + +#function definiciones de function no pueden estar vacías, pero si por alguna razón tiene +# una definición de function sin contenido, ingrese la instrucción pass para evitar un error. + + +def myfunction(): + pass + +#--------------------------------------- + +def sumar(a, b): + return a + b + +resultado = sumar(5, 3) +print(f'Resultado sumar: {resultado}') +# print(f'Resultado sumar: {sumar(5,3}') + +#También podíamos haber llamado a la función dentro de nuestro método print +print(f'Resultado sumar: {sumar(5,3)}') + +# --------------------------- +# función con múltiples parámetros con una sentencia de retorno +def multiplica(val1, val2): + return val1 * val2 + +multiplica(3, 5) # muestra 15 en la consola + +#--------------------------------------- + +# esta es una función básica de suma +def suma(a, b): + return a + b + +result = suma(1, 2) +# result = 3 + + +#--------------------------------------- +# VALORES POR DEFECTO +#--------------------------------------- +# esta es una función básica de suma con balores predeterminados +def suma(a, b=3): + return a + b + +result = suma(1) +# result = 4 + + +#--------------------------------------- +# Indicio de qué tipo de dato vamos a manejar: +#--------------------------------------- + +def sumar(a:int = 0, b:int = 0) -> int: +#def sumar(a = 0, b = 0): + return a + b + + resultado = sumar() +#print(f'Resultado sumar: {resultado}') +print(f'Resultado sumar: {sumar(45, 654)}') +#uanque le hemos dicho el tipo de los parámetros no estamos obligados a cumplirlo. +print(f'Resultado sumar: {sumar("aNGEL", "Garcia")}') + + + +#--------------------------------------- +""" +Crear una función para sumar los valores recibidos de tipo numérico, +utilizando argumentos variables *args como parámetro de la función +y regresar como resultado la suma de todos los valores pasados como argumentos. +""" + +# Definimos nuestra funcion para sumar valores +def sumar_valores(*args): + resultado = 0 + # Iteramos cada elemento + for valor in args: + # resultado = resultado + valor + resultado += valor + return resultado + + +# Llamada a la funcion +print(sumar_valores(3, 5, 9, 4, 6, 45, 444)) + +#--------------------------------------- +# Distintos tipos de datos como argumentos en Python + +def desplegarNombres(nombres): + for nombre in nombres: + print(nombre) + +#nombres = ['Juan', 'Karla', 'Guillermo'] +#desplegarNombres(nombres) +#desplegarNombres('Carlos') +#desplegarNombres((8, 9)) +desplegarNombres([10, 11]) + +#--------------------------------------- +# FUNCIONES RECURSIVAS + +# 5! = 5 * 4 * 3 * 2 * 1 +# 5! = 5 * 4 * 3 * 2 +# 5! = 5 * 4 * 6 +# 5! = 5 * 24 +# 5! = 120 + +def factorial(numero): + if numero == 1: + return 1 + else: + return numero * factorial(numero-1) + +numero = 6 +resultado = factorial(numero) +print(f'El factorial de {numero} es {resultado}') + +#--------------------------------------- +""" +Imprimir numeros de 5 a 1 de manera descendente usando funciones recursivas. +Puede ser cualquier valor positivo, ejemplo, si pasamos el valor de 5, debe imprimir: +5 +4 +3 +2 +1 + +En caso de pasar el valor de 3, debe imprimir: +3 +2 +1 + +Si se pasan valores negativos no imprime nada +""" + +def imprimir_numero_recursivo(numero): + if numero >= 1: + print(numero) + imprimir_numero_recursivo(numero - 1) + elif numero == 0: + return + elif numero < 0: + print('Valor incorrecto...') + +imprimir_numero_recursivo(5000000) + +#--------------------------------------- + +def cuenta_regresiva(numero): + numero -= 1 + if numero > 0: + print (numero) + cuenta_regresiva(numero) + else: + print ("Boooooooom!") + print ("Fin de la función"), numero + +cuenta_regresiva(5) + +#--------------------------------------- +""" +Ejercicio: Calculadora de Impuestos +Crear una función para calcular el total de un pago incluyendo un impuesto aplicado. +# Formula: pago_total = pago_sin_impuesto + pago_sin_impuesto * (impuesto/100) +""" + +# Funcion que calcula el total de un pago incluyendo el impuesto +def calcular_total_pago(pago_sin_impuesto, impuesto): + pago_total = pago_sin_impuesto + pago_sin_impuesto * (impuesto/100) + return pago_total + +# Ejecutamos la funcion +pago_sin_impuesto = float(input('Proporcione el pago sin impuestos: ')) +impuesto = float(input('Proporcione el monto del impuesto:')) +pago_con_impuesto = calcular_total_pago(pago_sin_impuesto, impuesto) +print(f'Pago con impuesto: {pago_con_impuesto}') + +#--------------------------------------- +#--------------------------------------- +""" +Ejercicio: Convertidor de Temperatura +Realizar dos funciones para convertir de grados celsius a fahrenheit y viceversa. +""" + +# Funcion que convierte de celsius a fahrenheit +def celsius_fahrenheit(celsius): + return celsius * 9 / 5 + 32 + +# Funcion que convierte de fahrenheit a celsius +def fahrenheit_celsius(fahrenheit): + return (fahrenheit - 32) * 5 / 9 + +# Realizamos algunas pruebas de conversion +celsius = float(input('Proporcione su valor en celsius: ')) +resultado = celsius_fahrenheit(celsius) +# Imprimimos el resultado +print(f'{celsius} C a F: {resultado:.2f}') + +# Realizamos la prueba de grados fahrenheit a celsius +fahrenheit = float(input('Proporcione su valor en fahrenheit: ')) +resultado = fahrenheit_celsius(fahrenheit) +# Imprimimos el resultado +print(f'{fahrenheit} F a C: {resultado:0.2f}') + + + + + + + + +def suma(num1, num2): + print("suma= ", num1+num2) \ No newline at end of file diff --git a/Ejercicios de clase/301_funciones_lambda.py b/Ejercicios de clase/301_funciones_lambda.py new file mode 100644 index 0000000..3f5f0cf --- /dev/null +++ b/Ejercicios de clase/301_funciones_lambda.py @@ -0,0 +1,74 @@ + +# ------------------------------------- +# FUNCIONES LAMBDA +# ------------------------------------- + +# Es una función anónima (sin nombre) que puedes definir en una sola línea. +# Ideal para usar como funciones cortas y rápidas, especialmente cuando las +# pasas como argumento a otras funciones. + +# Sintaxis: +# lambda argumentos: expresión + +# 🎯 Ejemplo básico + +doble = lambda x: x * 2 +print(doble(5)) # → 10 + +# Equivale a: + +def doble(x): + return x * 2 + +# 🔥 Casos de uso típicos +# 1. Con map() → aplicar una función a cada elemento de una lista + +numeros = [1, 2, 3, 4] +cuadrados = list(map(lambda x: x**2, numeros)) +print(cuadrados) # → [1, 4, 9, 16] + +# 2. Con filter() → filtrar elementos que cumplan una condición + +pares = list(filter(lambda x: x % 2 == 0, numeros)) +print(pares) # → [2, 4] + +# 3. Con sorted() → ordenar con una clave personalizada + +personas = [ + {"nombre": "Ana", "edad": 30}, + {"nombre": "Luis", "edad": 25}, + {"nombre": "Carlos", "edad": 40} +] + +ordenadas = sorted(personas, key=lambda p: p["edad"]) +print(ordenadas) + +# 4. Dentro de expresiones simples + +sumar = lambda a, b: a + b +print(sumar(3, 4)) # → 7 + +# ⚠️ ¿Cuándo no usar lambda? +# Si la función tiene más de una línea → usa def. + +# Si necesitas claridad o reutilización → mejor con def y un nombre descriptivo. + +# Si necesitas anotaciones de tipo o docstrings → usa def. + + +# 👎 NO recomendable +procesar = lambda x: x**2 if x > 0 else -x # confuso + +# 👍 Mejor +def procesar(x): + """Aplica una función especial según el valor de x.""" + return x**2 if x > 0 else -x + +# 🧪 Mini reto: convertir una función en lambda + +def multiplicar(a, b): + return a * b + +# Versión lambda: + +multiplicar = lambda a, b: a * b \ No newline at end of file diff --git a/Ejercicios de clase/305_Ejercicios_funciones_01.py b/Ejercicios de clase/305_Ejercicios_funciones_01.py new file mode 100644 index 0000000..9dbc6be --- /dev/null +++ b/Ejercicios de clase/305_Ejercicios_funciones_01.py @@ -0,0 +1,10 @@ + +# Escribe una función llamada saludar que tome un nombre como parámetro y +# devuelva un saludo personalizado, por ejemplo, "¡Hola, [nombre]!". + + +def saludar(nombre): + return f"¡Hola, {nombre}!" + +# Llamada a la función +print(saludar("Juan")) \ No newline at end of file diff --git a/Ejercicios de clase/310_Ejercicios_funciones_02.py b/Ejercicios de clase/310_Ejercicios_funciones_02.py new file mode 100644 index 0000000..8d84090 --- /dev/null +++ b/Ejercicios de clase/310_Ejercicios_funciones_02.py @@ -0,0 +1,10 @@ + +# Escribe una función llamada es_par que tome un número como parámetro +# y devuelva True si el número es par y False si es impar. + +def es_par(numero): + return numero % 2 == 0 + +# Llamada a la función +print(es_par(4)) # True +print(es_par(7)) # False \ No newline at end of file diff --git a/Ejercicios de clase/315_Ejercicios_funciones_03.py b/Ejercicios de clase/315_Ejercicios_funciones_03.py new file mode 100644 index 0000000..dc7e2cb --- /dev/null +++ b/Ejercicios de clase/315_Ejercicios_funciones_03.py @@ -0,0 +1,18 @@ + +# Escribe una función llamada calcular_area_rectangulo que tome la base +# y la altura de un rectángulo como parámetros y devuelva su área. +# Luego, escribe otra función llamada calcular_area_circulo que tome +# el radio de un círculo y devuelva su área (usa math.pi para el valor de π). + + +import math + +def calcular_area_rectangulo(base, altura): + return base * altura + +def calcular_area_circulo(radio): + return math.pi * radio ** 2 + +# Llamadas a las funciones +print(calcular_area_rectangulo(5, 10)) # 50 +print(calcular_area_circulo(3)) # Aproximadamente 28.27 \ No newline at end of file diff --git a/Ejercicios de clase/320_Ejercicios_funciones_04.py b/Ejercicios de clase/320_Ejercicios_funciones_04.py new file mode 100644 index 0000000..6ac70d6 --- /dev/null +++ b/Ejercicios de clase/320_Ejercicios_funciones_04.py @@ -0,0 +1,13 @@ + +# Escribe una función llamada contar_vocales que tome una cadena de texto +# como parámetro y devuelva el número de vocales (a, e, i, o, u) que contiene. +# Ignora mayúsculas y minúsculas. + + +def contar_vocales(texto): + texto = texto.lower() + vocales = "aeiou" + return sum(1 for letra in texto if letra in vocales) + +# Llamada a la función +print(contar_vocales("Hola Mundo")) # 4 diff --git a/Ejercicios de clase/321_Ejercicios_funciones_05.py b/Ejercicios de clase/321_Ejercicios_funciones_05.py new file mode 100644 index 0000000..18c3668 --- /dev/null +++ b/Ejercicios de clase/321_Ejercicios_funciones_05.py @@ -0,0 +1,22 @@ + + +# Escribe una función llamada es_primo que tome un número como parámetro y +# devuelva True si es primo y False si no lo es. Luego, escribe otra función +# llamada lista_primos que tome un número n y devuelva una lista con todos +# los números primos menores que n. + + +def es_primo(numero): + if numero < 2: + return False + for i in range(2, int(numero ** 0.5) + 1): + if numero % i == 0: + return False + return True + +def lista_primos(n): + return [x for x in range(2, n) if es_primo(x)] + +# Llamadas a las funciones +print(es_primo(17)) # True +print(lista_primos(20)) # [2, 3, 5, 7, 11, 13, 17, 19] \ No newline at end of file diff --git a/Ejercicios de clase/330_challenge_jurassic_park.py b/Ejercicios de clase/330_challenge_jurassic_park.py new file mode 100644 index 0000000..3bbf557 --- /dev/null +++ b/Ejercicios de clase/330_challenge_jurassic_park.py @@ -0,0 +1,33 @@ +""" +En Jurassic Park, se ha observado que los dinosaurios carnívoros, como el temible T-Rex, depositan un número par de huevos. Imagina que tienes una lista de números enteros en la que cada número representa la cantidad de huevos puestos por un dinosaurio en el parque. + +Importante: Solo se consideran los huevos de los dinosaurios carnívoros (T-Rex) aquellos números que son pares. + +Objetivo: +Escribe una función en Python que reciba una lista de números enteros y devuelva la suma total de los huevos que pertenecen a los dinosaurios carnívoros (es decir, la suma de todos los números pares en la lista). +""" + +from os import system +if system("clear") != 0: system("cls") + +# Para ver si un número es par +# siempre usamos el módulo % +# nos da el resto de la división: eggs % 2 == 2 + +def count_carnivore_dinosaur_eggs(egg_list) -> int: + """ + Esta función recibe una lista de numeros enteros que representan la cantidad de huevos que han puesto diferentes dinosaurios en el parque jurásico y los de número par son de carnívoros. Devuelve un número con la suma de todos los huevos de carnívoros. + """ + total_carnivore_eggs = 0 + + for eggs in egg_list: + if eggs % 2 == 0: + total_carnivore_eggs += eggs + + # esta forma más corta: + # total_carnivore_eggs = sum(filter(lambda x: x % 2 == 0, egg_list)) + + return total_carnivore_eggs + +egg_list = [3, 4, 7, 5, 8] +print(count_carnivore_dinosaur_eggs(egg_list)) # 12 \ No newline at end of file diff --git a/Ejercicios de clase/335_challenge_find_first_sum.py b/Ejercicios de clase/335_challenge_find_first_sum.py new file mode 100644 index 0000000..fa8c36f --- /dev/null +++ b/Ejercicios de clase/335_challenge_find_first_sum.py @@ -0,0 +1,37 @@ +""" +Dado un array de números y un número goal, encuentra los dos primeros números del array que sumen el número goal y devuelve sus índices. Si no existe tal combinación, devuelve None. + +nums = [4, 5, 6, 2] +goal = 8 + +find_first_sum(nums, goal) # [2, 3] +""" + +from os import system +if system("clear") != 0: system("cls") + +# def find_first_sum(nums, goal): +# # early return, una validación rápida +# if len(nums) == 0: return None + +# for i in range(len(nums)): +# for j in range(i + 1, len(nums)): +# if nums[i] + nums[j] == goal: +# return [i, j] + +# return None # no se encontró ninguna combinación + +def find_first_sum(nums, goal): + seen = {} # diccionario para guardar el numero y su índice + + for index, value in enumerate(nums): + missing = goal - value + if missing in seen: return [seen[missing], index] + seen[value] = index # guardar el número actual a los vistos, porque no hemos encontrado la combinación + + return None + +nums = [4, 5, 6, 2] +goal = 8 +result = find_first_sum(nums, goal) # [2, 3] +print(result) \ No newline at end of file diff --git a/Ejercicios de clase/340_dictionaries.py b/Ejercicios de clase/340_dictionaries.py new file mode 100644 index 0000000..f0294a7 --- /dev/null +++ b/Ejercicios de clase/340_dictionaries.py @@ -0,0 +1,64 @@ +### +# 04 - Dictionaries +# Los diccionarios son colecciones de pares clave-valor. +# Sirven para almacenar datos relacionados. +### + +from os import system +if system("clear") != 0: system("cls") + +# ejemplo tipico de diccionario +persona = { + "nombre": "midudev", + "edad": 25, + "es_estudiante": True, + "calificaciones": [7, 8, 9], + "socials": { + "twitter": "@midudev", + "instagram": "@midudev", + "facebook": "midudev" + } +} + +# para acceder a los valores +print(persona["nombre"]) +print(persona["calificaciones"][2]) +print(persona["socials"]["twitter"]) + +# cambiar valores al acceder +persona["nombre"] = "madeval" +persona["calificaciones"][2] = 10 + +# eliminar completamente una propiedad +del persona["edad"] +# print(persona) + +es_estudiante = persona.pop("es_estudiante") +print(f"es_estudiante: {es_estudiante}") +print(persona) + +# sobreescribir un diccionario con otro diccionario +a = { "name": "miduev", "age": 25 } +b = { "name": "madeval", "es_estudiante": True } + +a.update(b) +print(a) + +# comprobar si existe una propiedad +print("name" in persona) # False +print("nombre" in persona) # True + +# obtener todas las claves +print("\nkeys:") +print(persona.keys()) + +# obtener todas los valores +print("\nvalues:") +print(persona.values()) + +# obtener tanto clave como valor +print("\nitems:") +print(persona.items()) + +for key, value in persona.items(): + print(f"{key}: {value}") \ No newline at end of file diff --git a/Ejercicios de clase/345challenge_battle.py b/Ejercicios de clase/345challenge_battle.py new file mode 100644 index 0000000..df878f0 --- /dev/null +++ b/Ejercicios de clase/345challenge_battle.py @@ -0,0 +1,55 @@ +""" +Tienes dos listas de números, lista_a y lista_b, ambas de la misma longitud. + +Cada número en lista_a se "enfrenta" al número en la misma posición en lista_b. + +- Si el número en lista_a es mayor, su valor se suma al siguiente número en lista_a. +- Si el número en lista_b es mayor, su valor se suma al siguiente número en lista_b. +- Si los dos números son iguales, ambos se eliminan y no afectan al siguiente par. + +Debes simular estos enfrentamientos y devolver el resultado final: +- Si al final queda un número en lista_a, devuelve ese número seguido de la letra "a" (por ejemplo, "3a"). +- Si al final queda un número en lista_b, devuelve ese número seguido de la letra "b" (por ejemplo, "2b"). +- En caso de empate, devuelve la letra "x". + +lista_a = [2, 4, 2] +lista_b = [3, 3, 4] + +resultado = battle(lista_a, lista_b) # -> "2b" + +# Explicación: +# - 2 vs 3: gana 3 (+1) +# - 4 vs 3+1: empate +# - 2 vs 4: gana 4 (+2) +# Resultado: "2b" + +lista_a = [4, 4, 4] +lista_b = [2, 8, 2] + +resultado = battle(lista_a, lista_b) # -> "x" + +# Explicación: +# - 4 vs 2: gana 4 (+2) +# - 4+2 vs 8: gana 8 (+2) +# - 4 vs 2+2: empate +# Resultado: "x" +""" + +from os import system +if system("clear") != 0: system("cls") + +# Fuerza bruta: buscar la solución A SACO. +# Algoritmos ocultos o cálculos o fórmulas +# Programación dinámica: buscar una solución mas eficiente + + +def battle(lista_a, lista_b): + puntos_a = sum(lista_a) + puntos_b = sum(lista_b) + return f"{puntos_a - puntos_b}a" if puntos_a > puntos_b else f"{puntos_b - puntos_a}b" if puntos_b > puntos_a else "x" + + +lista_a = [4, 4, 4] +lista_b = [2, 8, 2] +winner = battle(lista_a, lista_b) +print(winner) diff --git a/Ejercicios de clase/355_re.py b/Ejercicios de clase/355_re.py new file mode 100644 index 0000000..0487ad2 --- /dev/null +++ b/Ejercicios de clase/355_re.py @@ -0,0 +1,123 @@ +## +# 01 - Expresiones regulares +# https://regex101.com/ +# + +""" Las expresiones regulares son una secuencia de caracteres que forman un patrón de búsqueda. + Se utilizan para la búsqueda de cadenas de texto, validación de datos, etc. """ + + +""" ¿Por qué aprender Regex? + +- Búsqueda avanzada: Encontrar patrones específicos en textos grandes de forma rápida y precisa. (un editor de Markdown sólo usando Regex) + +- Validación de datos: Asegurarte que los datos que ingresa un usuario como el email, teléfono, etc. son correctos. + +- Manipulación del texto: Extraer, reemplazar y modificar partes de la cadena de texto fácilmente +""" + +# 1. Importar el módulo de expresiones regulares "re" +import re +# 2. Crear un patrón, que es una cadena de texto que describe lo que queremos encontrar +pattern = "Hola" +# 3. El texto donde queremos buscar +text = "Hola mundo" +# 4. Usar la función de búsqueda de "re" +result = re.search(pattern, text) + + +if result: + print("He encontrado el patrón en el texto") +else: + print("No he encontrado el patrón en el texto") + +# .group() devuelve la cadena que coincide con el pattern +print(result.group()) + +# .start() devolver la posición inicial de la coincidencia +print(result.start()) + +# .end() devolver la posición final de la coincidencia +print(result.end()) + +# EJERCICIO 01 +# Encuentra la primera ocurrencia de la palabra "IA" en el siguiente texto +# e indica en que posición empieza y termina la coincidencia. +text = "Todo el mundo dice que la IA nos va a quitar el trabajo. Pero solo hace falta ver cómo la puede cagar con las Regex para ir con cuidado" +pattern = "IA" +found_ia = re.search(pattern, text) + +if found_ia: + print(f"He encontrado el patrón en el texto en la posición {found_ia.start()} y termina en la posición {found_ia.end()}") +else: + print("No he encontrado el patrón en el texto") + +# ----------------------- + +### Encontrar todas las coincidencias de un patrón +# .findall() devuelve una lista con todas las coincidencias +import re +text = "Me gusta Python. Python es lo máximo. Aunque Python no es tan difícil, ojo con Python" +pattern = "Python" + +# Si ponemos un punto es un carácter comodín, es como el * en las búsquedas de Windows. +# pattern = "Py.hon" + +matches = re.findall(pattern, text) + +print(len(matches)) + +# ------------------------- + +# iter() devuelve un iterador que contiene todos los resultados de la búsqueda +import re +text = "Me gusta Python. Python es lo máximo. Aunque Python no es tan difícil, ojo con Python" +pattern = "Python" + +matches = re.finditer(pattern, text) + +for match in matches: + print(match.group(), match.start(), match.end()) + +# EJERCICIO 02 +# Encuentra todas las ocurrencias de la palabra "midu" en el siguiente texto e indica en que posición empieza y termina cada coincidencia y cuantas veces se encontró. +text = "Este es el curso de Python de midudev. ¡Suscríbete a midudev si te gusta este contenido! midu" + +### Modificadores - FLAGS + +# Los modificadores son opciones que se pueden agregar a un patrón para cambiar su comportamiento + +# re.IGNORECASE: Ignora las mayúsculas y minúsculas + +text = "Todo el mundo dice que la IA nos va a quitar el trabajo. Pero la ia no es tan mala. ¡Viva la Ia!" +pattern = "IA" +found = re.findall(pattern, text, re.IGNORECASE) + +if found: print(found) + +# EJERCICIO 03 +# Encuentra todas las ocurrencias de la palabra "python" en el siguiente texto, sin distinguir entre mayúsculas y minúsculas. +text = "Este es el curso de Python de midudev. ¡Suscríbete a python si te gusta este contenido! PYTHON" + +### Reemplazar el texto + +# .sub() reemplaza todas las coincidencias de un patrón en un texto + +text = "Hola, mundo! Hola de nuevo. Hola otra vez." +pattern = "hola" +replacement = "Adiós" + +new_text = re.sub(pattern, replacement, text, flags=re.IGNORECASE) +print(new_text) + + + + + + + + + + + + diff --git a/Ejercicios de clase/356_metachars.py b/Ejercicios de clase/356_metachars.py new file mode 100644 index 0000000..964c8a8 --- /dev/null +++ b/Ejercicios de clase/356_metachars.py @@ -0,0 +1,130 @@ +### +# 02 - Meta caracteres +# Los metacaracteres son simbolos especiales con significados especificos en las expresiones regulares +### + +import re + +# 1. El punto (.) +# Coincidir con cualquier caracter excepto una nueva linea + +text = "Hola mundo, H0la de nuevo, H$la otra vez" +pattern = "H.la" # Hola, H0la, H$la + +found = re.findall(pattern, text) + +if (found): + print(found) +else: + print("No se ha encontrado el patrón") + + +text = "casa caasa cosa cisa cesa causa" +pattern = "c.sa" + +matches = re.findall(pattern, text) +print(matches) + +# -------------------- + +text = "Hola mundo, H0la de nuevo, H$la otra vez" +pattern = r"H.la" # Hola, H0la, H$la + +found = re.findall(pattern, text) + +if (found): + print(found) +else: + print("No se ha encontrado el patrón") + + +# Cómo usar la barra invertida para anular el significado especial de un símbolo +text = "Mi casa es blanca. Y el coche es negro." +pattern = r"\." + +matches = re.findall(pattern, text) + +print(matches) + +# \d: coincide con cualquier dígito (0-9) + +text = "El número de teléfono es 123456789" + +# Uso de cuantificadores {} +# found = re.findall(r'\d\d\d\d\d\d\d\d\d', text) +found = re.findall(r'\d{9}', text) + +print(found) + +# Ejercicio: Detectar si hay un número de España en el texto gracias al prefijo +34 + +text = "Mi número de teléfono es +34 688999999 apúntalo vale?" +pattern = r"\+34 \d{9}" +found = re.search(pattern, text) +if found: print(f"Encontré el número de teléfono {found.group()}") + +# \w: Coincide con cualquier caracter alfanumerico (a-z, A-Z, 0-9, _) + +text = "el_rubius_69" +pattern = r"\w" +found = re.findall(pattern, text) +print(found) + +# \s: Coincide con cualqueir espacio en blanco (espacio, tabulación, salto de línea) +text = "Hola mundo\n¿Cómo estás?\t" +pattern = r"\s" +matches = re.findall(pattern, text) +print(matches) + +# ^: Coincide con el principio de una cadena +username = "423_name%22" +pattern = r"^\w" # validar nombre de usuario + +valid = re.search(pattern, username) + +if valid: print("El nombre de usuario es válido") +else: print("El nombre de usuario no es válido") + +phone = "+34 688999999" +pattern = r"^\+\d{1,3} " + +valid = re.search(pattern, phone) + +if valid: print("El número de teléfono es válido") +else: print("El número de teléfono no es válido") + +# $: Coincide con el final de una cadena +text = "Hola mundo." +pattern = r"mundo$" + +valid = re.search(pattern, text) + +if valid: print("La cadena es válida") +else: print("La cadena no es válida") + +# EJERCICIO +# Valida que un correo sea de gmail +text = "miduga@hotmail.com" +pattern = r"@gmail.com$" +valid = re.search(pattern, text) + +if valid: print("El correo es gmail válido") +else: print("El correo no es válido") + +# EJERCICIO: +# Tenemos una lista de archivos, necesitamos saber los nombres de los ficheros con extension .txt +files = "file1.txt file2.pdf midu-of.webp secret.txt" + +# \b: Coincide con el principio o final de una palabra +text = "casa casada cosa cosas casado casa" +pattern = r"\bc.sa\b" + +found = re.findall(pattern, text) +print(found) + +# |: Coincidr con una opción u otra +fruits = "platano, piña, manzana, aguacate, palta, pera, aguacate, aguacate" +pattern = r"palta|aguacate|p..a|\b\w{7}\b" + +matches = re.findall(pattern, fruits) +print(matches) \ No newline at end of file diff --git a/Ejercicios de clase/357_quantifiers.py b/Ejercicios de clase/357_quantifiers.py new file mode 100644 index 0000000..ccfdc3d --- /dev/null +++ b/Ejercicios de clase/357_quantifiers.py @@ -0,0 +1,57 @@ +### +# 03 - Quantifiers +# Los cuantificadores se utilizan para especificar cuántas ocurrencias de un carácter o grupo de caracteres se deben encontrar en una cadena. +### + +import re + +# *: Puede aparecer 0 o más veces +text = "aaaba" +pattern = "a*" +matches = re.findall(pattern, text) +print(matches) + +# Ejercicio 1: +# ¿Cuantas palabras tienen de 0 a más "a" y después una b? + +# +: Una a más veces +text = "dddd aaa ccc a bb aa casa" +pattern = "a+" +matches = re.findall(pattern, text) +print(matches) + +# ?: Cero o una vez +text = "aaabacb" +pattern = "a?b" +matches = re.findall(pattern, text) +print(matches) + +# Ejercicio: Haz opcional que aparezca un +34 en el siguiente texto +phone = "+34 688999999" + +# {n}: Exactamente n veces +text = "aaaaaa aa aaaa" +pattern = "a{3}" +matches = re.findall(pattern, text) + +print(matches) + +# {n, m}: De n a m veces +text = "u uu uuu u" +pattern = r"\w{2,3}" +matches = re.findall(pattern, text) +print(matches) + +# Ejercicio: +# Encuentra las palabras de 4 a 6 letras en el siguiente texto +words = "ala casa árbol león cinco murcielago" +pattern = r"\b\w{4,6}\b" +matches = re.findall(pattern, words) +print(matches) + +# Ejercicio +# Encuentra las palabras de más de 6 letras +words = "ala fantastico casa árbol león cinco murcielago" +pattern = r"\b\w{6,}\b" +matches = re.findall(pattern, words) +print(matches) \ No newline at end of file diff --git a/Ejercicios de clase/358_sets.py b/Ejercicios de clase/358_sets.py new file mode 100644 index 0000000..25c2159 --- /dev/null +++ b/Ejercicios de clase/358_sets.py @@ -0,0 +1,53 @@ +import re + +# [:] Coincide con cualquier caracter dentro de los corchetes + +username = "rub.$ius_69+" +pattern = r"^[\w._%+-]+$" + +match = re.search(pattern, username) +if match: + print("El nombre de usuario es válido: ", match.group()) +else: + print("El nombre de usuario no es válido") + + +# Buscar todas las vocales de una palabra +text = "Hola mundo" +pattern = r"[aeiou]" +matches = re.findall(pattern, text) +print(matches) + +# Una Regex para encontrar las palabras man, fan y ban +# pero ignora el resto +text = "man ran fan ñan ban" +pattern = r"[mfb]an" + +matches = re.findall(pattern, text) +print(matches) + +# Ejercicio: +# Nos han complicado el asunto, porque ahora hay palabras que encajan pero no empiezan por esas letras. +# Solo queremos las palabras man, fan y ban +text = "omniman fanatico man bandana" +# \b + +text = "22" +pattern = r"[4-9]" + +matches = re.findall(pattern, text) +print(matches) + + +# Ejercicio final con todo lo aprendido +# Mejorar esto: https://www.computerhope.com/jargon/r/regular-expression.png + +## Buscar corner cases que no pasa y arreglarlo: +"lo.que+sea@shopping.online" +"michael@gov.co.uk" + +# [^]: Coincide con cualquier caracter que no esté dentro de los corchetes +text = "Hola mundo" +pattern = r"[^aeiou]" +matches = re.findall(pattern, text) +print(matches) \ No newline at end of file diff --git a/Ejercicios de clase/359_re_sandBox.py b/Ejercicios de clase/359_re_sandBox.py new file mode 100644 index 0000000..f8c1de4 --- /dev/null +++ b/Ejercicios de clase/359_re_sandBox.py @@ -0,0 +1,15 @@ +import re + +texto = "El código es 987-654" +patron = re.compile(r"(\d+)-(\d+)") + +match = patron.search(texto) + +if match: + print("Grupo completo:", match.group()) # 987-654 + print("Grupo 1:", match.group(1)) # 987 + print("Grupo 2:", match.group(2)) # 654 + print("Start grupo 1:", match.start(1)) # índice + print("End grupo 2:", match.end(2)) # índice + print("Span total:", match.span()) # (13, 20) + print("Texto original:", match.string) # El código es 987-654 diff --git a/Ejercicios de clase/375_dates.py b/Ejercicios de clase/375_dates.py new file mode 100644 index 0000000..7aa928a --- /dev/null +++ b/Ejercicios de clase/375_dates.py @@ -0,0 +1,56 @@ +# Trabajando con fechas y horas en Python + +from datetime import datetime, timedelta +import locale + +# 1. Obtener la fecha y hora actual +now = datetime.now() +print(f"Fecha y hora actual: {now}") + +# 2. Crear una fecha y hora específica +specific_date = datetime(2025, 2, 12, 15, 30, 0) +print(f"Fecha y hora específica: {specific_date}") + +# 3. Formatear fechas +# método strftime() para formatear fechas +# pasarle el objeto datetime y el formato especificado +# formato: +import locale +locale.setlocale(locale.LC_TIME, 'es_ES.UTF-8') + +format_date = now.strftime("%A %B %Y %H:%M:%S") +print(f"Fecha formateada: {format_date}") + +# 4. Operaciones con fechas (sumar/restar dias, minutos, horas, meses) +yesterday = datetime.now() - timedelta(days=1) +print(f"Ayer: {yesterday}") + +tomorrow = datetime.now() + timedelta(days=1) +print(f"Mañana: {tomorrow}") + +one_hour_after = datetime.now() + timedelta(hours=1) +print(f"Una hora después: {one_hour_after}") + +# 5. Obtener componentes individuales de una fecha +year = now.year +print(year) + +month = now.month +print(month) + +# 6. Calcular la diferencia entre 2 fechas +date1 = datetime.now() +date2 = datetime(2025, 2, 12, 15, 30, 0) +difference = date2 - date1 +print(f"Diferencia entre las fechas: {difference}") + + + + + + + + + + + diff --git a/Ejercicios de clase/381_Apendice_de_codigos_HTTP.txt b/Ejercicios de clase/381_Apendice_de_codigos_HTTP.txt new file mode 100644 index 0000000..0f71729 --- /dev/null +++ b/Ejercicios de clase/381_Apendice_de_codigos_HTTP.txt @@ -0,0 +1,30 @@ +✅ Códigos 2xx – Éxito +Código Significado +200 OK – Todo ha ido bien +201 Created – Se ha creado algo nuevo +202 Accepted – Aceptado, pero aún no procesado +204 No Content – Todo bien, pero sin respuesta (vacía) + +⚠️ Códigos 3xx – Redirección + +Código Significado +301 Moved Permanently – URL redirigida permanentemente +302 Found – Redirección temporal +304 Not Modified – El recurso no ha cambiado + +❌ Códigos 4xx – Error del cliente + +Código Significado +400 Bad Request – Petición mal formada +401 Unauthorized – No autorizado (falta token/login) +403 Forbidden – Prohibido, no tienes permisos +404 Not Found – No se ha encontrado el recurso +409 Conflict – Conflicto con el estado actual del servidor + +💥 Códigos 5xx – Error del servidor + +Código Significado +500 Internal Server Error – Fallo interno +502 Bad Gateway – El servidor recibió una respuesta inválida +503 Service Unavailable – El servidor no está disponible +504 Gateway Timeout – Se agotó el tiempo de espera \ No newline at end of file diff --git a/Ejercicios de clase/385_Modulos.py b/Ejercicios de clase/385_Modulos.py new file mode 100644 index 0000000..d88b5b4 --- /dev/null +++ b/Ejercicios de clase/385_Modulos.py @@ -0,0 +1,38 @@ + +# Módulos + +""" +Para llamar a una función que tengamos en un módulo tenemos que importarla y luego +usar la nomenclatura del punto: +Suponiendo que en un módulo funciones.py tenemos la siguiente función suma: +""" +def suma(num1, num2): + print("suma= ", num1+num2) + +# Desde otro módulo la llamaríamos así: + +import funciones +funciones.suma(3,4) #Además de importar debemos usar la nomenclatura del punto. + + +# Para simplificar también podemos poner: + +from funciones import suma +suma(3,4) + +# De esta forma, además, ya no necesitamos usar la nomenclatura del punto. + +# --------------------------------------- + + +# Si queremos importar todo el contenido de un paquete: + +from funciones import * + +# La función dir() enumera todos los elementos de un módulo. + +import funciones + +x = dir(funciones) +print(x) +2400 \ No newline at end of file diff --git a/Ejercicios de clase/390_POO_1.py b/Ejercicios de clase/390_POO_1.py new file mode 100644 index 0000000..0228666 --- /dev/null +++ b/Ejercicios de clase/390_POO_1.py @@ -0,0 +1,43 @@ + + + +# POO + +# CREACIÓN DE UNA CLASE + + +class Coche: +# Declaración de atributos + largo = 250 + ancho = 120 + ruedas = 4 + peso = 900 + color = "rojo" + is_enMarcha = False + +# Declaración de métodos + def arrancar(self): # self hace referencia a la instancia de clase. + self.is_enMarcha = True # Es como si pusiésemos miCoche.is_enMarcha = True + + def estado(self): + if (self.is_enMarcha == True): + return "El coche está arrancado" + else: + return "El coche está parado" + +# Declaración de una instancia de clase, objeto de clase o ejemplar de clase. +miCoche = Coche() +miCoche2 = Coche() + +# Acceso a un atributo de la clase Coche. Nomenclatura del punto. +print("El largo del coche es de" , miCoche.largo, "cm.") +miCoche.arrancar() +print(miCoche.estado()) +print(miCoche.color) + +# Acceso a un método de la clase Coche. Nomenclatura del punto. +print("El coche está arrancado:" , miCoche.arrancar()) + +#Modificamos el valor de una propiedad +miCoche2.ruedas = 10 +print("El coche2 tiene:" , miCoche2.ruedas, "ruedas.") \ No newline at end of file diff --git a/Ejercicios de clase/395_POO_1b con constructor.py b/Ejercicios de clase/395_POO_1b con constructor.py new file mode 100644 index 0000000..0c989f1 --- /dev/null +++ b/Ejercicios de clase/395_POO_1b con constructor.py @@ -0,0 +1,44 @@ +# POO + +# CREACIÓN DE UNA CLASE + +class Coche: + # Constructor + def __init__(self, largo, ancho, ruedas, peso, color): + self.largo = largo + self.ancho = ancho + self.ruedas = ruedas + self.peso = peso + self.color = color + self.is_enMarcha = False + + # Declaración de métodos + def arrancar(self): # self hace referencia a la instancia de clase. + self.is_enMarcha = True # Es como si pusiésemos miCoche.is_enMarcha = True + + def estado(self): + if self.is_enMarcha: + return "El coche está arrancado" + else: + return "El coche está parado" + +# Declaración de una instancia de clase, objeto de clase o ejemplar de clase. +miCoche = Coche(250, 120, 4, 900, "rojo") + +miCoche2 = Coche(250, 120, 4, 900, "azul") + +# Acceso a un atributo de la clase Coche. Nomenclatura del punto. +print("El largo del coche es de", miCoche.largo, "cm.") +miCoche.arrancar() +print(miCoche.estado()) +print(miCoche.color) + +# Acceso a un método de la clase Coche. Nomenclatura del punto. +print("El coche está arrancado:", miCoche.arrancar()) + +# Modificamos el valor de una propiedad +miCoche2.ruedas = 10 +print("El coche2 tiene:", miCoche2.ruedas, "ruedas.") + + + diff --git a/Ejercicios de clase/400_POO_1c con constructor.py b/Ejercicios de clase/400_POO_1c con constructor.py new file mode 100644 index 0000000..28af9fb --- /dev/null +++ b/Ejercicios de clase/400_POO_1c con constructor.py @@ -0,0 +1,50 @@ +# POO + +# CREACIÓN DE UNA CLASE +class Usuario: + # Declaración de atributos + nombre = "Angel" + __edad = 47 + login = "admin" + password = "1234" + email = "angel@loquesea.com" + telefono = 666666666 + + # Declaración de métodos + def resumen(self): # self hace referencia a la instancia de clase. + print(f'Los datos del usuario son:\n' + f'Nombre: {self.nombre}\n' + f'Edad: {self.__edad}\n' + f'Login: {self.login}\n' + f'Password: {self.password}\n' + f'Email: {self.email}\n' + f'Teléfono: {self.telefono}') + + def cambiaEdad(self): + edadIntroducida = int(input("Introduce edad entre 18-100:")) + + if 18 < edadIntroducida < 100: + #if edadIntroducida<18 or edadIntroducida>100: + + + self.__edad = edadIntroducida + print("Edad introducida correcta") + return + else: + print("La edad introducida no es correcta.") + self.cambiaEdad() + return "" + + + def muestraEdad(self): + print('La edad del usuario es:', self.__edad, 'años.') + return "" + + +administrador = Usuario() + +administrador.resumen() + +print(administrador.cambiaEdad()) +print(administrador.muestraEdad()) +print(administrador.__edad) #error diff --git "a/Ejercicios de clase/405_POO_1d con encapsulaci\303\263n.py" "b/Ejercicios de clase/405_POO_1d con encapsulaci\303\263n.py" new file mode 100644 index 0000000..3d9983c --- /dev/null +++ "b/Ejercicios de clase/405_POO_1d con encapsulaci\303\263n.py" @@ -0,0 +1,50 @@ +# POO + +# CREACIÓN DE UNA CLASE +class Usuario: + # Declaración de atributos + nombre = "Angel" + __edad = 47 + login = "admin" + password = "1234" + email = "angel@loquesea.com" + telefono = 666666666 + + # Declaración de métodos + def resumen(self): # self hace referencia a la instancia de clase. + print(f'Los datos del usuario son:\n' + f'Nombre: {self.nombre}\n' + f'Edad: {self.__edad}\n' + f'Login: {self.login}\n' + f'Password: {self.password}\n' + f'Email: {self.email}\n' + f'Teléfono: {self.telefono}') + + def cambiaEdad(self): + edadIntroducida = int(input("Introduce edad entre 18-100:")) + + if 18 < edadIntroducida < 100: + #if edadIntroducida<18 and edadIntroducida>100: + + + self.__edad = edadIntroducida + print("Edad introducida correcta") + return + else: + print("La edad introducida no es correcta.") + self.cambiaEdad() + return "" + + + def muestraEdad(self): + print('La edad del usuario es:', self.__edad, 'años.') + return "" + + +administrador = Usuario() + +administrador.resumen() + +print(administrador.cambiaEdad()) +print(administrador.muestraEdad()) +print(administrador.edad) #error diff --git a/Ejercicios de clase/410_POO_AreaRectangulo.py b/Ejercicios de clase/410_POO_AreaRectangulo.py new file mode 100644 index 0000000..f4d8be6 --- /dev/null +++ b/Ejercicios de clase/410_POO_AreaRectangulo.py @@ -0,0 +1,20 @@ +class Rectangulo: + def __init__(self, base, altura): + self.base = base + self.altura = altura + + def cacular_area(self): + return self.base * self.altura + + +base = int(input('Proporciona la base: ')) +altura = int(input('Proporciona la altura: ')) + +rectangulo1 = Rectangulo(base, altura) +print(f'Área rectángulo: {rectangulo1.cacular_area()}') + +base = int(input('Proporciona la base: ')) +altura = int(input('Proporciona la altura: ')) + +rectangulo2 = Rectangulo(base, altura) +print(f'Área rectángulo: {rectangulo2.cacular_area()}') diff --git a/Ejercicios de clase/415_POO_volumenCubo.py b/Ejercicios de clase/415_POO_volumenCubo.py new file mode 100644 index 0000000..32ca877 --- /dev/null +++ b/Ejercicios de clase/415_POO_volumenCubo.py @@ -0,0 +1,23 @@ + + +class Cubo: + def __init__(self, ancho, alto, profundo): + self.ancho = ancho + self.alto = alto + self.profundo = profundo + + def calcular_volumen(self): + return self.ancho * self.alto * self.profundo + + +ancho = int(input('Proporciona el ancho: ')) +alto = int(input('Proporciona el alto: ')) +profundo = int(input('Proprociona lo profundo: ')) + +cubo1 = Cubo(ancho, alto, profundo) +cubo2 = Cubo(ancho, alto, profundo) +cubo3 = Cubo(ancho, alto, profundo) + +print(f'Volúmen cubo: {cubo1.calcular_volumen()}') +print(f'Volúmen cubo: {cubo2.calcular_volumen()}') +print(f'Volúmen cubo: {cubo3.calcular_volumen()}') diff --git "a/Ejercicios de clase/420_POO_Ecapsulaci\303\263n.py" "b/Ejercicios de clase/420_POO_Ecapsulaci\303\263n.py" new file mode 100644 index 0000000..a5c7028 --- /dev/null +++ "b/Ejercicios de clase/420_POO_Ecapsulaci\303\263n.py" @@ -0,0 +1,30 @@ +# POO + +# CREACIÓN DE UNA CLASE + + +class Coche(): +# Método constructor + def __init__(self): + self.__largo = 250 + self.__ancho = 120 + self.__ruedas = 4 + self.__peso = 900 + self.__color = "rojo" + self.__is_enMarcha = False + +# Declaración de métodos + def arrancar(self): # self hace referencia a la instancia de clase. + self.is_enMarcha = True # Es como si pusiésemos miCoche.is_enMarcha = True + + def estado(self): + if (self.is_enMarcha == True): + return "El coche está arrancado" + else: + return "El coche está parado" + +# Declaración de una instancia de clase, objeto de clase o ejemplar de clase. +miCoche = Coche() + +miCoche.__ruedas = 9 +print("Mi coche tiene",miCoche.__ruedas, "ruedas.") diff --git "a/Ejercicios de clase/425_POO_Ecapsulaci\303\263n2.py" "b/Ejercicios de clase/425_POO_Ecapsulaci\303\263n2.py" new file mode 100644 index 0000000..bf36cb2 --- /dev/null +++ "b/Ejercicios de clase/425_POO_Ecapsulaci\303\263n2.py" @@ -0,0 +1,35 @@ +# POO + +# CREACIÓN DE UNA CLASE + +class Persona: + def __init__(self, nombre, apellido, edad): + self._nombre = nombre + self.apellido = apellido + self.edad = edad + + @property + def nombre(self): + print('Llamando método get nombre') + return self._nombre + + @nombre.setter + def nombre(self, nombre): + print('Llamando método set nombre') + self._nombre = nombre + + def mostrar_detalle(self): + print(f'Persona: {self._nombre} {self.apellido} {self.edad}') + + #Sin decoradores + + + #def mostrar_detalle(self): + # print(f'Persona: {self.nombre()} {self.apellido} {self.edad}') + + +persona1 = Persona('Juan', 'Perez', 28) +persona1.nombre = 'Juan Carlos' +print(persona1.nombre) +# persona1._nombre = 'Cambio' +# print(persona1._nombre) diff --git "a/Ejercicios de clase/430_POO_Ecapsulaci\303\263n4_readOnly.py" "b/Ejercicios de clase/430_POO_Ecapsulaci\303\263n4_readOnly.py" new file mode 100644 index 0000000..b9162ff --- /dev/null +++ "b/Ejercicios de clase/430_POO_Ecapsulaci\303\263n4_readOnly.py" @@ -0,0 +1,25 @@ +class Persona: + def __init__(self, nombre, apellido, edad): + self._nombre = nombre + self.apellido = apellido + self.edad = edad + + @property + def nombre(self): + print('Llamando método get nombre') + return self._nombre + + # @nombre.setter + # def nombre(self, nombre): + # print('Llamando método set nombre') + # self._nombre = nombre + + def mostrar_detalle(self): + print(f'Persona: {self._nombre} {self.apellido} {self.edad}') + + +persona1 = Persona('Juan', 'Perez', 28) +persona1.nombre = 'Juan Carlos' +print(persona1.nombre) +# persona1._nombre = 'Cambio' +# print(persona1._nombre) diff --git "a/Ejercicios de clase/435_POO_Ecapsulaci\303\263n5.py" "b/Ejercicios de clase/435_POO_Ecapsulaci\303\263n5.py" new file mode 100644 index 0000000..3ad84ac --- /dev/null +++ "b/Ejercicios de clase/435_POO_Ecapsulaci\303\263n5.py" @@ -0,0 +1,42 @@ +class Persona: + def __init__(self, nombre, apellido, edad): + self._nombre = nombre + self._apellido = apellido + self._edad = edad + + @property + def nombre(self): + return self._nombre + + @nombre.setter + def nombre(self, nombre): + self._nombre = nombre + + @property + def apellido(self): + return self._apellido + + @apellido.setter + def apellido(self, apellido): + self._apellido = apellido + + @property + def edad(self): + return self._edad + + @edad.setter + def edad(self, edad): + self._edad = edad + + def mostrar_detalle(self): + print(f'Persona: {self._nombre} {self._apellido} {self._edad}') + + +persona1 = Persona('Juan', 'Perez', 28) +persona1.nombre = 'Juan Carlos' +persona1.apellido = 'Lara' +persona1.edad = 30 +persona1.mostrar_detalle() + +# persona1._nombre = 'Cambio' +# print(persona1._nombre) diff --git a/Ejercicios de clase/440_POO_Herencia.py b/Ejercicios de clase/440_POO_Herencia.py new file mode 100644 index 0000000..c11db2c --- /dev/null +++ b/Ejercicios de clase/440_POO_Herencia.py @@ -0,0 +1,52 @@ + + + +# POO + +# CREACIÓN DE UNA CLASE PADRE +# Todas las clases heredan de la superclase OBJECT +# Es como si pusiésemos: class Empleado(object): + +class Empleado(): +# Método constructor + def __init__(self, nombre, cargo): + self.nombre = nombre + self.cargo = cargo + self.sueldo = 10000 + + def modificaSueldo(self, sueldo): + self.sueldo = sueldo + + def muestraSueldo(self): + print("El sueldo del", self.cargo, "es de", self.sueldo) + + +conserje = Empleado("Manolo", "conserje") + +conserje.modificaSueldo(15000) + +conserje.muestraSueldo() + + + +class Jefe(Empleado): + + + def plusSueldo(self, plus): + self.sueldo = self.sueldo + plus + + def muestraSueldo(self): + print("El sueldo del", self.cargo, "es de", self.sueldo), + + + + +D_Andres = Jefe("D. Andrés", "jefe de ventas") + + +D_Andres.modificaSueldo(25000) +D_Andres.plusSueldo(5000) + +D_Andres.muestraSueldo() + +print(D_Andres.nombre) \ No newline at end of file diff --git a/Ejercicios de clase/445_POO_Decoradores_1.py b/Ejercicios de clase/445_POO_Decoradores_1.py new file mode 100644 index 0000000..9412e0e --- /dev/null +++ b/Ejercicios de clase/445_POO_Decoradores_1.py @@ -0,0 +1,29 @@ + +#Función decoradora + +def funcion_decoradora(funcion_a_decorar): + + def funcion_interior(): + print("El resultado es ") + + funcion_a_decorar() + + print(". Calculo terminado.") + + return funcion_interior + + +@funcion_decoradora +def suma(): + print(15+20) + +@funcion_decoradora +def resta(): + print(30-10) + +suma() +resta() + + + + diff --git a/Ejercicios de clase/450_POO_Decoradores_2.py b/Ejercicios de clase/450_POO_Decoradores_2.py new file mode 100644 index 0000000..e66f62d --- /dev/null +++ b/Ejercicios de clase/450_POO_Decoradores_2.py @@ -0,0 +1,29 @@ + +#Función decoradora con parámetros + +def funcion_decoradora(funcion_a_decorar): + + def funcion_interior(num1, num2): + print("El resultado es ") + + funcion_a_decorar(num1, num2) + + print(". Calculo terminado.") + + return funcion_interior + + +@funcion_decoradora +def suma(num1, num2): + print(num1+num2) + +# @funcion_decoradora +def resta(num1, num2): + print(num1-num2) + +suma(3,5) +resta(10,5) + + + + diff --git a/Ejercicios de clase/454_POO_Decoradores_3.py b/Ejercicios de clase/454_POO_Decoradores_3.py new file mode 100644 index 0000000..a93e1ed --- /dev/null +++ b/Ejercicios de clase/454_POO_Decoradores_3.py @@ -0,0 +1,34 @@ + +#Función decoradora con parámetros variables + +def funcion_decoradora(funcion_a_decorar): + + def funcion_interior(*args): + print("El resultado es ") + + funcion_a_decorar(*args) + + print(". Calculo terminado.") + + return funcion_interior + + +@funcion_decoradora +def suma(num1, num2): + print(num1+num2) + +# @funcion_decoradora +def resta(num1, num2): + print(num1-num2) + +@funcion_decoradora +def multiplica(num1, num2, num3): + print(num1*num2*num3) + +suma(3,5) +resta(10,5) +multiplica(2, 3, 4) + + + + diff --git a/Ejercicios de clase/460_POO_Decoradores_4.py b/Ejercicios de clase/460_POO_Decoradores_4.py new file mode 100644 index 0000000..60e5366 --- /dev/null +++ b/Ejercicios de clase/460_POO_Decoradores_4.py @@ -0,0 +1,39 @@ + +#Función decoradora con parámetros variables y/o de tipo diccionario + +def funcion_decoradora(funcion_a_decorar): + + def funcion_interior(*args, **kwargs): + print("El resultado es ") + + funcion_a_decorar(*args, **kwargs) + + print(". Calculo terminado.") + + return funcion_interior + + +@funcion_decoradora +def suma(num1, num2): + print(num1+num2) + +# @funcion_decoradora +def resta(num1, num2): + print(num1-num2) + +@funcion_decoradora +def multiplica(num1, num2, num3): + print(num1*num2*num3) + +@funcion_decoradora +def potencia(base, exponente): + print(pow(base, exponente)) + +suma(3,5) +resta(10,5) +multiplica(2, 3, 4) +potencia(base=3, exponente=4) + + + + diff --git a/Ejercicios de clase/465_POO_Herencia_1.py b/Ejercicios de clase/465_POO_Herencia_1.py new file mode 100644 index 0000000..fcb8a5c --- /dev/null +++ b/Ejercicios de clase/465_POO_Herencia_1.py @@ -0,0 +1,23 @@ +# Definición de la clase padre + +class Persona: + def __init__(self, nombre, edad): + self.nombre = nombre + self.edad = edad + + +# Definición de la clase hija que hereda de la clase padre. +class Empleado(Persona): + def __init__(self, nombre, edad, sueldo): + super().__init__(nombre, edad) #Nos permite acceder a los métodos del padre + self.sueldo = sueldo + + +Pepe = Persona("Pepe", 43) +print(f'La edad de Pepe es de {Pepe.edad}') + +# Instancia de la clase hija. +empleado1 = Empleado('Juan', 28, 5000) +print(empleado1.nombre) +print(empleado1.edad) +print(empleado1.sueldo) diff --git a/Ejercicios de clase/470_POO_Herencia_2.py b/Ejercicios de clase/470_POO_Herencia_2.py new file mode 100644 index 0000000..8b4072f --- /dev/null +++ b/Ejercicios de clase/470_POO_Herencia_2.py @@ -0,0 +1,33 @@ + + + + +class Persona(): + def __init__(self, nombre, edad, lugar): + self.nombre=nombre + self.edad=edad + self.lugar=lugar + + + def descripcion(self): + print("El nombre es ", self.nombre, ", tiene ", self.edad, " anyos", " y es de ", self.lugar) + + + # Para personalizar el constructor del padre de acuerdo a las necesidades del hijo se usa super(): + +class Empleado(Persona): + def __init__(self, salario, antiguedad, nombre_emp, edad_emp, lugar_epm): + super().__init__(nombre_emp, edad_emp, lugar_epm) + self.salario=salario + self.antiguedad=antiguedad + + def descripcion(self): + super().descripcion() + print("Salario: ", self.salario, ", antiguedad: ", self.antiguedad) + +Angel=Persona("Angel", 43, "Malaga") +Angel.descripcion() + +Empleado1=Empleado(2000, 2017, "Manolo", 33, "Madrid") +Empleado1.descripcion() + diff --git a/Ejercicios de clase/475_POO_Herencia_3.py b/Ejercicios de clase/475_POO_Herencia_3.py new file mode 100644 index 0000000..556645f --- /dev/null +++ b/Ejercicios de clase/475_POO_Herencia_3.py @@ -0,0 +1,28 @@ +class Persona: + def __init__(self, nombre, edad, lugar): + self.nombre = nombre + self.edad = edad + self.lugar = lugar + + def descripcion(self): + print("El nombre es ", self.nombre, ", tiene ", self.edad, " anyos", " y es de ", self.lugar) + + # Para personalizar el constructor del padre de acuerdo a las necesidades del hijo se usa super(): + + +class Empleado(Persona): + def __init__(self, salario, antiguedad, nombre_emp, edad_emp, lugar_epm): + super().__init__(nombre_emp, edad_emp, lugar_epm) + self.salario = salario + self.antiguedad = antiguedad + + def descripcion(self): + super().descripcion() + print("Salario: ", self.salario, ", antiguedad: ", self.antiguedad) + + +Angel = Persona("Angel", 43, "Malaga") +Angel.descripcion() + +Empleado1 = Empleado(2000, 2017, "Manolo", 33, "Madrid") +Empleado1.descripcion() diff --git a/Ejercicios de clase/480_POO_Herencia_Coche_1 copy.py b/Ejercicios de clase/480_POO_Herencia_Coche_1 copy.py new file mode 100644 index 0000000..8c239f2 --- /dev/null +++ b/Ejercicios de clase/480_POO_Herencia_Coche_1 copy.py @@ -0,0 +1,39 @@ + + +class Vehiculo(): + def __init__(self, marca, modelo): + self.marca = marca + self.modelo = modelo + self.color = "Rojo" + self.arrancado = False + self.parado = True + + def arrancar(self): + self.arrancado = True + self.parado = False + + def parar(self): + self.parado = True + self.arrancado = False + + def resumen(self): + print("Marca:", self.marca, "\n", + "Modelo:", self.modelo, "\n", + "Color:", self.color, "\n", + "Está arrancado:", self.arrancado,"\n", + "Está parado:", self.parado + ) + + +miCoche = Vehiculo("Renault", "Megane") + +miCoche.arrancar() + +miCoche.resumen() + +class Moto(Vehiculo): + pass + +miMoto = Moto("Kawasaki", "Ninja") + +miMoto.resumen() \ No newline at end of file diff --git a/Ejercicios de clase/485_POO_Herencia_Coche_herencia_multiple.py b/Ejercicios de clase/485_POO_Herencia_Coche_herencia_multiple.py new file mode 100644 index 0000000..592fa0c --- /dev/null +++ b/Ejercicios de clase/485_POO_Herencia_Coche_herencia_multiple.py @@ -0,0 +1,77 @@ + +# SOBREESCRITURA DE MÉTODOS + +class Vehiculo(): + def __init__(self, marca, modelo): + self.marca = marca + self.modelo = modelo + self.color = "Rojo" + self.arrancado = False + self.parado = True + + def arrancar(self): + self.arrancado = True + self.parado = False + + def parar(self): + self.parado = True + self.arrancado = False + + def resumen(self): + print("El modelo es un coche", "\n", + "Marca:", self.marca, "\n", + "Modelo:", self.modelo, "\n", + "Color:", self.color, "\n", + "Está arrancado:", self.arrancado,"\n", + "Está parado:", self.parado + ) + + +miCoche = Vehiculo("Renault", "Megane") + +miCoche.arrancar() + +miCoche.resumen() + +class Moto(Vehiculo): + is_carenado = False + + def poner_carenado(self): + self.is_carenado = True + + def resumen(self): + print("El modelo es una moto", "\n", + "Marca:", self.marca, "\n", + "Modelo:", self.modelo, "\n", + "Color:", self.color, "\n", + "Está arrancado:", self.arrancado,"\n", + "Está parado:", self.parado, "\n", + "Tiene carenado:", self.is_carenado + ) + +miMoto = Moto("Kawasaki", "Ninja") + +miMoto.resumen() + +class kwad(Moto): + pass + +miKwad = kwad("Kawasaki", "Stream casper") + +miKwad.resumen() + +class Vehiculo_electrico(): + voltaje = 78 + carga_rapida = True + + def muestra_Voltaje(self): + print("El voltaje del vehículo es de:", self.voltaje, "Kws") + +class Coche_electrico(Vehiculo, Vehiculo_electrico): + pass + +miCocheElectrico = Coche_electrico("Hyunday", "Ionic") + +miCocheElectrico.resumen() +miCocheElectrico.muestra_Voltaje() + \ No newline at end of file diff --git a/Ejercicios de clase/490_POO_Herencia_Coche_Sobreescritura.py b/Ejercicios de clase/490_POO_Herencia_Coche_Sobreescritura.py new file mode 100644 index 0000000..92c4b18 --- /dev/null +++ b/Ejercicios de clase/490_POO_Herencia_Coche_Sobreescritura.py @@ -0,0 +1,61 @@ + +# SOBREESCRITURA DE MÉTODOS + +class Vehiculo(): + def __init__(self, marca, modelo): + self.marca = marca + self.modelo = modelo + self.color = "Rojo" + self.arrancado = False + self.parado = True + + def arrancar(self): + self.arrancado = True + self.parado = False + + def parar(self): + self.parado = True + self.arrancado = False + + def resumen(self): + print("El modelo es un coche", "\n", + "Marca:", self.marca, "\n", + "Modelo:", self.modelo, "\n", + "Color:", self.color, "\n", + "Está arrancado:", self.arrancado,"\n", + "Está parado:", self.parado + ) + + +miCoche = Vehiculo("Renault", "Megane") + +miCoche.arrancar() + +miCoche.resumen() + +class Moto(Vehiculo): + is_carenado = False + + def poner_carenado(self): + self.is_carenado = True + + def resumen(self): + print("El modelo es una moto", "\n", + "Marca:", self.marca, "\n", + "Modelo:", self.modelo, "\n", + "Color:", self.color, "\n", + "Está arrancado:", self.arrancado,"\n", + "Está parado:", self.parado, "\n", + "Tiene carenado:", self.is_carenado + ) + +miMoto = Moto("Kawasaki", "Ninja") + +miMoto.resumen() + +class kwad(Moto): + pass + +miKwad = kwad("Kawasaki", "Stream casper") + +miKwad.resumen() \ No newline at end of file diff --git a/Ejercicios de clase/495_POO_Herencia_Coche_super.py b/Ejercicios de clase/495_POO_Herencia_Coche_super.py new file mode 100644 index 0000000..4683b68 --- /dev/null +++ b/Ejercicios de clase/495_POO_Herencia_Coche_super.py @@ -0,0 +1,48 @@ + + + +class Persona(): + def __init__(self, nombre, edad, ciudad): + self.nombre = nombre + self.edad = edad + self.ciudad = ciudad + + def resumen(self): + print("Nombre:", self.nombre, "\nEdad:", self.edad,"\nCiudad:",self.ciudad, "\n") + +persona1 = Persona("Manolo", 45, "Madrid") + +persona1.resumen() + +'''class Empleado(Persona): + def __init__(self, salario, antiguedad): + super().__init__("Andrés", 32, "Barcelona") + self.salario = salario + self.antiguedad = antiguedad + + +operario01 = Empleado(23000, 2) + +operario01.resumen() +''' + +#El problema es que todos los empleados se llamarían igual +# y que no nos saca salario y antiguedad + +class Empleado(Persona): + def __init__(self, nombre_empleado, edad_empleado, ciudad_empleado, salario, antiguedad): + super().__init__(nombre_empleado, edad_empleado, ciudad_empleado) + self.salario = salario + self.antiguedad = antiguedad + + def resumen(self): + print("Nombre:", self.nombre, "\nEdad:", self.edad,"\nCiudad:",self.ciudad, + "\nSalario", self.salario, "\nAntiguedad:", self.antiguedad, "años.") + +operario01 = Empleado("Andrés", 34, "Barcelona", 23000, 2) + +operario01.resumen() + +#Principio de sustitución +isinstance(operario01, Empleado) +isinstance(operario01, Persona) \ No newline at end of file diff --git a/Ejercicios de clase/500_POO_Herencia_Coche_super2.py b/Ejercicios de clase/500_POO_Herencia_Coche_super2.py new file mode 100644 index 0000000..8466b55 --- /dev/null +++ b/Ejercicios de clase/500_POO_Herencia_Coche_super2.py @@ -0,0 +1,81 @@ + + + +class Vehiculo(): + def __init__(self, marca, modelo): + self.marca = marca + self.modelo = modelo + self.color = "Rojo" + self.arrancado = False + self.parado = True + + def arrancar(self): + self.arrancado = True + self.parado = False + + def parar(self): + self.parado = True + self.arrancado = False + + def resumen(self): + print("El modelo es un coche", "\n", + "Marca:", self.marca, "\n", + "Modelo:", self.modelo, "\n", + "Color:", self.color, "\n", + "Está arrancado:", self.arrancado,"\n", + "Está parado:", self.parado + ) + + +miCoche = Vehiculo("Renault", "Megane") + +miCoche.arrancar() + +miCoche.resumen() + +class Moto(Vehiculo): + is_carenado = False + + def poner_carenado(self): + self.is_carenado = True + + def resumen(self): + print("El modelo es una moto", "\n", + "Marca:", self.marca, "\n", + "Modelo:", self.modelo, "\n", + "Color:", self.color, "\n", + "Está arrancado:", self.arrancado,"\n", + "Está parado:", self.parado, "\n", + "Tiene carenado:", self.is_carenado + ) + +miMoto = Moto("Kawasaki", "Ninja") + +miMoto.resumen() + +class kwad(Moto): + pass + +miKwad = kwad("Kawasaki", "Stream casper") + +miKwad.resumen() + +class Vehiculo_electrico(): + voltaje = 78 + carga_rapida = True + + def muestra_Voltaje(self): + print("El voltaje del vehículo es:", self.voltaje, "Kws") + +class Coche_electrico(Vehiculo, Vehiculo_electrico): + def __init__(self, marca, modelo, voltaje, carga_rapida): + super().__init__(marca, modelo) + self.voltaje = voltaje + self.carga_rapida = carga_rapida + + + +miCocheElectrico = Coche_electrico("Hyunday", "Ionic", 78, True) + +miCocheElectrico.resumen() +miCocheElectrico.muestra_Voltaje() \ No newline at end of file diff --git a/Ejercicios de clase/505_POO_Herencia_multiple.py b/Ejercicios de clase/505_POO_Herencia_multiple.py new file mode 100644 index 0000000..cc51302 --- /dev/null +++ b/Ejercicios de clase/505_POO_Herencia_multiple.py @@ -0,0 +1,23 @@ + + + +class ClaseA: + def metodo_a(self): + return "Método de ClaseA" + +class ClaseB: + def metodo_a(self): + return "Método de ClaseB" + +# Clase que hereda de ClaseA y ClaseB +class ClaseC(ClaseA, ClaseB): + def metodo_c(self): + return "Método de ClaseC" + +# Crear una instancia de ClaseC +objeto = ClaseC() + +# Acceder a métodos de las clases base +print(objeto.metodo_a()) # Salida: Método de ClaseA + +print(objeto.metodo_c()) # Salida: Método de ClaseC \ No newline at end of file diff --git a/Ejercicios de clase/510_POO_Sobrescritura_STR.py b/Ejercicios de clase/510_POO_Sobrescritura_STR.py new file mode 100644 index 0000000..fbb3b8d --- /dev/null +++ b/Ejercicios de clase/510_POO_Sobrescritura_STR.py @@ -0,0 +1,7 @@ +from Persona3 import * + +persona1 = Persona('Juan', 28) +print(persona1) + +empleado1 = Empleado('Karla', 30, 5000) +print(empleado1) \ No newline at end of file diff --git a/Ejercicios de clase/515_Modulos_usoPersona.py b/Ejercicios de clase/515_Modulos_usoPersona.py new file mode 100644 index 0000000..84cdd67 --- /dev/null +++ b/Ejercicios de clase/515_Modulos_usoPersona.py @@ -0,0 +1,4 @@ +from Persona import Persona + +persona1 = Persona('Karla', 'Gomez', 30) +persona1.mostrar_detalle() diff --git a/Ejercicios de clase/520_POO_EjercicioHerencia.py b/Ejercicios de clase/520_POO_EjercicioHerencia.py new file mode 100644 index 0000000..970b596 --- /dev/null +++ b/Ejercicios de clase/520_POO_EjercicioHerencia.py @@ -0,0 +1,57 @@ +""" +Definir una clase padre llamada Vehiculo y dos clases hijas llamadas Coche y Bicicleta, +las cuales heredan de la clase Padre Vehiculo. +La clase padre debe tener los siguientes atributos y métodos + +Vehiculo (Clase Padre): +-Atributos (color, ruedas) +-Métodos ( __init__() y __str__ ) + +Coche (Clase Hija de Vehículo) (Además de los atributos y métodos heredados de Vehículo): +-Atributos ( velocidad (km/hr) ) +-Métodos ( __init__() y __str__() ) + +Bicicleta (Clase Hija de Vehículo) (Además de los atributos y métodos heredados de Vehículo): +-Atributos ( tipo (urbana/montaña/etc ) +-Métodos ( __init__() y __str__() ) +""" + + +class Vehiculo: + def __init__(self, color, ruedas): + self.color = color + self.ruedas = ruedas + + def __str__(self): + return 'Color: ' + self.color + ', Ruedas: ' + str(self.ruedas) + + +class Coche(Vehiculo): + def __init__(self, color, ruedas, velocidad): + super().__init__(color, ruedas) + self.velocidad = velocidad + + def __str__(self): + return super().__str__() + ', Velocidad (km/hr): ' + str(self.velocidad) + + +class Bicicleta(Vehiculo): + def __init__(self, color, ruedas, tipo): + super().__init__(color, ruedas) + self.tipo = tipo + + def __str__(self): + return super().__str__() + ', Tipo: ' + self.tipo + + +# Creamos un objeto de la clase Vehiculo +vehiculo = Vehiculo('Rojo', 4) +print(vehiculo) + +# Creamos un objeto de la clase hija Coche +coche = Coche('Azul', 4, 150) +print(coche) + +# Creamos un objeto de la clase hija Bicicleta +bicicleta = Bicicleta('Blanca', 2, 'Urbano') +print(bicicleta) diff --git a/Ejercicios de clase/525_POO_Polimorfismo.py b/Ejercicios de clase/525_POO_Polimorfismo.py new file mode 100644 index 0000000..7f4d7f2 --- /dev/null +++ b/Ejercicios de clase/525_POO_Polimorfismo.py @@ -0,0 +1,15 @@ +from Empleado import Empleado +from Gerente import Gerente + + +def imprimir_detalles(objeto): + # print(objeto) + print(type(objeto)) + print(objeto.mostrar_detalles()) + + +empleado = Empleado('Juan', 5000) +imprimir_detalles(empleado) + +gerente = Gerente('Karla', 6000, 'Sistemas') +imprimir_detalles(gerente) diff --git a/Ejercicios de clase/530_POO_Polimorfismo2 copy.py b/Ejercicios de clase/530_POO_Polimorfismo2 copy.py new file mode 100644 index 0000000..6b6088d --- /dev/null +++ b/Ejercicios de clase/530_POO_Polimorfismo2 copy.py @@ -0,0 +1,47 @@ + +class Moto(): + def ruedas(self): + print("Moto. Vehículo con dos ruedas") + +class Coche(): + def ruedas(self): + print("Coche. Vehículo con cuatro ruedas") + +class Camion(): + def ruedas(self): + print("Camión. Vehículo con 8 ruedas") + +moto01 = Moto() +moto01.ruedas() + +coche01 = Coche() +coche01.ruedas() + +camion01 = Camion() +camion01.ruedas() + +#Polimorfismo + +class Moto(): + def ruedas(self): + print("Moto. Vehículo con dos ruedas") + +class Coche(): + def ruedas(self): + print("Coche. Vehículo con cuatro ruedas") + +class Camion(): + def ruedas(self): + print("Camión. Vehículo con 8 ruedas") + +def ruedas_vehiculos(vehiculo): + vehiculo.ruedas() + +vehiculo01 = Camion() +ruedas_vehiculos(vehiculo01) + +vehiculo02 = Coche() +ruedas_vehiculos(vehiculo02) + +vehiculo03 = Moto() +ruedas_vehiculos(vehiculo03) \ No newline at end of file diff --git a/Ejercicios de clase/535_POO_Creacion_Clases_01.py b/Ejercicios de clase/535_POO_Creacion_Clases_01.py new file mode 100644 index 0000000..581a68f --- /dev/null +++ b/Ejercicios de clase/535_POO_Creacion_Clases_01.py @@ -0,0 +1,26 @@ + + + + +# Clase sin constructor + +class Persona: + pass + +# Crear una instancia de la clase Persona +persona = Persona() + +# Agregar atributos a la instancia +persona.nombre = "Ana" +persona.edad = 30 + +# Definir un método para la clase +def presentarse(self): + return f"Hola, soy {self.nombre} y tengo {self.edad} años." + +# Asociar el método a la instancia +Persona.presentarse = presentarse + +# Uso +print(persona.presentarse()) # Salida: Hola, soy Ana y tengo 30 años. + diff --git a/Ejercicios de clase/540_POO_Creacion_Clases_05.py b/Ejercicios de clase/540_POO_Creacion_Clases_05.py new file mode 100644 index 0000000..3b2d751 --- /dev/null +++ b/Ejercicios de clase/540_POO_Creacion_Clases_05.py @@ -0,0 +1,22 @@ + + + + +# Clase Básica de un Círculo + +import math + +class Circulo: + def __init__(self, radio): + self.radio = radio + + def area(self): + return math.pi * self.radio ** 2 + + def perimetro(self): + return 2 * math.pi * self.radio + +# Uso +circulo = Circulo(5) +print("Área:", circulo.area()) +print("Perímetro:", circulo.perimetro()) diff --git a/Ejercicios de clase/545_POO_Creacion_Clases_10.py b/Ejercicios de clase/545_POO_Creacion_Clases_10.py new file mode 100644 index 0000000..9957498 --- /dev/null +++ b/Ejercicios de clase/545_POO_Creacion_Clases_10.py @@ -0,0 +1,26 @@ + +# Clase para un Libro + +class Libro: + + def __init__(self, titulo, autor, anio_publicacion): + self.titulo = titulo + self.autor = autor + self.anio_publicacion = anio_publicacion + + def descripcion(self): + return f"'{self.titulo}' por {self.autor} ({self.anio_publicacion})" + + # def is_antiguo(self): + # return self.anio_publicacion < 1968 + +# Uso +libro1 = Libro("Cien Años de Soledad", "Gabriel García Márquez", 1967) +libro2 = Libro("El quijote", "M.Cervantes", "Mil seiscientos cinco") + +print(libro1.descripcion()) +print(libro1.titulo) +print(libro2.descripcion()) + +# print("¿Es antiguo?", libro1.is_antiguo()) +# print("¿Es antiguo?", libro2.is_antiguo()) \ No newline at end of file diff --git a/Ejercicios de clase/550_POO_Creacion_Clases_15.py b/Ejercicios de clase/550_POO_Creacion_Clases_15.py new file mode 100644 index 0000000..1703104 --- /dev/null +++ b/Ejercicios de clase/550_POO_Creacion_Clases_15.py @@ -0,0 +1,34 @@ + + + +# Clase para una Calculadora Simple + +class Calculadora: + def __init__(self): + self.resultado = 0 + + def sumar(self, valor): + self.resultado += valor + return self.resultado + + def restar(self, valor): + self.resultado -= valor + return self.resultado + + def multiplicar(self, valor): + self.resultado *= valor + return self.resultado + + def dividir(self, valor): + if valor != 0: + self.resultado /= valor + else: + print("Error: División por cero") + return self.resultado + +# Uso +calc = Calculadora() +print("Suma:", calc.sumar(5)) +print("Resta:", calc.restar(2)) +print("Multiplicación:", calc.multiplicar(3)) +print("División:", calc.dividir(4)) diff --git a/Ejercicios de clase/555_POO_Creacion_Clases_16.py b/Ejercicios de clase/555_POO_Creacion_Clases_16.py new file mode 100644 index 0000000..83f6407 --- /dev/null +++ b/Ejercicios de clase/555_POO_Creacion_Clases_16.py @@ -0,0 +1,27 @@ +class Calculadora: + """ + Clase Aritmetica para realizar las operaciones de sumar, restar, etc + """ + + def __init__(self, num1, num2): + self.num1 = num1 + self.num2 = num2 + + def sumar(self): + return self.num1 + self.num2 + + def restar(self): + return self.num1 - self.num2 + + def multiplicar(self): + return self.num1 * self.num2 + + def dividir(self): + return self.num1 / self.num2 + + +calculo = Calculadora(5, 3) +print(f'Suma: {calculo.sumar()}') +print(f'Resta: {calculo.restar()}') +print(f'Multiplicación: {calculo.multiplicar()}') +print(f'División: {calculo.dividir():.2f}') diff --git a/Ejercicios de clase/560_POO_Creacion_Clases_20.py b/Ejercicios de clase/560_POO_Creacion_Clases_20.py new file mode 100644 index 0000000..4109934 --- /dev/null +++ b/Ejercicios de clase/560_POO_Creacion_Clases_20.py @@ -0,0 +1,31 @@ + + + +# Clase para una Cuenta Bancaria + +class CuentaBancaria: + def __init__(self, titular, saldo=0.0): + self.titular = titular + self.saldo = saldo + + def depositar(self, monto): + self.saldo += monto + return self.saldo + + def retirar(self, monto): + if monto <= self.saldo: + self.saldo -= monto + else: + print("Saldo insuficiente") + return self.saldo + + def mostrar_saldo(self): + return f"Saldo actual: ${self.saldo:.2f}" + +# Uso +cuenta = CuentaBancaria("Juan Pérez", 1000) +print(cuenta.mostrar_saldo()) +cuenta.depositar(500) +print(cuenta.mostrar_saldo()) +cuenta.retirar(300) +print(cuenta.mostrar_saldo()) diff --git a/Ejercicios de clase/565_POO_Creacion_Clases_25.py b/Ejercicios de clase/565_POO_Creacion_Clases_25.py new file mode 100644 index 0000000..b83c575 --- /dev/null +++ b/Ejercicios de clase/565_POO_Creacion_Clases_25.py @@ -0,0 +1,14 @@ + +# Constructores + +class Persona: + def __init__(self, nombre, edad): + self.nombre = nombre # Inicializa el atributo nombre + self.edad = edad # Inicializa el atributo edad + + def presentarse(self): + return f"Hola, soy {self.nombre} y tengo {self.edad} años." + +# Crear una instancia de la clase Persona +persona = Persona("Ana", 30) +print(persona.presentarse()) # Salida: Hola, soy Ana y tengo 30 años. diff --git a/Ejercicios de clase/570_POO_Creacion_Clases_26.py b/Ejercicios de clase/570_POO_Creacion_Clases_26.py new file mode 100644 index 0000000..d1c8905 --- /dev/null +++ b/Ejercicios de clase/570_POO_Creacion_Clases_26.py @@ -0,0 +1,39 @@ + + + +# POO + +# CREACIÓN DE UNA CLASE + + +class Coche(): + + def __init__(self): + self.largo = 250 + self.ancho = 120 + self.ruedas = 4 + self.peso = 900 + self.color = "rojo" + self.is_enMarcha = False + +# Declaración de métodos + def arrancar(self): # self hace referencia a la instancia de clase. + self.is_enMarcha = True # Es como si pusiésemos miCoche.is_enMarcha = True + + def estado(self): + if (self.is_enMarcha == True): + return "El coche está arrancado" + else: + return "El coche está parado" + +# Declaración de una instancia de clase, objeto de clase o ejemplar de clase. +miCoche = Coche() + +# Acceso a un atributo de la clase Coche. Nomenclatura del punto. +miCoche.ruedas = 7 +print("El largo del coche es de" , miCoche.largo, "cm.") +miCoche.arrancar() +print(miCoche.estado()) + +# Acceso a un método de la clase Coche. Nomenclatura del punto. +print("El coche está arrancado:" , miCoche.arrancar()) \ No newline at end of file diff --git a/Ejercicios de clase/575_POO_Creacion_Clases_30.py b/Ejercicios de clase/575_POO_Creacion_Clases_30.py new file mode 100644 index 0000000..b394bd3 --- /dev/null +++ b/Ejercicios de clase/575_POO_Creacion_Clases_30.py @@ -0,0 +1,18 @@ + + +# Constuctores con valores por defecto + +class Persona: + def __init__(self, nombre="Desconocido", edad=0): + self.nombre = nombre + self.edad = edad + + def presentarse(self): + return f"Hola, soy {self.nombre} y tengo {self.edad} años." + +# Crear instancias de la clase Persona con y sin valores por defecto +persona1 = Persona() +persona2 = Persona("Ana", 30) + +print(persona1.presentarse()) # Salida: Hola, soy Desconocido y tengo 0 años. +print(persona2.presentarse()) # Salida: Hola, soy Ana y tengo 30 años. diff --git a/Ejercicios de clase/580_POO_Creacion_Clases_31.py b/Ejercicios de clase/580_POO_Creacion_Clases_31.py new file mode 100644 index 0000000..74d11a9 --- /dev/null +++ b/Ejercicios de clase/580_POO_Creacion_Clases_31.py @@ -0,0 +1,19 @@ + + + +# POO + +# CONSTRUCTORES CON PARÁMETROS + +class Persona: + def __init__(self, nombre, apellido, edad): + self.nombre = nombre + self.apellido = apellido + self.edad = edad + +persona1 = Persona('Juan', 'Perez', 28) +print(persona1.nombre) +print(persona1.apellido) +print(persona1.edad) + + diff --git a/Ejercicios de clase/585_POO_Creacion_Clases_35.py b/Ejercicios de clase/585_POO_Creacion_Clases_35.py new file mode 100644 index 0000000..0b30100 --- /dev/null +++ b/Ejercicios de clase/585_POO_Creacion_Clases_35.py @@ -0,0 +1,22 @@ + +# Constructores en herencia + +class Animal: + def __init__(self, nombre): + self.nombre = nombre + + def hacer_sonido(self): + raise NotImplementedError("Este método debe ser implementado por las subclases") + +class Perro(Animal): + def __init__(self, nombre, raza): + super().__init__(nombre) # Llama al constructor de la clase base + self.raza = raza + + def hacer_sonido(self): + return "Guau" + +# Crear una instancia de la clase Perro +perro = Perro("Firulais", "Labrador") +print(f"{perro.nombre} es un {perro.raza} y dice {perro.hacer_sonido()}") # Salida: Firulais es un Labrador y dice Guau + diff --git a/Ejercicios de clase/590_POO_Creacion_Clases_40.py b/Ejercicios de clase/590_POO_Creacion_Clases_40.py new file mode 100644 index 0000000..8d33495 --- /dev/null +++ b/Ejercicios de clase/590_POO_Creacion_Clases_40.py @@ -0,0 +1,22 @@ + + +# Clase con atributos de tipo tupla y diccionario + +class Persona: + def __init__(self, nombre, apellido, edad, *valores, **terminos): + self.nombre = nombre + self.apellido = apellido + self.edad = edad + self.valores = valores + self.terminos = terminos + + def mostrar_detalle(self): + print(f'Persona: {self.nombre} {self.apellido} {self.edad} {self.valores} {self.terminos}') + + +persona1 = Persona('Juan', 'Perez', 28, '44553322', 2, 3, 5, m='manzana', p='pera') +persona1.mostrar_detalle() + +persona2 = Persona('Karla', 'Gomez', 30) +persona2.mostrar_detalle() + diff --git a/Ejercicios de clase/595_POO_Herencia_05.py b/Ejercicios de clase/595_POO_Herencia_05.py new file mode 100644 index 0000000..690a676 --- /dev/null +++ b/Ejercicios de clase/595_POO_Herencia_05.py @@ -0,0 +1,21 @@ + + +# Herencia Básica (Animal y Perro) + +class Animal: + def __init__(self, nombre): + self.nombre = nombre + + def hacer_sonido(self): + pass + +class Perro(Animal): + def hacer_sonido(self): + return "Guau" + + + +# Uso +perro = Perro("Firulais") +print(perro.nombre) +print(perro.hacer_sonido()) diff --git a/Ejercicios de clase/600_POO_Herencia_06.py b/Ejercicios de clase/600_POO_Herencia_06.py new file mode 100644 index 0000000..2816b9b --- /dev/null +++ b/Ejercicios de clase/600_POO_Herencia_06.py @@ -0,0 +1,18 @@ + + +# Herencia básica + +class Vehiculo: + def __init__(self, marca): + self.marca = marca + + def arrancar(self): + return "El vehículo está arrancando" + +class Coche(Vehiculo): + pass + +# Uso +mi_coche = Coche("Toyota") +print(mi_coche.marca) # Hereda el atributo marca +print(mi_coche.arrancar()) # Hereda el método arrancar diff --git a/Ejercicios de clase/605_POO_Herencia_07.py b/Ejercicios de clase/605_POO_Herencia_07.py new file mode 100644 index 0000000..3ec2aa4 --- /dev/null +++ b/Ejercicios de clase/605_POO_Herencia_07.py @@ -0,0 +1,32 @@ + + + +# Herencia básica + +class Persona: + def __init__(self, nombre, edad): + self.nombre = nombre + self.edad = edad + + def saludar(self): + return f"Hola, mi nombre es {self.nombre} y tengo {self.edad} años." + +class Estudiante(Persona): + pass + +class Profesor(Persona): + + def saludar(self): + return f"Hola, mi nombre es {self.nombre} , tengo {self.edad} años y soy profesor de matemáticas" + +# Uso +estudiante = Estudiante("Ana", 21) +print(estudiante.nombre) # Hereda el atributo nombre +print(estudiante.edad) # Hereda el atributo edad +print(estudiante.saludar()) # Hereda el método saludar + +profMate = Profesor("D. Miguel", 54) +print(profMate.nombre) +print(profMate.saludar()) + + diff --git a/Ejercicios de clase/610_POO_Herencia_08.py b/Ejercicios de clase/610_POO_Herencia_08.py new file mode 100644 index 0000000..affe51e --- /dev/null +++ b/Ejercicios de clase/610_POO_Herencia_08.py @@ -0,0 +1,29 @@ + + +# Crea una clase base llamada SerVivo con un método respirar que +# devuelva "Estoy respirando". +# Luego, crea una clase derivada llamada Animal que herede de SerVivo +# y añada un método moverse que devuelva "Me estoy moviendo". +# Finalmente, crea una clase derivada llamada Perro que herede +# de Animal y sobrescriba el método moverse para devolver "Estoy corriendo". +# Crea una instancia de Perro y muestra los resultados de los métodos. + + +class SerVivo: + def respirar(self): + return "Estoy respirando" + +class Animal(SerVivo): + def moverse(self): + return "Me estoy moviendo" + +class Perro(Animal): + def moverse(self): + return "Estoy corriendo" + +# Crear una instancia de Perro +mi_perro = Perro() + +# Mostrar los métodos +print(mi_perro.respirar()) # "Estoy respirando" +print(mi_perro.moverse()) # "Estoy corriendo" diff --git a/Ejercicios de clase/615_POO_Herencia_09.py b/Ejercicios de clase/615_POO_Herencia_09.py new file mode 100644 index 0000000..711c0ec --- /dev/null +++ b/Ejercicios de clase/615_POO_Herencia_09.py @@ -0,0 +1,30 @@ + + +# Crea una clase base llamada Dispositivo con un método encender que +# devuelva "El dispositivo está encendido". +# Luego, crea una clase derivada llamada Computadora que herede de Dispositivo +# y añada un método procesar_datos que devuelva "Procesando datos". +# Finalmente, crea una clase derivada llamada Laptop que herede de +# Computadora y sobrescriba el método procesar_datos para devolver +# "Procesando datos en la laptop". +# Crea una instancia de Laptop y muestra los resultados de los métodos. + +class Dispositivo: + def encender(self): + return "El dispositivo está encendido" + +class Computadora(Dispositivo): + def procesar_datos(self): + return "Procesando datos" + + +class Laptop(Computadora): + def procesar_datos(self): + return "Procesando datos en la laptop" + +# Crear una instancia de Laptop +mi_laptop = Laptop() + +# Mostrar los métodos +print(mi_laptop.encender()) # "El dispositivo está encendido" +print(mi_laptop.procesar_datos()) # "Procesando datos en la laptop" diff --git a/Ejercicios de clase/620_POO_Herencia_10.py b/Ejercicios de clase/620_POO_Herencia_10.py new file mode 100644 index 0000000..da4cde1 --- /dev/null +++ b/Ejercicios de clase/620_POO_Herencia_10.py @@ -0,0 +1,32 @@ + + + +# Crea una clase base llamada Vehiculo con un atributo marca y un método arrancar. +# Luego, crea una clase derivada llamada Coche que herede de Vehiculo y añada +# un atributo numero_puertas y un método abrir_puertas. +# Crea una instancia de Coche y muestra sus atributos y métodos. + +class Vehiculo: + def __init__(self, marca): + self.marca = marca + + def arrancar(self): + return "El vehículo está arrancando" + +class Coche(Vehiculo): + def __init__(self, marca, numero_puertas): + super().__init__(marca) + self.numero_puertas = numero_puertas + + def abrir_puertas(self): + return f"Abrir {self.numero_puertas} puertas" + +# Crear una instancia de Coche +mi_coche = Coche("Toyota", 4) + +# Mostrar atributos y métodos +print(mi_coche.marca) # Hereda el atributo marca +print(mi_coche.arrancar()) # Hereda el método arrancar +print(mi_coche.numero_puertas) # Atributo propio de Coche +print(mi_coche.abrir_puertas()) # Método propio de Coche + diff --git a/Ejercicios de clase/625_POO_Herencia_11.py b/Ejercicios de clase/625_POO_Herencia_11.py new file mode 100644 index 0000000..b889ace --- /dev/null +++ b/Ejercicios de clase/625_POO_Herencia_11.py @@ -0,0 +1,33 @@ + + + + + + +# Crea una clase base llamada Animal con un atributo nombre y un método hacer_sonido. +# Luego, crea una clase derivada llamada Perro que herede de Animal y añada +# un atributo raza y un método ladrar. Crea una instancia de Perro y muestra sus atributos y métodos. + +class Animal: + def __init__(self, nombre): + self.nombre = nombre + + def hacer_sonido(self): + return "Algún sonido genérico" + +class Perro(Animal): + def __init__(self, nombre, raza): + super().__init__(nombre) + self.raza = raza + + def ladrar(self): + return "Guau guau" + +# Crear una instancia de Perro +mi_perro = Perro("Rex", "Labrador") + +# Mostrar atributos y métodos +print(mi_perro.nombre) # Hereda el atributo nombre +print(mi_perro.hacer_sonido()) # Hereda el método hacer_sonido +print(mi_perro.raza) # Atributo propio de Perro +print(mi_perro.ladrar()) # Método propio de Perro \ No newline at end of file diff --git a/Ejercicios de clase/630_POO_Herencia_12.py b/Ejercicios de clase/630_POO_Herencia_12.py new file mode 100644 index 0000000..d30e1f9 --- /dev/null +++ b/Ejercicios de clase/630_POO_Herencia_12.py @@ -0,0 +1,33 @@ + + + +# Crea una clase base llamada Persona con atributos nombre y edad, y un método saludar. +# Luego, crea una clase derivada llamada Estudiante que herede de Persona y +# añada un atributo carrera y un método estudiar. +# Crea una instancia de Estudiante y muestra sus atributos y métodos. + +class Persona: + def __init__(self, nombre, edad): + self.nombre = nombre + self.edad = edad + + def saludar(self): + return f"Hola, mi nombre es {self.nombre} y tengo {self.edad} años." + +class Estudiante(Persona): + def __init__(self, nombre, edad, carrera): + super().__init__(nombre, edad) + self.carrera = carrera + + def estudiar(self): + return f"Estoy estudiando {self.carrera}." + +# Crear una instancia de Estudiante +estudiante = Estudiante("Ana", 21, "Ingeniería") + +# Mostrar atributos y métodos +print(estudiante.nombre) # Hereda el atributo nombre +print(estudiante.edad) # Hereda el atributo edad +print(estudiante.saludar()) # Hereda el método saludar +print(estudiante.carrera) # Atributo propio de Estudiante +print(estudiante.estudiar()) # Método propio de Estudiante diff --git a/Ejercicios de clase/635_POO_Herencia_13.py b/Ejercicios de clase/635_POO_Herencia_13.py new file mode 100644 index 0000000..58bece4 --- /dev/null +++ b/Ejercicios de clase/635_POO_Herencia_13.py @@ -0,0 +1,3 @@ + + + diff --git a/Ejercicios de clase/640_POO_Herencia_14.py b/Ejercicios de clase/640_POO_Herencia_14.py new file mode 100644 index 0000000..6120b37 --- /dev/null +++ b/Ejercicios de clase/640_POO_Herencia_14.py @@ -0,0 +1,4 @@ + + + + diff --git a/Ejercicios de clase/645_POO_Herencia_15.py b/Ejercicios de clase/645_POO_Herencia_15.py new file mode 100644 index 0000000..cb1ff61 --- /dev/null +++ b/Ejercicios de clase/645_POO_Herencia_15.py @@ -0,0 +1,37 @@ + + +# Herencia con Métodos Sobrescritos (Vehículo, Coche, y Bicicleta) + +class Vehiculo: + def __init__(self, marca, modelo): + self.marca = marca + self.modelo = modelo + + def descripcion(self): + return f"{self.marca} {self.modelo}" + + def tipo(self): + pass + +class Coche(Vehiculo): + def __init__(self, marca, modelo, num_puertas): + super().__init__(marca, modelo) + self.num_puertas = num_puertas + + def tipo(self): + return "Coche" + +class Bicicleta(Vehiculo): + def __init__(self, marca, modelo, tipo_bicicleta): + super().__init__(marca, modelo) + self.tipo_bicicleta = tipo_bicicleta + + def tipo(self): + return "Bicicleta" + +# Uso +coche = Coche("Toyota", "Corolla", 4) +bicicleta = Bicicleta("Giant", "Escape 3", "Híbrida") +print(coche.descripcion(), "-", coche.tipo()) +print(bicicleta.descripcion(), "-", bicicleta.tipo()) + diff --git a/Ejercicios de clase/650_POO_Herencia_16.py b/Ejercicios de clase/650_POO_Herencia_16.py new file mode 100644 index 0000000..6120b37 --- /dev/null +++ b/Ejercicios de clase/650_POO_Herencia_16.py @@ -0,0 +1,4 @@ + + + + diff --git a/Ejercicios de clase/655_POO_Herencia_17.py b/Ejercicios de clase/655_POO_Herencia_17.py new file mode 100644 index 0000000..6120b37 --- /dev/null +++ b/Ejercicios de clase/655_POO_Herencia_17.py @@ -0,0 +1,4 @@ + + + + diff --git a/Ejercicios de clase/660_POO_Herencia_18.py b/Ejercicios de clase/660_POO_Herencia_18.py new file mode 100644 index 0000000..6120b37 --- /dev/null +++ b/Ejercicios de clase/660_POO_Herencia_18.py @@ -0,0 +1,4 @@ + + + + diff --git a/Ejercicios de clase/665_POO_Herencia_19.py b/Ejercicios de clase/665_POO_Herencia_19.py new file mode 100644 index 0000000..6120b37 --- /dev/null +++ b/Ejercicios de clase/665_POO_Herencia_19.py @@ -0,0 +1,4 @@ + + + + diff --git a/Ejercicios de clase/670_POO_Herencia_20.py b/Ejercicios de clase/670_POO_Herencia_20.py new file mode 100644 index 0000000..ba7a157 --- /dev/null +++ b/Ejercicios de clase/670_POO_Herencia_20.py @@ -0,0 +1,32 @@ + + +# Herencia con Métodos Adicionales y Atributos (Empleado y Programador) + +class Empleado: + def __init__(self, nombre, edad, salario): + self.nombre = nombre + self.edad = edad + self.salario = salario + + def detalles(self): + return f"Empleado: {self.nombre}, Edad: {self.edad}, Salario: ${self.salario}" + +class Programador(Empleado): + def __init__(self, nombre, edad, salario, lenguajes): + super().__init__(nombre, edad, salario) + self.lenguajes = lenguajes + + def detalles(self): + return f"Programador: {self.nombre}, Edad: {self.edad}, Salario: ${self.salario}, Lenguajes: {', '.join(self.lenguajes)}" + + def agregar_lenguaje(self, lenguaje): + self.lenguajes.append(lenguaje) + +# Uso +empleado = Empleado("Juan Pérez", 30, 50000) +programador = Programador("Ana Gómez", 25, 60000, ["Python", "JavaScript"]) +print(empleado.detalles()) +print(programador.detalles()) + +programador.agregar_lenguaje("Java") +print(programador.detalles()) diff --git a/Ejercicios de clase/675_POO_Herencia_21.py b/Ejercicios de clase/675_POO_Herencia_21.py new file mode 100644 index 0000000..6120b37 --- /dev/null +++ b/Ejercicios de clase/675_POO_Herencia_21.py @@ -0,0 +1,4 @@ + + + + diff --git a/Ejercicios de clase/680_POO_Herencia_22.py b/Ejercicios de clase/680_POO_Herencia_22.py new file mode 100644 index 0000000..6120b37 --- /dev/null +++ b/Ejercicios de clase/680_POO_Herencia_22.py @@ -0,0 +1,4 @@ + + + + diff --git a/Ejercicios de clase/685_POO_Herencia_23.py b/Ejercicios de clase/685_POO_Herencia_23.py new file mode 100644 index 0000000..6120b37 --- /dev/null +++ b/Ejercicios de clase/685_POO_Herencia_23.py @@ -0,0 +1,4 @@ + + + + diff --git a/Ejercicios de clase/690_POO_Herencia_24.py b/Ejercicios de clase/690_POO_Herencia_24.py new file mode 100644 index 0000000..6120b37 --- /dev/null +++ b/Ejercicios de clase/690_POO_Herencia_24.py @@ -0,0 +1,4 @@ + + + + diff --git a/Ejercicios de clase/695_POO_Herencia_25.py b/Ejercicios de clase/695_POO_Herencia_25.py new file mode 100644 index 0000000..478eb24 --- /dev/null +++ b/Ejercicios de clase/695_POO_Herencia_25.py @@ -0,0 +1,32 @@ + +# Herencia Múltiple Básica + +class Vehiculo: + def __init__(self, marca): + self.marca = marca + + def detalles(self): + return f"Vehiculo: {self.marca}" + + +class Motor: + def __init__(self, tipo_motor): + self.tipo_motor = tipo_motor + + def detalles(self): + return f"Motor: {self.tipo_motor}" + +class Coche(Motor, Vehiculo): + def __init__(self, marca, tipo_motor, modelo): + Vehiculo.__init__(self, marca) + Motor.__init__(self, tipo_motor) + self.modelo = modelo + + def descripcion(self): + return f"{self.marca} {self.modelo} con motor {self.tipo_motor}" + + +# Uso +coche = Coche("Toyota", "V6", "Corolla") +print(coche.descripcion()) +print(coche.detalles()) diff --git a/Ejercicios de clase/700_POO_Herencia_26.py b/Ejercicios de clase/700_POO_Herencia_26.py new file mode 100644 index 0000000..6120b37 --- /dev/null +++ b/Ejercicios de clase/700_POO_Herencia_26.py @@ -0,0 +1,4 @@ + + + + diff --git a/Ejercicios de clase/705_POO_Herencia_27.py b/Ejercicios de clase/705_POO_Herencia_27.py new file mode 100644 index 0000000..6120b37 --- /dev/null +++ b/Ejercicios de clase/705_POO_Herencia_27.py @@ -0,0 +1,4 @@ + + + + diff --git a/Ejercicios de clase/710_POO_Herencia_30.py b/Ejercicios de clase/710_POO_Herencia_30.py new file mode 100644 index 0000000..51b436a --- /dev/null +++ b/Ejercicios de clase/710_POO_Herencia_30.py @@ -0,0 +1,31 @@ + + +# Herencia Múltiple con Métodos de Diferentes Clases + +class Persona: + def __init__(self, nombre, edad): + self.nombre = nombre + self.edad = edad + + def presentarse(self): + return f"Soy {self.nombre} y tengo {self.edad} años." + +class Empleado: + def __init__(self, salario): + self.salario = salario + + def mostrar_salario(self): + return f"Mi salario es ${self.salario}" + +class Gerente(Persona, Empleado): + def __init__(self, nombre, edad, salario, departamento): + Persona.__init__(self, nombre, edad) + Empleado.__init__(self, salario) + self.departamento = departamento + + def detalles(self): + return f"{self.presentarse()}, trabajo en el departamento de {self.departamento} y {self.mostrar_salario()}." + +# Uso +gerente = Gerente("Carlos Martínez", 40, 75000, "Ventas") +print(gerente.detalles()) diff --git a/Ejercicios de clase/715_POO_Herencia_35.py b/Ejercicios de clase/715_POO_Herencia_35.py new file mode 100644 index 0000000..5a5f07d --- /dev/null +++ b/Ejercicios de clase/715_POO_Herencia_35.py @@ -0,0 +1,22 @@ + + +# Herencia Múltiple con Propiedades y Métodos Especiales + +class Nadador: + def nadar(self): + return "Estoy nadando" + +class Corredor: + def correr(self): + return "Estoy corriendo" + +class Triatleta(Nadador, Corredor): + def __init__(self, nombre): + self.nombre = nombre + + def competir(self): + return f"{self.nombre} compite en triatlón: {self.nadar()}, {self.correr()}." + +# Uso +triatleta = Triatleta("Laura Sánchez") +print(triatleta.competir()) diff --git a/Ejercicios de clase/720_POO_Herencia_36.py b/Ejercicios de clase/720_POO_Herencia_36.py new file mode 100644 index 0000000..7db97de --- /dev/null +++ b/Ejercicios de clase/720_POO_Herencia_36.py @@ -0,0 +1,81 @@ + + + + +# Crea una jerarquía de clases para un sistema de trabajo en una empresa. +# Comienza con una clase base Persona (abuelo), luego crea una clase +# derivada Empleado (padre) que herede de Persona, y finalmente, una +# clase Gerente (hija) que herede de Empleado. +# Además, añade una clase Habilidad que represente habilidades adicionales +# que un empleado puede tener. +# Haz que Gerente herede tanto de Empleado como de Habilidad (herencia múltiple). + +# Asegúrate de: + +# Utilizar atributos y métodos en cada clase. +# Sobrescribir métodos en las clases derivadas. +# Utilizar super() para llamar a métodos de las clases base. +# Mostrar el uso de la herencia múltiple. + + +# Clase base +class Persona: + def __init__(self, nombre, edad): + self.nombre = nombre + self.edad = edad + + def presentarse(self): + return f"Hola, me llamo {self.nombre} y tengo {self.edad} años." + +# Clase derivada de Persona +class Empleado(Persona): + def __init__(self, nombre, edad, salario): + super().__init__(nombre, edad) # Llamada a constructor de Persona + self.salario = salario + + def presentarse(self): + # Sobrescribir método presentarse y usar super() + return super().presentarse() + f" Soy empleado y gano {self.salario} euros al año." + + def trabajar(self): + return "Estoy trabajando." + +# Otra clase base para herencia múltiple +class Habilidad: + def __init__(self, habilidades): + self.habilidades = habilidades + + def mostrar_habilidades(self): + return f"Tengo las siguientes habilidades: {', '.join(self.habilidades)}" + +# Clase derivada de Empleado y Habilidad (herencia múltiple) +class Gerente(Empleado, Habilidad): + def __init__(self, nombre, edad, salario, habilidades, departamento): + Empleado.__init__(self, nombre, edad, salario) # Llamada a constructor de Empleado + Habilidad.__init__(self, habilidades) # Llamada a constructor de Habilidad + self.departamento = departamento + + def presentarse(self): + # Sobrescribir método presentarse y usar super() para Empleado y Persona + return super().presentarse() + f" Soy gerente del departamento de {self.departamento}." + + def trabajar(self): + # Sobrescribir método trabajar + return "Estoy supervisando a los empleados." + +# Crear instancias y mostrar el uso de los métodos +persona = Persona("Juan", 50) +empleado = Empleado("Ana", 30, 35000) +gerente = Gerente("Carlos", 40, 60000, ["Liderazgo", "Gestión de proyectos"], "IT") + +# Mostrar presentaciones +print(persona.presentarse()) +print(empleado.presentarse()) +print(gerente.presentarse()) + +# Mostrar trabajo +print(empleado.trabajar()) +print(gerente.trabajar()) + +# Mostrar habilidades del gerente +print(gerente.mostrar_habilidades()) diff --git a/Ejercicios de clase/725_POO_Encapsulacion_01.py b/Ejercicios de clase/725_POO_Encapsulacion_01.py new file mode 100644 index 0000000..fbbbcaf --- /dev/null +++ b/Ejercicios de clase/725_POO_Encapsulacion_01.py @@ -0,0 +1,29 @@ + +# Encapsulación Básica con Atributos Privados + +class Persona: + def __init__(self, nombre, edad): + self.__nombre = nombre # Atributo privado + self.__edad = edad # Atributo privado + + def obtener_nombre(self): + return self.__nombre + + def establecer_nombre(self, nombre): + self.__nombre = nombre + + def obtener_edad(self): + return self.__edad + + def establecer_edad(self, edad): + if edad > 0: + self.__edad = edad + else: + print("La edad debe ser positiva") + +# Uso +persona = Persona("Juan", 30) +print(persona.obtener_nombre()) +persona.establecer_edad(35) +print(persona.obtener_edad()) +print(persona.edad) diff --git a/Ejercicios de clase/730_POO_Encapsulacion_02.py b/Ejercicios de clase/730_POO_Encapsulacion_02.py new file mode 100644 index 0000000..8fc00ac --- /dev/null +++ b/Ejercicios de clase/730_POO_Encapsulacion_02.py @@ -0,0 +1,17 @@ + +# Crea una clase CuentaBancaria que tenga un atributo privado __saldo. +# Implementa un método getter llamado get_saldo que devuelva el saldo actual. +# Crea una instancia de CuentaBancaria y muestra el saldo usando el método getter. + +class CuentaBancaria: + def __init__(self, saldo_inicial): + self.__saldo = saldo_inicial + + def get_saldo(self): + return self.__saldo + +# Crear una instancia de CuentaBancaria +mi_cuenta = CuentaBancaria(1000) + +# Mostrar el saldo usando el método getter +print("Saldo inicial:", mi_cuenta.get_saldo()) diff --git a/Ejercicios de clase/735_POO_Encapsulacion_03.py b/Ejercicios de clase/735_POO_Encapsulacion_03.py new file mode 100644 index 0000000..0549a13 --- /dev/null +++ b/Ejercicios de clase/735_POO_Encapsulacion_03.py @@ -0,0 +1,26 @@ + +# Modifica la clase CuentaBancaria para que tenga un método setter llamado set_saldo +# que permita modificar el saldo solo si el nuevo saldo es positivo. +# Usa este método para intentar establecer un saldo negativo y observa el resultado. + +class CuentaBancaria: + def __init__(self, saldo_inicial): + self.__saldo = saldo_inicial + + def get_saldo(self): + return self.__saldo + + def set_saldo(self, nuevo_saldo): + if nuevo_saldo >= 0: + self.__saldo = nuevo_saldo + else: + print("El saldo no puede ser negativo.") + +# Crear una instancia de CuentaBancaria +mi_cuenta = CuentaBancaria(1000) + +# Intentar establecer un saldo negativo +mi_cuenta.set_saldo(-500) + +# Mostrar el saldo después del intento +print("Saldo después del intento:", mi_cuenta.get_saldo()) diff --git a/Ejercicios de clase/740_POO_Encapsulacion_04.py b/Ejercicios de clase/740_POO_Encapsulacion_04.py new file mode 100644 index 0000000..29c1e63 --- /dev/null +++ b/Ejercicios de clase/740_POO_Encapsulacion_04.py @@ -0,0 +1,17 @@ + +# Crea una clase Empleado que tenga un atributo protegido _sueldo y un método +# público mostrar_sueldo que imprima el sueldo. Crea una instancia de Empleado +# y llama al método mostrar_sueldo. + +class Empleado: + def __init__(self, sueldo_inicial): + self._sueldo = sueldo_inicial + + def mostrar_sueldo(self): + print(f"El sueldo es: {self._sueldo}") + +# Crear una instancia de Empleado +empleado = Empleado(50000) + +# Llamar al método mostrar_sueldo +empleado.mostrar_sueldo() diff --git a/Ejercicios de clase/745_POO_Encapsulacion_05.py b/Ejercicios de clase/745_POO_Encapsulacion_05.py new file mode 100644 index 0000000..02bca0b --- /dev/null +++ b/Ejercicios de clase/745_POO_Encapsulacion_05.py @@ -0,0 +1,37 @@ + + +# Crea una clase Estudiante con atributos privados __nombre y __nota. +# Implementa métodos getter para ambos atributos y un método setter para __nota +# que solo permita valores entre 0 y 10. Crea una instancia de Estudiante, +# establece y muestra sus valores usando los métodos adecuados. + +class Estudiante: + def __init__(self, nombre, nota): + self.__nombre = nombre + self.__nota = nota + + def get_nombre(self): + return self.__nombre + + def get_nota(self): + return self.__nota + + def set_nota(self, nueva_nota): + if 0 <= nueva_nota <= 10: + self.__nota = nueva_nota + else: + print("La nota debe estar entre 0 y 10.") + +# Crear una instancia de Estudiante +estudiante = Estudiante("Ana", 8) + +# Mostrar el nombre y la nota +print("Nombre:", estudiante.get_nombre()) +print("Nota inicial:", estudiante.get_nota()) + +# Intentar establecer una nueva nota válida e inválida +estudiante.set_nota(9) +print("Nueva nota válida:", estudiante.get_nota()) + +estudiante.set_nota(15) +print("Nota después del intento inválido:", estudiante.get_nota()) diff --git a/Ejercicios de clase/750_POO_Encapsulacion_06.py b/Ejercicios de clase/750_POO_Encapsulacion_06.py new file mode 100644 index 0000000..d2413f7 --- /dev/null +++ b/Ejercicios de clase/750_POO_Encapsulacion_06.py @@ -0,0 +1,23 @@ + + +# Crea una clase Libro con un atributo privado __titulo y un método +# privado __mostrar_titulo que imprime el título del libro. +# Implementa un método público leer_titulo que llame al método +# privado __mostrar_titulo. +# Crea una instancia de Libro y llama al método leer_titulo. + +class Libro: + def __init__(self, titulo): + self.__titulo = titulo + + def __mostrar_titulo(self): + print(f"El título del libro es: {self.__titulo}") + + def leer_titulo(self): + self.__mostrar_titulo() + +# Crear una instancia de Libro +mi_libro = Libro("El Principito") + +# Llamar al método leer_titulo +mi_libro.leer_titulo() diff --git a/Ejercicios de clase/755_POO_Encapsulacion_07.py b/Ejercicios de clase/755_POO_Encapsulacion_07.py new file mode 100644 index 0000000..965c519 --- /dev/null +++ b/Ejercicios de clase/755_POO_Encapsulacion_07.py @@ -0,0 +1,42 @@ + +# Crea una clase Zapatilla que tenga un atributo privado __color. +# Implementa métodos getter y setter para el color, donde el setter +# solo permita los colores "blanco", "negro" y "rojo". +# Si se intenta establecer un color no válido, muestra un mensaje +# indicando que el color no es válido y pide al usuario que elija +# un color válido. +# Crea una instancia de Zapatilla, permite al usuario elegir un color +# y muestra el color de la zapatilla. + + +class Zapatilla: + def __init__(self, color_inicial): + self.__color = color_inicial + + def get_color(self): + return self.__color + + def set_color(self, nuevo_color): + if nuevo_color in ["blanco", "negro", "rojo"]: + self.__color = nuevo_color + else: + print("Color no válido. Por favor, elija entre 'blanco', 'negro' o 'rojo'.") + +# Crear una instancia de Zapatilla con un color inicial válido +mi_zapatilla = Zapatilla("blanco") + +# Mostrar el color inicial +print("Color inicial de la zapatilla:", mi_zapatilla.get_color()) + +# Permitir al usuario elegir un nuevo color +nuevo_color = input("Elige un color para la zapatilla (blanco, negro, rojo): ").strip().lower() +mi_zapatilla.set_color(nuevo_color) + +# Intentar establecer un color hasta que sea válido +while mi_zapatilla.get_color() != nuevo_color: + nuevo_color = input("Elige un color para la zapatilla (blanco, negro, rojo): ").strip().lower() + mi_zapatilla.set_color(nuevo_color) + +# Mostrar el color final de la zapatilla +print("Color final de la zapatilla:", mi_zapatilla.get_color()) + diff --git a/Ejercicios de clase/760_POO_Encapsulacion_08.py b/Ejercicios de clase/760_POO_Encapsulacion_08.py new file mode 100644 index 0000000..175c921 --- /dev/null +++ b/Ejercicios de clase/760_POO_Encapsulacion_08.py @@ -0,0 +1,94 @@ + + +# Crea una clase Zapatilla que tenga los atributos privados +# __color, __precio, __talla y __stock. +# Implementa métodos getter y setter para el color, la talla y el stock. +# El setter del color solo permite "blanco", "negro" y "rojo", y el setter +# de la talla permite tallas entre 36 y 45. El setter del stock debe aceptar +# solo valores positivos. +# El precio depende del color: "blanco" (60€), "negro" (65€) y "rojo" (70€). +# Si el color, la talla o el stock no son válidos, muestra un mensaje indicando el error. +# Crea una instancia de Zapatilla, permite al usuario elegir el color, +# la talla y el stock, y muestra los detalles de la zapatilla. + +class Zapatilla: + def __init__(self, color_inicial, talla_inicial, stock_inicial): + self.__color = color_inicial + self.__talla = talla_inicial + self.__stock = stock_inicial + self.__precio = self.__establecer_precio(color_inicial) + + def get_color(self): + return self.__color + + def get_precio(self): + return self.__precio + + def get_talla(self): + return self.__talla + + def get_stock(self): + return self.__stock + + def set_color(self, nuevo_color): + if nuevo_color in ["blanco", "negro", "rojo"]: + self.__color = nuevo_color + self.__precio = self.__establecer_precio(nuevo_color) + else: + print("Color no válido. Por favor, elija entre 'blanco', 'negro' o 'rojo'.") + + def set_talla(self, nueva_talla): + if 36 <= nueva_talla <= 45: + self.__talla = nueva_talla + else: + print("Talla no válida. Por favor, elija una talla entre 36 y 45.") + + def set_stock(self, nuevo_stock): + if nuevo_stock >= 0: + self.__stock = nuevo_stock + else: + print("Stock no válido. Por favor, elija un valor positivo.") + + def __establecer_precio(self, color): + precios = { + "blanco": 60, + "negro": 65, + "rojo": 70 + } + return precios.get(color, 0) + +# Crear una instancia de Zapatilla con un color, una talla y un stock iniciales válidos +mi_zapatilla = Zapatilla("blanco", 40, 10) + +# Mostrar el color, la talla, el stock y el precio iniciales +print(f"Color inicial de la zapatilla: {mi_zapatilla.get_color()}, Talla: {mi_zapatilla.get_talla()}, Stock: {mi_zapatilla.get_stock()}, Precio: {mi_zapatilla.get_precio()}€") + +# Permitir al usuario elegir un nuevo color +nuevo_color = input("Elige un color para la zapatilla (blanco, negro, rojo): ").strip().lower() +mi_zapatilla.set_color(nuevo_color) + +# Intentar establecer un color hasta que sea válido +while mi_zapatilla.get_color() != nuevo_color: + nuevo_color = input("Elige un color para la zapatilla (blanco, negro, rojo): ").strip().lower() + mi_zapatilla.set_color(nuevo_color) + +# Permitir al usuario elegir una nueva talla +nueva_talla = int(input("Elige una talla para la zapatilla (36-45): ").strip()) +mi_zapatilla.set_talla(nueva_talla) + +# Intentar establecer una talla hasta que sea válida +while mi_zapatilla.get_talla() != nueva_talla: + nueva_talla = int(input("Elige una talla para la zapatilla (36-45): ").strip()) + mi_zapatilla.set_talla(nueva_talla) + +# Permitir al usuario elegir una nueva cantidad en stock +nuevo_stock = int(input("Elige la cantidad en stock para la zapatilla: ").strip()) +mi_zapatilla.set_stock(nuevo_stock) + +# Intentar establecer una cantidad en stock hasta que sea válida +while mi_zapatilla.get_stock() != nuevo_stock: + nuevo_stock = int(input("Elige la cantidad en stock para la zapatilla: ").strip()) + mi_zapatilla.set_stock(nuevo_stock) + +# Mostrar el color, la talla, el stock y el precio final de la zapatilla +print(f"Color final de la zapatilla: {mi_zapatilla.get_color()}, Talla: {mi_zapatilla.get_talla()}, Stock: {mi_zapatilla.get_stock()}, Precio: {mi_zapatilla.get_precio()}€") diff --git a/Ejercicios de clase/765_POO_Encapsulacion_09.py b/Ejercicios de clase/765_POO_Encapsulacion_09.py new file mode 100644 index 0000000..542e03c --- /dev/null +++ b/Ejercicios de clase/765_POO_Encapsulacion_09.py @@ -0,0 +1,41 @@ + + +# Encapsulación con Métodos y Propiedades + +class CuentaBancaria: + def __init__(self, titular, saldo): + self.__titular = titular # Atributo privado + self.__saldo = saldo # Atributo privado + + @property + def saldo(self): + return self.__saldo + + @saldo.setter + def saldo(self, monto): + if monto >= 0: + self.__saldo = monto + else: + print("El saldo no puede ser negativo") + + def depositar(self, monto): + if monto > 0: + self.__saldo += monto + else: + print("El monto a depositar debe ser positivo") + + def retirar(self, monto): + if 0 < monto <= self.__saldo: + self.__saldo -= monto + else: + print("Monto inválido o saldo insuficiente") + +# Uso +cuenta = CuentaBancaria("Ana", 1000) +cuenta.depositar(500) +print(cuenta.saldo) +cuenta.retirar(200) +print(cuenta.saldo) +cuenta.saldo = 1500 # Usando el setter +print(cuenta.saldo) +print(cuenta._CuentaBancaria__saldo) # Accediendo a una propiedad privada. NO RECOMENDADO!!!! diff --git a/Ejercicios de clase/770_POO_Encapsulacion_10.py b/Ejercicios de clase/770_POO_Encapsulacion_10.py new file mode 100644 index 0000000..511bac8 --- /dev/null +++ b/Ejercicios de clase/770_POO_Encapsulacion_10.py @@ -0,0 +1,29 @@ + +# Encapsulación con Métodos de Clase y Métodos Estáticos + +class Producto: + __impuesto = 0.18 # Atributo de clase privado + + def __init__(self, nombre, precio): + self.__nombre = nombre # Atributo privado + self.__precio = precio # Atributo privado + + @classmethod + def establecer_impuesto(cls, impuesto): + if 0 <= impuesto <= 1: + cls.__impuesto = impuesto + else: + print("El impuesto debe estar entre 0 y 1") + + @classmethod + def obtener_impuesto(cls): + return cls.__impuesto + + def precio_final(self): + return self.__precio * (1 + Producto.__impuesto) + +# Uso +Producto.establecer_impuesto(0.20) +producto = Producto("Laptop", 1000) +print(producto.precio_final()) +print(Producto.obtener_impuesto()) diff --git a/Ejercicios de clase/775_POO_Polimorfismo_01.py b/Ejercicios de clase/775_POO_Polimorfismo_01.py new file mode 100644 index 0000000..8261852 --- /dev/null +++ b/Ejercicios de clase/775_POO_Polimorfismo_01.py @@ -0,0 +1,21 @@ + + +# Polimorfismo con Métodos + +class Perro: + def hacer_sonido(self): + return "Guau" + +class Gato: + def hacer_sonido(self): + return "Miau" + +def hacer_sonidos(animal): + print(animal.hacer_sonido()) + +# Uso +perro = Perro() +gato = Gato() + +hacer_sonidos(perro) # Salida: Guau +hacer_sonidos(gato) # Salida: Miau diff --git a/Ejercicios de clase/780_POO_Polimorfismo_10.py b/Ejercicios de clase/780_POO_Polimorfismo_10.py new file mode 100644 index 0000000..68b712f --- /dev/null +++ b/Ejercicios de clase/780_POO_Polimorfismo_10.py @@ -0,0 +1,28 @@ + +# Polimorfismo con Herencia y Métodos Sobrescritos + +class Figura: + def area(self): + pass + +class Circulo(Figura): + def __init__(self, radio): + self.radio = radio + + def area(self): + import math + return math.pi * self.radio ** 2 + +class Rectangulo(Figura): + def __init__(self, ancho, alto): + self.ancho = ancho + self.alto = alto + + def area(self): + return self.ancho * self.alto + +# Uso +figuras = [Circulo(5), Rectangulo(3, 4)] + +for figura in figuras: + print(f"Área: {figura.area()}") diff --git a/Ejercicios de clase/785_POO_Polimorfismo_15.py b/Ejercicios de clase/785_POO_Polimorfismo_15.py new file mode 100644 index 0000000..edef06c --- /dev/null +++ b/Ejercicios de clase/785_POO_Polimorfismo_15.py @@ -0,0 +1,20 @@ + +# Polimorfismo con Interfaces Implícitas + +class Pato: + def hacer_sonido(self): + return "Cuac" + +class Persona: + def hacer_sonido(self): + return "Hola" + +def llamar_sonido(cosa): + print(cosa.hacer_sonido()) + +# Uso +pato = Pato() +persona = Persona() + +llamar_sonido(pato) # Salida: Cuac +llamar_sonido(persona) # Salida: Hola diff --git a/Ejercicios de clase/790_POO_Polimorfismo_16.py b/Ejercicios de clase/790_POO_Polimorfismo_16.py new file mode 100644 index 0000000..957eb03 --- /dev/null +++ b/Ejercicios de clase/790_POO_Polimorfismo_16.py @@ -0,0 +1,30 @@ +class Empleado: + def __init__(self, nombre, salario): + self.nombre = nombre + self.salario = salario + + def mostrar_detalle(self): + return f"Empleado: {self.nombre}, Salario: {self.salario}€" + +class Director(Empleado): + def __init__(self, nombre, salario, departamento): + super().__init__(nombre, salario) # Hereda los atributos de Empleado + self.departamento = departamento + + def mostrar_detalle(self): + return f"Director: {self.nombre}, Salario: {self.salario}€, Departamento: {self.departamento}" + + +# Función polimórfica +def imprimir_detalle(persona): + print(persona.mostrar_detalle()) + + +# Crear instancias de Empleado y Director +empleado = Empleado("Luis", 2500) +director = Director("Ana", 5000, "Finanzas") + +# Usar la función polimórfica +imprimir_detalle(empleado) # Llama a mostrar_detalle() de Empleado +imprimir_detalle(director) # Llama a mostrar_detalle() de Director + diff --git a/Ejercicios de clase/795_POO_Cases_Abstractas_01.py b/Ejercicios de clase/795_POO_Cases_Abstractas_01.py new file mode 100644 index 0000000..83920db --- /dev/null +++ b/Ejercicios de clase/795_POO_Cases_Abstractas_01.py @@ -0,0 +1,43 @@ + + +# Clases abstractas + +from abc import ABC, abstractmethod + +class Figura(ABC): + @abstractmethod + def area(self): + pass + + @abstractmethod + def perimetro(self): + pass + +class Circulo(Figura): + def __init__(self, radio): + self.radio = radio + + def area(self): + import math + return math.pi * self.radio ** 2 + + def perimetro(self): + import math + return 2 * math.pi * self.radio + +class Rectangulo(Figura): + def __init__(self, ancho, alto): + self.ancho = ancho + self.alto = alto + + def area(self): + return self.ancho * self.alto + + def perimetro(self): + return 2 * (self.ancho + self.alto) + +# Uso +figuras = [Circulo(5), Rectangulo(3, 4)] + +for figura in figuras: + print(f"Área: {figura.area()}, Perímetro: {figura.perimetro()}") diff --git a/Ejercicios de clase/800_POO_Cases_Abstractas_02.py b/Ejercicios de clase/800_POO_Cases_Abstractas_02.py new file mode 100644 index 0000000..ea702fb --- /dev/null +++ b/Ejercicios de clase/800_POO_Cases_Abstractas_02.py @@ -0,0 +1,35 @@ + +from abc import ABC, abstractmethod + +# Definir una clase abstracta +class Animal(ABC): + @abstractmethod + def hacer_sonido(self): + pass # Este método debe ser implementado por las subclases + +# Subclase que hereda de la clase abstracta +class Perro(Animal): + def hacer_sonido(self): + return "¡Guau!" + +# Subclase que hereda de la clase abstracta +class Gato(Animal): + def hacer_sonido(self): + return "¡Miau!" + +# Crear instancias de las subclases +perro = Perro() +gato = Gato() + +print(perro.hacer_sonido()) # Salida: ¡Guau! +print(gato.hacer_sonido()) # Salida: ¡Miau! + +# ------------------------------ +# Si una subclase no implementa todos los métodos abstractos de la clase base, +# Python lanzará un error al intentar instanciar la subclase. Por ejemplo: + +# class Pajaro(Animal): +# pass + +# # Esto lanzará un error porque no se implementó el método abstracto +# pajaro = Pajaro() # TypeError: Can't instantiate abstract class Pajaro with abstract method hacer_sonido \ No newline at end of file diff --git a/Ejercicios de clase/805_POO_Cases_Abstractas_10.py b/Ejercicios de clase/805_POO_Cases_Abstractas_10.py new file mode 100644 index 0000000..36ec608 --- /dev/null +++ b/Ejercicios de clase/805_POO_Cases_Abstractas_10.py @@ -0,0 +1,43 @@ + +# Clase Abstracta con Métodos y Propiedades Abstractas + +from abc import ABC, abstractmethod + +class Empleado(ABC): + @abstractmethod + def calcular_salario(self): + pass + + @property + @abstractmethod + def tipo(self): + pass + +class EmpleadoTiempoCompleto(Empleado): + def __init__(self, salario_mensual): + self.salario_mensual = salario_mensual + + def calcular_salario(self): + return self.salario_mensual + + @property + def tipo(self): + return "Tiempo Completo" + +class EmpleadoPorHora(Empleado): + def __init__(self, horas_trabajadas, tarifa_por_hora): + self.horas_trabajadas = horas_trabajadas + self.tarifa_por_hora = tarifa_por_hora + + def calcular_salario(self): + return self.horas_trabajadas * self.tarifa_por_hora + + @property + def tipo(self): + return "Por Hora" + +# Uso +empleados = [EmpleadoTiempoCompleto(3000), EmpleadoPorHora(120, 15)] + +for empleado in empleados: + print(f"Tipo: {empleado.tipo}, Salario: {empleado.calcular_salario()}") diff --git a/Ejercicios de clase/810_POO_Clase_Decoradores_01.py b/Ejercicios de clase/810_POO_Clase_Decoradores_01.py new file mode 100644 index 0000000..f4e7b28 --- /dev/null +++ b/Ejercicios de clase/810_POO_Clase_Decoradores_01.py @@ -0,0 +1,21 @@ + + +# Clase con Propiedades + +class Rectangulo: + def __init__(self, ancho, alto): + self.ancho = ancho + self.alto = alto + + @property + def area(self): + return self.ancho * self.alto + + @property + def perimetro(self): + return 2 * (self.ancho + self.alto) + +# Uso +rectangulo = Rectangulo(3, 4) +print("Área:", rectangulo.area) +print("Perímetro:", rectangulo.perimetro) diff --git a/Ejercicios de clase/815_scraping_basic.py b/Ejercicios de clase/815_scraping_basic.py new file mode 100644 index 0000000..89ceaaa --- /dev/null +++ b/Ejercicios de clase/815_scraping_basic.py @@ -0,0 +1,28 @@ +# pip3 install requests -> instalas la dependencia para hacer peticiones + +import requests +import re + +url = 'https://www.apple.com/es/shop/buy-mac/macbook-air/' + +response = requests.get(url) + +if response.status_code == 200: + print('La petición fue exitosa') + + html = response.text + print(html) + + # regular expression para encontrar el precio + price_pattern = r'(.*?)' + match = re.search(price_pattern, html) + + if match: + print(f"El precio del producto es: {match.group(1)}") + + # get the title if the patter is found + title_pattern = r'(.*?)' + match = re.search(title_pattern, html) + + if match: + print(f"El título de la web es: {match.group(1)}") diff --git a/Ejercicios de clase/820_scraping_beautiful.py b/Ejercicios de clase/820_scraping_beautiful.py new file mode 100644 index 0000000..29b4201 --- /dev/null +++ b/Ejercicios de clase/820_scraping_beautiful.py @@ -0,0 +1,35 @@ +from bs4 import BeautifulSoup +import requests + +url = 'https://www.apple.com/es/shop/buy-mac/macbook-air/' +headers = { + 'User-Agent': 'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; Googlebot/2.1; +http://www.google.com/bot.html) Chrome/131.0.0 Safari/537.36' +} +response = requests.get(url, headers=headers) + +if response.status_code == 200: + print('La petición fue exitosa') + + soup = BeautifulSoup(response.text, 'html.parser') + + # print(soup.prettify()) + title_tag = soup.title + if title_tag: + print(f"El título de la web es: {title_tag.text}") + + # find price using bs + # price_span = soup.find('span', class_='rc-prices-fullprice') + # if price_span: + # print(f"El precio del producto es: {price_span.text}") + + # find all the prices + # prices_span = soup.find_all(class_='rc-prices-fullprice') + # for price in prices_span: + # print(f"El precio del producto es: {price.text}") + + # find each product and get the name and the price + products = soup.find_all(class_='rc-productselection-item') + for product in products: + name = product.find(class_="list-title").text + price = product.find(class_="rc-prices-fullprice").attrs + print(f"El producto con las características:\n {name}\nPrecio de {price}\n\n") \ No newline at end of file diff --git a/Ejercicios de clase/825_wiki_scraper.py b/Ejercicios de clase/825_wiki_scraper.py new file mode 100644 index 0000000..1162b2c --- /dev/null +++ b/Ejercicios de clase/825_wiki_scraper.py @@ -0,0 +1,45 @@ +from bs4 import BeautifulSoup +from urllib.parse import urljoin +import requests + +def scrape_url(url: str): + headers = { + 'User-Agent': 'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; Googlebot/2.1; +http://www.google.com/bot.html) Chrome/131.0.0 Safari/537.36' + } + response = requests.get(url, headers=headers) + + if response.status_code == 200: + print('La petición fue exitosa') + + soup = BeautifulSoup(response.text, 'html.parser') + + # Extraer todos los + titulos = [titulo.string for titulo in soup.find_all('h1')] + # print(titulos) + + # Extraer todos los enlaces + enlaces = [urljoin(url, enlace.get('href')) for enlace in soup.find_all('a')] + # print(enlaces) + + # extraer todo el contenido de la página de texto + # all_text = soup.get_text() + # print(all_text) + + # extraer el texto del elemento main + # main_text = soup.find('main').get_text() + # print(main_text) + + # extraer de la id mw-content-text + # content_text = soup.find('div', {'id': 'mw-content-text'}).get_text() + # print(content_text) + + # extrar el open graph si existe + # og_image = soup.find('meta', {'property': 'og:image'}) + + og_image = soup.find('meta', property='og:image') + if og_image: + print(og_image['content']) + else: + print('No se encontró la imagen') + +scrape_url('https://midu.dev') \ No newline at end of file diff --git a/Ejercicios de clase/830_seo_cli.py b/Ejercicios de clase/830_seo_cli.py new file mode 100644 index 0000000..3d93e28 --- /dev/null +++ b/Ejercicios de clase/830_seo_cli.py @@ -0,0 +1,43 @@ +import requests +import argparse + +from bs4 import BeautifulSoup +from urllib.parse import urljoin + +parser = argparse.ArgumentParser(description="Web scraping to check SEO for a given URL") +parser.add_argument('url', type=str, help='The URL of the site you want to scrape and check') +args = parser.parse_args() +url = args.url + +headers = { + 'User-Agent': 'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; Googlebot/2.1; +http://www.google.com/bot.html) Chrome/131.0.0 Safari/537.36' +} +response = requests.get(url, headers=headers) + +if response.status_code == 200: + print('La petición fue exitosa') + + soup = BeautifulSoup(response.text, 'html.parser') + + print(f"\033[34mRevisando la página: {url}\033[0m") + print("\nSEO básico:") + + titulo_pagina = soup.title.string + + if titulo_pagina: + print(f"\033[46mEl título de la página es: {titulo_pagina}\033[0m") + if len(titulo_pagina) < 70: + print("\033[32m✅ El título de la página tiene una longitud adecuada\033[0m") + else: + print("⚠️ El título de la página es DEMASIADO largo") + + # extrae todos los titulos h1 + titulos = [titulo.text for titulo in soup.find_all('h1')] + if not titulos: + print("\033[31m❌ No se encontraron títulos h1 en la página\033[0m") + elif len(titulos) > 1: + print("\033[31m❌ Hay más de un título h1 en la página\033[0m") + for titulo in titulos: + print(titulo) + else: + print("\033[32m✅ Hay un título h1 en la página\033[0m") \ No newline at end of file diff --git a/Ejercicios de clase/835_playwright.py b/Ejercicios de clase/835_playwright.py new file mode 100644 index 0000000..76f0752 --- /dev/null +++ b/Ejercicios de clase/835_playwright.py @@ -0,0 +1,17 @@ +import re # regular expression +from playwright.sync_api import Page, expect + +def test_has_title(page: Page): + page.goto("https://playwright.dev/") + + # Expect a title "to contain" a substring. + expect(page).to_have_title(re.compile("Playwright")) + +def test_get_started_link(page: Page): + page.goto("https://playwright.dev/") + + # Click the get started link. + page.get_by_role("link", name="Get started").click() + + # Expects page to have a heading with the name of Installation. + expect(page.get_by_role("heading", name="Installation")).to_be_visible() \ No newline at end of file diff --git a/Ejercicios de clase/840_playwright_scraping.py b/Ejercicios de clase/840_playwright_scraping.py new file mode 100644 index 0000000..8edbae3 --- /dev/null +++ b/Ejercicios de clase/840_playwright_scraping.py @@ -0,0 +1,19 @@ +from playwright.sync_api import sync_playwright + +url = 'https://midu.dev' + +with sync_playwright() as p: + browser = p.chromium.launch(headless=False, slow_mo=2000) + page = browser.new_page() + page.goto(url) + + first_article_anchor = page.locator('article a').first + print(first_article_anchor.text_content()) + first_article_anchor.click() + + page.wait_for_load_state() + + curso_content_container = page.locator('text="Contenido del curso"') + curso_content_sibling = curso_content_container.locator('xpath=./div/') + + browser.close() \ No newline at end of file diff --git a/Ejercicios de clase/850_Excepciones_01.txt b/Ejercicios de clase/850_Excepciones_01.txt new file mode 100644 index 0000000..e83cb5c --- /dev/null +++ b/Ejercicios de clase/850_Excepciones_01.txt @@ -0,0 +1,30 @@ + +Las excepciones son errores que ocurren durante la ejecución de un programa. +Por ejemplo, intentar dividir entre cero o acceder a una posición inexistente +de una lista. + +Python permite capturar estos errores y actuar en consecuencia sin que el +programa termine abruptamente. + +🧱 Estructura básica de manejo de excepciones + +try: + # Código que puede causar un error +except TipoDeError: + # Código que se ejecuta si ocurre ese error +else: + # (Opcional) Código que se ejecuta si NO ocurre ningún error +finally: + # (Opcional) Código que se ejecuta siempre, ocurra o no el error + + +Excepciones más comunes: + +Excepción ¿Cuándo ocurre? + +ZeroDivisionError Dividir entre cero +ValueError Conversión de tipos inválida +IndexError Índice fuera del rango de una secuencia +KeyError Clave inexistente en un diccionario +TypeError Operación no válida entre tipos distintos +FileNotFoundError Archivo no encontrado \ No newline at end of file diff --git a/Ejercicios de clase/855_Excepciones_02.py b/Ejercicios de clase/855_Excepciones_02.py new file mode 100644 index 0000000..2eaa560 --- /dev/null +++ b/Ejercicios de clase/855_Excepciones_02.py @@ -0,0 +1,26 @@ +print('*** Manejo de Excepciones ***') + +def dividir(numerador, denominador): + try: + # Revisamos si el denominador es igual a 0 + if denominador == 0: + raise Exception('El denominador es igual a 0') + resultado = numerador / denominador + print(f'Resultado de la división: {resultado}') + except Exception as e: + print(f'Ocurrio un error: {e}') + else: + print(f'No ocurrió ningún error') + finally: + print(f'Terminamos de procesar la excepcion\n') + # except ZeroDivisionError: + # print('Error: No se puede dividir entre cero') + # except TypeError: + # print('Error: Los operandos deben ser numericos') + + +# Ejemplo de uso +dividir(10, 2) +dividir(10, 0) +dividir(10, '0') +print("El programa sigue") \ No newline at end of file diff --git a/Ejercicios de clase/860_Excepciones_03.py b/Ejercicios de clase/860_Excepciones_03.py new file mode 100644 index 0000000..3a6a127 --- /dev/null +++ b/Ejercicios de clase/860_Excepciones_03.py @@ -0,0 +1,20 @@ +try: + numero = int(input("Introduce un número: ")) + resultado = 10 / numero + print("Resultado:", resultado) +except ZeroDivisionError: + print("¡Error! No se puede dividir entre cero.") +except ValueError: + print("¡Error! Debes introducir un número válido.") +else: + print("La operación se realizó con éxito.") +finally: + print("Fin del bloque try-except.") + +# Si pones 0, se lanza ZeroDivisionError. + +# Si pones "abc", se lanza ValueError. + +# else se ejecuta si no hay error. + +# finally siempre se ejecuta. \ No newline at end of file diff --git a/Ejercicios de clase/865_Excepciones_04.py b/Ejercicios de clase/865_Excepciones_04.py new file mode 100644 index 0000000..9d039e2 --- /dev/null +++ b/Ejercicios de clase/865_Excepciones_04.py @@ -0,0 +1,33 @@ + +# Ejemplo 2: Acceso a una lista fuera de rango + +lista = [1, 2, 3] + +try: + print(lista[5]) +except IndexError as e: + print(f"Error: {e}") + + + +# Ejemplo 3: Uso de múltiples excepciones + +try: + num = int(input("Número: ")) + print(10 / num) +except (ValueError, ZeroDivisionError) as e: + print("Ocurrió un error:", e) + + + +# Ejemplo 4: Bucle hasta que el usuario lo haga bien + +while True: + try: + edad = int(input("Introduce tu edad: ")) + break + except ValueError: + print("Eso no es un número. Inténtalo otra vez.") + + + diff --git a/Ejercicios de clase/870_Excepciones_05.py b/Ejercicios de clase/870_Excepciones_05.py new file mode 100644 index 0000000..6ce94d3 --- /dev/null +++ b/Ejercicios de clase/870_Excepciones_05.py @@ -0,0 +1,26 @@ +# Crear tus propias excepciones + +# La palabra clave raise lanza una excepción (es decir, provoca un error +# intencionalmente) en el momento que tú decides, para que el flujo del +# programa salte al bloque except correspondiente o se detenga si no se captura. + +# ¿Por qué querrías lanzar una excepción tú mismo? +# Para validar datos (por ejemplo, edades negativas, textos vacíos, etc.). + +# Para detectar condiciones anómalas en tu código y tratarlas de forma controlada. + +# Para usar tus propias excepciones personalizadas. + + +class EdadInvalidaError(Exception): + pass + +def verificar_edad(edad): + if edad < 0: + raise EdadInvalidaError("La edad no puede ser negativa.") + print("Edad válida:", edad) + +try: + verificar_edad(-5) +except EdadInvalidaError as e: + print("Error personalizado:", e) \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..7b88ce4 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 F Javier + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git "a/Material did\303\241ctico/Chuleta GitHub.docx" "b/Material did\303\241ctico/Chuleta GitHub.docx" index 8d3f13d..888361b 100644 Binary files "a/Material did\303\241ctico/Chuleta GitHub.docx" and "b/Material did\303\241ctico/Chuleta GitHub.docx" differ diff --git a/README.md b/README.md new file mode 100644 index 0000000..437dec3 --- /dev/null +++ b/README.md @@ -0,0 +1,115 @@ +## 📘 Curso de Python - Nivel Básico y Avanzado + +Este es un repositorio educativo que contiene material didáctico, ejemplos prácticos y ejercicios para aprender Python desde cero hasta un nivel avanzado. Además, incluye recursos complementarios de HTML, CSS y JavaScript para brindar una formación integral en desarrollo web. + +## 🧰 Contenido del Curso + +El repositorio está estructurado en las siguientes secciones: + +## 🐍 Python + +- Fundamentos del lenguaje: variables, tipos de datos, operadores, estructuras de control. +- Funciones y módulos: definición, argumentos, retorno de valores, importación de módulos. +- Estructuras de datos: listas, tuplas, diccionarios, conjuntos. +- Programación orientada a objetos: clases, objetos, herencia, encapsulamiento. +- Manejo de errores: excepciones, bloques try-except. +- Archivos y persistencia de datos: lectura y escritura de archivos, uso de pickle. +- Ejercicios prácticos: problemas resueltos y propuestos para afianzar los conocimientos. + +## 🌐 HTML + +- Estructura básica de una página web: etiquetas principales, encabezados, párrafos, listas. +- Enlaces e imágenes: inserción y manejo de recursos multimedia. +- Formularios: creación y validación de formularios básicos. + +## 🎨 CSS + +- Selectores y propiedades: estilos básicos, colores, fuentes, márgenes, padding. +- Modelo de caja: comprensión y aplicación del box model. +- Diseño responsivo: uso de media queries para adaptar el diseño a diferentes dispositivos. + +## 💻 JavaScript + +- Sintaxis básica: variables, operadores, estructuras de control. +- Funciones y eventos: definición de funciones, manejo de eventos del DOM. +- Manipulación del DOM: acceso y modificación de elementos HTML. +- Ejercicios prácticos: scripts interactivos para mejorar la experiencia del usuario. + +## 📂 Estructura del Repositorio + +```plaintext +Curso_Python/ +├── 01 HTML/ +├── 02 CSS/ +├── 03 JAVASCRIPT/ +├── 10 PYTHON/ +├── Ejercicios de clase/ +├── Material didáctico/ +├── mi_lista.pkl +├── midic.pkl +├── short.zen.txt +└── the_zen_of_python.txt +``` + +- 01 HTML: Contiene ejemplos y ejercicios relacionados con HTML. +- 02 CSS: Incluye estilos y prácticas de diseño con CSS. +- 03 JAVASCRIPT: Scripts y ejercicios para aprender JavaScript. +- 10 PYTHON: Material principal del curso de Python. +- Ejercicios de clase: Problemas y soluciones discutidos durante las sesiones. +- Material didáctico: Recursos adicionales como presentaciones y documentos de apoyo. +- Archivos .pkl y .txt: Datos serializados y textos de referencia, como "The Zen of Python". + +## 🚀 Cómo Empezar + +1. Clonar el repositorio: + + ```bash + git clone https://github.com/guizafj/Curso_Python.git + cd Curso_Python + ``` + +2. Requisitos: + +- Python 3.x instalado. +- Editor de código (recomendado: Visual Studio Code). + +3. Ejecutar ejemplos de python: + +Navega a la carpeta 10 PYTHON y ejecuta los scripts deseados: + + ```bash + python nombre_del_script.py + ``` + +4. Visualizar ejemplos de HTML/CSS/JavaScript: + +Abre los archivos .html en tu navegador para ver los ejemplos en acción. + +## 🎯 Objetivos del Curso + +- Brindar una comprensión sólida de los fundamentos de Python. +- Desarrollar habilidades prácticas mediante ejercicios y proyectos. +- Introducir conceptos básicos de desarrollo web con HTML, CSS y JavaScript. +- Preparar a los estudiantes para proyectos más complejos y desarrollo full-stack. + +## 🤝 Contribuciones + +¡Las contribuciones son bienvenidas! Si deseas colaborar: + + 1. Haz un fork del repositorio. + 2. Crea una nueva rama (git checkout -b feature/nueva-funcionalidad). + 3. Realiza tus cambios y haz commit (git commit -m 'Añadir nueva funcionalidad'). + 4. Sube tus cambios a tu fork (git push origin feature/nueva-funcionalidad). + 5. Abre un Pull Request describiendo tus cambios. + +## 📄 Licencia + +Este proyecto está bajo la Licencia MIT. Consulta el archivo LICENSE para más detalles. + +## 📬 Contacto + +Para consultas o sugerencias: + +Autor: guizafj + +Correo: contacto@dguiza.dev \ No newline at end of file diff --git a/mi_lista.pkl b/mi_lista.pkl new file mode 100644 index 0000000..6a0672c Binary files /dev/null and b/mi_lista.pkl differ diff --git a/midic.pkl b/midic.pkl new file mode 100644 index 0000000..ff9f739 Binary files /dev/null and b/midic.pkl differ diff --git a/short.zen.txt b/short.zen.txt new file mode 100644 index 0000000..f95ee6e --- /dev/null +++ b/short.zen.txt @@ -0,0 +1,20 @@ +... Bello es mejor que feo. +... Explícito es mejor que implícito. +... Simple es mejor que complejo. +... Complejo es mejor que complicado. +... Plano es mejor que anidado. +... Espaciado es mejor que denso. +... La legibilidad es importante. +... Los casos especiales no son lo suficientemente especiales como para romper las reglas. +... Sin embargo la practicidad le gana a la pureza. +... Los errores nunca deberían pasar silenciosamente. +... A menos que se silencien explícitamente. +... Frente a la ambigüedad, evitar la tentación de adivinar. +... Debería haber una, y preferiblemente solo una, manera obvia de hacerlo. +... A pesar de que eso no sea obvio al principio a menos que seas Holandés. +... Ahora es mejor que nunca. +... A pesar de que nunca es muchas veces mejor que *ahora* mismo. +... Si la implementación es difícil de explicar, es una mala idea. +... Si la implementación es fácil de explicar, puede que sea una buena idea. +... Los espacios de nombres son una gran idea, ¡tengamos más de esos! +... diff --git a/the_zen_of_python.txt b/the_zen_of_python.txt new file mode 100644 index 0000000..608f4a0 --- /dev/null +++ b/the_zen_of_python.txt @@ -0,0 +1,20 @@ +Gur Mra bs Clguba, ol Gvz Crgref + Ornhgvshy vf orggre guna htyl. + Rkcyvpvg vf orggre guna vzcyvpvg. + Fvzcyr vf orggre guna pbzcyrk. + Pbzcyrk vf orggre guna pbzcyvpngrq. + Syng vf orggre guna arfgrq. + Fcnefr vf orggre guna qrafr. + Ernqnovyvgl pbhagf. + Fcrpvny pnfrf nera'g fcrpvny rabhtu gb oernx gur ehyrf. + Nygubhtu cenpgvpnyvgl orngf chevgl. + Reebef fubhyq arire cnff fvyragyl. + Hayrff rkcyvpvgyl fvyraprq. + Va gur snpr bs nzovthvgl, ershfr gur grzcgngvba gb thrff. + Gurer fubhyq or bar-- naq cersrenoyl bayl bar --boivbhf jnl gb qb vg. + Nygubhtu gung jnl znl abg or boivbhf ng svefg hayrff lbh'er Qhgpu. + Abj vf orggre guna arire. + Nygubhtu arire vf bsgra orggre guna *evtug* abj. + Vs gur vzcyrzragngvba vf uneq gb rkcynva, vg'f n onq vqrn. + Vs gur vzcyrzragngvba vf rnfl gb rkcynva, vg znl or n tbbq vqrn. + Anzrfcnprf ner bar ubaxvat terng vqrn -- yrg'f qb zber bs gubfr! \ No newline at end of file diff --git a/zen_encriptado.txt b/zen_encriptado.txt new file mode 100644 index 0000000..9d24d58 --- /dev/null +++ b/zen_encriptado.txt @@ -0,0 +1,20 @@ +... Oryyb rf zrwbe dhr srb. +... Rkcyípvgb rf zrwbe dhr vzcyípvgb. +... Fvzcyr rf zrwbe dhr pbzcyrwb. +... Pbzcyrwb rf zrwbe dhr pbzcyvpnqb. +... Cynab rf zrwbe dhr navqnqb. +... Rfcnpvnqb rf zrwbe dhr qrafb. +... Yn yrtvovyvqnq rf vzcbegnagr. +... Ybf pnfbf rfcrpvnyrf ab fba yb fhsvpvragrzragr rfcrpvnyrf pbzb cnen ebzcre ynf ertynf. +... Fva rzonetb yn cenpgvpvqnq yr tnan n yn chermn. +... Ybf reeberf ahapn qroreína cnfne fvyrapvbfnzragr. +... N zrabf dhr fr fvyrapvra rkcyípvgnzragr. +... Seragr n yn nzovtürqnq, rivgne yn gragnpvóa qr nqvivane. +... Qroreín unore han, l cersrevoyrzragr fbyb han, znaren boivn qr unpreyb. +... N crfne qr dhr rfb ab frn boivb ny cevapvcvb n zrabf dhr frnf Ubynaqéf. +... Nuben rf zrwbe dhr ahapn. +... N crfne qr dhr ahapn rf zhpunf irprf zrwbe dhr *nuben* zvfzb. +... Fv yn vzcyrzragnpvóa rf qvsípvy qr rkcyvpne, rf han znyn vqrn. +... Fv yn vzcyrzragnpvóa rf sápvy qr rkcyvpne, chrqr dhr frn han ohran vqrn. +... Ybf rfcnpvbf qr abzoerf fba han tena vqrn, ¡gratnzbf záf qr rfbf! +...