├── .gitignore ├── Bienvenida.md ├── Clases ├── 01 print │ └── 01 print('Hola mundo') .py ├── 02 Variables │ └── 02 Variables.py ├── 03 Operadores │ ├── 03 Operadores _1+'1'=11 .py │ ├── 03.3 Operadores comparativos.py │ └── 03.9 Operadores logicos.py ├── 04 Srtings │ ├── 04 Strings.py │ └── 04.5 Funciones.py ├── 05 Listas │ ├── 05 Listas.py │ └── 05.2 Operaciones comunes.py ├── 06 Tuples │ ├── 06 Tuples.py │ └── 06.2 Operaciones comunes.py ├── 07 Sets │ ├── 07 sets.py │ └── 07.2 Operaciones comunes.py ├── 08 Dictionaries │ ├── 08 Dictionaries.py │ └── 08.2 Operaciones comunes.py ├── 09 Condicionales │ └── 09 Condicionales.py ├── 10 Bucles │ └── 10 Bucles.py ├── 11 Funciones │ └── 11 Funciones.py ├── 12 Modulos │ ├── 12 Modulos.py │ └── mi_modulo.py ├── 13 Comprensión de listas │ └── 13 Comprensión de listas.py ├── 14 Funciones de orden superior │ └── 14 Funciones de orden superior.py ├── 15 Errores de tipo en Python │ └── 15 Errores de tipo en Python.md ├── 16 Fecha y hora de Python │ └── 16 Fecha y hora de Python.py ├── 17 Manejo de excepciones │ └── 17 Manejo de excepciones.py └── graphical-tic-tac-toe │ ├── README.md │ ├── requirements.txt │ └── src │ ├── __pycache__ │ └── game_logic.cpython-310.pyc │ ├── game_logic.py │ ├── main.py │ └── ui │ ├── __init__.py │ └── game_ui.py ├── Ejercicios ├── 01 Hola mundo │ ├── 01 Hola mundo.md │ ├── HolaMundo-Alejosor.py │ ├── HolaMundo-Diego17cp.py │ └── HolaMundo-JulianB0315.py ├── 02 Cambios de variables │ ├── 02 Cambios de variables.md │ ├── CambiosDeVariables-Diego17cp.py │ ├── Cambiosdevariables-Alejosor.py │ └── Cambiosdevariables-JulianB0315.py ├── 03 Operadores │ ├── 03 Operadores.md │ ├── Operadores-Alejosor.py │ ├── Operadores-Diego17cp.py │ └── Operadores-JulianB0315.py ├── 04 Strings │ ├── 04 Strings.md │ └── Strings--JulianB0315.py ├── 05 Listas │ ├── 05 Listas .md │ └── listas-JulianB0315.py ├── 06 Tuples │ ├── 06 Tuples .md │ └── tuples-JulianB0315.py ├── 07 Sets │ ├── 07 Sets.md │ └── sets-JulianB0315.py ├── 08 Dictionaries │ ├── 08 Dictionaries.md │ └── sets-JulianB0315.py ├── 09 Condicionales │ ├── 09 Condicionales.md │ └── Condicionales-JulianB0315.py ├── 10 Bucles │ ├── 10 Bucles .md │ └── Bucles-JulianB0315.py ├── 11 Funciones │ ├── 11 Funciones.md │ └── Funciones-JulianB0315.py ├── 12 Modulos │ ├── Modulos-JulianB0315.py │ └── Modulos.md ├── 13 Compresión de listas │ ├── 13 Compresión de listas.md │ └── Compresión de listas-JulianB0315.py ├── 14 Funciones de orden superior │ ├── 14 Funciones de orden superior.md │ ├── Funciones de orden superior.py │ ├── __pycache__ │ │ └── countries_data.cpython-311.pyc │ └── countries_data.py ├── 16 Fecha y hora de Python │ └── 16 Fecha y hora de Python.md ├── Biometricos │ ├── EJ 01.py │ └── EJ 02.py ├── Ej de Varianza Y Desviacion │ ├── Ej 01.py │ └── Ej 02.py ├── Pandas │ ├── Ejercicio 01 │ │ ├── Informe_ventas.py │ │ ├── usuarios.csv │ │ └── ventas.csv │ └── Ejercicio 02 │ │ ├── Tienda.py │ │ ├── inventario.csv │ │ └── usuarios.csv ├── Practicas personales │ ├── Py-class 01 │ │ ├── Clinica.py │ │ ├── banco.py │ │ └── ejemplo_pilas.py │ ├── Py-class 02 │ │ ├── Biblioteca_publica.py │ │ └── Biblioteca_publica_pandas.py │ ├── Py-class 03 │ │ ├── Biblioteca_publica_IA.py │ │ ├── IA 01.py │ │ ├── bot_biblioteca.py │ │ ├── libros.csv │ │ └── usuarios.csv │ ├── Py-class 04 │ │ ├── Cuentas.xlsx │ │ ├── Transacciones.xlsx │ │ ├── banco.py │ │ └── maplot.py │ ├── Py-class 05 │ │ ├── MM-ej 01.py │ │ └── MM-ej 02.py │ ├── Py-class 06 │ │ └── Ejemplos clase │ │ │ ├── Datagrama01.py │ │ │ ├── Datagrama02.py │ │ │ ├── Dtagrama.py │ │ │ ├── data1.ipynb │ │ │ ├── data2.ipynb │ │ │ └── data3.ipynb │ └── Py-class 07 │ │ ├── Pruebas.py │ │ └── Redes.py ├── Redes Neuronales │ ├── Redes neuronales.py │ └── entregable.py └── Vision artificial en ML │ └── face_recognition_example.py ├── Fuera de tema ├── 01.py ├── 02.py ├── 03.py ├── 04.py ├── 05.py ├── 06.py ├── 07.py ├── 08.py └── Juegos xd │ └── Tres en raya.py ├── LICENSE └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | Ejercicios/14 Funciones de orden superior/__pycache__/ 2 | Ejercicios/Practicas personales/Py-class 03/__pycache__/ -------------------------------------------------------------------------------- /Bienvenida.md: -------------------------------------------------------------------------------- 1 | # [![My Skills](https://skillicons.dev/icons?i=github&theme=dark)](https://skillicons.dev) **Colaboradores:** 2 | 1. Julian [**JulianB0315**](https://github.com/Julianb0315) 3 | 2. Alejandro [**Alejosor**](https://github.com/Alejosor) 4 | 3. Diego [**Diego17cp**](https://github.com/Diego17cp) -------------------------------------------------------------------------------- /Clases/01 print/01 print('Hola mundo') .py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | # Algo muy bueno de python desde ser fácil de aprender es su propia Wiki https://docs.python.org/es/3/ desde como Instalar y una ayuda de donde apoyarse 7 | # Comenzamos de un "Print" escribimos del print ya continuación abrimos y cerramos comillas dobles o simples y paréntesis 8 | print("Hola mundo") 9 | print('Hola mundo') 10 | #------------------------------------------------------------------------------------------------------------------------------------------- 11 | # Un print es demasiado fácil probemos con algo mas 12 | """ 13 | Los comentarios son una 14 | ayuda para ubicar un proceso 15 | rapido o simplemente documentar 16 | puedes hacerlos con 17 | # ' y """ 18 | #------------------------------------------------------------------------------------------------------------------------------------------- 19 | #Existen diferentes tipos de datos para letras, numeros, decimales, etc. 20 | #Consulta del tipo de dato 21 | print(type("Hola mundo")) #Tipo "str" 22 | print(type(True)) #Tipo "bool" 23 | print(type(5)) #Tipo "int" 24 | print(type(1.5)) #Tipo "float" 25 | print(type(1+2J)) #Tipo "complex" 26 | print(type([1,2,3])) #Tipo "list" 27 | print(type(["Hola","mundo"])) #Tipo "list" 28 | print(type({'Nombre':'Julian'})) #Tipo "dict" 29 | print(type((1.3, 1.4, 1.5))) #Tipo "tuple" 30 | #Ahora ya estas list@ para el primer Modulo "01 Hola Mundo" https://github.com/JulianB0315/Python_0_to_hero/blob/main/Ejercicios/01%20Hola%20mundo/01%20Hola%20mundo.md 31 | #------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------- /Clases/02 Variables/02 Variables.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | # ------------------------------------------------------------------------------------------------------------------------------------------- 7 | #Ahora aprendamos las variables 8 | #Para tener una buena base y practica a la hora de escribir variables debemos tener en cuenta los siente ejemplos: 9 | #Forma correcta: 10 | 11 | first_mane='Pablo' 12 | last_name='Acuña' 13 | mun1=10 14 | 15 | #Forma incorrecta (si quieres comprobar quita el comentario): 16 | #last@name='Acuña' 17 | #first-name='Pedro' 18 | #1mun=8 19 | #--------------------------------------------------------------------------------------------------------------------------------------------- 20 | #Podemos tener diferentes tipos de variables como: 21 | tipo_string='Hola tengo'# 'str' 22 | #Imprimimos la variable con un print el nombre de la variable sin las comillas 23 | print(tipo_string) 24 | 25 | tipo_int=20 # 'int' 26 | #Con los números igual 27 | print(tipo_int) 28 | 29 | #Y con demas 30 | tipo_bool=False 31 | print(tipo_bool) 32 | #------------------------------------------------------------------------------------------------------------------------------------------- 33 | #Podemos llamar diferentes variables y escribir líneas de texto, sin importar el tipo siempre y cuando estén separadas con comas 34 | print(tipo_string,tipo_int,'este dato es',tipo_bool) 35 | 36 | #------------------------------------------------------------------------------------------------------------------------------------------- 37 | #Ahora probemos con cambiar los tipos de variables a str 38 | edad=18 39 | print(edad) 40 | print(type(edad)) 41 | 42 | #Cambiemos esta variable de int a str 43 | string_edad=str(edad) 44 | print(string_edad) 45 | print(type(string_edad)) 46 | 47 | #Un boolean a str 48 | python=True 49 | print(type(python)) 50 | 51 | str_python=str(python) 52 | print(str_python) 53 | print(type(str_python)) 54 | 55 | #------------------------------------------------------------------------------------------------------------------------------------------- 56 | #Ahora probemos algo más poner varias variables en una sola línea 57 | nombre,ciclo,carrera,respuesta='Juan',3,'Ingeniero en sofware',True 58 | #Ahora probemos en una cadena de texto las variables anteriores 59 | print('Soy',nombre,'estudio',carrera,'voy por el ciclo N°',ciclo,'esto es la',respuesta ) 60 | #Importante debes de tener cuidado al hacer esto, por que puedes crear posibles errores 61 | 62 | #------------------------------------------------------------------------------------------------------------------------------------------- 63 | #Después de haber aprendido las variables y algunos de sus tipos 64 | #Probemos que el propio usuario ingrese el valor de esas variables 65 | nombre=input('¿Cual es tu nombre?') 66 | edad=input('¿Cuantos es tu edad?') 67 | print('Hola',nombre,'de',edad,'años de edad') 68 | #Si te diste cuenta antes la variable nombre tenia otro valor que es Juan pero al crear un input con la misma variable cambiamos el valor de la misma 69 | #Dato Importante: Las variables pueden cambiar durante el procedimiento de código, como el valor y el tipo de dato 70 | #Esto solo se puede hacer en lenguajes como Python 71 | #------------------------------------------------------------------------------------------------------------------------------------------- 72 | #Pero que pasa si intentamos forzar el valor de la variable para que siempre sea un str 73 | prueba: str='Hola mundo' 74 | prueba=30 75 | #veamos si prueba si la variable sigue como str 76 | print(type(prueba)) 77 | #Como vemos no funciona esto solo pasa en Python, pero es una mala practica por que puede generar errores 78 | #------------------------------------------------------------------------------------------------------------------------------------------- 79 | #Ahora ya estas list@ para el Modulo "Cambios variables" https://github.com/JulianB0315/Python_0_to_hero/blob/main/Ejercicios/02%20Cambios%20de%20variables/02%20Cambios%20de%20variables.md 80 | -------------------------------------------------------------------------------- /Clases/03 Operadores/03 Operadores _1+'1'=11 .py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | _1='1' 8 | print(_1+'1') 9 | #------------------------------------------------------------------------------------------------------------------------------------------- 10 | #Operadores aritméticos los cuales son : 11 | print('Operadores aritmeticos') 12 | print('Suma') 13 | print(1 + 2) 14 | print('Resta') 15 | print(2 - 1) 16 | print('Multiplicación') 17 | print(2 * 3) 18 | print('División') 19 | print(9 / 3)#Poniendo una solo / la división solo dará decimal si lo necesita 20 | print(7 / 2)#Como en este caso siendo la operación más exacta 21 | print(7 // 2)#Poniendo dos veces / la división no tendrá decimal y será redondeada 22 | print(10 // 3) 23 | print('Residuos de la división') 24 | print(3 % 2) #Muestra los residuos de una división 25 | print('Potencia') 26 | print(3 ** 2) 27 | #Lo mismo se puede hacer como variables creadas previamente o introducidas al correr el código 28 | print('Con variables') 29 | v1=2 30 | v2=30 31 | print('Suma') 32 | print(v1 + v2) 33 | print('Resta') 34 | print(v2 - v1) 35 | print('Multiplicación') 36 | print(v2 * v1) 37 | print('División') 38 | print(v2 / v1) 39 | #------------------------------------------------------------------------------------------------------------------------------------------- 40 | #Una cosa interesante de los operadores es que podemos usarlos en cadenas de texto(multiplicación,potencia y suma) 41 | print('Operadores aritmeticos en cadenas de texto') 42 | print('Hola'+str(5)) 43 | # Tambien 44 | print(' Hola '*5) 45 | print(' Hola '*(2**2) ) 46 | #En caso de la suma es una remplazo de las comas y en la multiplicación de multiplica el str anterior solo se pueden usar valores de tipo int 47 | print('Funciona '+ 'tambien '+'con '+'cadenas '+'de '+'texto') 48 | #------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------- /Clases/03 Operadores/03.3 Operadores comparativos.py: -------------------------------------------------------------------------------- 1 | #------------------------------------------------------------------------------------------------------------------------------------------- 2 | #Ahora veamos los operadores comparativos como dice su nombre sirven para comparar variables, datos, etc. 3 | print('Operadores comparativos') 4 | #Usemos variables 5 | print('Variables de tipo int') 6 | n1=5 7 | n2=10 8 | print(n1>n2) #mayor que 9 | print(n1=n2) #mayor o igual que 11 | print(n1<=n2) #menor o igual que 12 | print(n1==n2) #igual que 13 | print(n1!=n2) #diferente que 14 | #Al ejecutar el código la consola nos dará true o false, pero ¿Por qué? es por que esta diciendo si tu declaración es verdadera o falsa 15 | #Pero de podra hacer con str 16 | print('Variables de tipo str') 17 | str1='Messi' 18 | str2='Ronaldo' 19 | print(str1>str2) #mayor que 20 | print(str1=str2) #mayor o igual que 22 | print(str1<=str2) #menor o igual que 23 | print(str1==str2) #igual que 24 | print(str1!=str2) #diferente que 25 | #MMM ¿Sera que Ronaldo es mejor que Messi? Mentira los que hace Python es ordenar por orden alfabético no contando caracteres donde la A=1 y la Z=27 26 | #Veamos si es cierto 27 | print('Variables de tipo str parte 2') 28 | str3='Cristiano' 29 | print(str1>str3) #mayor que 30 | print(str1=str3) #mayor o igual que 32 | print(str1<=str3) #menor o igual que 33 | print(str1==str3) #igual que 34 | print(str1!=str3) #diferente que 35 | #Si quiero comprar la longuitud usa el len() al inicio de la variable o encerrando la cadena de texto 36 | print('Variables de tipo str con len()') 37 | print(len(str1)>len(str2)) #mayor que 38 | print(len('Pablo')>len('Sebastian')) #mayor que 39 | #------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------- /Clases/03 Operadores/03.9 Operadores logicos.py: -------------------------------------------------------------------------------- 1 | #------------------------------------------------------------------------------------------------------------------------------------------- 2 | # Veamos operadores Logicos 3 | print('Operadores Logicos') 4 | # En caso de and une las dos cosa a que se refiere que si un comparación no se cumple soltar falso veamos algunos ejemplos 5 | #Si los dos cumple 6 | str1='Messi' 7 | str2='Ronaldo' 8 | str3='Cristiano' 9 | n1=5 10 | n2=10 11 | print('Operador and') 12 | print(str1!=str3 and len('Pablo')!=len('Sebastian')) 13 | print(str1n2 and str1>str3) 16 | print(str1>=str3 and n1>=n2) 17 | #En caso de or una de las dos comparaciones debe de ser verdad 18 | print('Operador or') 19 | print(str1!=str3 and len('Pablo')!=len('Sebastian')) 20 | print(str1n2 and str1>str3) 22 | print(str1>=str3 and n1>=n2) 23 | #El not es un poco más complicado 24 | #Pero no imposible este lo que hace es dar true su la comparación no se cumple de lo que este en parentesis 25 | print('Operador not') 26 | print(not(str1str3)) 29 | print(not(str1!=str3)) 30 | #Y con esto terminamos nota: vimos la lógica Boolena te recomiendo verla y estudiarla es una base de para todos los lenguajes de programación 31 | #------------------------------------------------------------------------------------------------------------------------------------------- 32 | #Ahora ya estas list@ para el Modulo "Operadores"https://github.com/JulianB0315/Python_0_to_hero/blob/main/Ejercicios/03%20Operadores/03%20Operadores.md -------------------------------------------------------------------------------- /Clases/04 Srtings/04 Strings.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #El texto es un tipo de datos de cadena. Cualquier tipo de datos escrito como texto es una cadena. 7 | #Cualquier dato bajo cotización simple, doble o triple son cadenas. 8 | #Existen diferentes métodos de cadena y funciones integradas para tratar los tipos de datos de cadena. 9 | #Para verificar la longitud de una cadena, use el método len(). 10 | #Creamos una variable 11 | string="A" 12 | print(string)#Imprime solo el valor de variable, pero agregando la función len() se usa para contar las letras de str 13 | print(len(string)) 14 | string_02= 'Hola mundoooo!' # No solo te limites a una letra crea tu oración 15 | print(string_02) # Hola mundooo! 16 | print(len(string_02)) 17 | string_03="Aprendemos python de una manera fácil" 18 | print(len(string_03)) 19 | #------------------------------------------------------------------------------------------------------------------------------------------- 20 | #Podemos usar las comillas para pone nuestra cadena de texto en varias líneas 21 | multi_string='''Python es demasiado fácil de 22 | aprender en este repositorio, 23 | actualizamos los ficheros cada semana''' 24 | print(multi_string) 25 | #Con las comillas dobles es igual 26 | multi_string="""Python es demasiado fácil de 27 | aprender en este repositorio, 28 | actualizamos los ficheros cada semana""" 29 | print(multi_string) 30 | #------------------------------------------------------------------------------------------------------------------------------------------- 31 | #Podemos conectar cadenas de texto 32 | Nombre = 'Pablo' 33 | Apellido = 'Escobar' 34 | Espacio = ' ' 35 | nombre_completo = Nombre+Espacio+ Apellido#Pablo Escobar 36 | print(nombre_completo) 37 | print(len(Nombre)) 38 | print(len(Apellido)) 39 | print(len(Nombre) > len(Apellido)) 40 | print(len(nombre_completo)) 41 | #------------------------------------------------------------------------------------------------------------------------------------------- 42 | #En Python y otros lenguajes de programación \ seguido de un carácter es una secuencia de escape 43 | print('Es fácil aprender Python.\n¿Lo estas entendiendo?')#\n: nueva línea 44 | print('Clases\tTemas\tModulos')#\t: Tab significa(8 espacios) 45 | print('print(Hola mundo)\t1\t1') 46 | print('Variables \t3\t1') 47 | print('Operadores \t3\t1') 48 | print('Strings \t3\t1') 49 | print('Este es un símbolo de barra invertida (\\)') 50 | print('En todos los lenguajes de programación comienza con \"¡Hola, mundo!\"') # para escribir una comilla doble dentro de una comilla simple 51 | #------------------------------------------------------------------------------------------------------------------------------------------- 52 | #En Python hay formas para formatear cadenas de textos 53 | #El operador “%” es utilizado ora formatear un conjunto de variables incluyendo una “tupla”(Una línea de tamaño fijo) 54 | print('Formateo') 55 | nombre01 = 'Diego' 56 | apellido01 = 'Alfonso' 57 | edad = 20 58 | print('Hola soy %s %s y mi edad es de %d años' %(nombre01, apellido01,edad)) 59 | print('Hola soy {} {} y mi edad es de {} años'.format(nombre01,apellido01,edad)) 60 | print(f'Hola soy {nombre01} {apellido01} y mi edad es de {edad} años') 61 | #%s - Cadena (o cualquier objeto con una representación de cadena, como números) 62 | #%d - Enteros 63 | #%f - Números de punto flotante 64 | #"%.número de dígitosf" - Números de punto flotante con precisión fija 65 | # 66 | radio = 10 67 | pi = 3.14 68 | area = pi * radio ** 2 69 | print('El área del círculo con un radio %d es %.2f.' %(radio, area))#el 2 se uso para poner los dos numeros despues del punto 70 | print('El área del círculo con un radio {} es {}.' .format(radio, area)) 71 | print(f'El área del círculo con un radio {radio} es {area}.') 72 | #ahora con list 73 | libreria = ['Django', 'Flask', 'NumPy', 'Matplotlib','Pandas'] 74 | print('Las siguientes son bibliotecas de Python:%s' %(libreria)) 75 | #------------------------------------------------------------------------------------------------------------------------------------------- 76 | #Esta Interpolación de cadenas /f-Strings es de Python 3,6 a mas 77 | a = 4 78 | b = 3 79 | print(f'{a} + {b} = {a +b}') 80 | print(f'{a} - {b} = {a - b}') 81 | print(f'{a} * {b} = {a * b}') 82 | print(f'{a} / {b} = {a / b:.2f}') 83 | print(f'{a} % {b} = {a % b}') 84 | print(f'{a} // {b} = {a // b}') 85 | print(f'{a} ** {b} = {a ** b}') 86 | #------------------------------------------------------------------------------------------------------------------------------------------- 87 | #Desempaquetado de caracteres 88 | print('Desempaquetado de caracteres') 89 | lenguaje="python" 90 | a,b,c,d,e,f=lenguaje 91 | print(a)#p 92 | print(b)#y 93 | print(c)#t 94 | print(d)#h 95 | print(e)#o 96 | print(f)#n 97 | #ahora veamos la divison 98 | print('Division') 99 | first_letter = lenguaje[0] 100 | print(first_letter)#p 101 | first_letter = lenguaje[1:3]#yt 102 | print(first_letter)#p 103 | first_letter = lenguaje[-1] 104 | print(first_letter)#Con una menos iniciamos desde el final 105 | first_letter = lenguaje[1:] 106 | print(first_letter)#Imprime desde donde le indiques 107 | first_letter = lenguaje[::-1] 108 | print(first_letter)#Pondremos la palabra al reves 109 | pto = lenguaje[0:6:2] 110 | print(pto) # Pto 111 | #------------------------------------------------------------------------------------------------------------------------------------------- 112 | #Ahora ya estas list@ para el Modulo "https://github.com/JulianB0315/Python_0_to_hero/blob/main/Ejercicios/04%20Strings/04%20Strings.md" 113 | -------------------------------------------------------------------------------- /Clases/04 Srtings/04.5 Funciones.py: -------------------------------------------------------------------------------- 1 | #Ahora veamos una poco de las funciones que nos da Python con los strings 2 | #------------------------------------------------------------------------------------------------------------------------------------------- 3 | print('Funciones') 4 | print('capitalize') 5 | cadenas = 'vamos cuatro clases de Python' 6 | print(cadenas.capitalize())#Esta función convierte la primera letra en mayúscula 7 | print('count') 8 | print(cadenas.count('s')) # Devuelve ocurrencias de subcadena en cadena, count(subcadena, start=.., end=..). 9 | print(cadenas.count('a', 1, 21)) #El inicio es una indexación inicial para contar y el final es el último índice para contar. 10 | print(cadenas.count('a')) 11 | print('endswith') 12 | print(cadenas.endswith('on'))#Comprueba si una cadena termina con un final especificado 13 | print(cadenas.endswith('tion')) 14 | cadenas = 'vamos\tcuatro\tclases\tde\tPython' 15 | print('expandtabs') 16 | print(cadenas.expandtabs()) #Reemplaza el carácter de pestaña con espacios, el tamaño de pestaña predeterminado es 8. Se necesita un argumento de tamaño de pestaña 17 | print(cadenas.expandtabs(10)) 18 | print('find y rfind') 19 | cadenas = 'vamos cuatro clases de Python' 20 | print(cadenas.find('a')) #Devuelve el índice de la primera aparición de una subcadena, si no se encuentra devuelve -1 21 | print(cadenas.find('th')) 22 | print(cadenas.rfind('y'))#Devuelve el índice de la última aparición de una subcadena, si no se encuentra, devuelve -1 23 | print(cadenas.rfind('th')) 24 | print('index') 25 | cadenas='Vamos cuatro clases de Python' 26 | sub_cadena='cl' 27 | print(cadenas.index(sub_cadena)) #Devuelve el índice más bajo de una subcadena, los argumentos adicionales indican el índice inicial y final (predeterminado 0 y longitud de cadena - 1). 28 | #print(cadenas.index(sub_cadena, 14)) # Si no se encuentra la subcadena, aumenta un valorError. 29 | print(cadenas.rindex(sub_cadena))#Devuelve el índice más alto de una subcadena 30 | #print(cadenas.rindex(sub_cadena, 14))#los argumentos adicionales indican el índice inicial y final (el valor predeterminado es 0 y la longitud de la cadena es 1) 31 | print('isdecimal')#Esta función comprueba los números soltando true si hay alguno 32 | n1='30' 33 | print(n1.isdecimal())#true 34 | n2='39.5' 35 | print(n2.isdecimal())#falses 36 | n3='378 abc' 37 | print(n3.isdecimal())#falses 38 | n4='1+2' 39 | print(n4.isdecimal())#falses 40 | print('isdigit')#Comprueba si todos los caracteres de una cadena son números (0-9 y algunos otros caracteres unicode para números) 41 | print(n1.isdigit())#true 42 | print(n2.isdigit())#falses 43 | print(n3.isdigit())#falses 44 | print(n4.isdigit())#falses 45 | print('isnumeric')#Comprueba si todos los caracteres de una cadena están relacionados con números o números (al igual que isdigit(), solo acepta más símbolos, como ½) 46 | print(n1.isnumeric()) 47 | print(n2.isnumeric()) 48 | print(n3.isnumeric()) 49 | print('isidentifier') 50 | cadenas='Vamos cuatro clases de Python' 51 | print(cadenas.isidentifier())# Comprueba un identificador válido: comprueba si una cadena es un nombre de variable válido 52 | cadenas='Vamos_cuatro_clases_de_Python' 53 | print(cadenas.isidentifier()) 54 | print('islower')#Comprueba si todos los caracteres del alfabeto en la cadena están en minúsculas 55 | cadenas='vamos cuatro clases de python' 56 | print(cadenas.islower()) 57 | cadenas='Vamos cuatro clases de Python' 58 | print(cadenas.islower()) 59 | print('isupper') 60 | cadenas='vamos cuatro clases de python' 61 | print(cadenas.isupper()) 62 | cadenas='VAMOS CUATRO CLASES DE PYTHON' 63 | print(cadenas.isupper()) 64 | print('join')#Devuelve una cadena concatenada 65 | web= ['HTML', 'CSS', 'JavaScript', 'React'] 66 | resultado = ' '.join(web) 67 | print(resultado) 68 | resultado = ','.join(web) 69 | print(resultado) 70 | print('strip')#Elimina todos los caracteres dados a partir del principio y el final de la cadena 71 | cadenas='vamos cuatro clases de pythonnnnnnnnnnnnnnnn' 72 | print(cadenas.strip('noth')) 73 | print('replace') 74 | cadenas='Vamos cuatro clases de python' 75 | print(cadenas.replace('python','codigos')) 76 | print('split')#Divide la cadena, usando una cadena o espacio dado como separador 77 | print(cadenas.split()) 78 | print('title')#Devuelve una cadena de título en caja 79 | print(cadenas.title()) 80 | print('swapcase')# Convierte todos los caracteres en mayúsculas a minúsculas y todos los caracteres en minúsculas a caracteres en mayúsculas 81 | cadenas='vamos cuatro clases de python' 82 | print(cadenas.swapcase()) 83 | cadenas='Vamos Cuatro Clases De Python' 84 | print(cadenas.swapcase()) 85 | cadenas='cuatro clases de Python' 86 | print('startswith')#Comprueba si la Cadena Comienza con la Cadena Especificada 87 | print(cadenas.startswith('cuatro')) 88 | cadenas='4 clases de Python' 89 | print(cadenas.startswith('cuatro')) 90 | #------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------- /Clases/05 Listas/05 Listas.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | #Anteriormente vimos las listas, pero solo como un tipo de dato, pero ¿Qué son las listas y cuáles son? 8 | #Hay cuatro tipos de datos de recopilación en Python 9 | #Estos son list,Tuple,Set,Dictionary 10 | #List: es una colección que está ordenada y cambiante(modificable). Permite miembros duplicados. 11 | #Tuple: es una colección ordenada e inmutable o no modificable(inmutable). Permite miembros duplicados. 12 | #Set: es una colección que no está ordenada, no está indexada y no es modificable, pero podemos agregar nuevos elementos al conjunto. No se permiten miembros duplicados. 13 | #Dictionary:es una colección que es desordenada, cambiante(modificable) e indexada. Sin miembros duplicados. 14 | #Una lista es la recopilación de diferentes tipos de datos que están ordenados y modificables(mutables). Una lista puede estar vacía o puede tener diferentes elementos de tipo de datos. 15 | #------------------------------------------------------------------------------------------------------------------------------------------- 16 | #Ahora que sabemos todo esto hagamos una lista 17 | #Hay dos maneras de hacer lista como paréntesis o con corchetes 18 | empty_list = list() #Dentro de los paréntesis debes de poner los elementos de tu lista 19 | print(len(empty_list))#0 por no haber elementos 20 | empty_list = [] #Dentro de los corchetes debes de poner los elementos 21 | print(len(empty_list)) # 0 por no haber elementos 22 | #Usemos las función len() para contar los elementos de la lista 23 | #Creamos las listas 24 | frutas = ['platano', 'naranja', 'mango', 'manzana'] 25 | vegetales = ['Tomate', 'Papa', 'Palta','Cebolla', 'Zanahoria'] 26 | lacteaos= ['leche', 'mantequilla', 'queso', 'yoghurt'] 27 | web= ['HTML', 'CSS', 'JS', 'React','Redux', 'Node', 'MongDB'] 28 | paises = ['Argentina', 'Colombia', 'Chile', 'Bolivia', 'Perú'] 29 | #mostramos 30 | print('Frutas:', frutas) 31 | print('Cantidad de frutas:', len(frutas)) 32 | print('Vegetales:', vegetales) 33 | print('Cantidad de vegetales:', len(vegetales)) 34 | print('Lacteos',lacteaos) 35 | print('Cantidad de lacteos:', len(lacteaos)) 36 | print('Web:', web) 37 | print('NCantidad de web:', len(web)) 38 | print('Paises:', paises) 39 | print('Cantidad de paises:', len(paises)) 40 | #------------------------------------------------------------------------------------------------------------------------------------------- 41 | #Una lista puede contener diferentes tipos de elementos 42 | lista = ['Juan', 250, True, {'Pais':'Perú', 'Cuidad':'Lima'}] -------------------------------------------------------------------------------- /Clases/06 Tuples/06 Tuples.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | #Una tupla es una colección de diferentes tipos de datos que es ordenada e inmutable (inmutable). 8 | #Las tuplas están escritas con corchetes redondos, (). Una vez que se crea una tupla, no podemos cambiar sus valores. 9 | #No podemos usar métodos de agregar, insertar, eliminar en una tupla porque no es modificable (mutable). 10 | #A diferencia de la lista, la tupla tiene pocos métodos. 11 | #Métodos relacionados con las tuplas: 12 | #tuple(): para crear una tupla vacía 13 | #count(): para contar el número de un elemento especificado en una tupla 14 | #operador: para unir dos o más tuplas y crear una nueva tupla 15 | #------------------------------------------------------------------------------------------------------------------------------------------- 16 | #Ahora que ya sabemos algo de “tuples” veamos como crear uno en python 17 | tuples=()#Se crean comno las listas pero con parentisis 18 | tuples_eje=tuple()#o usando el constructor de tuple() 19 | #Así serie un tuples con valores 20 | tpl=('item1','item2','item3','item4','item5') 21 | frutas=('manzana','pera','durazno','sandia') 22 | #------------------------------------------------------------------------------------------------------------------------------------------- 23 | #Los tuples como las listas tienen longitud (cuantos elementos o datos contiene) y esta se mide con len() 24 | tpl=('item1','item2','item3','item4','item5') 25 | print(len(tpl)) 26 | #------------------------------------------------------------------------------------------------------------------------------------------- 27 | -------------------------------------------------------------------------------- /Clases/06 Tuples/06.2 Operaciones comunes.py: -------------------------------------------------------------------------------- 1 | #------------------------------------------------------------------------------------------------------------------------------------------- 2 | #Indexación Positiva 3 | # Similar al tipo de datos de lista, utilizamos la indexación positiva o negativa para acceder a los elementos de tupla. 4 | frutas = ('platano', 'naranja', 'mango', 'manzana') 5 | # 0 1 2 3 6 | arti_1=frutas[0] 7 | print(arti_1) 8 | arti_2=frutas[1] 9 | print(arti_2) 10 | arti_3=len(frutas)-1 11 | print(arti_3) 12 | #------------------------------------------------------------------------------------------------------------------------------------------- 13 | #Indexación negativa 14 | #Medios de indexación negativos que comienzan desde el final, 15 | #-1 se refiere al último elemento, -2 se refiere al segundo último y el negativo de la longitud de lista/tupla se refiere al primer elemento. 16 | vegetales = ('Tomate', 'Papa', 'Palta','Cebolla', 'Zanahoria') 17 | # -5 -4 -3 -2 -1 18 | arti1 = vegetales[-4] 19 | print(arti1) 20 | arti2 = vegetales[-3] 21 | print(arti2) 22 | ulti_vege= vegetales[-1] 23 | print(ulti_vege) 24 | #Ahora aprendamos a cortar los artículos de los tuples 25 | #Podemos cortar una subtupla especificando un rango de índices por dónde empezar y por dónde terminar en la tupla, 26 | #el valor de retorno será una nueva tupla con los elementos especificados. 27 | #Rango de index positivo 28 | tpl=('item1','item2','item3','item4','item5') 29 | todo=tpl[0:5] 30 | print(todo) 31 | todos=tpl[0:] 32 | print(todos) 33 | dos_items=tpl[1:3] 34 | print(dos_items) 35 | #------------------------------------------------------------------------------------------------------------------------------------------- 36 | #Rango de index negativo 37 | frutas=('manzana','pera','durazno','sandia') 38 | todas = frutas[-4:] 39 | print(todas) 40 | pera_sandia = frutas[-3:-1] 41 | print(pera_sandia) 42 | todas2 = frutas[-3:] 43 | print(todas2) 44 | #------------------------------------------------------------------------------------------------------------------------------------------- 45 | #Ahora cambiemos de tuples a listas 46 | #Podemos cambiar tuplas a listas y listas a tuplas. Tuple es inmutable si queremos modificar una tupla debemos cambiarla a una lista. 47 | tpl = ('item1', 'item2', 'item3','item4','item5','item6','item7') 48 | lst = list(tpl) 49 | print(lst) 50 | tpl2=tuple(lst) 51 | print(tpl2) 52 | #------------------------------------------------------------------------------------------------------------------------------------------- 53 | #ahora comprobemos los artículos de una tuples 54 | tpl = ('item1', 'item2', 'item3','item4','item5','item6','item7') 55 | print('item10' in tpl) 56 | print('item4' in tpl) 57 | print('item100' in tpl) 58 | #------------------------------------------------------------------------------------------------------------------------------------------- 59 | #Union de tuples 60 | #Podemos unir dos o más tuplas usando + operador 61 | tpl1 = ('item1', 'item2', 'item3') 62 | tpl2 = ('item4', 'item5','item6') 63 | tpl3 = tpl1 + tpl2 64 | print(tpl3) 65 | #------------------------------------------------------------------------------------------------------------------------------------------- 66 | #Eliminar Tuples 67 | #No es posible eliminar un solo elemento en una tupla, pero es posible eliminar la tupla usando del. 68 | tpl1 = ('item1', 'item2', 'item3') 69 | del tpl1 70 | #print(tpl1) no existe 71 | #------------------------------------------------------------------------------------------------------------------------------------------- 72 | #Ahora ya estas list@ para el Modulo "https://github.com/JulianB0315/Python_0_to_hero/blob/main/Ejercicios/06%20Tuples/05%20Listas%20.md" 73 | -------------------------------------------------------------------------------- /Clases/07 Sets/07 sets.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | #Set es una colección de artículos. 8 | #Como ejemplo toma un conjunto matemática que se puede aplicar en Python, 9 | # un set viene a ser una colección de elementos distintos, desordenados y no indexados 10 | #En Python set se utiliza para almacenar elementos únicos 11 | #Sabiendo eso pasemos a la programación de un set 12 | #------------------------------------------------------------------------------------------------------------------------------------------- 13 | #Set vacio 14 | st=set() 15 | st={'item1', 'item2', 'item3', 'item4'} 16 | #Set lleno 17 | frutas={'platano','naranja','manzana','limon'} 18 | #------------------------------------------------------------------------------------------------------------------------------------------- 19 | #Como ya sabemos crear un set ahora obtengamos la longitud de este mismo 20 | #Usamos len() para contar la longitud de conjunto 21 | frutas={'platano','naranja','manzana','limon'} 22 | cuentaFrutas=len(frutas) 23 | print(cuentaFrutas) 24 | #------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------- /Clases/08 Dictionaries/08 Dictionaries.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | #Un diccionario es una colección desordenada, modificable e indexada. En Python, los diccionarios se escriben con llaves y tienen claves y valores. 8 | # Ejemplo básico 9 | diccionario = { 10 | "nombre": "Juan", 11 | "edad": 25, 12 | "profesión": "Ingeniero" 13 | } 14 | 15 | print(diccionario) # {'nombre': 'Juan', 'edad': 25, 'profesión': 'Ingeniero'} 16 | #Alguna de las características de los diccionarios son: 17 | #Claves únicas: Cada clave debe ser única. Si intentas duplicar una clave, se sobrescribirá el valor anterior. 18 | #Claves inmutables: Solo pueden ser de tipos inmutables como strings, números o tuplas. 19 | #Acceso rápido a los valores: Los valores se acceden usando las claves, no índices. 20 | #------------------------------------------------------------------------------------------------------------------------------------------- 21 | """ Crear un diccionario en python y hay diferentes formas de hacerlo""" 22 | #Para crea un diccionario vacío, puedes usar {} o tambiem la funcion dict() 23 | # Ejemplo de diccionario vacío 24 | diccionario = {} 25 | print(diccionario) # {} 26 | # Ejemplo de diccionario vacío con dict() 27 | diccionario = dict() 28 | print(diccionario) # {} 29 | #------------------------------------------------------------------------------------------------------------------------------------------- 30 | #Diccionario valores iniciales 31 | #Puedes definir un diccionario con pares clave-valor entre llaves. 32 | # Ejemplo de diccionario con valores iniciales 33 | diccionario = { 34 | "nombre": "Juan", 35 | "edad": 25, 36 | "profesión": "Ingeniero" 37 | } 38 | print(diccionario) # {'nombre': 'Juan', 'edad': 25, 'profesión': 'Ingeniero'} 39 | #-------------------------------------------------------------------------------------------------------------------------------------------- 40 | #Diccionario con dict() 41 | #También puedes usar la función dict() para crear un diccionario con valores iniciales. 42 | # Ejemplo de diccionario con dict() 43 | diccionario = dict(nombre="Juan", edad=25, profesión="Ingeniero") 44 | print(diccionario) # {'nombre': 'Juan', 'edad': 25, 'profesión': 'Ingeniero'} 45 | #------------------------------------------------------------------------------------------------------------------------------------------- 46 | #Usando listas o tuplas de pares clave-valor 47 | #Puedes construir un diccionario a partir de una lista o tupla de pares clave-valor usando dict(). 48 | #Lista de tuplas 49 | datos = [("nombre", "Juan"), ("edad", 25), ("profesión", "Ingeniero")] 50 | persona = dict(datos) 51 | print(persona) # {'nombre': 'Juan', 'edad': 25, 'profesión': 'Ingeniero'} 52 | 53 | #Tupla de tuplas 54 | datos = (("nombre", "Juan"), ("edad", 25), ("profesión", "Ingeniero")) 55 | persona = dict(datos) 56 | print(persona) # {'nombre': 'Juan', 'edad': 25, 'profesión': 'Ingeniero'} 57 | #------------------------------------------------------------------------------------------------------------------------------------------- 58 | #Usando la comprensión de diccionarios 59 | #La comprensión de diccionarios te permite crear diccionarios de una forma compacta y eficiente. 60 | #Nota: Todavia no aprendemos bucles y no se incluiran en este en los ejercicios 61 | #Ejemplo: Crear un diccionario con cuadrados de números 62 | cuadrados = {x:x**2 for x in range(1, 6)} 63 | print(cuadrados) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25} 64 | 65 | #Ejemplo: Convertir una lista en un diccionario 66 | nombres = ["Juan", "María", "Carlos"] 67 | longitudes = {nombre: len(nombre) for nombre in nombres} 68 | print(longitudes) # {'Juan': 4, 'María': 5, 'Carlos': 6} 69 | #------------------------------------------------------------------------------------------------------------------------------------------- 70 | #Desde dos listas usando zip() 71 | #Si tenemos dos listas relacionadas, podemos combinarlas en un diccionario usando zip(). 72 | # Ejemplo: Convertir dos listas en un diccionario 73 | claves = ["nombre", "edad", "profesión"] 74 | valores = ["Juan", 25, "Ingeniero"] 75 | persona = dict(zip(claves, valores)) 76 | print(persona) # {'nombre': 'Juan', 'edad': 25, 'profesión': 'Ingeniero'} 77 | #------------------------------------------------------------------------------------------------------------------------------------------- 78 | #Diccionario con valores predeterminados 79 | #Puedes crear un diccionario con valores predeterminados usando dict.fromkeys(). 80 | # Ejemplo: Crear un diccionario con valores predeterminados 81 | claves = ["nombre", "edad", "profesión"] 82 | persona = dict.fromkeys(claves, "desconocido") 83 | print(persona) # {'nombre': 'desconocido', 'edad': 'desconocido', 'profesión': 'desconocido'} 84 | #------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------- /Clases/10 Bucles/10 Bucles.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | #¿Qué es un bucle? 8 | #Un bucle es una herramienta que nos permite ejecutar un conjunto de instrucciones varias veces sin tener que escribir el código repetidamente. 9 | #Los usamos para automatizar tareas repetitivas, como procesar listas de datos o realizar cálculos hasta que se cumpla cierta condición. 10 | #------------------------------------------------------------------------------------------------------------------------------------------- 11 | #Bucles con for: 12 | #Piensa en el bucle for como una herramienta que te ayuda a recorrer una lista de cosas o realizar una acción un número específico de veces. 13 | #Cómo funciona: 14 | #Imagina que tienes una lista de elementos (como números o palabras). 15 | #El bucle toma cada elemento de la lista, uno por uno, y ejecuta las instrucciones que le indiques. 16 | #Ejemplo: 17 | #Usaremos una lista de frutas y un bucle for para imprimir cada fruta en la lista. 18 | #Sintaxis: 19 | frutas = ["manzana", "banana", "cereza"] 20 | for x in frutas: 21 | print(x) 22 | #Esto es como decir: "Por cada fruta en la lista de frutas, imprímela". 23 | #Otra utilidad es repetir algo un número fijo de veces. Por ejemplo: 24 | for i in range(5): 25 | print("Hola") 26 | #Esto imprimirá "Hola" 5 veces. Aquí, range(5) genera los números del 0 al 4. 27 | #------------------------------------------------------------------------------------------------------------------------------------------- 28 | #Bucles con while: 29 | #El bucle while se basa en una condición. Mientras la condición sea verdadera (True), el bucle seguirá ejecutándose. 30 | #Es como una luz verde que te dice "sigue". 31 | #Cómo funciona: 32 | #Define una condición que se evalúa antes de cada repetición. 33 | #Si la condición es verdadera, el código dentro del bucle se ejecuta. 34 | #Si la condición se vuelve falsa, el bucle se detiene. 35 | #Ejemplo: 36 | #Hagamos un bucle while que imprima los números del 0 al 4. 37 | #Sintaxis: 38 | contador = 0 39 | while contador < 5: 40 | print(contador) 41 | contador += 1 42 | #Esto imprimirá los números del 0 al 4. 43 | #Nota: Si olvidas incrementar el contador, el bucle se ejecutará para siempre. ¡Cuidado! 44 | #------------------------------------------------------------------------------------------------------------------------------------------- 45 | #Control de los bucles 46 | #A veces, necesitas detener un bucle antes de que termine. Puedes hacerlo con las palabras clave break y continue. 47 | #Break: Detiene el bucle por completo. 48 | #Continue: Detiene la iteración actual y continúa con la siguiente. 49 | #Ejemplo: 50 | #Imprimamos los números del 0 al 4, pero detengámonos si llegamos al 2. 51 | contador = 0 52 | while contador < 5: 53 | print(contador) 54 | if contador == 2: 55 | break 56 | contador += 1 57 | #Esto imprimirá 0, 1 y 2. 58 | #Ejemplo: 59 | #Imprimamos los números del 0 al 4, pero saltemos el 2. 60 | contador = 0 61 | while contador < 5: 62 | contador += 1 63 | if contador == 2: 64 | continue 65 | print(contador) 66 | #Esto imprimirá 1, 3, 4 y 5. 67 | #------------------------------------------------------------------------------------------------------------------------------------------- 68 | #Bucles anidados 69 | #Puedes poner un bucle dentro de otro bucle. Esto se llama bucles anidados. 70 | #Ejemplo: 71 | #Imprimamos una tabla de multiplicar del 1 al 5. 72 | for i in range(1, 6): 73 | for j in range(1, 11): 74 | print(i * j, end=" ") 75 | print() 76 | #Esto imprimirá una tabla de multiplicar del 1 al 5. 77 | #Nota: Los bucles anidados pueden ser difíciles de seguir. Asegúrate de entender cómo funcionan antes de usarlos. 78 | #------------------------------------------------------------------------------------------------------------------------------------------- 79 | #¿Cómo decidir entre for y while? 80 | #Usa for cuando sepas exactamente cuántas veces quieres iterar o tengas un conjunto de elementos para recorrer. 81 | #Usa while cuando la cantidad de repeticiones dependa de una condición que puede cambiar durante la ejecución. 82 | #------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------- /Clases/11 Funciones/11 Funciones.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | #Definición de una función 8 | #Una función es un bloque de código que se ejecuta solo cuando es llamada. Se define con la palabra clave def. 9 | #Ejemplo: 10 | def ejemplo(): 11 | print("Esta es una función en Python.") 12 | #Esto define una función llamada ejemplo que imprime un mensaje. 13 | #Para ejecutar la función, simplemente llámala: 14 | ejemplo() 15 | #------------------------------------------------------------------------------------------------------------------------------------------- 16 | #Función sin parámetros 17 | #Una función puede no recibir datos de entrada. 18 | #Ejemplo: 19 | def saludo(): 20 | print("Hola, mundo!") 21 | #Llamamos a la función: 22 | saludo() 23 | #------------------------------------------------------------------------------------------------------------------------------------------- 24 | #Función que devuelve un valor 25 | #Se utiliza la palabra clave return para devolver un valor. 26 | #Ejemplo: 27 | def suma(a, b): 28 | return a + b 29 | #Llamamos a la función y guardamos el resultado en una variable: 30 | resultado = suma(5, 3) 31 | print(resultado) 32 | #------------------------------------------------------------------------------------------------------------------------------------------- 33 | #Función con parámetros 34 | #Las funciones pueden recibir datos como parámetros para personalizar su ejecución. 35 | #Ejemplo: 36 | def saludo(nombre): 37 | print(f"Hola, {nombre}!") 38 | #Llamamos a la función y pasamos un argumento: 39 | saludo("Julian") 40 | #------------------------------------------------------------------------------------------------------------------------------------------- 41 | #Paso de argumentos con clave y valor 42 | #Se pueden pasar parámetros nombrados (keyword arguments) para mayor claridad. 43 | #Ejemplo: 44 | def saludo(nombre, apellido): 45 | print(f"Hola, {nombre} {apellido}!") 46 | #Llamamos a la función con argumentos nombrados: 47 | saludo(apellido="Burga", nombre="Julian") 48 | #------------------------------------------------------------------------------------------------------------------------------------------- 49 | #Función con parámetros predeterminados 50 | #Los parámetros predeterminados tienen un valor por defecto si no se proporciona uno al llamar la función. 51 | #Ejemplo: 52 | def saludo(nombre="Invitado"): 53 | print(f"Hola, {nombre}!") 54 | #Llamamos a la función sin argumentos: 55 | saludo() 56 | saludo("Lucía") 57 | #------------------------------------------------------------------------------------------------------------------------------------------- 58 | #Número arbitrario de argumentos 59 | #Se puede usar *args para aceptar una cantidad indefinida de argumentos. 60 | #Ejemplo: 61 | def saludo(*nombres): 62 | for nombre in nombres: 63 | print(f"Hola, {nombre}!") 64 | #Llamamos a la función con varios argumentos: 65 | saludo("Julian", "Lucía", "Pedro") 66 | #------------------------------------------------------------------------------------------------------------------------------------------- 67 | #Número arbitrario y predeterminado de parámetros 68 | #Se combinan *args y parámetros predeterminados para mayor flexibilidad. 69 | #Ejemplo: 70 | def saludo(*nombres, mensaje="Hola"): 71 | for nombre in nombres: 72 | print(f"{mensaje}, {nombre}!") 73 | #Llamamos a la función con varios argumentos y un mensaje personalizado: 74 | saludo("Julian", "Lucía", "Pedro", mensaje="Buen día") 75 | #------------------------------------------------------------------------------------------------------------------------------------------- 76 | #Función como parámetro de otra función 77 | #En Python, las funciones son objetos, por lo que pueden ser pasadas como parámetros. 78 | #Ejemplo: 79 | def saludo(): 80 | return "Hola" 81 | def despedida(): 82 | return "Adiós" 83 | def conversacion(funcion): 84 | print(funcion()) 85 | #Llamamos a la función conversacion y pasamos otra función como argumento: 86 | conversacion(saludo) 87 | conversacion(despedida) 88 | #------------------------------------------------------------------------------------------------------------------------------------------- 89 | # Buenas prácticas 90 | # Dale un nombre descriptivo a tus funciones. 91 | # Documenta las funciones usando cadenas de documentación (""" """). 92 | # Mantén el cuerpo de las funciones limpio y legible. 93 | # Escribe funciones que hagan una sola cosa. 94 | #------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------- /Clases/12 Modulos/12 Modulos.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | # ¿Qué es un módulo? 8 | # Un módulo en Python es un archivo que contiene definiciones de funciones, clases y variables que puedes reutilizar en otros archivos. 9 | # Su propósito es organizar el código y promover la reutilización. 10 | # Ejemplo de un módulo: 11 | # Un archivo llamado mi_modulo.py con el siguiente contenido: 12 | def saludar(nombre): 13 | return f"Hola, {nombre}!" 14 | PI = 3.14159 15 | # Puedes usar este módulo en otro archivo para aprovechar sus funciones y variables. 16 | #------------------------------------------------------------------------------------------------------------------------------------------- 17 | # Creación de un módulo 18 | # Paso 1: Crear el archivo del módulo 19 | # Crea un archivo llamado mi_modulo.py con este contenido: 20 | def saludar(nombre): 21 | return f"Hola, {nombre}!" 22 | 23 | def despedir(nombre): 24 | return f"Adiós, {nombre}!" 25 | 26 | PI = 3.14159 27 | # Paso 2: Usar el módulo 28 | # En otro archivo, por ejemplo main.py, puedes importarlo: 29 | import mi_modulo 30 | #------------------------------------------------------------------------------------------------------------------------------------------- 31 | print(mi_modulo.saludar("Juan")) 32 | print(f"El valor de PI es: {mi_modulo.PI}") 33 | # Importación de funciones desde un módulo 34 | # Puedes importar funciones específicas de un módulo: 35 | from mi_modulo import saludar 36 | 37 | print(saludar("Ana")) # No es necesario usar el prefijo mi_modulo. 38 | #------------------------------------------------------------------------------------------------------------------------------------------- 39 | # Importación de funciones y cambio de nombre 40 | # Puedes cambiar el nombre de las funciones o del módulo al importarlo: 41 | from mi_modulo import saludar as saludar_func 42 | 43 | print(saludar_func("Carlos")) 44 | # O cambiar el nombre del módulo completo: 45 | 46 | import mi_modulo as mm 47 | 48 | print(mm.saludar("Laura")) 49 | #------------------------------------------------------------------------------------------------------------------------------------------- 50 | # Importación de módulos integrados 51 | # Python incluye muchos módulos integrados que puedes usar directamente. Aquí exploraremos algunos: 52 | # Módulo os 53 | # El módulo os permite interactuar con el sistema operativo. 54 | import os 55 | # Obtener el directorio actual 56 | print(os.getcwd()) 57 | # Crear una nueva carpeta 58 | os.mkdir("nueva_carpeta") 59 | # Módulo sys 60 | # El módulo sys permite interactuar con el intérprete de Python. 61 | import sys 62 | # Ver la versión de Python 63 | print(sys.version) 64 | # Ver rutas donde Python busca módulos 65 | print(sys.path) 66 | # Módulo statistics 67 | # Este módulo ofrece funciones para cálculos estadísticos. 68 | import statistics 69 | datos = [1, 2, 3, 4, 5, 6] 70 | print("Media:", statistics.mean(datos)) 71 | print("Mediana:", statistics.median(datos)) 72 | # Módulo math 73 | # El módulo math proporciona funciones matemáticas avanzadas. 74 | import math 75 | print("Raíz cuadrada de 16:", math.sqrt(16)) 76 | print("Seno de 90°:", math.sin(math.radians(90))) 77 | # Módulo string 78 | # El módulo string contiene constantes y funciones útiles para manejar cadenas. 79 | import string 80 | # Mostrar todas las letras 81 | print(string.ascii_letters) 82 | # Plantilla de cadena 83 | template = string.Template("Hola, $nombre!") 84 | print(template.substitute(nombre="Luis")) 85 | # Módulo random 86 | # El módulo random genera números aleatorios y selecciona elementos al azar. 87 | import random 88 | # Número aleatorio entre 1 y 10 89 | print(random.randint(1, 10)) 90 | # Elegir un elemento al azar de una lista 91 | opciones = ["rojo", "azul", "verde"] 92 | print(random.choice(opciones)) 93 | #------------------------------------------------------------------------------------------------------------------------------------------- 94 | # Modelos en Frameworks (Django) 95 | # En Django, los modelos representan tablas en una base de datos. Cada clase en un modelo equivale a una tabla, y cada atributo corresponde a una columna. 96 | 97 | # Ejemplo en Django: 98 | # from django.db import models 99 | 100 | # class Tarea(models.Model): 101 | # titulo = models.CharField(max_length=200) 102 | # descripcion = models.TextField() 103 | # estado = models.CharField(max_length=20, default="Pendiente") 104 | 105 | # def __str__(self): 106 | # return self.titulo -------------------------------------------------------------------------------- /Clases/12 Modulos/mi_modulo.py: -------------------------------------------------------------------------------- 1 | def saludar(nombre): 2 | return f"Hola, {nombre}!" 3 | 4 | def despedir(nombre): 5 | return f"Adiós, {nombre}!" 6 | 7 | PI = 3.14159 -------------------------------------------------------------------------------- /Clases/13 Comprensión de listas/13 Comprensión de listas.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | #Comprensión de Listas 8 | #La comprensión de listas es una manera concisa y elegante de construir listas a partir de secuencias. Es considerablemente más rápida y clara que usar bucles `for` tradicionales. 9 | #Sintaxis: 10 | # [expresion for elemento in iterable if condicion] 11 | #expresion: Operación o valor que será incluido en la lista resultante. 12 | #elemento: Cada elemento del iterable que se recorre. 13 | #iterable: Cualquier objeto iterable como listas, cadenas o rangos. 14 | #condicion: (Opcional) Un filtro que determina si el elemento se incluye en la lista. 15 | #------------------------------------------------------------------------------------------------------------------------------------------- 16 | #Crear una lista de caracteres desde una cadena 17 | language = 'Python' 18 | list_chars = [char for char in language] 19 | print(list_chars) # Salida: ['P', 'y', 't', 'h', 'o', 'n'] 20 | #Generar una lista de números al cuadrado 21 | squares = [i**2 for i in range(11)] 22 | print(squares) # Salida: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 23 | #Filtrar números pares 24 | even_numbers = [i for i in range(21) if i % 2 == 0] 25 | print(even_numbers) # Salida: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20] 26 | #Aplanar una lista de listas 27 | nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 28 | flat_list = [num for sublist in nested_list for num in sublist] 29 | print(flat_list) # Salida: [1, 2, 3, 4, 5, 6, 7, 8, 9] 30 | #------------------------------------------------------------------------------------------------------------------------------------------- 31 | #Funciones Lambda 32 | #Las funciones lambda son pequeñas funciones anónimas de una sola línea. Se usan cuando se necesita una función simple para operaciones rápidas. 33 | #Sintaxis: 34 | #lambda parametros: expresion 35 | #parametros: Argumentos de la función. 36 | #expresion: Lo que será evaluado y devuelto como resultado. 37 | #Multiplicar un número por dos 38 | multiply_by_two = lambda x: x * 2 39 | print(multiply_by_two(4)) # Salida: 8 40 | #Elevar un número al cuadrado 41 | square = lambda x: x**2 42 | print(square(5)) # Salida: 25 43 | #Función Lambda con múltiples argumentos 44 | add_three_numbers = lambda a, b, c: a + b + c 45 | print(add_three_numbers(1, 2, 3)) # Salida: 6 46 | #------------------------------------------------------------------------------------------------------------------------------------------- 47 | #Creación de Funciones Lambda 48 | #Las funciones lambda también pueden crearse dinámicamente para realizar operaciones más complejas. 49 | #Función Lambda que eleva un número a una potencia 50 | power_function = lambda x, power: x**power 51 | print(power_function(2, 3)) # Salida: 8 52 | print([power_function(i, 3) for i in range(1, 6)]) # Salida: [1, 8, 27, 64, 125] 53 | #------------------------------------------------------------------------------------------------------------------------------------------- 54 | #Función Lambda dentro de otra función 55 | # Las funciones lambda pueden usarse dentro de otras funciones para crear comportamientos personalizados. 56 | #Generar una función de potencia 57 | def power(base): 58 | return lambda exponent: base**exponent 59 | square = power(3)(2) # 3^2 60 | cube = power(2)(3) # 2^3 61 | print(square) # Salida: 9 62 | print(cube) # Salida: 8 63 | #Filtrar números impares y elevarlos al cuadrado 64 | def filter_and_square(numbers): 65 | return [x**2 for x in numbers if (lambda y: y % 2 != 0)(x)] 66 | numbers = list(range(10)) 67 | print(filter_and_square(numbers)) # Salida: [1, 9, 25, 49, 81] -------------------------------------------------------------------------------- /Clases/14 Funciones de orden superior/14 Funciones de orden superior.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | # 1. Funciones de orden superior (Higher Order Functions) 8 | # Definición: 9 | # Una función de orden superior es aquella que: 10 | # Recibe otra función como argumento. 11 | # Devuelve otra función como resultado. 12 | # Ejemplo 13 | def saludo(): 14 | return "¡Hola, mundo!" 15 | 16 | def ejecuta_funcion(func): 17 | return func() 18 | 19 | print(ejecuta_funcion(saludo)) # Resultado: ¡Hola, mundo! 20 | # Actividad: Escribe una función que reciba otra función como argumento y la ejecute varias veces. 21 | #------------------------------------------------------------------------------------------------------------------------------------------- 22 | # 2. Funciones como parámetros (Function as a Parameter) 23 | # Ejemplo 24 | def operacion_matematica(operacion, a, b): 25 | return operacion(a, b) 26 | 27 | def suma(a, b): 28 | return a + b 29 | 30 | def resta(a, b): 31 | return a - b 32 | print(operacion_matematica(suma, 5, 3)) # Resultado: 8 33 | print(operacion_matematica(resta, 5, 3)) # Resultado: 2 34 | # Actividad: Crea una función que reciba otra para calcular el área de un triángulo, un círculo o un cuadrado. 35 | #------------------------------------------------------------------------------------------------------------------------------------------- 36 | # 3. Funciones como valores de retorno (Function as a Return Value) 37 | # Ejemplo 38 | def generador_de_operaciones(operacion): 39 | if operacion == "suma": 40 | return lambda a, b: a + b 41 | elif operacion == "multiplicacion": 42 | return lambda a, b: a * b 43 | 44 | operacion = generador_de_operaciones("suma") 45 | print(operacion(10, 5)) # Resultado: 15 46 | # Actividad: Crea una función que devuelva una función para calcular intereses simples o compuestos. 47 | #------------------------------------------------------------------------------------------------------------------------------------------- 48 | # 4. Closures en Python 49 | # Definición: Una closure es una función que "recuerda" las variables de su entorno, incluso después de que ese entorno haya terminado. 50 | # Ejemplo 51 | def contador(): 52 | cuenta = 0 53 | def incrementar(): 54 | nonlocal cuenta 55 | cuenta += 1 56 | return cuenta 57 | return incrementar 58 | 59 | mi_contador = contador() 60 | print(mi_contador()) # Resultado: 1 61 | print(mi_contador()) # Resultado: 2 62 | # Actividad: Escribe un closure que permita llevar un registro de la suma acumulada de números. 63 | #------------------------------------------------------------------------------------------------------------------------------------------- 64 | # 5. Decoradores en Python 65 | # A. Creación de decoradores 66 | # Ejemplo 67 | def decorador(func): 68 | def envoltura(): 69 | print("Antes de ejecutar la función") 70 | func() 71 | print("Después de ejecutar la función") 72 | return envoltura 73 | 74 | @decorador 75 | def decir_hola(): 76 | print("¡Hola!") 77 | 78 | decir_hola() 79 | # B. Aplicación de múltiples decoradores 80 | # Ejemplo 81 | def decorador1(func): 82 | def envoltura(): 83 | print("Decorador 1") 84 | func() 85 | return envoltura 86 | 87 | def decorador2(func): 88 | def envoltura(): 89 | print("Decorador 2") 90 | func() 91 | return envoltura 92 | 93 | @decorador1 94 | @decorador2 95 | def funcion(): 96 | print("Función principal") 97 | 98 | funcion() 99 | # C. Decoradores con parámetros 100 | # Ejemplo 101 | def decorador_con_parametros(prefijo): 102 | def decorador(func): 103 | def envoltura(*args, **kwargs): 104 | print(f"{prefijo}: Antes de ejecutar la función") 105 | resultado = func(*args, **kwargs) 106 | print(f"{prefijo}: Después de ejecutar la función") 107 | return resultado 108 | return envoltura 109 | return decorador 110 | 111 | @decorador_con_parametros("DEBUG") 112 | def sumar(a, b): 113 | return a + b 114 | 115 | print(sumar(3, 4)) 116 | # Actividad: Crea un decorador que registre en un archivo de texto todas las ejecuciones de una función. 117 | #------------------------------------------------------------------------------------------------------------------------------------------- 118 | # 6. Funciones integradas de orden superior 119 | # A. map 120 | # Ejemplo: 121 | numeros = [1, 2, 3, 4] 122 | doble = map(lambda x: x * 2, numeros) 123 | print(list(doble)) # Resultado: [2, 4, 6, 8] 124 | # B. filter 125 | # Ejemplo: 126 | numeros = [1, 2, 3, 4] 127 | pares = filter(lambda x: x % 2 == 0, numeros) 128 | print(list(pares)) # Resultado: [2, 4] 129 | # C. reduce 130 | # Ejemplo: 131 | from functools import reduce 132 | numeros = [1, 2, 3, 4] 133 | suma = reduce(lambda x, y: x + y, numeros) 134 | print(suma) # Resultado: 10 -------------------------------------------------------------------------------- /Clases/15 Errores de tipo en Python/15 Errores de tipo en Python.md: -------------------------------------------------------------------------------- 1 | ```python 2 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 3 | # ****🤖Programador:Julian Burga Bracamonte****** 4 | # ********************************************** 5 | # ****🔒GitHub:https://github.com/JulianB0315 ** 6 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 7 | ``` 8 | # Python Type Errors 9 | 10 | En esta clase exploraremos los tipos de errores más comunes en Python, sus causas y cómo manejarlos de manera efectiva. 11 | 12 | ## Tipos de errores en Python 13 | 14 | ### 1. **SyntaxError** 15 | Este error ocurre cuando el código tiene un problema de sintaxis y no puede ser interpretado por Python. 16 | 17 | #### Ejemplo: 18 | ```python 19 | if True 20 | print("Hola") 21 | ``` 22 | ```shell 23 | File "", line 1 24 | if True 25 | ^ 26 | SyntaxError: expected ':' 27 | ``` 28 | 29 | #### Solución: 30 | Asegúrate de que la sintaxis sea correcta: 31 | ```python 32 | if True: 33 | print("Hola") 34 | ``` 35 | 36 | --- 37 | 38 | ### 2. **NameError** 39 | Se produce cuando se intenta usar una variable o función que no ha sido definida. 40 | 41 | #### Ejemplo: 42 | ```python 43 | print(nombre) 44 | ``` 45 | ```shell 46 | Traceback (most recent call last): 47 | File "", line 1, in 48 | NameError: name 'nombre' is not defined 49 | ``` 50 | 51 | #### Solución: 52 | Define la variable antes de usarla: 53 | ```python 54 | nombre = "Juan" 55 | print(nombre) 56 | ``` 57 | 58 | --- 59 | 60 | ### 3. **IndexError** 61 | Ocurre cuando intentas acceder a un índice que no existe en una lista. 62 | 63 | #### Ejemplo: 64 | ```python 65 | lista = [1, 2, 3] 66 | print(lista[5]) 67 | ``` 68 | ```shell 69 | Traceback (most recent call last): 70 | File "", line 1, in 71 | IndexError: list index out of range 72 | ``` 73 | 74 | #### Solución: 75 | Asegúrate de que el índice esté dentro del rango: 76 | ```python 77 | lista = [1, 2, 3] 78 | if len(lista) > 5: 79 | print(lista[5]) 80 | else: 81 | print("Índice fuera de rango") 82 | ``` 83 | 84 | --- 85 | 86 | ### 4. **ModuleNotFoundError** 87 | Sucede cuando intentas importar un módulo que no está instalado o no existe. 88 | 89 | #### Ejemplo: 90 | ```python 91 | import mod_inexistente 92 | ``` 93 | ```shell 94 | Traceback (most recent call last): 95 | File "", line 1, in 96 | ModuleNotFoundError: No module named 'mod_inexistente' 97 | ``` 98 | 99 | #### Solución: 100 | Instala o corrige el nombre del módulo: 101 | ```bash 102 | pip install nombre_modulo 103 | ``` 104 | O importa el módulo correcto: 105 | ```python 106 | import math 107 | ``` 108 | 109 | --- 110 | 111 | ### 5. **AttributeError** 112 | Ocurre cuando intentas acceder a un atributo o método que no existe para un objeto. 113 | 114 | #### Ejemplo: 115 | ```python 116 | texto = "Hola" 117 | texto.apender("!") 118 | ``` 119 | ```shell 120 | Traceback (most recent call last): 121 | File "", line 1, in 122 | AttributeError: 'str' object has no attribute 'apender' 123 | ``` 124 | 125 | #### Solución: 126 | Verifica los métodos disponibles para el objeto: 127 | ```python 128 | texto = "Hola" 129 | texto = texto + "!" 130 | print(texto) 131 | ``` 132 | 133 | --- 134 | 135 | ### 6. **KeyError** 136 | Se produce cuando intentas acceder a una clave que no existe en un diccionario. 137 | 138 | #### Ejemplo: 139 | ```python 140 | diccionario = {"nombre": "Juan"} 141 | print(diccionario["edad"]) 142 | ``` 143 | ```shell 144 | Traceback (most recent call last): 145 | File "", line 1, in 146 | KeyError: 'edad' 147 | ``` 148 | 149 | #### Solución: 150 | Usa el método `get` para proporcionar un valor predeterminado: 151 | ```python 152 | diccionario = {"nombre": "Juan"} 153 | print(diccionario.get("edad", "Clave no encontrada")) 154 | ``` 155 | 156 | --- 157 | 158 | ### 7. **TypeError** 159 | Se da cuando realizas una operación entre tipos incompatibles. 160 | 161 | #### Ejemplo: 162 | ```python 163 | print("Hola" + 5) 164 | ``` 165 | ```shell 166 | Traceback (most recent call last): 167 | File "", line 1, in 168 | TypeError: can only concatenate str (not "int") to str 169 | ``` 170 | 171 | #### Solución: 172 | Convierte los tipos apropiadamente: 173 | ```python 174 | print("Hola" + str(5)) 175 | ``` 176 | 177 | --- 178 | 179 | ### 8. **ImportError** 180 | Sucede cuando no se puede importar una función o clase de un módulo. 181 | 182 | #### Ejemplo: 183 | ```python 184 | from math import raiz 185 | ``` 186 | ```shell 187 | Traceback (most recent call last): 188 | File "", line 1, in 189 | ImportError: cannot import name 'raiz' from 'math' 190 | ``` 191 | 192 | #### Solución: 193 | Asegúrate de usar los nombres correctos: 194 | ```python 195 | from math import sqrt 196 | ``` 197 | 198 | --- 199 | 200 | ### 9. **ValueError** 201 | Se produce cuando una función recibe un argumento con el tipo correcto pero un valor inapropiado. 202 | 203 | #### Ejemplo: 204 | ```python 205 | numero = int("Hola") 206 | ``` 207 | ```shell 208 | Traceback (most recent call last): 209 | File "", line 1, in 210 | ValueError: invalid literal for int() with base 10: 'Hola' 211 | ``` 212 | 213 | #### Solución: 214 | Verifica los valores antes de convertirlos: 215 | ```python 216 | texto = "123" 217 | if texto.isdigit(): 218 | numero = int(texto) 219 | ``` 220 | 221 | --- 222 | 223 | ### 10. **ZeroDivisionError** 224 | Ocurre cuando intentas dividir un número por cero. 225 | 226 | #### Ejemplo: 227 | ```python 228 | resultado = 10 / 0 229 | ``` 230 | ```shell 231 | Traceback (most recent call last): 232 | File "", line 1, in 233 | ZeroDivisionError: division by zero 234 | ``` 235 | 236 | #### Solución: 237 | Verifica que el divisor no sea cero: 238 | ```python 239 | divisor = 0 240 | if divisor != 0: 241 | resultado = 10 / divisor 242 | else: 243 | print("No se puede dividir por cero") 244 | ``` 245 | 246 | --- 247 | 248 | ## Resumen 249 | Estos errores son comunes al programar en Python, pero con buenas prácticas y validaciones adecuadas puedes evitarlos y solucionarlos rápidamente. ¡Sigue practicando para mejorar tus habilidades! 250 | 251 | -------------------------------------------------------------------------------- /Clases/16 Fecha y hora de Python/16 Fecha y hora de Python.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | # 1. Introducción a datetime 8 | # En Python, el módulo datetime proporciona clases para trabajar con fechas y horas. 9 | # Este módulo es muy útil cuando necesitamos realizar operaciones con fechas, como obtener la fecha y hora actual, 10 | # formatear fechas, o calcular la diferencia entre dos momentos en el tiempo. 11 | #------------------------------------------------------------------------------------------------------------------------------------------- 12 | # 2. Obteniendo información de la fecha y hora actual 13 | # Para obtener la fecha y hora actuales, usamos la clase datetime del módulo datetime. 14 | from datetime import datetime 15 | 16 | # Obtener la fecha y hora actuales 17 | ahora = datetime.now() 18 | print("Fecha y hora actual:", ahora) 19 | # Explicación: 20 | # datetime.now() devuelve un objeto datetime que contiene la fecha y hora actuales. 21 | # El resultado se verá algo como 2025-01-14 13:45:30.123456. 22 | #------------------------------------------------------------------------------------------------------------------------------------------- 23 | # 3. Formateando la fecha con strftime 24 | # A veces necesitamos presentar la fecha en un formato específico. Para esto, usamos el método strftime(), 25 | # que nos permite formatear la fecha como una cadena. 26 | # Formatear la fecha 27 | fecha_formateada = ahora.strftime("%Y-%m-%d %H:%M:%S") 28 | print("Fecha formateada:", fecha_formateada) 29 | # Explicación: 30 | # %Y: Año con cuatro dígitos (ej. 2025). 31 | # %m: Mes con dos dígitos (ej. 01). 32 | # %d: Día con dos dígitos (ej. 14). 33 | # %H: Hora en formato de 24 horas. 34 | # %M: Minutos. 35 | # %S: Segundos. 36 | #------------------------------------------------------------------------------------------------------------------------------------------- 37 | # 4. Convertir una cadena de texto a una fecha con strptime 38 | # A veces tenemos fechas en forma de cadenas y necesitamos convertirlas a un objeto datetime. Para ello, usamos el método strptime(), 39 | # que convierte una cadena en un objeto datetime según el formato que le especifiquemos. 40 | # Convertir una cadena de texto a fecha 41 | fecha_str = "2025-01-14 15:30:00" 42 | fecha_convertida = datetime.strptime(fecha_str, "%Y-%m-%d %H:%M:%S") 43 | print("Fecha convertida:", fecha_convertida) 44 | # Explicación: 45 | # strptime() toma dos argumentos: la cadena de fecha y el formato en que está escrita. 46 | #------------------------------------------------------------------------------------------------------------------------------------------- 47 | # 5. Usando solo la fecha con la clase date 48 | # Si solo necesitas la parte de la fecha (sin la hora), puedes usar la clase date. 49 | # Obtener solo la fecha 50 | solo_fecha = ahora.date() 51 | print("Solo la fecha:", solo_fecha) 52 | # Explicación: 53 | # now.date() devuelve solo la parte de la fecha, sin la hora. El formato será YYYY-MM-DD. 54 | #------------------------------------------------------------------------------------------------------------------------------------------- 55 | # 6. Usando objetos time para representar solo la hora 56 | # De manera similar, si solo necesitas la parte de la hora, puedes usar la clase time. 57 | # Obtener solo la hora 58 | solo_hora = ahora.time() 59 | print("Solo la hora:", solo_hora) 60 | # Explicación: 61 | # now.time() devuelve solo la parte de la hora, en formato HH:MM:SS.mmmmmm. 62 | #------------------------------------------------------------------------------------------------------------------------------------------- 63 | # 7. Calculando la diferencia entre dos puntos en el tiempo 64 | # A veces necesitamos calcular la diferencia entre dos fechas u horas. Esto se puede hacer utilizando timedelta, 65 | # que representa una diferencia entre dos objetos datetime. 66 | # Calcular la diferencia entre dos fechas 67 | fecha_inicial = datetime(2025, 1, 14, 10, 30) 68 | fecha_final = datetime(2025, 1, 14, 15, 45) 69 | diferencia = fecha_final - fecha_inicial 70 | print("Diferencia de tiempo:", diferencia) 71 | # Explicación: 72 | # La resta de dos objetos datetime da como resultado un objeto timedelta, que muestra la diferencia entre ellos en días, segundos y microsegundos. 73 | #------------------------------------------------------------------------------------------------------------------------------------------- 74 | # Resumen 75 | # datetime.now(): Obtener la fecha y hora actuales. 76 | # strftime(): Formatear un objeto datetime como cadena. 77 | # strptime(): Convertir una cadena de texto a un objeto datetime. 78 | # date(): Obtener solo la fecha (sin hora). 79 | # time(): Obtener solo la hora (sin fecha). 80 | # timedelta: Calcular la diferencia entre dos fechas u horas. -------------------------------------------------------------------------------- /Clases/17 Manejo de excepciones/17 Manejo de excepciones.py: -------------------------------------------------------------------------------- 1 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🎮 2 | # ****🤖Programador:Julian Burga Bracamonte****** 3 | # ********************************************** 4 | # ****🔒GitHub:https://github.com/JulianB0315 ** 5 | # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🏀 6 | #------------------------------------------------------------------------------------------------------------------------------------------- 7 | # 1. Manejo de Excepciones en Python 8 | # El manejo de excepciones permite gestionar errores de manera controlada para que no detengan la ejecución de un programa. 9 | # Estructura básica: 10 | try: 11 | # Bloque donde podría ocurrir una excepción 12 | resultado = 10 / 0 13 | except ZeroDivisionError as e: 14 | # Manejo de la excepción 15 | print(f"Error: {e}") 16 | else: 17 | # Si no ocurre ninguna excepción 18 | print(f"Resultado: {resultado}") 19 | finally: 20 | # Este bloque siempre se ejecuta 21 | print("Ejecución finalizada.") 22 | #------------------------------------------------------------------------------------------------------------------------------------------- 23 | # Tipos comunes de excepciones: 24 | # ZeroDivisionError: División entre cero. 25 | # ValueError: Valor inválido. 26 | # TypeError: Tipo de dato incorrecto. 27 | # FileNotFoundError: Archivo no encontrado. 28 | #------------------------------------------------------------------------------------------------------------------------------------------- 29 | # Crear excepciones personalizadas: 30 | class MiExcepcion(Exception): 31 | pass 32 | try: 33 | raise MiExcepcion("Este es un error personalizado.") 34 | except MiExcepcion as e: 35 | print(f"Capturado: {e}") 36 | #------------------------------------------------------------------------------------------------------------------------------------------- 37 | # 2. Empaquetado y Desempaquetado de Argumentos 38 | # Desempaquetado 39 | # El desempaquetado permite extraer elementos de listas, tuplas o diccionarios de manera sencilla. 40 | # Desempaquetado de listas y tuplas: 41 | numeros = [1, 2, 3] 42 | a, b, c = numeros 43 | print(a, b, c) # Salida: 1 2 3 44 | # Uso de asterisco para capturar el resto: 45 | valores = [1, 2, 3, 4, 5] 46 | a, *b, c = valores 47 | print(a, b, c) # Salida: 1 [2, 3, 4] 5 48 | # Desempaquetado de diccionarios: 49 | datos = {"nombre": "Ana", "edad": 25} 50 | clave1, clave2 = datos 51 | print(clave1, clave2) # Salida: nombre edad 52 | # # Desempaquetado de valores: 53 | print(*datos.values()) # Salida: Ana 25 54 | #------------------------------------------------------------------------------------------------------------------------------------------- 55 | # Empaquetado 56 | # El empaquetado permite agrupar elementos en una lista, tupla o diccionario 57 | #------------------------------------------------------------------------------------------------------------------------------------------- 58 | # Empaquetado de listas y tuplas: 59 | def empaquetar(*args): 60 | print(args) 61 | empaquetar(1, 2, 3, 4) # Salida: (1, 2, 3, 4) 62 | #------------------------------------------------------------------------------------------------------------------------------------------- 63 | # Empaquetado de diccionarios: 64 | def empaquetar_diccionario(**kwargs): 65 | print(kwargs) 66 | empaquetar_diccionario(nombre="Luis", edad=30) # Salida: {'nombre': 'Luis', 'edad': 30} 67 | #------------------------------------------------------------------------------------------------------------------------------------------- 68 | # 3. Propagación en Python 69 | # La propagación ocurre cuando una excepción no es manejada en un nivel y se pasa al nivel superior. 70 | def dividir(a, b): 71 | if b == 0: 72 | raise ValueError("No se puede dividir entre cero.") 73 | return a / b 74 | def calcular(): 75 | try: 76 | print(dividir(10, 0)) 77 | except ValueError as e: 78 | print(f"Error propagado: {e}") 79 | calcular() # Salida: Error propagado: No se puede dividir entre cero. 80 | #------------------------------------------------------------------------------------------------------------------------------------------- 81 | # 4. Enumerar y Zip 82 | # Enumerar: 83 | frutas = ["manzana", "pera", "uva"] 84 | for indice, fruta in enumerate(frutas): 85 | print(indice, fruta) 86 | # Salida: 87 | # 0 manzana 88 | # 1 pera 89 | # 2 uva 90 | # La función enumerate agrega índices a los elementos de una lista o iterable. 91 | nombres = ["Ana", "Luis", "Sofía"] 92 | edades = [25, 30, 22] 93 | 94 | for nombre, edad in zip(nombres, edades): 95 | print(f"{nombre} tiene {edad} años.") 96 | # Salida: 97 | # Ana tiene 25 años. 98 | # Luis tiene 30 años. 99 | # Sofía tiene 22 años. 100 | #------------------------------------------------------------------------------------------------------------------------------------------- 101 | -------------------------------------------------------------------------------- /Clases/graphical-tic-tac-toe/README.md: -------------------------------------------------------------------------------- 1 | # Graphical Tic-Tac-Toe 2 | 3 | This project is a graphical implementation of the classic Tic-Tac-Toe game using the CustomTkinter library. It provides an interactive user interface for players to enjoy the game. 4 | 5 | ## Project Structure 6 | 7 | ``` 8 | graphical-tic-tac-toe 9 | ├── src 10 | │ ├── main.py # Entry point of the application 11 | │ ├── game_logic.py # Contains game logic for Tic-Tac-Toe 12 | │ ├── ui 13 | │ │ ├── __init__.py # Initialization file for the UI package 14 | │ │ └── game_ui.py # Defines the graphical user interface 15 | ├── requirements.txt # Lists project dependencies 16 | └── README.md # Project documentation 17 | ``` 18 | 19 | ## Requirements 20 | 21 | To run this project, you need to install the following dependencies: 22 | 23 | - CustomTkinter 24 | 25 | You can install the required packages using pip. Create a virtual environment and run: 26 | 27 | ``` 28 | pip install -r requirements.txt 29 | ``` 30 | 31 | ## Running the Game 32 | 33 | To start the game, run the following command in your terminal: 34 | 35 | ``` 36 | python src/main.py 37 | ``` 38 | 39 | Enjoy playing Tic-Tac-Toe! -------------------------------------------------------------------------------- /Clases/graphical-tic-tac-toe/requirements.txt: -------------------------------------------------------------------------------- 1 | CustomTkinter==0.3.2 2 | tkintertable==1.2.0 -------------------------------------------------------------------------------- /Clases/graphical-tic-tac-toe/src/__pycache__/game_logic.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/JulianB0315/Python_0_to_hero/9552ddb7e00d2f9e0107da4141370afada1f3e8b/Clases/graphical-tic-tac-toe/src/__pycache__/game_logic.cpython-310.pyc -------------------------------------------------------------------------------- /Clases/graphical-tic-tac-toe/src/game_logic.py: -------------------------------------------------------------------------------- 1 | def verificar_ganador(tablero, jugador): 2 | # Verificar filas, columnas y diagonales 3 | for i in range(3): 4 | if all(tablero[i][j] == jugador for j in range(3)) or all(tablero[j][i] == jugador for j in range(3)): 5 | return True 6 | if tablero[0][0] == tablero[1][1] == tablero[2][2] == jugador or tablero[0][2] == tablero[1][1] == tablero[2][0] == jugador: 7 | return True 8 | return False 9 | 10 | def tablero_lleno(tablero): 11 | return all(tablero[i][j] != " " for i in range(3) for j in range(3)) 12 | 13 | def inicializar_tablero(): 14 | return [[" " for _ in range(3)] for _ in range(3)] -------------------------------------------------------------------------------- /Clases/graphical-tic-tac-toe/src/main.py: -------------------------------------------------------------------------------- 1 | from customtkinter import CTk, CTkButton, CTkLabel, CTkFrame 2 | import game_logic 3 | 4 | class TicTacToeApp: 5 | def __init__(self, master): 6 | self.master = master 7 | self.master.title("Tic Tac Toe") 8 | self.master.geometry("400x400") 9 | 10 | self.board = [[" " for _ in range(3)] for _ in range(3)] 11 | self.current_player = "X" 12 | 13 | self.create_widgets() 14 | 15 | def create_widgets(self): 16 | self.buttons = [[None for _ in range(3)] for _ in range(3)] 17 | self.frame = CTkFrame(self.master) 18 | self.frame.pack(pady=20) 19 | 20 | for row in range(3): 21 | for col in range(3): 22 | self.buttons[row][col] = CTkButton(self.frame, text=" ", width=60, height=60, 23 | command=lambda r=row, c=col: self.make_move(r, c)) 24 | self.buttons[row][col].grid(row=row, column=col, padx=5, pady=5) 25 | 26 | self.status_label = CTkLabel(self.master, text=f"Turno del jugador {self.current_player}") 27 | self.status_label.pack(pady=10) 28 | 29 | def make_move(self, row, col): 30 | if self.board[row][col] == " ": 31 | self.board[row][col] = self.current_player 32 | self.buttons[row][col].configure(text=self.current_player) 33 | 34 | if game_logic.verificar_ganador(self.board, self.current_player): 35 | self.status_label.configure(text=f"¡El jugador {self.current_player} ha ganado!") 36 | self.disable_buttons() 37 | elif game_logic.tablero_lleno(self.board): 38 | self.status_label.configure(text="¡Es un empate!") 39 | else: 40 | self.current_player = "O" if self.current_player == "X" else "X" 41 | self.status_label.configure(text=f"Turno del jugador {self.current_player}") 42 | 43 | def disable_buttons(self): 44 | for row in range(3): 45 | for col in range(3): 46 | self.buttons[row][col].configure(state="disabled") 47 | 48 | if __name__ == "__main__": 49 | root = CTk() 50 | app = TicTacToeApp(root) 51 | root.mainloop() -------------------------------------------------------------------------------- /Clases/graphical-tic-tac-toe/src/ui/__init__.py: -------------------------------------------------------------------------------- 1 | # This file is intentionally left blank. -------------------------------------------------------------------------------- /Clases/graphical-tic-tac-toe/src/ui/game_ui.py: -------------------------------------------------------------------------------- 1 | from customtkinter import CTk, CTkButton, CTkLabel, CTkFrame 2 | import tkinter as tk 3 | 4 | class GameUI: 5 | def __init__(self, master, game_logic): 6 | self.master = master 7 | self.game_logic = game_logic 8 | self.master.title("Tic-Tac-Toe") 9 | self.master.geometry("400x400") 10 | 11 | self.board_frame = CTkFrame(self.master) 12 | self.board_frame.pack(pady=20) 13 | 14 | self.buttons = [[None for _ in range(3)] for _ in range(3)] 15 | self.current_player = "X" 16 | 17 | for i in range(3): 18 | for j in range(3): 19 | self.buttons[i][j] = CTkButton(self.board_frame, text="", width=10, height=3, 20 | command=lambda row=i, col=j: self.make_move(row, col)) 21 | self.buttons[i][j].grid(row=i, column=j) 22 | 23 | self.status_label = CTkLabel(self.master, text="Turn: Player X") 24 | self.status_label.pack(pady=10) 25 | 26 | def make_move(self, row, col): 27 | if self.game_logic.make_move(row, col, self.current_player): 28 | self.buttons[row][col].configure(text=self.current_player) 29 | if self.game_logic.check_winner(self.current_player): 30 | self.status_label.configure(text=f"Player {self.current_player} wins!") 31 | self.disable_buttons() 32 | elif self.game_logic.is_board_full(): 33 | self.status_label.configure(text="It's a tie!") 34 | else: 35 | self.current_player = "O" if self.current_player == "X" else "X" 36 | self.status_label.configure(text=f"Turn: Player {self.current_player}") 37 | 38 | def disable_buttons(self): 39 | for row in range(3): 40 | for col in range(3): 41 | self.buttons[row][col].configure(state=tk.DISABLED) -------------------------------------------------------------------------------- /Ejercicios/01 Hola mundo/01 Hola mundo.md: -------------------------------------------------------------------------------- 1 | # Hola mundo 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!TAREAS] 9 | >## Actividades: 10 | > 1. Crea un print de mandado un saludo 11 | >2. Crea 4 prints de diferentes tipos de clases 12 | 13 | >[!TIP] 14 | >## Y recuerda: 15 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/01 Hola mundo/HolaMundo-Alejosor.py: -------------------------------------------------------------------------------- 1 | # Imprimir un saludo 2 | print("¡Hola gente soy Alejosor!") 3 | 4 | # Variables de los diferentes tipos de datos 5 | tipo_str = "Hello World!" 6 | tipo_int = 50 7 | tipo_float = 3.14 8 | tipo_bool = True 9 | tipo_complex = 1+2J 10 | lista_numeros = [11, 22, 33] 11 | lista_strings = ["Spain", "Colombia"] 12 | diccionario = {'Jugador': 'Ronaldo'} 13 | tupla = (1, 2, 3) 14 | 15 | 16 | # Imprimir variables 17 | print(tipo_str) 18 | print(tipo_int) 19 | print(tipo_float) 20 | print(tipo_bool) 21 | print(tipo_complex) 22 | print(lista_numeros) 23 | print(lista_strings) 24 | print(diccionario) 25 | 26 | -------------------------------------------------------------------------------- /Ejercicios/01 Hola mundo/HolaMundo-Diego17cp.py: -------------------------------------------------------------------------------- 1 | # Mi primer ejercicio en este repo 2 | print("Hola Mundo"); 3 | print("Esto es una string"); 4 | print(10); # Esto es un int 5 | print(1.2); # Esto es un float 6 | print(True); # Esto es un boolean 7 | print([1,2,3]); # Esto es una lista o array 8 | -------------------------------------------------------------------------------- /Ejercicios/01 Hola mundo/HolaMundo-JulianB0315.py: -------------------------------------------------------------------------------- 1 | #Mi saludo 2 | print('Hola mundo soy Julian') 3 | #los 4 tipos de prints 4 | print('Tipo str') 5 | print(type('Hola que tal')) 6 | print('Tipo bool') 7 | print(type(True)) 8 | print('Tipo int') 9 | print(type(30)) 10 | print('Tipo list') 11 | print(type([30, 40])) 12 | 13 | -------------------------------------------------------------------------------- /Ejercicios/02 Cambios de variables/02 Cambios de variables.md: -------------------------------------------------------------------------------- 1 | # Cambios de Variables 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!TAREAS] 9 | >## Actividades: 10 | >1. Crea una cadena de texto diciendo tu nombre, edad y con alguna afirmación (print)con solo variables (mínimo de 3 tipos de variables). 11 | >2. Crea tres variables de diferentes tipos de datos y cambia el tipo de dato a “str” comprueba el cambio con un “type”. 12 | >3. Crea tres variables con datos que usuario o tu puedan ingresar y después muestra las variables con un print. 13 | 14 | >[!TIP] 15 | >## Y recuerda: 16 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/02 Cambios de variables/CambiosDeVariables-Diego17cp.py: -------------------------------------------------------------------------------- 1 | # Ejercicio 1 2 | nombre="Diego" 3 | edad=18 4 | pais="Perú" 5 | carrera="Ing. Software" 6 | print("Hola, soy "+nombre+", soy de "+pais+", tengo "+str(edad)+" años y estudio la carrera de "+carrera) 7 | # Ejercicio 2 8 | boolean=True 9 | cambio=3.74 10 | lenguajes=3 11 | boolean_str=str(boolean) 12 | cambio_str=str(cambio) 13 | lengujes=str(lenguajes) 14 | print(type(lenguajes)) 15 | print(type(cambio)) 16 | print(type(boolean)) 17 | # Ejercicio 3 18 | name=input("¿Cuál es tu nombre?") 19 | langfav=input("¿Cuál es tu lenguaje de programación favorito?") 20 | comidafav=input("¿Cuál es tu comida favorita?") 21 | print("Me llamo "+name+", mi lenguaje de programación favorito es JavaScript y mi comida favorita es el"+comidafav) 22 | -------------------------------------------------------------------------------- /Ejercicios/02 Cambios de variables/Cambiosdevariables-Alejosor.py: -------------------------------------------------------------------------------- 1 | # 1. Crea una cadena de texto diciendo tu nombre, edad y con alguna afirmación (print)con solo variables (mínimo de 3 tipos de variables). 2 | # Variables 3 | nombre = "Alejandro" 4 | edad = 23 5 | afirmacion = True 6 | 7 | # Crear y imprimir la cadena de texto 8 | print(f"Mi nombre es {nombre}, tengo {edad} años y mi afirmación es que me gusta programar es {afirmacion}.\n" ) 9 | 10 | # 2. Crea tres variables de diferentes tipos de datos y cambia el tipo de dato a “str” comprueba el cambio con un “type”. 11 | # Variables de diferentes tipos cada una 12 | numero = 25 13 | decimal = 3.14 14 | booleano = False 15 | 16 | # Cambiamos el tipo de dato a str y comprobamos el cambio con type 17 | numero_str = str(numero) 18 | print(type(numero_str)) # 19 | 20 | decimal_str = str(decimal) 21 | print(type(decimal_str)) # 22 | 23 | booleano_str = str(booleano) 24 | print(type(booleano_str)) # 25 | 26 | # 3. Crea tres variables con datos que usuario o tu puedan ingresar y después muestra las variables con un print. 27 | # Ingresa datos por el usuario 28 | nombre = input("Ingresa tu nombre: ") 29 | edad = input("Ingresa tu edad: ") 30 | ciudad = input("Ingresa tu ciudad: ") 31 | 32 | # Mostramos las variables 33 | print(f"Nombre: {nombre}\n") 34 | print(f"Edad: {edad}\n") 35 | print(f"Ciudad: {ciudad}\n") 36 | -------------------------------------------------------------------------------- /Ejercicios/02 Cambios de variables/Cambiosdevariables-JulianB0315.py: -------------------------------------------------------------------------------- 1 | #Actividad 1 2 | nombre1='Hola soy Julian tengo' 3 | edad=19 4 | carrera='años y estudio Ingeniería en software ' 5 | pregunta='¿Este dato es?' 6 | dato=True 7 | 8 | print(nombre1,edad,carrera,pregunta,dato) 9 | 10 | #Actividad 2 11 | 12 | num1=3.14 13 | list1=[30,40,50] 14 | bool1=False 15 | 16 | print(type(num1)) 17 | print(type(list1)) 18 | print(type(bool1)) 19 | 20 | str_num1=str(num1) 21 | print(type(str_num1)) 22 | 23 | str_list1=str(list1) 24 | print(type(str_list1)) 25 | 26 | str_bool1=str(bool1) 27 | print(type(str_bool1)) 28 | 29 | #Actividad 3 30 | nombre2=input('¿Cómo te llamas?') 31 | años=input('¿Cuál es tu edad?') 32 | comida=input('¿Cuál es tu comida favorita?') 33 | 34 | print('Hola',nombre2,'de',años,'años de edad') 35 | print('Te gusta el',comida,'que buen gusto!!') -------------------------------------------------------------------------------- /Ejercicios/03 Operadores/03 Operadores.md: -------------------------------------------------------------------------------- 1 | # Operadores 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!TAREAS] 9 | >## Actividades: 10 | >1. Crea una calculadora que sume, reste, multiplique y divida variables anteriormente introducidas. 11 | >2. Multiplica una cadena de texto. 12 | 13 | >[!TIP] 14 | >## Y recuerda: 15 | ># "Si puedes imaginarlo puedes programarlo" 16 | -------------------------------------------------------------------------------- /Ejercicios/03 Operadores/Operadores-Alejosor.py: -------------------------------------------------------------------------------- 1 | # Calculadora básica 2 | a = float(input("Introduce el primer número: ")) 3 | b = float(input("Introduce el segundo número: ")) 4 | 5 | print(f"Suma: {a + b}") 6 | print(f"Resta: {a - b}") 7 | print(f"Multiplicación: {a * b}") 8 | print(f"División: {a / b}") 9 | 10 | 11 | 12 | # Multiplicar una cadena de texto 13 | cadena = input("Introduce una cadena de texto: ") 14 | n = int(input("Introduce un número para multiplicar la cadena: ")) 15 | print(f"Resultado: {(cadena + " ") * n}") 16 | 17 | 18 | 19 | -------------------------------------------------------------------------------- /Ejercicios/03 Operadores/Operadores-Diego17cp.py: -------------------------------------------------------------------------------- 1 | # Ejercicio 1 2 | num1=20 3 | num2=10 4 | print("La suma de ambos números es",num1+num2) 5 | print("La resta de ambos números es",num1-num2) 6 | print("La multiplicación de ambos números es",num1*num2) 7 | print("La división de ambos números es",num1/num2) 8 | # Ejercicio 2 9 | multiplicador=10 10 | print("Hola mundo "*multiplicador) 11 | -------------------------------------------------------------------------------- /Ejercicios/03 Operadores/Operadores-JulianB0315.py: -------------------------------------------------------------------------------- 1 | #Crea una calculadora que sume, reste, multiplique y divida variables anteriormente introducidas. 2 | n1=30.4 3 | n2=40,5 4 | print('La suma de n1 mas n2 es ',n1+n2) 5 | print('La resta de n1 menos n2 es ',n1-n2) 6 | print('La división de n1 entre n2 es ',n1/n2) 7 | print('La multiplicación de n1 por10 n2 es ',n1*n2) 8 | #Multiplica una cadena de texto. 9 | n3=5 10 | print(' Hola '*n3) 11 | -------------------------------------------------------------------------------- /Ejercicios/04 Strings/04 Strings.md: -------------------------------------------------------------------------------- 1 | # Strings 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!TAREAS] 9 | >## Actividades: 10 | >1. Crea una tabla de dos variables con todas las operaciones. 11 | >2. Crea cadenas de texto con variables usado Formateo. 12 | >3. Crea una variable con tu nombre y desempaqueta letra por letra. 13 | 14 | >[!TIP] 15 | >## Y recuerda: 16 | ># "Si puedes imaginarlo puedes programarlo" 17 | -------------------------------------------------------------------------------- /Ejercicios/04 Strings/Strings--JulianB0315.py: -------------------------------------------------------------------------------- 1 | #1. Crea una tabla de dos variables con todas las operaciones. 2 | a = 32 3 | b = 4 4 | print(f'{a} + {b} = {a +b}') 5 | print(f'{a} - {b} = {a - b}') 6 | print(f'{a} * {b} = {a * b}') 7 | print(f'{a} / {b} = {a / b:.2f}') 8 | print(f'{a} % {b} = {a % b}') 9 | print(f'{a} // {b} = {a // b}') 10 | print(f'{a} ** {b} = {a ** b}') 11 | #2. Crea cadenas de texto con variables usado Formateo. 12 | nombre = 'Julian' 13 | apellido = 'Burga' 14 | estudio = 'Ingeniería en software ' 15 | print('Hola soy %s %s y estudio %s.' %(nombre, apellido,estudio)) 16 | print('Hola soy {} {} y estudio {}.'.format(nombre,apellido,estudio)) 17 | print(f'Hola soy {nombre} y estudio {apellido} y {estudio} ') 18 | #3. Crea una variable con tu nombre y desempaqueta letra por letra 19 | yo='Julian' 20 | a,b,c,d,e,f=yo 21 | print(a) 22 | print(b) 23 | print(c) 24 | print(d) 25 | print(e) 26 | print(f) -------------------------------------------------------------------------------- /Ejercicios/05 Listas/05 Listas .md: -------------------------------------------------------------------------------- 1 | # Listas 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!TASKS] 9 | >## Actividades: 10 | >1. **Acceso a elementos:**
Crea la lista program en ella guarde lenguajes de programación (mínimo de 4 elementos) y accede a los elementos con la indexación positiva y negativa 11 | >2. **Modificación de elementos:**
Crea la lista pc y guarda en ella componentes de pc con esa lista hará los siguiente:
a) Cambiar elementos por otro con la indexación positiva y negativa.
b) Comprueba elementos "in"
c) Inserta elementos a lista con append() y insert()
d) Crea una lista llamada procesadores y únela a lista pc con extend()
e) Orden la lista con sort () y sorted()
f) Ahora elimina algunos elementos y limpia la lista con clear()
Nota: Mostrar en cada paso. 12 | 13 | >[!TIP] 14 | >## Y recuerda: 15 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/05 Listas/listas-JulianB0315.py: -------------------------------------------------------------------------------- 1 | """Acceso a elementos:""" 2 | program = ["Python", "Java", "C++", "JavaScript"] 3 | #Usando indexación positiva 4 | print(program[0]) 5 | print(program[1]) 6 | print(program[2]) 7 | print(program[3]) 8 | #Usando indexación negativa 9 | print(program[-1]) 10 | print(program[-2]) 11 | print(program[-3]) 12 | print(program[-4]) 13 | """Modificación de elementos:""" 14 | 15 | pc = ["CPU", "RAM", "GPU", "HDD"] 16 | print(pc) 17 | # Cambiar elementos usando indexación positiva 18 | pc[1] = "SSD" 19 | print(pc) 20 | # Cambiar elementos usando indexación negativa 21 | pc[-1] = "PSU" 22 | print(pc) 23 | # Comprobar si un elemento está en la lista 24 | print("GPU" in pc) 25 | # Usar append() para añadir un elemento al final de la lista 26 | print("RAM" in pc) 27 | pc.append("Motherboard") 28 | print(pc) 29 | # Usar insert() para añadir un elemento en una posición específica 30 | pc.insert(2, "RAM") 31 | print(pc) 32 | # Crear la lista procesadores 33 | procesadores = ["Intel", "AMD"] 34 | # Unir la lista procesadores a la lista pc con extend() 35 | pc.extend(procesadores) 36 | print(pc) 37 | # Ordenar la lista con sort() (modifica la lista original) 38 | pc.sort() 39 | print(pc) 40 | 41 | # Ordenar la lista con sorted() (crea una nueva lista ordenada) 42 | pc_sorted = sorted(pc) 43 | print(sorted(pc,reverse=True)) 44 | 45 | # Eliminar un elemento específico 46 | pc.remove("Intel") 47 | print(pc) 48 | # Limpiar la lista con clear() 49 | pc.clear() 50 | print(pc) -------------------------------------------------------------------------------- /Ejercicios/06 Tuples/06 Tuples .md: -------------------------------------------------------------------------------- 1 | # Tuples 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!TASKS] 9 | >## Actividades: 10 | >1. Crea 4 tuples sobre web, program, database y framework. 11 | >2. Con el tuples web accede a sus artículos con indexación positiva y negativa. 12 | >3. Con el program convertirlo de una lista y elimina. 13 | >4. Y con las listas database únela con framework. 14 | 15 | >[!TIP] 16 | >## Y recuerda: 17 | ># "Si puedes imaginarlo puedes programarlo" 18 | -------------------------------------------------------------------------------- /Ejercicios/06 Tuples/tuples-JulianB0315.py: -------------------------------------------------------------------------------- 1 | """"1. Crea 4 tuples sobre web, program, database y framework.""" 2 | 3 | web = ('HTML', 'CSS', 'JavaScript', 'HTTP') 4 | program = ('Python', 'Java', 'C++', 'JavaScript') 5 | database = ('MySQL', 'PostgreSQL', 'SQLite', 'MongoDB') 6 | framework = ('Django', 'Flask', 'Spring', 'React') 7 | 8 | """"Con el tuples web accede a sus artículos con indexación positiva y negativa.""" 9 | elemento_1_positivo = web[0] 10 | elemento_2_positivo = web[1] 11 | 12 | elemento_1_negativo = web[-1] 13 | elemento_2_negativo = web[-2] 14 | 15 | print("Elementos de la tupla web (positiva):", elemento_1_positivo, elemento_2_positivo) 16 | print("Elementos de la tupla web (negativa):", elemento_1_negativo, elemento_2_negativo) 17 | 18 | """"Con el program convertirlo de una lista y elimina.""" 19 | program_lista = list(program) 20 | program=tuple(program_lista) 21 | del program 22 | 23 | """"Y con las listas database únela con framework.""" 24 | database_framework= database + framework 25 | 26 | print(database_framework) -------------------------------------------------------------------------------- /Ejercicios/07 Sets/07 Sets.md: -------------------------------------------------------------------------------- 1 | # Sets 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!TASKS] 9 | >## Actividades: 10 | >1. **Operaciones básicas con un conjunto**: 11 | > - Crea un conjunto llamado frutas con los elementos 'manzana', 'plátano', 'cereza', 'pera'. 12 | > - Encuentra la longitud del conjunto frutas y muéstralo en la consola. 13 | > - Añade 'mango' al conjunto frutas y muestra el conjunto actualizado. 14 | > - Añade múltiples frutas al conjunto frutas al mismo tiempo. Usa las frutas 'uva', 'kiwi', y 'fresa'. 15 | > - Elimina 'pera' del conjunto frutas usando remove y muestra el conjunto resultante. Luego, elimina 'cereza' con discard y muestra el conjunto. 16 | >2. **Comprobación de subconjunto y superconjunto**: 17 | > - Crea un conjunto A = {1, 2, 3, 4, 5}. 18 | > - Comprueba si el conjunto A es un subconjunto de {1, 2, 3, 4, 5, 6, 7} usando el método issubset(). 19 | > - Comprueba si el conjunto A es un superconjunto de {1, 2, 3} usando el método issuperset(). 20 | >3. **Diferencia y diferencia simétrica**: 21 | > - Crea un conjunto numeros = {1, 2, 3, 4, 5, 6}. 22 | > - Encuentra la diferencia entre el conjunto numeros y {4, 5, 6, 7, 8} usando el operador - y muéstrala. 23 | > - Encuentra la diferencia simétrica entre el conjunto numeros y {4, 5, 6, 7, 8} usando el operador ^ y muestra el resultado. 24 | >4. **Conversiones y tamaño**: 25 | > - Crea una lista de edades edades = [12, 15, 18, 20, 12, 15, 18]. 26 | > - Convierte la lista edades en un conjunto y compara la longitud de la lista y el conjunto. 27 | > - Muestra cuál de los dos es más grande (la lista o el conjunto) y explica por qué. 28 | > 5. **Palabras únicas en una frase** 29 | > - Crea una cadena de texto frase = "Me gusta aprender Python y disfrutar de la programación". 30 | > - Utiliza el método split() para separar la frase en palabras y conviértelas en un conjunto para obtener las palabras únicas. 31 | > - Muestra cuántas palabras únicas hay en la frase. 32 | 33 | >[!TIP] 34 | >## Y recuerda: 35 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/07 Sets/sets-JulianB0315.py: -------------------------------------------------------------------------------- 1 | """Operaciones básicas con un conjunto""" 2 | 3 | # Crear el conjunto frutas 4 | frutas = {'manzana', 'plátano', 'cereza', 'pera'} 5 | # 2. Longitud del conjunto 6 | print(len(frutas)) 7 | # 3. Añadir 'mango' 8 | frutas.add('mango') 9 | print(frutas) 10 | # 4. Añadir múltiples frutas 11 | frutas.update({'uva', 'kiwi', 'fresa'}) 12 | print(frutas) 13 | # 5. Eliminar 'pera' con remove 14 | frutas.remove('pera') 15 | print(frutas) 16 | # Eliminar 'cereza' con discard 17 | frutas.discard('cereza') 18 | print(frutas) 19 | 20 | """Comprobación de subconjunto y superconjunto""" 21 | 22 | # Crear el conjunto A 23 | A = {1, 2, 3, 4, 5} 24 | # 2. Comprobar si A es un subconjunto de {1, 2, 3, 4, 5, 6, 7} 25 | conjunto_b = {1, 2, 3, 4, 5, 6, 7} 26 | print(A.issubset(conjunto_b)) 27 | # 3. Comprobar si A es un superconjunto de {1, 2, 3} 28 | conjunto_c = {1, 2, 3} 29 | print(A.issuperset(conjunto_c)) 30 | 31 | """Diferencia y diferencia simétrica""" 32 | 33 | # Crear el conjunto numeros 34 | numeros = {1, 2, 3, 4, 5, 6} 35 | # 2. Diferencia entre numeros y {4, 5, 6, 7, 8} 36 | conjunto_d = {4, 5, 6, 7, 8} 37 | print(numeros - conjunto_d) 38 | # 3. Diferencia simétrica entre numeros y {4, 5, 6, 7, 8} 39 | print(numeros ^ conjunto_d) 40 | 41 | """Conversiones y tamaño""" 42 | 43 | # Crear la lista edades 44 | edades = [12, 15, 18, 20, 12, 15, 18] 45 | # 2. Convertir la lista en un conjunto 46 | edades_set = set(edades) 47 | # 3. Comparar longitudes 48 | print(len(edades)) 49 | print(len(edades_set)) 50 | 51 | 52 | """Palabras únicas en una frase""" 53 | # Crear la frase 54 | frase = "Me gusta aprender Python y disfrutar de la programación" 55 | 56 | # 2. Convertir la frase en un conjunto de palabras únicas 57 | palabras = set(frase.split()) 58 | 59 | # 3. Mostrar la cantidad de palabras únicas 60 | print(len(palabras)) 61 | -------------------------------------------------------------------------------- /Ejercicios/08 Dictionaries/08 Dictionaries.md: -------------------------------------------------------------------------------- 1 | # Dictionaries 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!NOTE] 9 | >## Actividades: 10 | > ## **Ejercicio 1: Diccionario de mascota** 11 | > 1. Crea un diccionario llamado `pet` con las claves: `name`, `type`, `age` y `color`. Asigna valores a estas claves directamente. 12 | > 2. Muestra el diccionario completo. 13 | > 3. Agrega una nueva clave llamada `owner` y asigna un valor. 14 | > 4. Modifica el valor de la clave `age` para incrementarlo en 1. 15 | > 5. Elimina la clave `color` del diccionario. 16 | > 6. Imprime el diccionario final. 17 | > ## **Ejercicio 2: Información personal** 18 | > 1. Crea un diccionario llamado `person` con las siguientes claves: 19 | > - `first_name` 20 | > - `last_name` 21 | > - `age` 22 | > - `city` 23 | > 2. Asigna valores directamente a las claves. 24 | > 3. Muestra el valor de la clave `city`. 25 | > 4. Agrega una nueva clave llamada `phone` con un número de teléfono. 26 | > 5. Cambia el valor de la clave `age` para que sea un número 5 años mayor. 27 | > 6. Elimina la clave `phone`. 28 | > 7. Muestra el diccionario actualizado. 29 | > ## **Ejercicio 3: Almacén de productos** 30 | > 1. Crea un diccionario llamado `product` con las claves: `name`, `price`, `quantity`. 31 | > 2. Asigna valores a estas claves directamente. 32 | > 3. Modifica el valor de `quantity` para agregar 10 unidades más. 33 | > 4. Muestra el precio del producto. 34 | > 5. Agrega una nueva clave llamada `category` con un valor de categoría del producto. 35 | > 6. Elimina la clave `price`. 36 | > 7. Imprime el diccionario final. 37 | > ## **Ejercicio 4: Libro favorito** 38 | > 1. Crea un diccionario llamado `book` con las claves: `title`, `author`, `year`, `pages`. 39 | > 2. Asigna valores a estas claves. 40 | > 3. Cambia el valor de `pages` para aumentar en 20. 41 | > 4. Agrega una nueva clave llamada `genre` con un valor. 42 | > 5. Muestra el título y el autor del libro. 43 | > 6. Elimina la clave `year` del diccionario. 44 | > 7. Imprime el diccionario actualizado. 45 | > ## **Ejercicio 5: Diccionario de comida** 46 | > 1. Crea un diccionario llamado `food` con las claves: `name`, `type`, `calories`. 47 | > 2. Asigna valores a las claves directamente. 48 | > 3. Agrega una nueva clave llamada `is_healthy` y asigna un valor booleano (`True` o `False`). 49 | > 4. Cambia el valor de `calories` para reducirlo en 50. 50 | > 5. Elimina la clave `type`. 51 | > 6. Muestra el diccionario completo. 52 | > ## **Ejercicio 6: Actualización de contactos** 53 | > 1. Crea un diccionario llamado `contact` con las claves: `name`, `email`, `phone`. 54 | > 2. Asigna valores iniciales a las claves. 55 | > 3. Cambia el valor de `phone` por un nuevo número. 56 | > 4. Agrega una nueva clave llamada `address` con una dirección. 57 | > 5. Elimina la clave `email`. 58 | > 6. Muestra el diccionario final. 59 | 60 | >[!TIP] 61 | >## Y recuerda: 62 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/08 Dictionaries/sets-JulianB0315.py: -------------------------------------------------------------------------------- 1 | ## **Ejercicio 1: Diccionario de mascota** 2 | pet = {"name": "Fido", "type": "dog", "age": 5, "color": "brown"} 3 | print(pet) 4 | 5 | pet["owner"] = "Juan" 6 | pet["age"] += 1 7 | del pet["color"] 8 | print(pet) 9 | 10 | 11 | ## **Ejercicio 2: Información personal** 12 | person = {"first_name": "Maria", "last_name": "Gomez", "age": 30, "city": "Lima"} 13 | print(person["city"]) 14 | 15 | person["phone"] = "987654321" 16 | person["age"] += 5 17 | del person["phone"] 18 | print(person) 19 | 20 | 21 | ## **Ejercicio 3: Almacén de productos** 22 | product = {"name": "Laptop", "price": 1500, "quantity": 20} 23 | product["quantity"] += 10 24 | print(product["price"]) 25 | 26 | product["category"] = "Electronics" 27 | del product["price"] 28 | print(product) 29 | 30 | 31 | ## **Ejercicio 4: Libro favorito** 32 | book = {"title": "Cien años de soledad", "author": "Gabriel Garcia Marquez", "year": 1967, "pages": 471} 33 | book["pages"] += 20 34 | book["genre"] = "Magical realism" 35 | 36 | print(book["title"], "por", book["author"]) 37 | del book["year"] 38 | print(book) 39 | 40 | 41 | ## **Ejercicio 5: Diccionario de comida** 42 | food = {"name": "Apple", "type": "Fruit", "calories": 95} 43 | food["is_healthy"] = True 44 | food["calories"] -= 50 45 | del food["type"] 46 | print(food) 47 | 48 | 49 | ## **Ejercicio 6: Actualización de contactos** 50 | contact = {"name": "Carlos", "email": "carlos@example.com", "phone": "123456789"} 51 | contact["phone"] = "987654321" 52 | contact["address"] = "123 Main St" 53 | del contact["email"] 54 | print(contact) 55 | -------------------------------------------------------------------------------- /Ejercicios/09 Condicionales/09 Condicionales.md: -------------------------------------------------------------------------------- 1 | # Dictionaries 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!NOTE] 9 | > ## Actividades: 10 | > ## **Ejercicio 1: Determinar si puedes aprender a conducir** 11 | > 1. Solicita al usuario que ingrese su edad con `input()`. 12 | > 2. Si la edad es 18 o más, muestra: **"Eres lo suficientemente mayor para aprender a conducir."** 13 | > 3. Si es menor, calcula cuántos años faltan para tener 18 y muestra: **"Necesitas X años más para aprender a conducir."** 14 | > ## **Ejercicio 2: Comparar edades** 15 | > 1. Define una edad predefinida (por ejemplo, `mi_edad = 25`). 16 | > 2. Solicita al usuario que ingrese su edad con `input()`. 17 | > 3. Compara las edades y muestra: 18 | > - Si el usuario es mayor, muestra: **"Eres X años mayor que yo."** 19 | > - Si es menor, muestra: **"Soy X años mayor que tú."** 20 | > - Si ambas edades son iguales, muestra: **"Tenemos la misma edad."** 21 | > ## **Ejercicio 3: Comparar dos números** 22 | > 1. Solicita al usuario dos números. 23 | > 2. Muestra: 24 | > - **"A es mayor que B"** si el primer número es mayor. 25 | > - **"A es menor que B"** si el primer número es menor. 26 | > - **"A es igual a B"** si ambos números son iguales. 27 | > ## **Ejercicio 4: Calificar estudiantes según sus notas** 28 | > 1. Solicita una puntuación entre 0 y 100 al usuario. 29 | > 2. Asigna calificaciones según este rango: 30 | > - **80-100:** A 31 | > - **70-79:** B 32 | > - **60-69:** C 33 | > - **50-59:** D 34 | > - **0-49:** F 35 | > 3. Muestra la calificación correspondiente. 36 | > ## **Ejercicio 5: Determinar la estación del año** 37 | > 1. Solicita al usuario un mes (por ejemplo, **"Septiembre"**). 38 | > 2. Según el mes, muestra la estación: 39 | > - **Septiembre, Octubre, Noviembre:** Otoño. 40 | > - **Diciembre, Enero, Febrero:** Invierno. 41 | > - **Marzo, Abril, Mayo:** Primavera. 42 | > - **Junio, Julio, Agosto:** Verano. 43 | > ## **Ejercicio 6: Lista de frutas** 44 | > 1. Define una lista: `frutas = ['banana', 'naranja', 'mango', 'limón']`. 45 | > 2. Solicita al usuario que ingrese el nombre de una fruta. 46 | > 3. Si la fruta ya está en la lista, muestra: **"Esa fruta ya existe en la lista."** 47 | > 4. Si no está, agrégala a la lista y muestra la lista actualizada. 48 | > ## **Ejercicio 7: Trabajando con diccionarios** 49 | > Usa el siguiente diccionario: 50 | > ```python 51 | > persona = { 52 | > 'nombre': 'Juan', 53 | > 'apellido': 'Pérez', 54 | > 'edad': 30, 55 | > 'país': 'España', 56 | > 'casado': True, 57 | > 'habilidades': ['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], 58 | > 'dirección': { 59 | > 'calle': 'Calle Luna', 60 | > 'código_postal': '28001' 61 | > } 62 | > } 63 | > ``` 64 | > 1. **Verificar habilidades:** Si el diccionario tiene la clave `habilidades`, imprime la habilidad en el medio de la lista. 65 | > 2. **Buscar "Python":** Si `habilidades` incluye **"Python"**, muestra: **"Tiene conocimientos de Python."** 66 | > 3. **Evaluar habilidades:** 67 | > - Si tiene `JavaScript` y `React`, muestra: **"Es un desarrollador frontend."** 68 | > - Si tiene `Node`, `Python` y `MongoDB`, muestra: **"Es un desarrollador backend."** 69 | > - Si tiene `React`, `Node` y `MongoDB`, muestra: **"Es un desarrollador fullstack."** 70 | > - En otro caso, muestra: **"Título desconocido."** 71 | > 4. **Verificar estado civil y país:** Si la persona está casada y vive en España, muestra: 72 | > ```plaintext 73 | > Nombre completo: Juan Pérez 74 | > País: España 75 | > Estado civil: Casado 76 | > ``` 77 | 78 | >[!TIP] 79 | >## Y recuerda: 80 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/09 Condicionales/Condicionales-JulianB0315.py: -------------------------------------------------------------------------------- 1 | ## **Ejercicio 1: Determinar si puedes aprender a conducir** 2 | edad = int(input("Ingrese su edad: ")) 3 | if edad >= 18: 4 | print("Eres lo suficiente mayor para aprender a conducir") 5 | else: 6 | edad_faltante= 18 - edad 7 | print(f"Necesitas {edad_faltante} años más para aprender a conducir") 8 | 9 | ## **Ejercicio 2: Comparar edades** 10 | mi_edad = 20 11 | usuario_edad = int(input("Ingrese la edad del usuario: ")) 12 | if mi_edad > usuario_edad: 13 | print(f"Soy {mi_edad-usuario_edad} años mayor que tú") 14 | elif mi_edad < usuario_edad: 15 | print(f"Eres {usuario_edad-mi_edad} años mayor que yo") 16 | else: 17 | print("Tenemos la misma edad") 18 | ## **Ejercicio 3: Comparar dos números** 19 | a= int(input("Ingrese el valor de a: ")) 20 | b= int(input("Ingrese el valor de b: ")) 21 | if a > b: 22 | print("a es mayor que b") 23 | elif a < b: 24 | print("b es mayor que a") 25 | else: 26 | print("a es igual a b") 27 | 28 | ## **Ejercicio 4: Calificar estudiantes según sus notas** 29 | nota = int(input("Ingrese la nota del estudiante, mayor a 0 menor de 100: ")) 30 | if nota >= 80 and nota <= 100: 31 | print("A") 32 | elif nota >= 70 and nota < 80: 33 | print("B") 34 | elif nota >= 60 and nota < 70: 35 | print("C") 36 | elif nota >= 50 and nota < 60: 37 | print("D") 38 | elif nota >= 0 and nota < 50: 39 | print("F") 40 | else: 41 | print("Nota no válida") 42 | 43 | ## **Ejercicio 5: Determinar la estación del año** 44 | mes = input("Ingrese el mes en el que se encuentra: ") 45 | meses_verano = ["junio", "julio", "agosto"] 46 | meses_otono = ["septiembre", "octubre", "noviembre"] 47 | meses_invierno = ["diciembre", "enero", "febrero"] 48 | meses_primavera = ["marzo", "abril", "mayo"] 49 | if mes in meses_verano: 50 | print("Verano") 51 | elif mes in meses_otono: 52 | print("Otoño") 53 | elif mes in meses_invierno: 54 | print("Invierno") 55 | elif mes in meses_primavera: 56 | print("Primavera") 57 | else: 58 | print("Mes no válido") 59 | 60 | ## **Ejercicio 6: Lista de frutas** 61 | frutas = ['banana', 'naranja', 'mango', 'limón'] 62 | fruta = input("Ingrese una fruta: ") 63 | if fruta in frutas: 64 | print("La fruta está en la lista") 65 | else: 66 | frutas.append(fruta) 67 | print("La fruta no está en la lista, se ha añadido a la lista") 68 | print(frutas) 69 | 70 | ## **Ejercicio 7: Trabajando con diccionarios** 71 | persona = { 72 | 'nombre': 'Juan', 73 | 'apellido': 'Pérez', 74 | 'edad': 30, 75 | 'país': 'España', 76 | 'casado': True, 77 | 'habilidades': ['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], 78 | 'dirección': { 79 | 'calle': 'Calle Luna', 80 | 'código_postal': '28001' 81 | } 82 | } 83 | if 'habilidades' in persona: 84 | habilidades = persona['habilidades'] 85 | print("Su habilidades son: ", habilidades[len(habilidades) // 2]) 86 | else: 87 | print("No tiene habilidades") 88 | 89 | #Buscar python 90 | if 'Python' in persona['habilidades']: 91 | print("Python está en sus habilidades") 92 | else: 93 | print("Python no está en sus habilidades") 94 | 95 | #Evaluar habilidades 96 | if set(persona['habilidades']) == {"JavaScript", "React"}: 97 | print("Es un desarrollador frontend.") 98 | elif set(persona['habilidades']) == {"Node","Python", "MongoDB"}: 99 | print("Es un desarrollador backend.") 100 | elif set(persona['habilidades']) == { "React", "Node", "MongoDB"}: 101 | print("Es un desarrollador fullstack.") 102 | else: 103 | print("Titulo desconocido") 104 | 105 | #Evaluar estado civil y país 106 | if persona['casado'] and persona['país'] == 'España': 107 | print("Nombre ;",persona['nombre'], persona['apellido']) 108 | print("País ;",persona['país']) 109 | if persona['casado']: 110 | print("Estado civil ; Casado") 111 | else: 112 | print("Estado civil ; Soltero") -------------------------------------------------------------------------------- /Ejercicios/10 Bucles/10 Bucles .md: -------------------------------------------------------------------------------- 1 | # Bucles 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!NOTE] 9 | > ## Actividades: 10 | > ## **Ejercicio 1: Números múltiplos de 5** 11 | > 1. Crea un programa que imprima todos los números múltiplos de 5 entre 1 y 50. 12 | > 2. Usa un bucle `for` para iterar del 1 al 50. 13 | > 3. Muestra los números que sean divisibles por 5. 14 | > ## **Ejercicio 2: Pirámide invertida** 15 | > 1. Escribe un programa que imprima la siguiente pirámide invertida: 16 | > ```plaintext 17 | > ******* 18 | > ***** 19 | > *** 20 | > * 21 | > ``` 22 | > 2. Usa un bucle `for` y ajusta el espaciado en cada línea. 23 | > ## **Ejercicio 3: Letras de una palabra** 24 | > 1. Solicita al usuario que ingrese una palabra usando `input()`. 25 | > 2. Usa un bucle `for` para imprimir cada letra de la palabra en una línea diferente. 26 | > 3. Indica la posición de cada letra al imprimirla. 27 | > ## **Ejercicio 4: Suma de números hasta 100** 28 | > 1. Escribe un programa que calcule la suma de todos los números del 1 al 100. 29 | > 2. Usa un bucle `while` para realizar la suma. 30 | > 3. Muestra el resultado al final. 31 | > ## **Ejercicio 5: Pedir un número positivo** 32 | > 1. Solicita al usuario que ingrese un número positivo. 33 | > 2. Si el número ingresado es negativo o cero, sigue pidiendo hasta que el usuario ingrese un número válido. 34 | > 3. Usa un bucle `while` para verificar la validez del número. 35 | > ## **Ejercicio 6: Contar vocales** 36 | > 1. Dado el string `"programación en Python"`, cuenta cuántas vocales tiene. 37 | > 2. Usa un bucle `for` para iterar sobre los caracteres del string. 38 | > 3. Muestra el conteo total de vocales. 39 | > ## **Ejercicio 7: Tabla de multiplicar de un número** 40 | > 1. Solicita al usuario que ingrese un número del 1 al 10. 41 | > 2. Usa un bucle `for` para imprimir la tabla de multiplicar de ese número. 42 | > 3. Muestra los resultados en el formato: 43 | > ```plaintext 44 | > 5 x 1 = 5 45 | > 5 x 2 = 10 46 | > ... 47 | > 5 x 10 = 50 48 | > ``` 49 | 50 | >[!TIP] 51 | >## Y recuerda: 52 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/10 Bucles/Bucles-JulianB0315.py: -------------------------------------------------------------------------------- 1 | ## **Ejercicio 1: Números múltiplos de 5** 2 | for i in range(1, 51): 3 | if i % 5 == 0: 4 | print(i) 5 | 6 | ## **Ejercicio 2: Pirámide invertida** 7 | 8 | altura = 4 9 | for x in range(altura,0, -1): 10 | espacios = " " * (altura - x) 11 | estrellas = "*" * (x * 2 - 1) 12 | print(espacios + estrellas) 13 | 14 | ## **Ejercicio 3: Letras de una palabra** 15 | palabra = input("Ingrese una palabra: ") 16 | for indice,letra in enumerate(palabra): 17 | print(f"La letra {letra} está en la posición {indice + 1}") 18 | 19 | ## **Ejercicio 4: Suma de números hasta 100** 20 | suma = 0 21 | num = 1 22 | while suma <= 100: 23 | num += suma 24 | suma += 1 25 | print(f"La suma de los números es: {num}") 26 | 27 | ## **Ejercicio 5: Pedir un número positivo** 28 | num = int(input("Ingrese un número positivo: ")) 29 | while num <= 0: 30 | num = int(input("Ingrese un número positivo: ")) 31 | print("Número ingresado correctamente") 32 | 33 | ## **Ejercicio 6: Contar vocales** 34 | string="programación en Python" 35 | conteo_letras = 0 36 | for letras in string: 37 | if letras in "aeiouáéíóú": 38 | conteo_letras += 1 39 | print(f"La cantidad de letras en la palabra es: {conteo_letras}") 40 | 41 | ## **Ejercicio 7: Tabla de multiplicar de un número** 42 | numero_multiplicar = int(input("Ingrese un número para mostrar su tabla de multiplicar del 1 al 10: ")) 43 | while numero_multiplicar <= 0 or numero_multiplicar > 10: 44 | numero_multiplicar = int(input("Ingrese un número para mostrar su tabla de multiplicar del 1 al 10: ")) 45 | for i in range(1, 11): 46 | print(f"{numero_multiplicar} x {i} = {numero_multiplicar * i}") -------------------------------------------------------------------------------- /Ejercicios/11 Funciones/11 Funciones.md: -------------------------------------------------------------------------------- 1 | # Funciones 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!NOTE] 9 | > ### Actividades 10 | > 1. **Suma de dos números** 11 | > Declara una función `sumar_dos_numeros` que reciba dos parámetros y devuelva su suma. 12 | > 2. **Área de un círculo** 13 | > Escribe una función `area_circulo` que calcule el área de un círculo dado el radio. 14 | > 3. **Suma de argumentos arbitrarios** 15 | > Escribe una función `sumar_todo` que tome un número arbitrario de argumentos y devuelva la suma. Si algún elemento no es un número, proporciona un mensaje claro. 16 | > 4. **Convertir temperatura** 17 | > Declara una función `convertir_celsius_a_fahrenheit` que convierta una temperatura de °C a °F. 18 | > 5. **Estaciones del año** 19 | > Crea una función `determinar_estacion` que reciba un mes y devuelva la estación: Primavera, Verano, Otoño o Invierno. 20 | > 6. **Imprimir elementos de una lista** 21 | > Declara una función `imprimir_lista` que tome una lista como parámetro y muestre cada elemento en una nueva línea. 22 | > 7. **Lista invertida** 23 | > Declara una función `invertir_lista` que tome una lista como parámetro y devuelva la lista en orden inverso. 24 | > 8. **Capitalizar elementos de una lista** 25 | > Crea una función `capitalizar_lista` que reciba una lista y devuelva otra con los elementos capitalizados. 26 | > 9. **Agregar un elemento a una lista** 27 | > Declara una función `agregar_elemento` que tome una lista y un elemento como parámetros y devuelva la lista con el nuevo elemento añadido. 28 | > 10. **Eliminar un elemento de una lista** 29 | > Escribe una función `eliminar_elemento` que tome una lista y un elemento como parámetros y devuelva la lista sin ese elemento. 30 | > 11. **Suma de un rango de números** 31 | > Declara una función `suma_de_numeros` que tome un número como parámetro y devuelva la suma de todos los números desde 1 hasta ese número. 32 | > 12. **Suma de números impares** 33 | > Declara una función `suma_de_impares` que tome un número como parámetro y devuelva la suma de todos los números impares en ese rango. 34 | > 13. **Suma de números pares** 35 | > Declara una función `suma_de_pares` que tome un número como parámetro y devuelva la suma de todos los números pares en ese rango. 36 | > 14. **Contar pares e impares** 37 | > Crea una función `contar_pares_e_impares` que reciba un número positivo y cuente cuántos números pares e impares hay desde 1 hasta ese número. 38 | > 15. **Factorial de un número** 39 | > Declara una función `factorial` que reciba un número entero positivo y devuelva su factorial. 40 | > 16. **Verificar si una lista está vacía** 41 | > Declara una función `esta_vacia` que reciba una lista y determine si está vacía o no. 42 | > 17. **Calcular estadísticas de una lista** 43 | > Escribe funciones que reciban una lista y calculen: media, mediana, moda, rango, varianza y desviación estándar. 44 | > 18. **Número primo** 45 | > Declara una función `es_primo` que reciba un número y determine si es primo o no. 46 | > 19. **Verificar elementos únicos** 47 | > Escribe una función que reciba una lista y verifique si todos los elementos son únicos. 48 | > 20. **Verificar tipos de datos** 49 | > Crea una función que reciba una lista y determine si todos los elementos son del mismo tipo de dato. 50 | > 21. **Variable válida en Python** 51 | > Escribe una función que determine si una cadena es un nombre de variable válido en Python. 52 | > 22. **Idiomas más hablados** 53 | > Declara una función `idiomas_mas_hablados` que devuelva los 10 o 20 idiomas más hablados en el mundo en orden descendente. 54 | > 23. **Países más poblados** 55 | > Crea una función `paises_mas_poblados` que devuelva los 10 o 20 países más poblados en orden descendente. 56 | 57 | >[!TIP] 58 | >## Y recuerda: 59 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/11 Funciones/Funciones-JulianB0315.py: -------------------------------------------------------------------------------- 1 | # 1 Suma de dos número 2 | def suma_dos_numeros(a, b): 3 | return a + b 4 | resultado = suma_dos_numeros(3, 4) 5 | print(resultado) 6 | 7 | # 2 Área de un círculo 8 | def area_circulo(radio): 9 | return 3.14159 * radio ** 2 10 | resultado = area_circulo(6) 11 | print(resultado) 12 | 13 | # 3 Suma de argumentos arbitrarios 14 | def sumar_todo(*args): 15 | suma = 0 16 | for arg in args: 17 | if not isinstance(arg, (int, float)): 18 | return f"Error: '{arg}' no es un número válido." 19 | suma += arg 20 | return suma 21 | print(sumar_todo(1, 2, 3, 4)) 22 | print(sumar_todo(1, 'a', 3)) 23 | # 4 Convertir temperatura 24 | def convertir_celsius_a_fahrenheit(celsius): 25 | return celsius * 9/5 + 32 26 | resultado = convertir_celsius_a_fahrenheit(100) 27 | print(resultado) 28 | 29 | # 5 Estaciones del año 30 | def determinar_estacion(mes): 31 | if mes in (1, 2, 12): 32 | return 'Invierno' 33 | elif mes in (3, 4, 5): 34 | return 'Primavera' 35 | elif mes in (6, 7, 8): 36 | return 'Verano' 37 | elif mes in (9, 10, 11): 38 | return 'Otoño' 39 | else: 40 | return 'Mes no válido' 41 | resultado = determinar_estacion(5) 42 | print(resultado) 43 | 44 | # 6 Imprimir elementos de una lista 45 | def imprimir_lista(lista): 46 | for elemento in lista: 47 | print(elemento) 48 | imprimir_lista([1, 2, 3, 4, 5]) 49 | 50 | # 7 Lista invertida 51 | def invertir_lista(lista): 52 | return lista[::-1] 53 | resultado = invertir_lista([1, 2, 3, 4, 5]) 54 | print(resultado) 55 | 56 | # 8 Capitalizar elementos de una lista 57 | def capitalizar_lista(lista): 58 | return [elemento.capitalize() for elemento in lista] 59 | resultado = capitalizar_lista(['hola', 'mundo']) 60 | print(resultado) 61 | 62 | # 9 Agregar un elemento a una lista 63 | def agregar_elemento(lista, elemento): 64 | lista.append(elemento) 65 | return lista 66 | resultado = agregar_elemento([1, 2, 3, 4, 5], 6) 67 | print(resultado) 68 | 69 | # 10 Eliminar un elemento de una lista 70 | def eliminar_elemento(lista,elemento): 71 | lista.remove(elemento) 72 | return lista 73 | resultado = eliminar_elemento([1, 2, 3, 4, 5], 3) 74 | print(resultado) 75 | 76 | # 11 Suma de un rango de números 77 | def suma_de_numeros(n): 78 | return sum(range(n + 1)) 79 | resultado = suma_de_numeros(10) 80 | print(resultado) 81 | 82 | # 12 Suma de números impares 83 | def suma_de_impares(n): 84 | return sum(range(1, n + 1, 2)) 85 | resultado = suma_de_impares(10) 86 | print(resultado) 87 | 88 | # 13 Suma de números pares 89 | def suma_de_pares(n): 90 | return sum(range(0, n + 1, 2)) 91 | resultado = suma_de_pares(10) 92 | print(resultado) 93 | 94 | # 14 Contar pares e impares 95 | def contar_pares_e_impares(n): 96 | pares = len(range(0, n + 1, 2)) 97 | impares = len(range(1, n + 1, 2)) 98 | return pares, impares 99 | resultado = contar_pares_e_impares(10) 100 | print(resultado) 101 | 102 | # 15 Factorial de un número 103 | def factorial(n): 104 | if n == 0: 105 | return 1 106 | return n * factorial(n - 1) 107 | resultado = factorial(5) 108 | print(resultado) 109 | 110 | # 16 Verificar si una lista está vacía 111 | def lista_vacia(lista): 112 | return len(lista) == 0 113 | resultado = lista_vacia([]) 114 | print(resultado) 115 | 116 | # 17 Calcular estadísticas de una lista 117 | def calcular_estadisticas(lista): 118 | return { 119 | 'media': sum(lista) / len(lista), 120 | 'mediana': lista[len(lista) // 2], 121 | 'moda': max(set(lista), key = lista.count), 122 | 'rango': max(lista) - min(lista), 123 | 'varianza': sum((x - sum(lista) / len(lista)) ** 2 for x in lista) / len(lista), 124 | 'desviación estándar': (sum((x - sum(lista) / len(lista)) ** 2 for x in lista) / len(lista)) ** 0.5 125 | } 126 | resultado = calcular_estadisticas([1, 2, 3, 4, 5]) 127 | print(resultado) 128 | 129 | # 18 Número primo 130 | def es_primo(n): 131 | if n < 2: 132 | return False 133 | for i in range(2, n): 134 | if n % i == 0: 135 | return False 136 | return True 137 | resultado = es_primo(7) 138 | print(resultado) 139 | 140 | # 19 Verificar elementos únicos 141 | def elementos_unicos(lista): 142 | return len(lista) == len(set(lista)) 143 | resultado = elementos_unicos([1, 2, 3, 4, 5]) 144 | print(resultado) 145 | 146 | # 20 Verificar tipos de datos 147 | def verificar_tipos(*args): 148 | return [type(arg) for arg in args] 149 | resultado = verificar_tipos(1, 'a', 3.0) 150 | print(resultado) 151 | 152 | # 21 Variable válida en Python 153 | import keyword 154 | 155 | def variable_valida(nombre): 156 | # Verificar si el nombre está vacío 157 | if not nombre: 158 | return False 159 | if nombre in keyword.kwlist: 160 | return False 161 | if not nombre.isidentifier(): 162 | return False 163 | return True 164 | resultado = variable_valida('hola') 165 | print(resultado) 166 | 167 | # 22 Idiomas más hablados 168 | def idiomas_mas_hablados(): 169 | return { 170 | 'Chino mandarín': 918000000, 171 | 'Español': 460000000, 172 | 'Inglés': 379000000, 173 | 'Hindi': 341000000, 174 | 'Árabe': 319000000, 175 | 'Bengalí': 228000000, 176 | 'Portugués': 221000000, 177 | 'Ruso': 154000000, 178 | 'Japonés': 128000000, 179 | 'Lahnda': 119000000 180 | } 181 | resultado = idiomas_mas_hablados() 182 | print(resultado) 183 | 184 | # 23 Países más poblados 185 | def paises_mas_poblados(): 186 | return { 187 | 'China': 1439323776, 188 | 'India': 1380004385, 189 | 'Estados Unidos': 331002651, 190 | 'Indonesia': 273523615, 191 | 'Pakistán': 220892340, 192 | 'Brasil': 212559417, 193 | 'Nigeria': 206139587, 194 | 'Bangladés': 164689383, 195 | 'Rusia': 145934462, 196 | 'México': 128932753 197 | } 198 | resultado = paises_mas_poblados() 199 | print(resultado) 200 | -------------------------------------------------------------------------------- /Ejercicios/12 Modulos/Modulos-JulianB0315.py: -------------------------------------------------------------------------------- 1 | #Ejercicio 1: 2 | def generar_id_usuario(): 3 | import random 4 | import string 5 | longitud = 6 6 | valores = string.ascii_letters + string.digits 7 | p = ''.join(random.choice(valores) for i in range(longitud)) 8 | return p 9 | print(generar_id_usuario()) 10 | 11 | #Ejercicio 2: 12 | def generar_ids_por_usuario(longitud,cantidad): 13 | import random 14 | import string 15 | valores = string.ascii_letters + string.digits 16 | for i in range(cantidad): 17 | p = ''.join(random.choice(valores) for i in range(longitud)) 18 | print(p) 19 | cantidad = int(input("Ingrese la cantidad de id's que desea generar: ")) 20 | longitud = int(input("Ingrese la longitud de los id's: ")) 21 | generar_ids_por_usuario(longitud,cantidad) 22 | 23 | #Ejercicio 3: 24 | def generar_color_rgb(): 25 | import random 26 | r = random.randint(0,255) 27 | g = random.randint(0,255) 28 | b = random.randint(0,255) 29 | return (r,g,b) 30 | print(generar_color_rgb()) 31 | 32 | #Ejercicio 4: 33 | def lista_colores_hexadecimales(cantidad): 34 | import random 35 | lista = [] 36 | for i in range(cantidad): 37 | r = random.randint(0,255) 38 | g = random.randint(0,255) 39 | b = random.randint(0,255) 40 | lista.append(f"#{r:02x}{g:02x}{b:02x}") 41 | return lista 42 | cantidad = int(input("Ingrese la cantidad de colores hexadecimales que desea generar: ")) 43 | print(lista_colores_hexadecimales(cantidad)) 44 | 45 | #Ejercicio 5: 46 | def lista_colores_rgb(cantidad): 47 | import random 48 | lista = [] 49 | for i in range(cantidad): 50 | r = random.randint(0,255) 51 | g = random.randint(0,255) 52 | b = random.randint(0,255) 53 | lista.append((r,g,b)) 54 | return lista 55 | cantidad = int(input("Ingrese la cantidad de colores RGB que desea generar: ")) 56 | print(lista_colores_rgb(cantidad)) 57 | 58 | #Ejercicio 6: 59 | def generar_colores(tipo,cantidad): 60 | if tipo == "RGB": 61 | return lista_colores_rgb(cantidad) 62 | elif tipo == "HEXA": 63 | return lista_colores_hexadecimales(cantidad) 64 | else: 65 | return "Tipo de color no soportado" 66 | tipo = input("Ingrese el tipo de color que desea generar (RGB/HEXA): ") 67 | cantidad = int(input("Ingrese la cantidad de colores que desea generar: ")) 68 | print(generar_colores(tipo,cantidad)) 69 | -------------------------------------------------------------------------------- /Ejercicios/12 Modulos/Modulos.md: -------------------------------------------------------------------------------- 1 | # Modulos 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!NOTE] 9 | > ### Actividades 10 | > ### **Ejercicio 1**: 11 | > Escribe una función llamada `generar_id_usuario`. La función generará un ID aleatorio de seis dígitos o caracteres. 12 | > ```python 13 | > # Salida esperada (un ejemplo): 14 | > # generar_id_usuario() 15 | > # '1ee33d' 16 | > ``` 17 | > ### **Ejercicio 2**: 18 | > Modifica el ejercicio anterior. Declara una función llamada `generar_ids_por_usuario`. La función no recibe parámetros directamente, pero pide al usuario dos entradas: 19 | > 1. El número de caracteres para cada ID. 20 | > 2. El número de IDs que se deben generar. 21 | > ```python 22 | > # Ejemplo de entrada del usuario: 5 5 23 | > # Salida esperada: 24 | > # kcsy2 25 | > # SMFYb 26 | > # bWmeq 27 | > # ZXOYh 28 | > # 2Rgxf 29 | > 30 | > # Otro ejemplo de entrada: 16 5 31 | > # Salida esperada: 32 | > # 1GCSgPLMaBAVQZ26 33 | > # YD7eFwNQKNs7qXaT 34 | > # ycArC5yrRupyG00S 35 | > # UbGxOFI7UXSWAyKN 36 | > # dIV0SSUTgAdKwStr 37 | > ``` 38 | > ### **Ejercicio 3**: 39 | > Escribe una función llamada `generar_color_rgb`. Esta función generará colores RGB aleatorios, donde cada valor del color (rojo, verde, azul) estará en el rango de 0 a 255. 40 | > ```python 41 | > # Salida esperada: 42 | > # generar_color_rgb() 43 | > # 'rgb(125,244,255)' 44 | > ``` 45 | > ### **Ejercicio 4**: 46 | > Escribe una función llamada `lista_colores_hexadecimales` que devuelva una lista de colores hexadecimales. La cantidad de colores será un parámetro que reciba la función. 47 | > ```python 48 | > # Ejemplo: 49 | > # lista_colores_hexadecimales(3) 50 | > # ['#a3e12f', '#03ed55', '#eb3d2b'] 51 | > ``` 52 | > ### **Ejercicio 5**: 53 | > Escribe una función llamada `lista_colores_rgb` que devuelva una lista de colores RGB. La cantidad de colores será un parámetro que reciba la función. 54 | > ```python 55 | > # Ejemplo: 56 | > # lista_colores_rgb(3) 57 | > # ['rgb(5, 55, 175)', 'rgb(50, 105, 100)', 'rgb(15, 26, 80)'] 58 | > ``` 59 | > ### **Ejercicio 6**: 60 | > Escribe una función llamada `generar_colores` que pueda generar una lista de colores hexadecimales o RGB. La función recibirá dos parámetros: 61 | > 1. El tipo de color: `'hexa'` o `'rgb'`. 62 | > 2. La cantidad de colores que se quieren generar. 63 | > ```python 64 | > # Ejemplo: 65 | > # generar_colores('hexa', 3) 66 | > # ['#a3e12f', '#03ed55', '#eb3d2b'] 67 | > 68 | > # generar_colores('rgb', 2) 69 | > # ['rgb(33,79,176)', 'rgb(120,55,90)'] 70 | > ``` 71 | 72 | 73 | >[!TIP] 74 | >## Y recuerda: 75 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/13 Compresión de listas/13 Compresión de listas.md: -------------------------------------------------------------------------------- 1 | # Compresión de listas 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!NOTE] 9 | > ### Actividades 10 | > 11 | > 1. **Filtrar solo los números positivos de la lista usando comprensión de listas:** 12 | > 13 | > ```python 14 | > numeros = [-10, -5, 0, 5, 10, 15, -20] 15 | > # Resultado esperado: [5, 10, 15] 16 | > ``` 17 | > 18 | > 2. **Aplanar la siguiente lista de listas en una lista unidimensional:** 19 | > 20 | > ```python 21 | > lista_anidada = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]] 22 | > # Resultado esperado: [1, 2, 3, 4, 5, 6, 7, 8] 23 | > ``` 24 | > 25 | > 3. **Crear una lista de potencias de un número:** 26 | > 27 | > ```python 28 | > # Genera una lista de potencias del 2 desde 2^0 hasta 2^10 29 | > # Resultado esperado: [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] 30 | > ``` 31 | > 32 | > 4. **Convertir las siguientes listas de países y ciudades a un formato personalizado:** 33 | > 34 | > ```python 35 | > paises = [[('Perú', 'Lima')], [('Chile', 'Santiago')], [('Colombia', 'Bogotá')]] 36 | > # Resultado esperado: [['PERÚ', 'PER', 'LIMA'], ['CHILE', 'CHI', 'SANTIAGO'], ['COLOMBIA', 'COL', 'BOGOTÁ']] 37 | > ``` 38 | > 39 | > 5. **Transformar las listas de países a un diccionario:** 40 | > 41 | > ```python 42 | > paises = [[('Perú', 'Lima')], [('Chile', 'Santiago')], [('Colombia', 'Bogotá')]] 43 | > # Resultado esperado: 44 | > # [{'pais': 'PERÚ', 'ciudad': 'LIMA'}, 45 | > # {'pais': 'CHILE', 'ciudad': 'SANTIAGO'}, 46 | > # {'pais': 'COLOMBIA', 'ciudad': 'BOGOTÁ'}] 47 | > ``` 48 | > 49 | > 6. **Concatenar nombres y apellidos en una lista de cadenas:** 50 | > 51 | > ```python 52 | > nombres = [[('Luis', 'Martínez')], [('Ana', 'García')], [('José', 'Pérez')]] 53 | > # Resultado esperado: ['Luis Martínez', 'Ana García', 'José Pérez'] 54 | > ``` 55 | > 56 | > 7. **Escribir una función lambda para calcular la pendiente o la intersección en el eje \( y \) de una función lineal:** 57 | > 58 | > La ecuación de una recta es \( y = mx + b \). Escribe una función lambda para: 59 | > 60 | > - Calcular la **pendiente** \( m \) dada la ecuación de dos puntos \((x1, y1)\) y \((x2, y2)\). 61 | > - Calcular la **intersección en el eje y** \( b \) usando la ecuación \( b = y - mx \). 62 | > 63 | > ```python 64 | > # Fórmulas: 65 | > # pendiente = lambda x1, y1, x2, y2: (y2 - y1) / (x2 - x1) 66 | > # intersección = lambda x, y, m: y - m * x 67 | > 68 | > # Prueba con puntos (2, 3) y (5, 11) 69 | > # Resultado esperado: pendiente = 2.666..., intersección = -2.333... 70 | > ``` 71 | 72 | >[!TIP] 73 | >## Y recuerda: 74 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/13 Compresión de listas/Compresión de listas-JulianB0315.py: -------------------------------------------------------------------------------- 1 | #1 Filtrar solo los números positivos de la lista usando comprensión de listas: 2 | numeros = [-10, -5, 0, 5, 10, 15, -20] 3 | positivos = [numero for numero in numeros if numero > 0] 4 | print(positivos) 5 | 6 | #2 Aplanar la siguiente lista de listas en una lista unidimensional: 7 | lista_anidada = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]] 8 | lista_aplanada = [numero for sublista in lista_anidada for lista in sublista for numero in lista] 9 | print(lista_aplanada) 10 | 11 | #3 Crear una lista de potencias de un número: 12 | base = 2 13 | potencias = [base ** i for i in range(11)] 14 | print(potencias) 15 | 16 | #4 Convertir las siguientes listas de países y ciudades a un formato personalizado: 17 | paises = [[('Perú', 'Lima')], [('Chile', 'Santiago')], [('Colombia', 'Bogotá')]] 18 | paises_personalizado = [[pais[0][0].upper(), pais[0][0][:3].upper(), pais[0][1].upper()]for pais in paises] 19 | print(paises_personalizado) 20 | 21 | #5 Transformar las listas de países a un diccionario: 22 | paises = [[('Perú', 'Lima')], [('Chile', 'Santiago')], [('Colombia', 'Bogotá')]] 23 | paises_dict = [{'pais': pais[0][0].upper(), 'ciudad': pais[0][1].upper()} for pais in paises] 24 | print(paises_dict) 25 | 26 | #6 Concatenar nombres y apellidos en una lista de cadenas: 27 | nombres = [[('Luis', 'Martínez')], [('Ana', 'García')], [('José', 'Pérez')]] 28 | nombres_completos = [f'{nombre[0][0]} {nombre[0][1]}' for nombre in nombres] 29 | print(nombres_completos) 30 | 31 | #7 Escribir una función lambda para calcular la pendiente o la intersección en el eje ( y ) de una función lineal: 32 | pendiente = lambda x1, y1, x2, y2: (y2 - y1) / (x2 - x1) 33 | interseccion = lambda x, y, m: y - m * x 34 | x1, y1 = 2, 3 35 | x2, y2 = 5, 11 36 | m = pendiente(x1, y1, x2, y2) 37 | print(f"Pendiente (m): {m}") 38 | b = interseccion(x1, y1, m) 39 | print(f"Intersección en el eje y (b): {b}") -------------------------------------------------------------------------------- /Ejercicios/14 Funciones de orden superior/14 Funciones de orden superior.md: -------------------------------------------------------------------------------- 1 | # Funciones de orden superior 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!NOTE] 9 | > ### Actividades 10 | ># Ejercicios: Nivel 1 11 | > 1. **Usar bucles `for`:** 12 | > - Usa un bucle `for` para imprimir cada país en una lista `countries = ["Estonia", "Finland", "Sweden", "Denmark", "Norway"]`. 13 | > - Usa un bucle `for` para imprimir cada nombre en una lista `names = ["Alice", "Bob", "Charlie", "Diana"]`. 14 | > - Usa un bucle `for` para imprimir cada número en una lista `numbers = [1, 2, 3, 4, 5]`. 15 | ># Ejercicios: Nivel 2 16 | > 1. **Usar `map`:** 17 | > - Usa `map` para crear una nueva lista cambiando cada país a mayúsculas en `countries`. 18 | > - Usa `map` para crear una nueva lista cambiando cada número a su cuadrado en `numbers`. 19 | > - Usa `map` para cambiar cada nombre a mayúsculas en `names`. 20 | > 2. **Usar `filter`:** 21 | > - Usa `filter` para filtrar los países que contienen la palabra `'land'` en la lista `countries`. 22 | > - Usa `filter` para filtrar los países con exactamente seis caracteres en `countries`. 23 | > - Usa `filter` para filtrar los países que tienen seis letras o más en `countries`. 24 | > - Usa `filter` para filtrar los países que comienzan con `'E'`. 25 | > 3. **Combinación de iteradores:** 26 | > - Encadena dos o más iteradores de lista, como: `arr.map(callback).filter(callback).reduce(callback)`. 27 | > 4. **Funciones personalizadas:** 28 | > - Declara una función llamada `get_string_lists` que tome una lista como parámetro y devuelva una lista que contenga solo los elementos tipo string. 29 | > - Usa `reduce` para sumar todos los números en `numbers`. 30 | > - Usa `reduce` para concatenar todos los países en la lista `countries` y producir esta oración: 31 | > *"Estonia, Finland, Sweden, Denmark, Norway, and Iceland are north European countries."* 32 | > 5. **Manipulación de listas:** 33 | > - Declara una función llamada `categorize_countries` que devuelva una lista de países con un patrón común, por ejemplo: `'land'`, `'ia'`, `'island'`, `'stan'`. 34 | > - Crea una función que devuelva un diccionario donde las claves sean las letras iniciales de los países y los valores sean el número de países que comienzan con esa letra. 35 | > - Declara una función `get_first_ten_countries` que devuelva los primeros diez países de la lista `countries`. 36 | > - Declara una función `get_last_ten_countries` que devuelva los últimos diez países de la lista `countries`. 37 | ># Ejercicios: Nivel 3 38 | > 1. **Manipulación de datos de países:** 39 | > Usando el archivo `countries_data.py`, realiza las siguientes tareas: 40 | > - Ordena los países por nombre, capital y población. 41 | > - Encuentra los diez idiomas más hablados por ubicación. 42 | > - Encuentra los diez países más poblados. 43 | > 2. **Análisis de datos avanzados:** 44 | > - Usa `map` para calcular la densidad de población (población / área) de cada país y devuelve una lista de diccionarios con los resultados. 45 | > - Usa `filter` para encontrar los países con un área mayor a 1 millón de kilómetros cuadrados. 46 | > - Usa `reduce` para calcular la población total de todos los países. 47 | > 3. **Crea reportes personalizados:** 48 | > - Declara una función que clasifique países por continente basándose en su ubicación. 49 | > - Crea un decorador que registre el tiempo de ejecución de cualquier función que procese los datos de países. 50 | > - Declara una función que encuentre el país con la mayor relación entre población y área. 51 | 52 | >[!TIP] 53 | >## Y recuerda: 54 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/14 Funciones de orden superior/__pycache__/countries_data.cpython-311.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/JulianB0315/Python_0_to_hero/9552ddb7e00d2f9e0107da4141370afada1f3e8b/Ejercicios/14 Funciones de orden superior/__pycache__/countries_data.cpython-311.pyc -------------------------------------------------------------------------------- /Ejercicios/16 Fecha y hora de Python/16 Fecha y hora de Python.md: -------------------------------------------------------------------------------- 1 | # Fecha y hora de Python 2 | 3 | >[!IMPORTANT] 4 | >## Recordatorio: 5 | >1. Los ejercicios se separan por módulos como “Hola mundo” conteniendo de 2 a 4 actividades relacionadas con la clase previamente leída. 6 | >2. Para mandar tu respuesta recuerda hacer un pull requests el la carpeta del módulo y también mandar el archivo con el formato **"[titulo del modulo] - [Nombre de usuario de GitHub]"** 7 | 8 | >[!NOTE] 9 | > # Actividades 10 | > ### Ejercicio 1: Obtener información de la fecha y hora actual 11 | > - Obtén el día, mes, año, hora, minuto y el timestamp actual utilizando el módulo `datetime`. 12 | > 13 | > ### Ejercicio 2: Formatear la fecha actual 14 | > - Usa el formato: `"%d/%m/%Y, %H:%M:%S"` para presentar la fecha y hora actuales de forma legible. 15 | > 16 | > ### Ejercicio 3: Convertir una cadena a un objeto `datetime` 17 | > - La cadena de ejemplo es: `"Hoy es 5 de diciembre, 2019."`. 18 | > - Convierte esta cadena a un objeto de tiempo. 19 | > 20 | > ### Ejercicio 4: Calcular la diferencia de tiempo hasta Año Nuevo 21 | > - Calcula cuántos días, horas y minutos faltan desde ahora hasta el 1 de enero del próximo año. 22 | > 23 | > ### Ejercicio 5: Calcular la diferencia desde el 1 de enero de 1970 24 | > - Calcula cuántos años, días, horas y minutos han pasado desde el 1 de enero de 1970 hasta ahora. 25 | > 26 | > ### Ejercicio 6: Reflexión sobre el uso del módulo `datetime` 27 | > - Piensa en aplicaciones del módulo `datetime` en el mundo real. Por ejemplo: 28 | > - Análisis de series temporales. 29 | > - Registrar marcas de tiempo en actividades de una aplicación. 30 | > - Calcular y mostrar la fecha de publicación de un artículo o publicación en un blog. 31 | 32 | >[!TIP] 33 | >## Y recuerda: 34 | ># "Si puedes imaginarlo puedes programarlo" -------------------------------------------------------------------------------- /Ejercicios/Biometricos/EJ 01.py: -------------------------------------------------------------------------------- 1 | from zk import ZK 2 | import cv2 3 | import face_recognition 4 | from chatterbot import ChatBot 5 | from chatterbot.trainers import ChatterBotCorpusTrainer 6 | 7 | # ========================= 8 | # Configuración del dispositivo ZKTeco 9 | # ========================= 10 | ZKTECO_IP = "192.168.1.201" 11 | ZKTECO_PORT = 4370 12 | 13 | # ========================= 14 | # Inicializar ChatBot 15 | # ========================= 16 | chatbot = ChatBot('MiBot') 17 | trainer = ChatterBotCorpusTrainer(chatbot) 18 | trainer.train('chatterbot.corpus.spanish') 19 | 20 | # ========================= 21 | # Registrar nuevo usuario en ZKTeco 22 | # ========================= 23 | def registrar_usuario(nombre, user_id="1234", role=0): 24 | zk = ZK(ZKTECO_IP, port=ZKTECO_PORT, timeout=5) 25 | try: 26 | conn = zk.connect() 27 | conn.disable_device() 28 | 29 | # Registrar usuario (sin huella) 30 | conn.set_user(uid=int(user_id), name=nombre, privilege=role, password='', group_id='', user_id=user_id) 31 | print(f"Usuario {nombre} (ID: {user_id}) registrado exitosamente. Ahora registra la huella directamente en el dispositivo.") 32 | conn.enable_device() 33 | conn.disconnect() 34 | except Exception as e: 35 | print(f"Error registrando usuario: {e}") 36 | 37 | # ========================= 38 | # Registrar rostro con la cámara 39 | # ========================= 40 | def registrar_rostro(nombre_archivo="persona_conocida.jpg"): 41 | cam = cv2.VideoCapture(0) 42 | print("Coloca tu rostro frente a la cámara y presiona 's' para capturar.") 43 | 44 | while True: 45 | ret, frame = cam.read() 46 | cv2.imshow("Registrar Rostro", frame) 47 | 48 | if cv2.waitKey(1) & 0xFF == ord('s'): 49 | cv2.imwrite(nombre_archivo, frame) 50 | print(f"Rostro capturado y guardado como '{nombre_archivo}'") 51 | break 52 | 53 | elif cv2.waitKey(1) & 0xFF == ord('q'): 54 | print("Registro cancelado.") 55 | break 56 | 57 | cam.release() 58 | cv2.destroyAllWindows() 59 | 60 | # ========================= 61 | # Verificación con ZKTeco MB360 (huella registrada) 62 | # ========================= 63 | def verificar_huella_con_zkteco(): 64 | zk = ZK(ZKTECO_IP, port=ZKTECO_PORT, timeout=5) 65 | try: 66 | print("Conectando al dispositivo ZKTeco...") 67 | conn = zk.connect() 68 | conn.disable_device() 69 | 70 | users = conn.get_users() 71 | if users: 72 | print("Usuarios encontrados en el dispositivo:") 73 | for user in users: 74 | print(f" - ID: {user.user_id}, Nombre: {user.name}") 75 | conn.enable_device() 76 | conn.disconnect() 77 | return True 78 | else: 79 | print("No hay usuarios registrados en el dispositivo.") 80 | conn.disconnect() 81 | return False 82 | 83 | except Exception as e: 84 | print(f"Error conectando al dispositivo: {e}") 85 | return False 86 | 87 | # ========================= 88 | # Verificación Facial 89 | # ========================= 90 | def verificar_rostro(): 91 | video_capture = cv2.VideoCapture(0) 92 | known_image = face_recognition.load_image_file("persona_conocida.jpg") 93 | known_encoding = face_recognition.face_encodings(known_image)[0] 94 | known_faces = [known_encoding] 95 | 96 | print("🧠 Escaneando rostro... Presiona 'q' para cancelar.") 97 | 98 | while True: 99 | ret, frame = video_capture.read() 100 | rgb_frame = frame[:, :, ::-1] 101 | face_locations = face_recognition.face_locations(rgb_frame) 102 | face_encodings = face_recognition.face_encodings(rgb_frame, face_locations) 103 | 104 | for (top, right, bottom, left), face_encoding in zip(face_locations, face_encodings): 105 | matches = face_recognition.compare_faces(known_faces, face_encoding) 106 | if True in matches: 107 | print("Rostro reconocido.") 108 | video_capture.release() 109 | cv2.destroyAllWindows() 110 | return True 111 | 112 | cv2.imshow('Reconocimiento Facial', frame) 113 | if cv2.waitKey(1) & 0xFF == ord('q'): 114 | break 115 | 116 | video_capture.release() 117 | cv2.destroyAllWindows() 118 | return False 119 | 120 | # ========================= 121 | # Iniciar ChatBot 122 | # ========================= 123 | def iniciar_chatbot(): 124 | print("\n ChatBot activado. Escribe 'salir' para terminar.") 125 | while True: 126 | entrada = input("Tú: ") 127 | if entrada.lower() == 'salir': 128 | print("Bot: ¡Hasta luego!") 129 | break 130 | respuesta = chatbot.get_response(entrada) 131 | print("Bot:", respuesta) 132 | 133 | # ========================= 134 | # Menú principal 135 | # ========================= 136 | def mostrar_menu(): 137 | print("\n=== MENÚ ===") 138 | print("1. Registrar nuevo usuario (huella)") 139 | print("2. Registrar nuevo rostro") 140 | print("3. Iniciar sistema biométrico") 141 | print("4. Salir") 142 | 143 | opcion = input("Selecciona una opción (1-4): ") 144 | 145 | if opcion == '1': 146 | nombre = input("Introduce el nombre del nuevo usuario: ") 147 | user_id = input("Introduce el ID del nuevo usuario: ") 148 | registrar_usuario(nombre, user_id) 149 | elif opcion == '2': 150 | registrar_rostro() 151 | elif opcion == '3': 152 | autenticado = False 153 | if verificar_huella_con_zkteco(): 154 | if verificar_rostro(): 155 | autenticado = True 156 | if autenticado: 157 | iniciar_chatbot() 158 | else: 159 | print("Acceso denegado.") 160 | elif opcion == '4': 161 | print("¡Hasta luego!") 162 | exit() 163 | else: 164 | print("Opción no válida. Intenta de nuevo.") 165 | 166 | # ========================= 167 | # Programa Principal 168 | # ========================= 169 | if __name__ == "__main__": 170 | while True: 171 | mostrar_menu() 172 | -------------------------------------------------------------------------------- /Ejercicios/Biometricos/EJ 02.py: -------------------------------------------------------------------------------- 1 | from zk import ZK 2 | import cv2 3 | import face_recognition 4 | from transformers import pipeline 5 | 6 | # ========================= 7 | # Configuración del dispositivo ZKTeco 8 | # ========================= 9 | ZKTECO_IP = "192.168.1.201" 10 | ZKTECO_PORT = 4370 11 | 12 | # ========================= 13 | # Inicializar ChatBot con Transformers 14 | # ========================= 15 | chatbot = pipeline("conversational", model="microsoft/DialoGPT-medium") 16 | 17 | # ========================= 18 | # Registrar nuevo usuario en ZKTeco 19 | # ========================= 20 | def registrar_usuario(nombre, user_id="1234", role=0): 21 | try: 22 | conn = ZK(ZKTECO_IP, port=ZKTECO_PORT, timeout=5, password=0).connect() 23 | conn.disable_device() 24 | conn.set_user(uid=user_id, name=nombre, privilege=role, password='', group_id='', card=0) 25 | print(f"Usuario {nombre} registrado exitosamente.") 26 | except Exception as e: 27 | print(f"Error registrando usuario: {e}") 28 | finally: 29 | if 'conn' in locals() and conn.is_connected(): 30 | conn.enable_device() 31 | conn.disconnect() 32 | 33 | # ========================= 34 | # Registrar rostro con la cámara 35 | # ========================= 36 | def registrar_rostro(nombre_archivo="persona_conocida.jpg"): 37 | video_capture = cv2.VideoCapture(0) 38 | print("Por favor, mira a la cámara para registrar tu rostro.") 39 | while True: 40 | ret, frame = video_capture.read() 41 | if not ret: 42 | print("Error accediendo a la cámara.") 43 | break 44 | cv2.imshow('Registro de Rostro', frame) 45 | if cv2.waitKey(1) & 0xFF == ord('s'): 46 | cv2.imwrite(nombre_archivo, frame) 47 | print(f"Rostro registrado y guardado como {nombre_archivo}.") 48 | break 49 | video_capture.release() 50 | cv2.destroyAllWindows() 51 | 52 | # ========================= 53 | # Verificación con ZKTeco MB360 (huella registrada) 54 | # ========================= 55 | def verificar_huella_con_zkteco(): 56 | try: 57 | conn = ZK(ZKTECO_IP, port=ZKTECO_PORT, timeout=5, password=0).connect() 58 | conn.disable_device() 59 | print("Coloca tu dedo en el lector de huellas.") 60 | # Simulación de verificación de huella 61 | autenticado = True # Cambiar según la lógica de verificación 62 | conn.enable_device() 63 | return autenticado 64 | except Exception as e: 65 | print(f"Error verificando huella: {e}") 66 | return False 67 | finally: 68 | if 'conn' in locals() and conn.is_connected(): 69 | conn.disconnect() 70 | 71 | # ========================= 72 | # Verificación Facial 73 | # ========================= 74 | def verificar_rostro(): 75 | video_capture = cv2.VideoCapture(0) 76 | print("Por favor, mira a la cámara para la verificación facial.") 77 | rostro_conocido = face_recognition.load_image_file("persona_conocida.jpg") 78 | encoding_rostro_conocido = face_recognition.face_encodings(rostro_conocido)[0] 79 | autenticado = False 80 | while True: 81 | ret, frame = video_capture.read() 82 | if not ret: 83 | print("Error accediendo a la cámara.") 84 | break 85 | rgb_frame = frame[:, :, ::-1] 86 | encodings_rostros = face_recognition.face_encodings(rgb_frame) 87 | for encoding in encodings_rostros: 88 | autenticado = face_recognition.compare_faces([encoding_rostro_conocido], encoding)[0] 89 | if autenticado: 90 | print("Verificación facial exitosa.") 91 | break 92 | if autenticado or cv2.waitKey(1) & 0xFF == ord('q'): 93 | break 94 | video_capture.release() 95 | cv2.destroyAllWindows() 96 | return autenticado 97 | 98 | # ========================= 99 | # Iniciar ChatBot 100 | # ========================= 101 | def iniciar_chatbot(): 102 | print("\nChatBot activado. Escribe 'salir' para terminar.") 103 | while True: 104 | entrada = input("Tú: ") 105 | if entrada.lower() == 'salir': 106 | print("Bot: ¡Hasta luego!") 107 | break 108 | respuesta = chatbot(entrada) 109 | print("Bot:", respuesta[0]['generated_text']) 110 | 111 | # ========================= 112 | # Menú principal 113 | # ========================= 114 | def mostrar_menu(): 115 | print("\nMenú Principal:") 116 | print("1. Registrar nuevo usuario") 117 | print("2. Registrar rostro") 118 | print("3. Verificar y acceder al ChatBot") 119 | print("4. Salir") 120 | opcion = input("Selecciona una opción: ") 121 | if opcion == '1': 122 | nombre = input("Ingresa el nombre del usuario: ") 123 | registrar_usuario(nombre) 124 | elif opcion == '2': 125 | registrar_rostro() 126 | elif opcion == '3': 127 | autenticado = verificar_huella_con_zkteco() and verificar_rostro() 128 | if autenticado: 129 | iniciar_chatbot() 130 | else: 131 | print("Acceso denegado.") 132 | elif opcion == '4': 133 | print("¡Hasta luego!") 134 | exit() 135 | else: 136 | print("Opción no válida. Intenta de nuevo.") 137 | 138 | # ========================= 139 | # Programa Principal 140 | # ========================= 141 | if __name__ == "__main__": 142 | while True: 143 | mostrar_menu() -------------------------------------------------------------------------------- /Ejercicios/Ej de Varianza Y Desviacion/Ej 01.py: -------------------------------------------------------------------------------- 1 | import statistics 2 | 3 | # Lista de números 4 | datos = [10, 12, 23, 23, 16, 23, 21, 16] 5 | 6 | # Calcular la varianza 7 | varianza = statistics.variance(datos) 8 | print(f"Varianza: {varianza}") 9 | 10 | # Calcular la desviación estándar 11 | desviacion_estandar = statistics.stdev(datos) 12 | print(f"Desviación estándar: {desviacion_estandar}") 13 | -------------------------------------------------------------------------------- /Ejercicios/Ej de Varianza Y Desviacion/Ej 02.py: -------------------------------------------------------------------------------- 1 | import pandas as pd 2 | import numpy as np 3 | 4 | # Ejemplo 1: Usando pandas 5 | df = pd.DataFrame({ 6 | 'Edades': [10, 12, 23, 23, 16, 23, 21, 16] 7 | }) 8 | print("Ejemplo con pandas:") 9 | print(f"Varianza: {df['Edades'].var()}") # Muestral (ddof=1 por defecto) 10 | print(f"Desviación estándar: {df['Edades'].std()}") 11 | 12 | # Ejemplo 2: Usando NumPy 13 | datos = np.array([10, 12, 23, 23, 16, 23, 21, 16]) 14 | print("\nEjemplo con NumPy:") 15 | varianza = np.var(datos) # Poblacional 16 | desviacion = np.std(datos) # Poblacional 17 | print(f"Varianza con NumPy: {varianza}") 18 | print(f"Desviación estándar con NumPy: {desviacion}") -------------------------------------------------------------------------------- /Ejercicios/Pandas/Ejercicio 01/Informe_ventas.py: -------------------------------------------------------------------------------- 1 | import pandas as pd 2 | import matplotlib.pyplot as plt 3 | 4 | df_ventas=pd.read_csv('Ejercicios/Pandas/Ejercicio 01/ventas.csv') 5 | df_usuarios=pd.read_csv('Ejercicios/Pandas/Ejercicio 01/usuarios.csv') 6 | 7 | def inicio(): 8 | print("Bienvenido al sistema de ventas") 9 | print("Ingresar usuario y contraseña") 10 | usuario=input("Usuario: ") 11 | contraseña=input("Contraseña: ") 12 | if usuario in df_usuarios['usuario'].values: 13 | if df_usuarios[df_usuarios['usuario']==usuario]['contrasena'].values[0]==contraseña: 14 | print("Usuario autenticado") 15 | menu() 16 | else: 17 | print("Contraseña incorrecta") 18 | inicio() 19 | else: 20 | print("Usuario no existe") 21 | inicio() 22 | 23 | def consultar_ventas(): 24 | print("Consulta de ventas") 25 | print(df_ventas) 26 | print("Siguiente consulta") 27 | print("1. Mostrar grafica de ventas por categoría") 28 | print("2. Mostrar grafica de ventas por producto") 29 | print("3. Regresar al menú principal") 30 | menu_consultar_ventas() 31 | 32 | def menu_consultar_ventas(): 33 | opcion=input("Ingrese una opción: ") 34 | if opcion=='1': 35 | df_ventas.groupby('Categoría').sum().reset_index().plot(kind='bar', x='Categoría', y='Total') 36 | plt.show() 37 | menu_consultar_ventas() 38 | elif opcion=='2': 39 | df_ventas.groupby('Producto')['Total'].sum().reset_index().plot(kind='bar', x='Producto', y='Total') 40 | plt.show() 41 | menu_consultar_ventas() 42 | elif opcion=='3': 43 | menu() 44 | else: 45 | print("Opción incorrecta") 46 | menu_consultar_ventas() 47 | 48 | def consultar_ventas_producto(): 49 | print("Consulta de ventas por producto") 50 | producto=input("Ingrese el nombre del producto: ") 51 | print(df_ventas[df_ventas['Producto']==producto]) 52 | print("Siguiente consulta") 53 | print("1. Mostrar grafica de ventas por producto") 54 | print("2. Regresar al menú principal") 55 | opcion=input("Ingrese una opción: ") 56 | if opcion=='1': 57 | df_ventas[df_ventas['Producto']==producto].groupby('Producto').sum().plot(kind='bar') 58 | plt.show() 59 | menu() 60 | elif opcion=='2': 61 | menu() 62 | else: 63 | print("Opción incorrecta") 64 | menu() 65 | 66 | def consultar_ventas_categoria(): 67 | print("Consulta de ventas por categoría") 68 | categoria=input("Ingrese el nombre de la categoría: ") 69 | print(df_ventas[df_ventas['Categoría']==categoria]) 70 | print("Siguiente consulta") 71 | print("1. Mostrar grafica de ventas por categoría") 72 | print("2. Regresar al menú principal") 73 | opcion=input("Ingrese una opción: ") 74 | if opcion=='1': 75 | df_ventas[df_ventas['Categoría']==categoria].groupby('Categoría').sum().plot(kind='bar') 76 | plt.show() 77 | menu() 78 | elif opcion=='2': 79 | menu() 80 | else: 81 | print("Opción incorrecta") 82 | menu() 83 | 84 | def consultar_ventas_fecha(): 85 | print("Consulta de ventas por fecha") 86 | fecha=input("Ingrese la fecha (yyyy-mm-dd): ") 87 | print(df_ventas[df_ventas['Fecha']==fecha]) 88 | print("Siguiente consulta") 89 | print("1. Mostrar grafica de ventas por fecha") 90 | print("2. Regresar al menú principal") 91 | opcion=input("Ingrese una opción: ") 92 | if opcion=='1': 93 | df_ventas[df_ventas['Fecha']==fecha].groupby('Fecha').sum().plot(kind='bar') 94 | plt.show() 95 | menu() 96 | elif opcion=='2': 97 | menu() 98 | else: 99 | print("Opción incorrecta") 100 | menu() 101 | 102 | def consultar_total_ventas(): 103 | print("Consulta de total de ventas") 104 | print("El total de ventas es: ",df_ventas['Total'].sum()) 105 | print("Siguiente consulta") 106 | print("1. Mostrar grafica de total de ventas") 107 | print("2. Regresar al menú principal") 108 | opcion=input("Ingrese una opción: ") 109 | if opcion=='1': 110 | df_ventas.groupby('Fecha').sum().plot(kind='bar') 111 | plt.show() 112 | menu() 113 | elif opcion=='2': 114 | menu() 115 | else: 116 | print("Opción incorrecta") 117 | menu() 118 | 119 | def menu(): 120 | print("Menú de opciones") 121 | print("1. Consultar ventas") 122 | print("2. Consultar ventas por producto") 123 | print("3. Consultar ventas por categoría") 124 | print("4. Consultar ventas por fecha") 125 | print("5. Consultar total de ventas") 126 | print("6. Salir") 127 | opcion=input("Ingrese una opción: ") 128 | if opcion=='1': 129 | consultar_ventas() 130 | elif opcion=='2': 131 | consultar_ventas_producto() 132 | elif opcion=='3': 133 | consultar_ventas_categoria() 134 | elif opcion=='4': 135 | consultar_ventas_fecha() 136 | elif opcion=='5': 137 | consultar_total_ventas() 138 | elif opcion=='6': 139 | print("Deseas salir del sistema (si/no)") 140 | respuesta=input().lower() 141 | if respuesta=='si': 142 | print("Hasta luego") 143 | elif respuesta=='no': 144 | menu() 145 | else: 146 | print("Opción incorrecta") 147 | menu() 148 | else: 149 | print("Opción incorrecta") 150 | menu() 151 | 152 | inicio() -------------------------------------------------------------------------------- /Ejercicios/Pandas/Ejercicio 01/usuarios.csv: -------------------------------------------------------------------------------- 1 | usuario,contrasena 2 | admin123,admin123 3 | user0001,password 4 | user0002,password 5 | user0003,password 6 | user0004,password 7 | user0005,password 8 | user0006,password 9 | user0007,password 10 | user0008,password 11 | user0009,password 12 | user0010,password -------------------------------------------------------------------------------- /Ejercicios/Pandas/Ejercicio 01/ventas.csv: -------------------------------------------------------------------------------- 1 | Fecha,Producto,Categoría,Cantidad,Precio Unitario,Total 2 | 2024-01-10,Laptop,Electrónica,2,1500,3000 3 | 2024-01-11,Mouse,Electrónica,5,20,100 4 | 2024-01-12,Silla,Muebles,1,200,200 5 | 2024-01-13,Escritorio,Muebles,1,400,400 6 | 2024-01-14,Teclado,Electrónica,3,50,150 7 | 2024-01-15,Monitor,Electrónica,2,300,600 8 | 2024-01-16,Impresora,Electrónica,1,200,200 9 | 2024-01-17,Teléfono,Electrónica,4,100,400 10 | 2024-01-18,Tablet,Electrónica,2,250,500 11 | 2024-01-19,Altavoces,Electrónica,3,75,225 12 | 2024-01-20,Webcam,Electrónica,5,40,200 13 | 2024-01-21,Router,Electrónica,2,80,160 14 | 2024-01-22,Microondas,Electrodomésticos,1,150,150 15 | 2024-01-23,Refrigerador,Electrodomésticos,1,800,800 16 | 2024-01-24,Lavadora,Electrodomésticos,1,600,600 17 | 2024-01-25,Secadora,Electrodomésticos,1,500,500 18 | 2024-01-26,Aspiradora,Electrodomésticos,2,100,200 19 | 2024-01-27,Plancha,Electrodomésticos,3,50,150 20 | 2024-01-28,Televisor,Electrónica,1,1000,1000 21 | 2024-01-29,Consola de Juegos,Electrónica,2,400,800 22 | 2024-01-30,Cámara,Electrónica,1,700,700 23 | 2024-01-31,Smartwatch,Electrónica,3,200,600 24 | 2024-02-01,Drone,Electrónica,1,1200,1200 25 | 2024-02-02,Proyector,Electrónica,1,500,500 26 | 2024-02-03,Disco Duro,Electrónica,4,100,400 27 | 2024-02-04,Memoria USB,Electrónica,10,20,200 28 | 2024-02-05,SSD,Electrónica,2,150,300 29 | 2024-02-06,Fuente de Poder,Electrónica,1,100,100 30 | 2024-02-07,Placa Madre,Electrónica,1,250,250 31 | 2024-02-08,Procesador,Electrónica,1,300,300 32 | 2024-02-09,RAM,Electrónica,2,80,160 33 | 2024-02-10,Enrutador,Electrónica,1,150,150 34 | 2024-02-11,Switch,Electrónica,2,100,200 35 | 2024-02-12,Modem,Electrónica,1,120,120 36 | 2024-02-13,Servidor,Electrónica,1,2000,2000 37 | 2024-02-14,Firewall,Electrónica,1,500,500 38 | 2024-02-15,UPS,Electrónica,1,300,300 39 | 2024-02-16,Monitor Curvo,Electrónica,1,400,400 40 | 2024-02-17,Teclado Mecánico,Electrónica,2,100,200 41 | 2024-02-18,Mouse Inalámbrico,Electrónica,3,50,150 42 | 2024-02-19,Altavoz Bluetooth,Electrónica,2,75,150 43 | 2024-02-20,Smart TV,Electrónica,1,1500,1500 44 | 2024-02-21,Consola Portátil,Electrónica,1,300,300 45 | 2024-02-22,Proyector 4K,Electrónica,1,800,800 46 | 2024-02-23,Disco Duro Externo,Electrónica,2,150,300 47 | 2024-02-24,Memoria RAM,Electrónica,4,80,320 48 | 2024-02-25,SSD Externo,Electrónica,1,200,200 49 | 2024-02-26,Fuente de Poder Modular,Electrónica,1,150,150 50 | 2024-02-27,Placa Base,Electrónica,1,250,250 51 | 2024-02-28,Procesador de Alta Gama,Electrónica,1,500,500 52 | 2024-02-29,RAM DDR4,Electrónica,2,100,200 53 | -------------------------------------------------------------------------------- /Ejercicios/Pandas/Ejercicio 02/inventario.csv: -------------------------------------------------------------------------------- 1 | ID,Producto,Categoría,Stock,Precio Unitario,Proveedor 2 | 1,Laptop,Electrónica,10,1500.0,TechCorp 3 | 2,Mouse,Electrónica,50,20.0,Peripherals Inc. 4 | 3,Silla Gamer,Muebles,5,250.0,FurniStore 5 | 4,Escritorio,Muebles,7,400.0,FurniStore 6 | 5,Teclado,Electrónica,30,45.0,Peripherals Inc. 7 | 6,Monitor,Electrónica,15,300.0,TechCorp 8 | 7,Impresora,Electrónica,8,120.0,PrintWorks 9 | 8,Tablet,Electrónica,20,200.0,TechCorp 10 | 9,Smartphone,Electrónica,25,800.0,MobileWorld 11 | 10,Router,Electrónica,40,70.0,NetGear 12 | 11,Disco Duro,Electrónica,60,100.0,Storage Solutions 13 | 12,Memoria USB,Electrónica,100,15.0,Peripherals Inc. 14 | 13,Webcam,Electrónica,35,50.0,TechCorp 15 | 14,Altavoces,Electrónica,22,75.0,SoundWave 16 | 15,Microfono,Electrónica,18,60.0,SoundWave 17 | 16,Proyector,Electrónica,5,500.0,VisualTech 18 | 17,Consola de Juegos,Electrónica,12,400.0,GameZone 19 | 18,Control de Juegos,Electrónica,45,60.0,GameZone 20 | 19,Televisor,Electrónica,10,1000.0,VisualTech 21 | 20,Refrigerador,Electrodomésticos,4,1200.0,HomeAppliances 22 | 21,Microondas,Electrodomésticos,10,300.0,HomeAppliances 23 | 22,Lavadora,Electrodomésticos,3,800.0,HomeAppliances 24 | 23,Secadora,Electrodomésticos,3,700.0,HomeAppliances 25 | 24,Aspiradora,Electrodomésticos,15,150.0,HomeAppliances 26 | 25,Plancha,Electrodomésticos,25,50.0,HomeAppliances 27 | 26,Cafetera,Electrodomésticos,20,100.0,HomeAppliances 28 | 27,Tostadora,Electrodomésticos,18,40.0,HomeAppliances 29 | 28,Licuadora,Electrodomésticos,12,80.0,HomeAppliances 30 | 29,Freidora,Electrodomésticos,10,120.0,HomeAppliances 31 | 30,Horno,Electrodomésticos,5,600.0,HomeAppliances 32 | 31,Colchón,Muebles,8,500.0,FurniStore 33 | 32,Armario,Muebles,6,700.0,FurniStore 34 | 33,Estantería,Muebles,10,150.0,FurniStore 35 | 34,Mesita de Noche,Muebles,12,100.0,FurniStore 36 | 35,Sofá,Muebles,4,800.0,FurniStore 37 | 36,Comedor,Muebles,3,1000.0,FurniStore 38 | 37,Alfombra,Muebles,15,200.0,FurniStore 39 | 38,Lámpara,Iluminación,20,60.0,LightHouse 40 | 39,Linterna,Iluminación,30,20.0,LightHouse 41 | 40,Velador,Iluminación,25,40.0,LightHouse 42 | 41,Panel Solar,Iluminación,0,500.0,LightHouse 43 | 42,Generador,Electrodomésticos,0,1500.0,HomeAppliances 44 | 43,Drone,Electrónica,0,1200.0,TechCorp 45 | 44,Smartwatch,Electrónica,0,300.0,MobileWorld 46 | 45,VR Headset,Electrónica,0,600.0,GameZone 47 | 46,Termostato Inteligente,Electrodomésticos,0,200.0,HomeAppliances 48 | 47,Robot Aspirador,Electrodomésticos,0,400.0,HomeAppliances 49 | 48,Altavoz Inteligente,Electrónica,0,150.0,SoundWave 50 | 49,Interruptor Inteligente,Iluminación,0,50.0,LightHouse 51 | 50,Cámara de Seguridad,Electrónica,0,250.0,TechCorp 52 | 51,Enchufe Inteligente,Electrodomésticos,0,30.0,HomeAppliances 53 | 52,Sensor de Movimiento,Electrónica,0,100.0,TechCorp 54 | 53,Detector de Humo,Electrodomésticos,0,80.0,HomeAppliances 55 | 54,Video Timbre,Electrónica,0,200.0,TechCorp 56 | 55,Control Remoto Universal,Electrónica,0,40.0,Peripherals Inc. 57 | 56,Monitor de Bebé,Electrónica,0,150.0,TechCorp 58 | 57,Humidificador,Electrodomésticos,0,100.0,HomeAppliances 59 | 58,Purificador de Aire,Electrodomésticos,0,300.0,HomeAppliances 60 | 59,Calefactor,Electrodomésticos,0,200.0,HomeAppliances 61 | 60,Deshumidificador,Electrodomésticos,10,250.0,HomeAppliances 62 | 61,Samsung J2 prime,Celar,10,1000.0,Samsung Pe 63 | -------------------------------------------------------------------------------- /Ejercicios/Pandas/Ejercicio 02/usuarios.csv: -------------------------------------------------------------------------------- 1 | usuario,contrasena 2 | admin123,admin123 3 | user0001,password 4 | user0002,password 5 | user0003,password 6 | user0004,password 7 | user0005,password 8 | user0006,password 9 | user0007,password 10 | user0008,password 11 | user0009,password 12 | user0010,password 13 | julian,julian 14 | diego,diego 15 | alejo,alejo 16 | david,david 17 | Tank123,123 18 | -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 01/Clinica.py: -------------------------------------------------------------------------------- 1 | pacientes = [] 2 | 3 | while True: 4 | print("Menu de Opciones") 5 | print("1. Insertar paciente") 6 | print("2. Buscar paciente") 7 | print("3. Calcular costo") 8 | print("4. Eliminar paciente") 9 | print("5. Salir") 10 | opc = input("Seleccione una opción (1-5):\n") 11 | if opc not in ['1', '2', '3', '4', '5']: 12 | print("Opción no válida. Intenta de nuevo.") 13 | continue 14 | if opc == '1': 15 | dni = input("Ingresar número de DNI del paciente: ") 16 | while len(dni) != 8 or not dni.isdigit(): 17 | print("Error: El DNI solo puede tener 8 dígitos y debe ser numérico.") 18 | dni = input("Ingresar nuevamente el DNI del paciente: ") 19 | 20 | apelPart = input("Ingrese apellido paterno: ") 21 | apelMart = input("Ingrese apellido materno: ") 22 | nom = input("Ingrese nombres: ") 23 | edad = input("Ingrese edad del paciente: ") 24 | tel = input("Ingresar teléfono del paciente: ") 25 | cos = 100 26 | informacion_paciente = [dni, apelPart, apelMart, nom, edad, tel, cos] 27 | pacientes.append(informacion_paciente) 28 | print("Información guardada correctamente.") 29 | elif opc == '2': 30 | dni_buscar = input("Ingrese el DNI del paciente a buscar: ") 31 | encontrado = False 32 | for paciente in pacientes: 33 | if paciente[0] == dni_buscar: 34 | print("Paciente encontrado: ") 35 | print(f"Nombres: {paciente[3]}") 36 | print(f"Apellidos: {paciente[1]} {paciente[2]}") 37 | print(f"Edad: {paciente[4]}") 38 | print(f"Telfono: {paciente[5]}") 39 | encontrado = True 40 | break 41 | if not encontrado: 42 | print("Paciente no encontrado.") 43 | elif opc == '3': 44 | dni_buscar = input("Ingrese el DNI del paciente para calcular el costo: ") 45 | encontrado = False 46 | for paciente in pacientes: 47 | if paciente[0] == dni_buscar: 48 | print(f"El costo del paciente con DNI {dni_buscar} es: {paciente[6]}") 49 | encontrado = True 50 | break 51 | if not encontrado: 52 | print("Paciente no encontrado.") 53 | elif opc == '4': 54 | dni_eliminar = input("Ingrese el DNI del paciente a eliminar: ") 55 | encontrado = False 56 | for paciente in pacientes: 57 | if paciente[0] == dni_eliminar: 58 | pacientes.remove(paciente) 59 | print(f"Paciente con DNI {dni_eliminar} ha sido eliminado.") 60 | encontrado = True 61 | break 62 | if not encontrado: 63 | print("Paciente no encontrado para eliminar.") 64 | elif opc == '5': 65 | print("Saliendo del sistema...") 66 | break -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 01/ejemplo_pilas.py: -------------------------------------------------------------------------------- 1 | class Pila: 2 | def __init__(self): 3 | self.items = [] 4 | 5 | def isEmpty(self): 6 | return len(self.items) == 0 7 | 8 | def push(self, item): 9 | self.items.append(item) 10 | 11 | def pop(self): 12 | if not self.isEmpty(): 13 | return self.items.pop() 14 | 15 | def peek(self): 16 | if not self.isEmpty(): 17 | return self.items[-1] 18 | 19 | def size(self): 20 | return len(self.items) 21 | 22 | # Uso de la pila 23 | pila = Pila() 24 | pila.push(1) 25 | pila.push(2) 26 | pila.push(3) 27 | 28 | print(pila.peek()) # Ver el elemento superior 29 | print(pila.pop()) # Eliminar el elemento superior 30 | print(pila.size()) # Ver el tamaño de la pila -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 03/IA 01.py: -------------------------------------------------------------------------------- 1 | import re 2 | import random 3 | 4 | def get_response(user_input): 5 | split_message = re.split(r'\s|,|;|:', user_input.lower()) 6 | response = check_for_greeting(split_message) 7 | return response 8 | 9 | def mesage_probability(user_message, recognised_words, single_response=False, required_words=[]): 10 | message_certainty = 0 11 | has_required_words = True 12 | 13 | for word in user_message: 14 | if word in recognised_words: 15 | message_certainty += 1 16 | 17 | percentage = float(message_certainty) / float(len(recognised_words)) 18 | 19 | for word in required_words: 20 | if word not in user_message: 21 | has_required_words = False 22 | break 23 | 24 | if has_required_words or single_response: 25 | return int(percentage * 100) 26 | else: 27 | return 0 28 | 29 | def check_for_greeting(message): 30 | high_prob={} 31 | 32 | def reponse(bot_response, list_of_words, single_response=False, required_words=[]): 33 | nonlocal high_prob 34 | high_prob[bot_response] = mesage_probability(message, list_of_words, single_response, required_words) 35 | 36 | reponse('Hola', ['hola', 'saludos', 'buenas'], single_response=True) 37 | reponse('Estoy bien y tú?', ['como', 'estas', 'buenas'], required_words=['como']) 38 | reponse('Estamos ubicados en Senati Chiclayo', ['ubicados', 'direccion', 'donde', 'ubicacion'], single_response=True) 39 | reponse('Hasta luego', ['adios', 'hasta', 'luego'], single_response=True) 40 | 41 | best_match = max(high_prob, key=high_prob.get) 42 | print(high_prob) 43 | 44 | return unknown() if high_prob[best_match] < 1 else best_match 45 | 46 | def unknown(): 47 | reponse = ['No entiendo lo que dices', 'No sé qué quieres decir', '¿Podrías repetirlo?', 'Búscalo en algún navegador'][random.randint(0, 3)] 48 | return reponse 49 | 50 | while True: 51 | print('Bot: ' + get_response(input('You: '))) 52 | -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 03/libros.csv: -------------------------------------------------------------------------------- 1 | titulo,autor,genero,fecha_emision,estado,precio,fecha_venta,prestado_a,fecha_devolucion 2 | El Resplandor,Stephen King,Terror,1977,disponible,25.0,,, 3 | Drácula,Bram Stoker,Terror,1897,vendido,18.0,2023-01-15,, 4 | El Padrino,Mario Puzo,Acción,1969,vendido,22.0,2025-02-27,, 5 | Matar a un ruiseñor,Harper Lee,Drama,1960,prestado,15.0,,Juan Perez,2023-12-01 6 | La lista de Schindler,Thomas Keneally,Drama,1982,disponible,20.0,,, 7 | Cementerio de animales,Stephen King,Terror,1983,prestado,24.0,,Julian,2025-03-06 8 | El silencio de los inocentes,Thomas Harris,Terror,1988,disponible,19.0,,, 9 | Misión imposible,Bruce Geller,Acción,1966,prestado,21.0,,Maria Lopez,2025-11-20 10 | Gladiador,Dewey Gram,Acción,2000,disponible,23.0,,, 11 | El gran Gatsby,F. Scott Fitzgerald,Drama,1925,vendido,17.0,2023-02-10,, 12 | Carrie,Stephen King,Terror,1974,disponible,20.0,,, 13 | It,Stephen King,Terror,1986,vendido,25.0,2023-03-01,, 14 | El hombre invisible,H.G. Wells,Terror,1897,disponible,18.0,,, 15 | Psicosis,Robert Bloch,Terror,1959,vendido,22.0,2023-04-10,, 16 | El exorcista,William Peter Blatty,Terror,1971,disponible,24.0,,, 17 | El fugitivo,Stephen King,Acción,1982,disponible,21.0,,, 18 | El último mohicano,James Fenimore Cooper,Acción,1826,vendido,19.0,2023-05-15,, 19 | Rambo,David Morrell,Acción,1972,disponible,23.0,,, 20 | La jungla de cristal,Roderick Thorp,Acción,1979,vendido,20.0,2023-06-20,, 21 | El código Da Vinci,Dan Brown,Acción,2003,disponible,22.0,,, 22 | Los miserables,Victor Hugo,Drama,1862,disponible,25.0,,, 23 | Orgullo y prejuicio,Jane Austen,Drama,1813,vendido,18.0,2023-07-25,, 24 | Cumbres borrascosas,Emily Brontë,Drama,1847,disponible,20.0,,, 25 | Rebelión en la granja,George Orwell,Drama,1945,vendido,15.0,2023-08-30,, 26 | 1984,George Orwell,Drama,1949,disponible,22.0,,, 27 | El guardián entre el centeno,J.D. Salinger,Drama,1951,vendido,19.0,2023-09-05,, 28 | El gran escape,Paul Brickhill,Acción,1950,disponible,21.0,,, 29 | El hombre de acero,Larry Tye,Acción,2012,vendido,24.0,2023-10-10,, 30 | El club de la pelea,Chuck Palahniuk,Acción,1996,disponible,23.0,,, 31 | El señor de los anillos,J.R.R. Tolkien,Acción,1954,vendido,25.0,2023-11-15,, 32 | El hobbit,J.R.R. Tolkien,Acción,1937,vendido,20.0,2025-02-27,, 33 | -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 03/usuarios.csv: -------------------------------------------------------------------------------- 1 | usuario,contrasena 2 | admin,admin 3 | user0001,password 4 | user0002,password 5 | user0003,password 6 | user0004,password 7 | user0005,password 8 | user0006,password 9 | user0007,password 10 | user0008,password 11 | user0009,password 12 | user0010,password 13 | -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 04/Cuentas.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/JulianB0315/Python_0_to_hero/9552ddb7e00d2f9e0107da4141370afada1f3e8b/Ejercicios/Practicas personales/Py-class 04/Cuentas.xlsx -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 04/Transacciones.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/JulianB0315/Python_0_to_hero/9552ddb7e00d2f9e0107da4141370afada1f3e8b/Ejercicios/Practicas personales/Py-class 04/Transacciones.xlsx -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 04/maplot.py: -------------------------------------------------------------------------------- 1 | import matplotlib.pyplot as plt 2 | 3 | a=[1,2,3,4,5] 4 | b=[44,55,66,77,88] 5 | 6 | plt.plot(a,b,label='Linea 1', color='red', linewidth=2) 7 | plt.title('Grafico de linea') 8 | plt.xlabel('Eje X') 9 | plt.show() 10 | 11 | x1=[3,4,5,6] 12 | y1=[5,6,3,4] 13 | 14 | x2=[2,5,8] 15 | y2=[3,4,3] 16 | 17 | plt.plot(x1,y1,label='Linea 1', color='red', linewidth=2) 18 | plt.plot(x2,y2,label='Linea 2', color='blue', linewidth=2) 19 | plt.title('Grafico de linea') 20 | plt.xlabel('Eje X') 21 | plt.ylabel('Eje Y') 22 | plt.legend() 23 | plt.grid() 24 | plt.show() 25 | 26 | x1=[0.25,1.25,3.25,2.25,4.25] 27 | y1=[10,55,32,80,20] 28 | 29 | x2=[0.75,1.75,2.75,3.75,4.75] 30 | y2=[42,26,78,15,10] 31 | 32 | plt.bar(x1,y1,label='Datos 1', width=0.5, color='blue') 33 | plt.bar(x2,y2,label='Datos 2', width=0.5, color='orange') 34 | plt.title('Grafico de barras') 35 | plt.xlabel('Eje X') 36 | plt.ylabel('Eje Y') 37 | plt.legend() 38 | plt.show() 39 | 40 | a = [22,55,62,45,21,22,34,42,42,4,2,102,95,85,55,110,120,70,65,55,111,115,80,75,65,54,44,43,42,48] 41 | bins = [0,10,20,30,40,50,60,70,80,90,100,110,120] 42 | plt.hist(a,bins,histtype='bar',rwidth=0.8, color='red') 43 | plt.title('Histograma') 44 | plt.xlabel('Eje X') 45 | plt.show() 46 | 47 | x1=[0.25,1.25,2.25,3.25,4.25] 48 | y1=[10,55,32,80,20] 49 | 50 | x2=[0.75,1.75,2.75,3.75,4.75] 51 | y2=[42,26,78,15,10] 52 | 53 | plt.scatter(x1,y1,label='Datos 1', color='red') 54 | plt.scatter(x2,y2,label='Datos 2', color='blue') 55 | plt.title('Grafico de dispersión') 56 | plt.xlabel('Eje X') 57 | plt.ylabel('Eje Y') 58 | plt.legend() 59 | plt.show() 60 | 61 | Ciclismo =[7,8,6,11,7] 62 | Maraton =[2,3,4,3,2] 63 | Futbol =[8,5,7,8,13] 64 | Natacion =[6,7,8,9,10] 65 | Divisiones = [1,2,3,4,5] 66 | 67 | deportes=["Ciclismo","Maraton","Futbol","Natacion", "Otro"] 68 | colores = ['red','blue','green','yellow','orange'] 69 | 70 | plt.pie(Divisiones,labels=deportes,colors=colores,startangle=90,shadow=True,explode=(0.1,0,0,0,0),autopct='%1.1f%%') 71 | plt.axis('equal') 72 | plt.title('Deportes favoritos') 73 | plt.show() 74 | 75 | x1=[0.25,1.25,2.25,3.25,4.25] 76 | y1=[10,55,32,80,20] 77 | y3=[10,55,32,80,20] 78 | 79 | x2=[0.75,1.75,2.75,3.75,4.75] 80 | y2=[42,26,78,15,10] 81 | y4=[42,26,78,15,10] 82 | 83 | plt.scatter(x1,y1,label='Datos 1', color='red') 84 | plt.scatter(x2,y2,label='Datos 2', color='blue') 85 | plt.plot(x1,y3,label='Linea 1', color='red', linewidth=2) 86 | plt.plot(x2,y4,label='Linea 2', color='blue', linewidth=2) 87 | plt.title('Grafico de dispersión') 88 | plt.xlabel('Eje X') 89 | plt.ylabel('Eje Y') 90 | plt.legend() 91 | plt.show() -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 05/MM-ej 01.py: -------------------------------------------------------------------------------- 1 | import statistics 2 | 3 | # Ejemplo de cálculo de la media 4 | numeros = [10, 20, 30, 40, 50] 5 | media = sum(numeros) / len(numeros) 6 | print(f"La media es: {media}") 7 | 8 | # Alternativa usando el módulo statistics 9 | media_alt = statistics.mean(numeros) 10 | print(f"La media (usando statistics) es: {media_alt}") 11 | 12 | # Ejemplo de cálculo de la mediana 13 | numeros2 = [10, 20, 30, 40, 50] 14 | mediana = statistics.median(numeros2) 15 | print(f"La mediana es: {mediana}") 16 | -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 05/MM-ej 02.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import pandas as pd 3 | 4 | data_1 = np.array([12, 15, 14, 10, 18, 20, 22, 19, 21]) 5 | 6 | media = np.mean(data_1) 7 | mediana = np.median(data_1) 8 | 9 | print(f'Array original: {data_1}') 10 | print(f'Media: {media:.2f}') 11 | print(f'Mediana: {mediana}') 12 | print('\n' + '-' * 50 + '\n') 13 | df = pd.DataFrame({ 14 | 'Nombre': ['Ana', 'Juan', 'Carlos', 'María', 'Luis'], 15 | 'Edad': [23, 25, 30, 27, 22], 16 | 'Salario': [3000, 3200, 2800, 3500, 4000] 17 | }) 18 | media_edad = df['Edad'].mean() 19 | mediana_edad = df['Edad'].median() 20 | 21 | media_salario = df['Salario'].mean() 22 | mediana_salario = df['Salario'].median() 23 | 24 | print(f"Media de edad: {media_edad}") 25 | print(f"Mediana de edad: {mediana_edad}") 26 | print(f"Media de salario: {media_salario}") 27 | print(f"Mediana de salario: {mediana_salario}") -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 06/Ejemplos clase/Datagrama01.py: -------------------------------------------------------------------------------- 1 | 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.cluster.hierarchy import dendrogram, linkage 5 | from sklearn.datasets import make_blobs 6 | 7 | X, _ = make_blobs(n_samples=10, centers=2, cluster_std=0.60, random_state=0) 8 | # Ejemplo de datos (10 puntos en 2 dimensiones) 9 | mis_datos = np.array([ 10 | [1.2, 1.6], 11 | [1.3, 2.1], 12 | [3.4, 4.5], 13 | [3.5, 4.6], 14 | [7.2, 8.3], 15 | [7.4, 8.5], 16 | [8.1, 7.2], 17 | [8.2, 7.5], 18 | [9.1, 9.2], 19 | [9.3, 19.4] 20 | ]) 21 | 22 | # Ahora, puedes aplicar el algoritmo de agrupamiento jerárquico a estos datos 23 | Z = linkage(mis_datos, method='ward') 24 | 25 | # Y graficar el dendrograma 26 | plt.figure(figsize=(10, 7)) 27 | dendrogram(Z) 28 | plt.title('Dendrograma del Agrupamiento Jerárquico') 29 | plt.xlabel('Índice de los datos') 30 | plt.ylabel('Distancia') 31 | plt.show() 32 | -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 06/Ejemplos clase/Datagrama02.py: -------------------------------------------------------------------------------- 1 | # Importamos las librerías necesarias 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from sklearn.cluster import KMeans 5 | from sklearn.datasets import make_blobs 6 | 7 | # Generamos un conjunto de datos ficticio (100 puntos en 3 clusters) 8 | X, _ = make_blobs(n_samples=100, centers=3, cluster_std=0.60, random_state=0) 9 | 10 | # Creamos el modelo K-Means con 3 clusters (puedes cambiar el número de clusters) 11 | kmeans = KMeans(n_clusters=3) 12 | 13 | # Ajustamos el modelo a los datos 14 | kmeans.fit(X) 15 | 16 | # Obtenemos las etiquetas (el cluster al que pertenece cada punto) 17 | etiquetas = kmeans.labels_ 18 | 19 | # Obtenemos los centroides de los clusters 20 | centroides = kmeans.cluster_centers_ 21 | 22 | # Visualizamos los resultados 23 | plt.scatter(X[:, 0], X[:, 1], c=etiquetas, cmap='viridis') 24 | plt.scatter(centroides[:, 0], centroides[:, 1], s=200, c='red', marker='X') # Centroides en rojo 25 | plt.title('Resultado de K-Means') 26 | plt.xlabel('Característica 1') 27 | plt.ylabel('Característica 2') 28 | plt.show() 29 | -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 06/Ejemplos clase/Dtagrama.py: -------------------------------------------------------------------------------- 1 | # Importamos las librerías necesarias 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.cluster.hierarchy import dendrogram, linkage 5 | from sklearn.datasets import make_blobs 6 | 7 | # Generamos algunos datos ficticios con make_blobs para ilustrar el algoritmo 8 | # Esto crea 100 puntos de datos, distribuidos en 3 clusters (puedes cambiar el número de clusters) 9 | X, _ = make_blobs(n_samples=50, centers=4, cluster_std=0.60, random_state=0) 10 | 11 | # Aplicamos el algoritmo de agrupamiento jerárquico aglomerativo 12 | # 'ward' es el método que minimiza la varianza dentro de cada cluster 13 | Z = linkage(X, method='ward') 14 | 15 | # Graficamos el dendrograma, que muestra la jerarquía de los clusters 16 | plt.figure(figsize=(12, 10)) 17 | dendrogram(Z) 18 | plt.title('Dendrograma del Agrupamiento Jerárquico') 19 | plt.xlabel('Índice de los datos') 20 | plt.ylabel('Distancia') 21 | plt.show() 22 | 23 | -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 07/Pruebas.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import pandas as pd 3 | import matplotlib.pyplot as plt 4 | import yfinance as yf 5 | import tensorflow as tf 6 | from sklearn.linear_model import LinearRegression 7 | from sklearn.preprocessing import MinMaxScaler 8 | from statsmodels.tsa.arima.model import ARIMA 9 | 10 | Sequential = tf.keras.models.Sequential 11 | LSTM = tf.keras.layers.LSTM 12 | Dense = tf.keras.layers.Dense 13 | EarlyStopping = tf.keras.callbacks.EarlyStopping 14 | 15 | # Descargar datos históricos de Bitcoin 16 | data = yf.download('BTC-USD', start='2022-01-01', end='2024-01-01') 17 | data = data[['Close']] # Solo nos interesa el precio de cierre 18 | 19 | # Convertir el índice en columna de fecha 20 | data.reset_index(inplace=True) 21 | data['Date'] = pd.to_datetime(data['Date']) 22 | 23 | # Convertir fechas a valores numéricos para regresión lineal 24 | data['Days'] = (data['Date'] - data['Date'].min()).dt.days 25 | 26 | # Dividir en entrenamiento (80%) y prueba (20%) 27 | train_size = int(len(data) * 0.8) 28 | train, test = data.iloc[:train_size], data.iloc[train_size:] 29 | 30 | # 📌 Modelo 1: ARIMA 31 | arima_model = ARIMA(train['Close'], order=(5,1,0)).fit() 32 | arima_pred = arima_model.forecast(steps=len(test)) 33 | 34 | # 📌 Modelo 2: Regresión Lineal 35 | lr = LinearRegression() 36 | lr.fit(train[['Days']], train['Close']) 37 | lr_pred = lr.predict(test[['Days']]) 38 | 39 | # 📌 Modelo 3: LSTM 40 | scaler = MinMaxScaler(feature_range=(0, 1)) 41 | train_scaled = scaler.fit_transform(train[['Close']]) 42 | 43 | X_train, y_train = [], [] 44 | for i in range(10, len(train_scaled)): 45 | X_train.append(train_scaled[i-10:i, 0]) 46 | y_train.append(train_scaled[i, 0]) 47 | X_train, y_train = np.array(X_train), np.array(y_train) 48 | X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1)) 49 | 50 | # Definir modelo LSTM 51 | model = Sequential([ 52 | LSTM(50, return_sequences=True, input_shape=(X_train.shape[1], 1)), 53 | LSTM(50), 54 | Dense(1) 55 | ]) 56 | model.compile(optimizer='adam', loss='mean_squared_error') 57 | 58 | # Entrenar modelo 59 | model.fit(X_train, y_train, epochs=10, batch_size=16, verbose=0) 60 | 61 | # Preparar datos de prueba para LSTM 62 | test_scaled = scaler.transform(test[['Close']]) 63 | X_test, y_test = [], test_scaled[10:] 64 | for i in range(10, len(test_scaled)): 65 | X_test.append(test_scaled[i-10:i, 0]) 66 | X_test = np.array(X_test) 67 | X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1)) 68 | 69 | # Predicción con LSTM 70 | lstm_pred = model.predict(X_test) 71 | lstm_pred = scaler.inverse_transform(lstm_pred) 72 | 73 | # 📊 Gráfico Comparativo 74 | plt.figure(figsize=(12, 6)) 75 | plt.plot(test['Date'], test['Close'], label='Real', color='black') 76 | plt.plot(test['Date'], arima_pred, label='ARIMA', linestyle='dashed', color='red') 77 | plt.plot(test['Date'], lr_pred, label='Regresión Lineal', linestyle='dashed', color='blue') 78 | plt.plot(test['Date'][10:], lstm_pred, label='LSTM', linestyle='dashed', color='green') 79 | plt.xlabel('Fecha') 80 | plt.ylabel('Precio BTC (USD)') 81 | plt.title('Comparación de Modelos de Predicción') 82 | plt.legend() 83 | plt.show() 84 | -------------------------------------------------------------------------------- /Ejercicios/Practicas personales/Py-class 07/Redes.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import pandas as pd 3 | import matplotlib.pyplot as plt 4 | import tensorflow as tf 5 | from sklearn.preprocessing import MinMaxScaler 6 | from sklearn.metrics import mean_squared_error, mean_absolute_percentage_error 7 | import yfinance as yf # Para obtener datos históricos 8 | 9 | Sequential = tf.keras.models.Sequential 10 | LSTM = tf.keras.layers.LSTM 11 | Dense = tf.keras.layers.Dense 12 | EarlyStopping = tf.keras.callbacks.EarlyStopping 13 | 14 | # 1. Descargar datos de Bitcoin (BTC-USD) desde Yahoo Finance 15 | df = yf.download('BTC-USD', start='2022-01-01', end='2024-01-01') 16 | df = df[['Close']] # Usamos solo el precio de cierre 17 | 18 | # 2. Normalizar datos 19 | scaler = MinMaxScaler(feature_range=(0,1)) 20 | df_scaled = scaler.fit_transform(df) 21 | 22 | # 3. Preparar datos para LSTM 23 | def crear_secuencias(datos, pasos=60): 24 | X, y = [], [] 25 | for i in range(len(datos) - pasos): 26 | X.append(datos[i:i+pasos]) 27 | y.append(datos[i+pasos]) 28 | return np.array(X), np.array(y) 29 | 30 | X, y = crear_secuencias(df_scaled) 31 | X = np.reshape(X, (X.shape[0], X.shape[1], 1)) # Reshape para LSTM 32 | 33 | # 4. Dividir datos en entrenamiento y prueba (80%-20%) 34 | train_size = int(len(X) * 0.8) 35 | X_train, X_test = X[:train_size], X[train_size:] 36 | y_train, y_test = y[:train_size], y[train_size:] 37 | 38 | # 5. Construir el modelo LSTM 39 | model = Sequential([ 40 | LSTM(50, return_sequences=True, input_shape=(X.shape[1], 1)), 41 | LSTM(50, return_sequences=False), 42 | Dense(25), 43 | Dense(1) 44 | ]) 45 | 46 | # 6. Compilar el modelo 47 | model.compile(optimizer='adam', loss='mean_squared_error') 48 | 49 | # 7. Configurar Early Stopping para evitar sobreajuste 50 | early_stopping = EarlyStopping(monitor='loss', patience=5, restore_best_weights=True) 51 | 52 | # 8. Entrenar el modelo 53 | print("Entrenando la red neuronal LSTM...") 54 | model.fit(X_train, y_train, epochs=50, batch_size=16, verbose=1, callbacks=[early_stopping]) 55 | 56 | # 9. Hacer predicciones 57 | predicciones = model.predict(X_test) 58 | predicciones = scaler.inverse_transform(predicciones) # Desnormalizar 59 | 60 | # 10. Evaluación del modelo 61 | y_test_original = scaler.inverse_transform(y_test.reshape(-1,1)) 62 | rmse = np.sqrt(mean_squared_error(y_test_original, predicciones)) 63 | mape = mean_absolute_percentage_error(y_test_original, predicciones) * 100 64 | precision = 100 - mape 65 | 66 | print(f'Error RMSE: {rmse:.2f}') 67 | print(f'Error MAPE: {mape:.2f}%') 68 | print(f'Precisión del modelo: {precision:.2f}%') 69 | 70 | # 11. Crear DataFrame de resultados 71 | df_test = df.iloc[-len(y_test):].copy() # Copia segura para evitar warnings 72 | df_test.loc[:, 'Real'] = y_test_original 73 | df_test.loc[:, 'Predicción'] = predicciones 74 | df_test.loc[:, 'Diferencia'] = df_test['Predicción'] - df_test['Real'] 75 | df_test.loc[:, '% Diferencia'] = (df_test['Diferencia'] / df_test['Real']) * 100 76 | 77 | # 12. Obtener datos por último día de cada mes 78 | df_meses = df_test.resample('ME').last()[['Real', 'Predicción', 'Diferencia', '% Diferencia']] 79 | print(df_meses) 80 | 81 | # 13. Graficar resultados 82 | plt.figure(figsize=(12,6)) 83 | plt.plot(df.index[-len(y_test):], y_test_original, label='Real') 84 | plt.plot(df.index[-len(predicciones):], predicciones, label='Predicción', linestyle='dashed') 85 | plt.legend() 86 | plt.title('Predicción del Precio de Bitcoin con LSTM') 87 | plt.xlabel('Fecha') 88 | plt.ylabel('Precio (USD)') 89 | plt.show() 90 | -------------------------------------------------------------------------------- /Ejercicios/Redes Neuronales/Redes neuronales.py: -------------------------------------------------------------------------------- 1 | import tensorflow as tf 2 | from tensorflow import keras 3 | import numpy as np 4 | import matplotlib.pyplot as plt 5 | 6 | # Cargar el dataset MNIST (imágenes de dígitos escritos a mano) 7 | mnist = keras.datasets.mnist 8 | (x_train, y_train), (x_test, y_test) = mnist.load_data() 9 | 10 | # Normalizar los valores de los píxeles de 0-255 a 0-1 para mejorar el entrenamiento 11 | x_train, x_test = x_train / 255.0, x_test / 255.0 12 | 13 | # Definir la arquitectura de la red neuronal 14 | model = keras.Sequential([ 15 | keras.layers.Flatten(input_shape=(28, 28)), # Convierte la imagen 28x28 en un vector de 784 valores 16 | keras.layers.Dense(128, activation='relu'), # Capa oculta con 128 neuronas y activación ReLU 17 | keras.layers.Dropout(0.2), # Dropout del 20% para evitar sobreajuste 18 | keras.layers.Dense(10, activation='softmax') # Capa de salida con 10 neuronas para las 10 clases (0-9) 19 | ]) 20 | 21 | # Compilar el modelo (configurar el optimizador, la función de pérdida y la métrica de evaluación) 22 | model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) 23 | 24 | # Entrenar la red neuronal con los datos de entrenamiento 25 | model.fit(x_train, y_train, epochs=5) 26 | 27 | # Evaluar el modelo en los datos de prueba 28 | test_loss, test_acc = model.evaluate(x_test, y_test) 29 | print(f'Precisión en test: {test_acc:.4f}') 30 | 31 | # Hacer predicciones con el modelo entrenado 32 | predictions = model.predict(x_test) 33 | 34 | # Mostrar una imagen con la predicción del modelo 35 | plt.imshow(x_test[0], cmap='gray') # Muestra la primera imagen del conjunto de prueba 36 | plt.title(f'Predicción: {np.argmax(predictions[0])}') # Muestra la predicción realizada por la red 37 | plt.savefig(f'Predicción_{np.argmax(predictions[0])}.png') # Guardar la figura en un archivo 38 | plt.close() # Cerrar la figura -------------------------------------------------------------------------------- /Ejercicios/Redes Neuronales/entregable.py: -------------------------------------------------------------------------------- 1 | # Importación de librerías necesarias 2 | import numpy as np 3 | import tensorflow as tf 4 | from sklearn.datasets import fetch_openml 5 | from sklearn.model_selection import train_test_split 6 | from sklearn.neighbors import KNeighborsClassifier 7 | from sklearn.metrics import accuracy_score, confusion_matrix, classification_report 8 | import matplotlib.pyplot as plt 9 | 10 | # Cargar datos MNIST desde OpenML 11 | mnist = fetch_openml('mnist_784') 12 | 13 | # Preprocesamiento: escalado de imágenes a [0, 1] 14 | X = mnist['data'] / 255.0 15 | y = mnist['target'].astype(int) 16 | 17 | # Dividir los datos en entrenamiento y prueba 18 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) 19 | 20 | # **K-Nearest Neighbors (KNN)** 21 | knn = KNeighborsClassifier(n_neighbors=3) 22 | knn.fit(X_train, y_train) 23 | 24 | # Predicciones con KNN 25 | y_pred_knn = knn.predict(X_test) 26 | 27 | # Evaluación de KNN 28 | print("Evaluación KNN") 29 | print(f"Precisión: {accuracy_score(y_test, y_pred_knn)}") 30 | print("Reporte de clasificación:") 31 | print(classification_report(y_test, y_pred_knn)) 32 | 33 | # **Red Neuronal Convolucional (CNN)** 34 | # Reestructuración de datos para CNN (debe tener la forma (num_samples, 28, 28, 1)) 35 | X_train_cnn = X_train.values.reshape(-1, 28, 28, 1) 36 | X_test_cnn = X_test.values.reshape(-1, 28, 28, 1) 37 | 38 | # Creación del modelo CNN 39 | model = tf.keras.models.Sequential([ 40 | tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)), 41 | tf.keras.layers.MaxPooling2D((2, 2)), 42 | tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), 43 | tf.keras.layers.MaxPooling2D((2, 2)), 44 | tf.keras.layers.Flatten(), 45 | tf.keras.layers.Dense(64, activation='relu'), 46 | tf.keras.layers.Dense(10, activation='softmax') # 10 clases (0-9) 47 | ]) 48 | 49 | # Compilación del modelo 50 | model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) 51 | 52 | # Entrenamiento del modelo CNN 53 | model.fit(X_train_cnn, y_train, epochs=5, validation_data=(X_test_cnn, y_test)) 54 | 55 | # Evaluación del modelo CNN 56 | test_loss, test_acc = model.evaluate(X_test_cnn, y_test) 57 | print(f"\nPrecisión CNN: {test_acc}") 58 | 59 | # **Visualización de resultados** 60 | plt.figure(figsize=(10,5)) 61 | plt.subplot(1, 2, 1) 62 | plt.imshow(X_test.iloc[0].values.reshape(28, 28), cmap='gray') 63 | plt.title(f"Predicción KNN: {y_pred_knn[0]}") 64 | plt.subplot(1, 2, 2) 65 | plt.imshow(X_test.iloc[0].values.reshape(28, 28), cmap='gray') 66 | plt.title(f"Predicción CNN: {np.argmax(model.predict(X_test_cnn[0:1]))}") 67 | plt.show() 68 | -------------------------------------------------------------------------------- /Ejercicios/Vision artificial en ML/face_recognition_example.py: -------------------------------------------------------------------------------- 1 | import cv2 2 | import datetime 3 | 4 | # Parámetros globales 5 | KNOWN_DISTANCE = 50.0 # Distancia conocida en cm 6 | KNOWN_WIDTH = 14.0 # Ancho promedio de una cara humana en cm 7 | FOCAL_LENGTH = 600 # Longitud focal calibrada (ajustar según la cámara) 8 | 9 | def initialize_camera(): 10 | """Inicializar la cámara con manejo de errores.""" 11 | video_capture = cv2.VideoCapture(0) 12 | if not video_capture.isOpened(): 13 | print("Error: No se pudo acceder a la cámara.") 14 | exit() 15 | return video_capture 16 | 17 | def detect_faces(frame, face_cascade): 18 | """Detectar caras en un cuadro dado.""" 19 | gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) 20 | faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30)) 21 | return faces 22 | 23 | def calculate_distance(face_width): 24 | """Calcular la distancia en cm basada en el ancho de la cara detectada.""" 25 | return (KNOWN_WIDTH * FOCAL_LENGTH) / face_width 26 | 27 | def draw_face_grid(frame, x, y, w, h): 28 | """Dibujar una cuadrícula de puntos dentro del área del rostro.""" 29 | step_x = w // 10 30 | step_y = h // 10 31 | for i in range(0, w, step_x): 32 | for j in range(0, h, step_y): 33 | cv2.circle(frame, (x + i, y + j), 2, (0, 255, 255), -1) # Puntos amarillos 34 | 35 | def save_biometric_data(image, biometric_data): 36 | """Guardar la imagen y los datos biométricos en un archivo.""" 37 | timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S") 38 | image_filename = f"foto_{timestamp}.png" 39 | data_filename = f"datos_biometricos_{timestamp}.txt" 40 | 41 | # Guardar la imagen 42 | cv2.imwrite(image_filename, image) 43 | 44 | # Guardar los datos biométricos 45 | with open(data_filename, "w") as file: 46 | file.write("Datos biométricos:\n") 47 | for data in biometric_data: 48 | file.write(f"Distancia: {data['distance']:.2f} cm, Ancho: {data['width']} px\n") 49 | 50 | print(f"Foto guardada como {image_filename}") 51 | print(f"Datos biométricos guardados en {data_filename}") 52 | 53 | def process_frame(frame, face_cascade): 54 | """Procesar un cuadro de video para detección de caras y cálculo de distancias.""" 55 | faces = detect_faces(frame, face_cascade) 56 | biometric_data = [] 57 | 58 | for (x, y, w, h) in faces: 59 | distance = calculate_distance(w) 60 | distance_text = f"Distancia: {distance:.2f} cm" 61 | 62 | # Dibujar el cuadro delimitador y las etiquetas para cada cara 63 | cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2) 64 | cv2.putText(frame, distance_text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1) 65 | 66 | # Dibujar puntos en una cuadrícula dentro del área del rostro 67 | draw_face_grid(frame, x, y, w, h) 68 | 69 | # Agregar datos biométricos 70 | biometric_data.append({"distance": distance, "width": w}) 71 | 72 | return frame, biometric_data 73 | 74 | def main(): 75 | """Función principal para ejecutar el programa.""" 76 | face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml') 77 | video_capture = initialize_camera() 78 | 79 | while True: 80 | ret, frame = video_capture.read() 81 | if not ret: 82 | print("Advertencia: No se pudo leer el cuadro de la cámara.") 83 | continue 84 | 85 | # Procesar el cuadro 86 | frame, biometric_data = process_frame(frame, face_cascade) 87 | 88 | # Mostrar el cuadro procesado 89 | cv2.imshow("Mapeo de Rostro y Distancias", frame) 90 | 91 | # Tomar una foto y guardar datos biométricos con la tecla 's' 92 | if cv2.waitKey(1) & 0xFF == ord('s'): 93 | save_biometric_data(frame, biometric_data) 94 | 95 | # Salir con la tecla 'q' 96 | if cv2.waitKey(1) & 0xFF == ord('q'): 97 | break 98 | 99 | # Liberar la cámara y cerrar ventanas 100 | video_capture.release() 101 | cv2.destroyAllWindows() 102 | 103 | if __name__ == "__main__": 104 | main() 105 | -------------------------------------------------------------------------------- /Fuera de tema/01.py: -------------------------------------------------------------------------------- 1 | def print_hola_mundo(): 2 | hola_mundo = [ 3 | # H 4 | "H.....H", 5 | "H.....H", 6 | "H.....H", 7 | "HHHHHHH", 8 | "H.....H", 9 | "H.....H", 10 | "H.....H", 11 | "", 12 | # O 13 | "..OOOO.", 14 | ".O....O", 15 | "O......O", 16 | "O......O", 17 | "O......O", 18 | ".O....O", 19 | "..OOOO.", 20 | "", 21 | # L 22 | "L......", 23 | "L......", 24 | "L......", 25 | "L......", 26 | "L......", 27 | "L......", 28 | "LLLLLL.", 29 | "", 30 | # A 31 | "...A...", 32 | "..A.A..", 33 | ".A...A.", 34 | "AAAAAAA", 35 | "A.....A", 36 | "A.....A", 37 | "A.....A", 38 | "", 39 | # Space 40 | ".......", 41 | "", 42 | # M 43 | "M.....M", 44 | "MM...MM", 45 | "M.M.M.M", 46 | "M..M..M", 47 | "M.....M", 48 | "M.....M", 49 | "M.....M", 50 | "", 51 | # U 52 | "U.....U", 53 | "U.....U", 54 | "U.....U", 55 | "U.....U", 56 | "U.....U", 57 | ".U...U.", 58 | "..UUU..", 59 | "", 60 | # N 61 | "N.....N", 62 | "NN....N", 63 | "N.N...N", 64 | "N..N..N", 65 | "N...N.N", 66 | "N....NN", 67 | "N.....N", 68 | "", 69 | # D 70 | "DDDD...", 71 | "D...D..", 72 | "D....D.", 73 | "D.....D", 74 | "D....D.", 75 | "D...D..", 76 | "DDDD...", 77 | "", 78 | # O 79 | "..OOOO.", 80 | ".O....O", 81 | "O......O", 82 | "O......O", 83 | "O......O", 84 | ".O....O", 85 | "..OOOO." 86 | ] 87 | 88 | for line in hola_mundo: 89 | print(line) 90 | 91 | print_hola_mundo() 92 | -------------------------------------------------------------------------------- /Fuera de tema/02.py: -------------------------------------------------------------------------------- 1 | def print_julian(): 2 | julian = [ 3 | # J 4 | " ***** ", 5 | " * ", 6 | " * ", 7 | " * ", 8 | " * * ", 9 | " * * ", 10 | " *** ", 11 | "", 12 | # U 13 | " * * ", 14 | " * * ", 15 | " * * ", 16 | " * * ", 17 | " * * ", 18 | " * * ", 19 | " ***** ", 20 | "", 21 | # L 22 | " * ", 23 | " * ", 24 | " * ", 25 | " * ", 26 | " * ", 27 | " * ", 28 | " ******* ", 29 | "", 30 | # I 31 | " ***** ", 32 | " * ", 33 | " * ", 34 | " * ", 35 | " * ", 36 | " * ", 37 | " ***** ", 38 | "", 39 | # A 40 | " *** ", 41 | " * * ", 42 | " * * ", 43 | " ******* ", 44 | " * * ", 45 | " * * ", 46 | " * * ", 47 | "", 48 | # N 49 | " * * ", 50 | " ** * ", 51 | " * * * ", 52 | " * * * ", 53 | " * * * ", 54 | " * ** ", 55 | " * * ", 56 | ] 57 | 58 | for line in julian: 59 | print(line) 60 | 61 | print_julian() 62 | -------------------------------------------------------------------------------- /Fuera de tema/03.py: -------------------------------------------------------------------------------- 1 | import random 2 | import time 3 | 4 | # Constantes 5 | TRACK_LENGTH = 50 6 | 7 | def print_track(car1_pos, car2_pos): 8 | track1 = "-" * car1_pos + "🛸" + "-" * (TRACK_LENGTH - car1_pos) 9 | track2 = "-" * car2_pos + "🛩️" + "-" * (TRACK_LENGTH - car2_pos) 10 | print(f"Carro 1: {track1}") 11 | print(f"Carro 2: {track2}") 12 | 13 | def race(): 14 | car1_pos = 0 15 | car2_pos = 0 16 | 17 | while car1_pos < TRACK_LENGTH and car2_pos < TRACK_LENGTH: 18 | car1_pos += random.randint(1, 3) 19 | car2_pos += random.randint(1, 3) 20 | 21 | # Limita la posición a la longitud de la pista 22 | car1_pos = min(car1_pos, TRACK_LENGTH) 23 | car2_pos = min(car2_pos, TRACK_LENGTH) 24 | 25 | print_track(car1_pos, car2_pos) 26 | time.sleep(0.5) 27 | print("\n" * 20) # Limpiar la pantalla 28 | 29 | if car1_pos >= TRACK_LENGTH and car2_pos >= TRACK_LENGTH: 30 | print("¡Es un empate!") 31 | elif car1_pos >= TRACK_LENGTH: 32 | print("¡El platillo volador gana!") 33 | else: 34 | print("¡El Avion gana!") 35 | 36 | if __name__ == "__main__": 37 | race() 38 | -------------------------------------------------------------------------------- /Fuera de tema/04.py: -------------------------------------------------------------------------------- 1 | def suma(a, b): 2 | return a + b 3 | 4 | def resta(a, b): 5 | return a - b 6 | 7 | def multiplicacion(a, b): 8 | return a * b 9 | 10 | def division(a, b): 11 | if b == 0: 12 | return "Error: División por cero" 13 | return a / b 14 | 15 | def calculadora(): 16 | print("Seleccione la operación:") 17 | print("1. Suma") 18 | print("2. Resta") 19 | print("3. Multiplicación") 20 | print("4. División") 21 | 22 | opcion = input("Ingrese su elección (1/2/3/4): ") 23 | 24 | if opcion in ['1', '2', '3', '4']: 25 | num1 = float(input("Ingrese el primer número: ")) 26 | num2 = float(input("Ingrese el segundo número: ")) 27 | 28 | if opcion == '1': 29 | print(f"El resultado de la suma es: {suma(num1, num2)}") 30 | elif opcion == '2': 31 | print(f"El resultado de la resta es: {resta(num1, num2)}") 32 | elif opcion == '3': 33 | print(f"El resultado de la multiplicación es: {multiplicacion(num1, num2)}") 34 | elif opcion == '4': 35 | print(f"El resultado de la división es: {division(num1, num2)}") 36 | else: 37 | print("Opción no válida. Por favor, seleccione una opción entre 1 y 4.") 38 | 39 | calculadora() 40 | -------------------------------------------------------------------------------- /Fuera de tema/05.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | def guess_number(): 4 | number_to_guess = random.randint(1, 100) 5 | attempts = 0 6 | 7 | print("¡Bienvenido al juego de Adivinar el Número!") 8 | print("Estoy pensando en un número entre 1 y 100.") 9 | 10 | while True: 11 | guess = int(input("Ingresa tu suposición: ")) 12 | attempts += 1 13 | 14 | if guess < number_to_guess: 15 | print("Demasiado bajo. Inténtalo de nuevo.") 16 | elif guess > number_to_guess: 17 | print("Demasiado alto. Inténtalo de nuevo.") 18 | else: 19 | print(f"¡Felicidades! Adivinaste el número en {attempts} intentos.") 20 | break 21 | 22 | if __name__ == "__main__": 23 | guess_number() 24 | -------------------------------------------------------------------------------- /Fuera de tema/06.py: -------------------------------------------------------------------------------- 1 | from turtle import * 2 | 3 | 4 | def estrella(longitud): 5 | for i in range(5): 6 | forward(longitud) 7 | right(180 - 36) 8 | 9 | 10 | def espiral_estrellas(): 11 | for i in range(72): 12 | # Estrella de 300 de longitud 13 | estrella(300) 14 | # Girar 5 grados 15 | right(5) 16 | 17 | 18 | # Yo no quiero animaciones 19 | speed(0) 20 | # Dibujar espiral 21 | espiral_estrellas() 22 | # El input es para pausar el programa 23 | input("Presiona Enter para salir...") 24 | -------------------------------------------------------------------------------- /Fuera de tema/07.py: -------------------------------------------------------------------------------- 1 | import turtle as t 2 | 3 | def draw_petal(turtle, fill_color, border_color, radius): 4 | turtle.color(border_color) 5 | turtle.begin_fill() 6 | turtle.circle(radius, 60) # Arc for one side of the petal 7 | turtle.left(120) # Angle to draw the petal shape 8 | turtle.circle(radius, 60) # Arc for the other side of the petal 9 | turtle.left(120) # Reset angle 10 | turtle.end_fill() 11 | turtle.color(fill_color) 12 | turtle.begin_fill() 13 | turtle.circle(radius, 60) # Arc for one side of the petal 14 | turtle.left(120) # Angle to draw the petal shape 15 | turtle.circle(radius, 60) # Arc for the other side of the petal 16 | turtle.left(120) # Reset angle 17 | turtle.end_fill() 18 | 19 | def draw_circle(turtle, color, radius, x, y): 20 | turtle.penup() 21 | turtle.goto(x, y - radius) 22 | turtle.pendown() 23 | turtle.color(color) 24 | turtle.begin_fill() 25 | turtle.circle(radius) 26 | turtle.end_fill() 27 | 28 | def draw_text(turtle, text, position, color, font_size, font_style): 29 | turtle.penup() 30 | turtle.goto(position) 31 | turtle.pendown() 32 | turtle.color(color) 33 | turtle.write(text, align="center", font=("Arial", font_size, font_style)) 34 | 35 | def draw_sunflower(): 36 | screen = t.Screen() 37 | screen.bgcolor("lightblue") 38 | screen.title("Te quiero mucho") 39 | 40 | flower = t.Turtle() 41 | flower.speed(10) 42 | 43 | # Draw the stem 44 | flower.penup() 45 | flower.goto(0, -100) # Start the stem at the base of the flower 46 | flower.setheading(-90) 47 | flower.color("green") 48 | flower.pendown() 49 | flower.pensize(30) # Increase the thickness of the stem 50 | flower.forward(300) # Length of the stem 51 | 52 | # Draw leaves 53 | flower.penup() 54 | flower.goto(-120, -350) # Position for the leaves 55 | flower.setheading(-45) 56 | flower.color("green") 57 | flower.pendown() 58 | flower.begin_fill() 59 | flower.circle(100, 90) # Adjusted leaf size 60 | flower.left(90) 61 | flower.circle(100, 90) 62 | flower.end_fill() 63 | 64 | flower.penup() 65 | flower.goto(120, -350) # Position for the leaves 66 | flower.setheading(135) 67 | flower.pendown() 68 | flower.begin_fill() 69 | flower.circle(100, 90) # Adjusted leaf size 70 | flower.left(90) 71 | flower.circle(100, 90) 72 | flower.end_fill() 73 | 74 | # Draw petals 75 | flower.penup() 76 | flower.goto(0, 50) # Position the flower higher up 77 | flower.setheading(0) 78 | flower.pendown() 79 | flower.pensize(1) # Reset to default 80 | for _ in range(20): # Number of petals 81 | draw_petal(flower, "yellow", "orange", 250) # Pétalos con borde amarillo oscuro 82 | flower.left(18) # Adjust angle for more petals 83 | 84 | # Draw the center of the sunflower 85 | draw_circle(flower, "brown", 80, 0, 50) # Smaller center size 86 | 87 | # Write "Te quiero" with a border 88 | draw_text(flower, "Te quiero", (0, 250), "red", 48, "bold") # Main text 89 | flower.pensize(2) # Border thickness 90 | flower.penup() 91 | flower.goto(0, 255) # Position for border 92 | flower.pendown() 93 | flower.color("darkred") 94 | flower.write("Te quiero", align="center", font=("Arial", 48, "bold")) # Border text 95 | 96 | # Hide the turtle 97 | flower.hideturtle() 98 | 99 | t.done() 100 | 101 | if __name__ == "__main__": 102 | draw_sunflower() -------------------------------------------------------------------------------- /Fuera de tema/08.py: -------------------------------------------------------------------------------- 1 | import turtle as t 2 | 3 | def draw_text(turtle, text, position, color, font_size, font_style): 4 | turtle.penup() 5 | turtle.goto(position) 6 | turtle.pendown() 7 | turtle.color(color) 8 | turtle.write(text, align="center", font=("Arial", font_size, font_style)) 9 | 10 | def draw_text_with_outline(turtle, text, position, text_color, outline_color, font_size, font_style, outline_width): 11 | # Draw the outline 12 | turtle.penup() 13 | turtle.goto(position[0] - outline_width, position[1] - outline_width) 14 | turtle.pendown() 15 | turtle.color(outline_color) 16 | turtle.pensize(outline_width) 17 | turtle.write(text, align="center", font=("Arial", font_size, font_style)) 18 | 19 | # Draw the text on top 20 | turtle.penup() 21 | turtle.goto(position) 22 | turtle.pendown() 23 | turtle.color(text_color) 24 | turtle.pensize(1) 25 | turtle.write(text, align="center", font=("Arial", font_size, font_style)) 26 | 27 | def draw_message(): 28 | screen = t.Screen() 29 | screen.bgcolor("lightblue") 30 | screen.title("Mensaje Especial") 31 | 32 | writer = t.Turtle() 33 | writer.speed(2) 34 | writer.hideturtle() 35 | 36 | # Draw "Para mi gran y único amor" with an outline 37 | draw_text_with_outline( 38 | writer, 39 | "Para mi gran y único amor", 40 | (0, 0), 41 | "purple", # Text color 42 | "darkviolet", # Outline color 43 | 36, # Font size 44 | "bold", # Font style 45 | 4 # Outline width 46 | ) 47 | 48 | t.done() 49 | 50 | if __name__ == "__main__": 51 | draw_message() 52 | -------------------------------------------------------------------------------- /Fuera de tema/Juegos xd/Tres en raya.py: -------------------------------------------------------------------------------- 1 | def imprimir_tablero(tablero): 2 | for fila in tablero: 3 | print(" | ".join(fila)) 4 | print("-" * 9) 5 | 6 | def verificar_ganador(tablero, jugador): 7 | # Verificar filas, columnas y diagonales 8 | for i in range(3): 9 | if all(tablero[i][j] == jugador for j in range(3)) or all(tablero[j][i] == jugador for j in range(3)): 10 | return True 11 | if tablero[0][0] == tablero[1][1] == tablero[2][2] == jugador or tablero[0][2] == tablero[1][1] == tablero[2][0] == jugador: 12 | return True 13 | return False 14 | 15 | def tablero_lleno(tablero): 16 | return all(tablero[i][j] != " " for i in range(3) for j in range(3)) 17 | 18 | def tres_en_raya(): 19 | tablero = [[" " for _ in range(3)] for _ in range(3)] 20 | jugador_actual = "X" 21 | 22 | while True: 23 | imprimir_tablero(tablero) 24 | print(f"Turno del jugador {jugador_actual}") 25 | fila = int(input("Ingresa la fila (0, 1, 2): ")) 26 | columna = int(input("Ingresa la columna (0, 1, 2): ")) 27 | 28 | if tablero[fila][columna] == " ": 29 | tablero[fila][columna] = jugador_actual 30 | if verificar_ganador(tablero, jugador_actual): 31 | imprimir_tablero(tablero) 32 | print(f"¡El jugador {jugador_actual} ha ganado!") 33 | break 34 | elif tablero_lleno(tablero): 35 | imprimir_tablero(tablero) 36 | print("¡Es un empate!") 37 | break 38 | jugador_actual = "O" if jugador_actual == "X" else "X" 39 | else: 40 | print("La posición ya está ocupada. Intenta de nuevo.") 41 | 42 | if __name__ == "__main__": 43 | tres_en_raya() -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # **Python desde cero 🥸** [![My Skills](https://skillicons.dev/icons?i=python&theme=dark)](https://skillicons.dev) 2 | ### **Ruta de estudio con clases y ejercicios de *Python* de la comunidad para la comunidad.** 3 | **Usando de base los metodos de estudio de Mouredev, el cual enseña su metodologia de estudio *paso a paso* desde lo basico hasta lo avanzado. Aquí dejo un enlace directo a su repositorio: [Python desde 0](https://github.com/mouredev/Hello-Python)** 4 | 5 | # [![My Skills](https://skillicons.dev/icons?i=python&theme=dark)](https://skillicons.dev)¿Que es Python? 6 | **Python es un lenguaje de programación ampliamente utilizado en las aplicaciones web, el desarrollo de software, la ciencia de datos y el machine learning (ML). Los desarrolladores utilizan Python porque es eficiente y fácil de aprender, además de que se puede ejecutar en muchas plataformas diferentes.** 7 | >[!IMPORTANT] 8 | >## Información importante ⚠️‼️ 9 | >* Cada semana se publica mínimo una nueva clase y un ejercicio de la misma, repartidos en carpetas numeradas por lecciones. 10 | >* Las clases y ejercicios siguen un orden basado en el grado de dificultad de los mismos, empezando desde lo más básico hasta lo más avanzado del lenguaje. 11 | >* Hay dos carpetas: Clases y Ejercicios, ahí encontrarás el material debidamente ordenado. 12 | 13 | > [!NOTE] 14 | >## Instrucciones 🗂️ 15 | >**Haz un [FORK](https://github.com/JulianB0315/Python_0_to_hero.git) del proyecto y trabaja con Git para ir sincronizando las actualizaciones.** 16 | >1. Si quieres compartir tu propia solución de un ejercicio con la comunidad, crea un fichero de código con tu nombre y extensión, y realiza una [**PULL REQUEST**](https://docs.github.com/es/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) contra el repositorio. 17 | >2. El fichero de código debe situarse dentro del directorio del ejercicio correspondiente. El título del fichero y Pull Request también debe seguir este formato: **"#[titulo del modulo] - [Nombre de usuario de GitHub]"** . En el ejemplo anterior sería **"hola mundo - JulianB0315"**. Se rechazarán las Pull Request que no sigan este formato o contengan ficheros adicionales. 18 | >3. Si necesitas ayuda o quieres comentar cualquier cosa sobre las clases o ejercicios, puedes dejar la consulta en la parte de [**ISSUES**](https://github.com/JulianB0315/Python_0_to_hero/issues). 19 | >4. Puedes proponer Pull Request con propuestas o correcciones sobre ejercicios del resto de los participantes si estos poseen errores. De esta manera colaboraremos y practicaremos para comprender de mejor manera el lenguaje. 20 | >5. Si se te solicita un cambio/corrección en una Pull Request, y al cabo de 2 semanas no se muestra nueva actividad, se cerrará esa petición para mantener el repositorio limpio. Por supuesto, puedes volver a enviar la Pull Request cuando quieras. 21 | 22 | > [!TIP] 23 | >## Guía rápida Git y GitHub ⏭️ 24 | >1. Realiza un [FORK](https://github.com/JulianB0315/Python_0_to_hero.git) del repositorio de python desde GitHub. 25 | >2. CLONA ese repositorio a tu máquina local `git clone [TU-REPOSITORIO]`. 26 | >3. (Opcional) Crea una RAMA para la solución y desplázate a ella `git checkout -b [EL-NOMBRE-DE-TU-RAMA]`. 27 | >4. Añade el fichero de tu solución al STAGE `git add [FICHERO-DE-TU-EJERCICIO]`. 28 | >5. Haz COMMIT con el mensaje de la solución `git commit -m "#[NÚMERO-EJERCICIO] - [NOMBRE-DE-USUARIO]"`. 29 | >6. Haz PUSH `git push [EL-NOMBRE-DE-TU-RAMA]` (puede ser la "main" o la que creaste en el paso 3). 30 | >7. En el repositorio principal debes ir a la rama y hacer [PULL REQUEST](https://docs.github.com/es/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request). 31 | >8. CONTRIBUYE. 32 | >9. CREA PULL REQUEST (cubre la plantilla que te aparecerá). 33 | >10. Si el proceso de entrega se ha realizado de forma correcta, se añadirá tu corrección al repositorio. En caso contrario, se te notificarán los cambios a realizar o los motivos del rechazo. 34 | 35 | > [!CAUTION] 36 | >*Si necesitas aprender Git y GitHub te recomiendo el siguiente curso de [Mouredev](https://github.com/mouredev) :*
37 | >**[Curso Git y GitHub](https://github.com/mouredev/hello-git)** 38 | 39 | --------------------------------------------------------------------------------