├── exercises ├── 27_listaswithfor.py ├── 15_slices.py ├── 21_for.py ├── 20_while.py ├── 08_condicionales.py ├── 11_funciones2.py ├── 23_recorrerstringfor.py ├── 26_break.py ├── 30_listas.py ├── 25_continue.py ├── 04_convertir-a-untipodiferente.py ├── 09_mascondicionales.py ├── 24_recorrerstrings.py ├── 19_bucles.py ├── 31_tuplas.py ├── 32_diccionario.py ├── 02_variables.py ├── 03_tiposdatossencillos.py ├── 17_megapalindromo.py ├── 06_conversor.py ├── 05_operadoreslógicosdecomparacion.py ├── 28_pruebadeprimalidad.py ├── 10_funciones.py ├── 16_palíndromo.py ├── 29_adivinaelnumero.py ├── 33_generadorcontrasenas.py ├── 01_operadores matematicos.py ├── 12_conversorfinal.py ├── 18_sinbucles.py ├── 14_cadenasdecaracteres.py ├── 22_tablasmultiplicar.py ├── 07_conversorinverso.py └── 13_piedrapapeltijera.py ├── solveds ├── recorrer.py ├── condicionales.py ├── for.py ├── break_continue.py ├── adivina_el_numero.py ├── palindromo.py ├── prueba_primalidad.py ├── conversor.py ├── generador_contrasena.py ├── diccionarios.py ├── funciones.py └── bucles.py ├── README.md ├── .github └── workflows │ └── codeql-analysis.yml ├── LICENSE └── notes.md /exercises/27_listaswithfor.py: -------------------------------------------------------------------------------- 1 | a = list(range(1001)) 2 | print(a) 3 | -------------------------------------------------------------------------------- /exercises/15_slices.py: -------------------------------------------------------------------------------- 1 | nombre = "Francisco" 2 | print(nombre[::-1]) 3 | -------------------------------------------------------------------------------- /exercises/21_for.py: -------------------------------------------------------------------------------- 1 | for contador in range(1, 1001): 2 | print(contador) 3 | -------------------------------------------------------------------------------- /exercises/20_while.py: -------------------------------------------------------------------------------- 1 | contador = 1 2 | print(contador) 3 | while contador < 1000: 4 | contador += 1 5 | print(contador) 6 | -------------------------------------------------------------------------------- /exercises/08_condicionales.py: -------------------------------------------------------------------------------- 1 | edad = int(input("Escribe tu edad: ")) 2 | 3 | if edad > 17: 4 | print("Eres mayor de edad!") 5 | else: 6 | print("Eres menor de edad!") 7 | -------------------------------------------------------------------------------- /exercises/11_funciones2.py: -------------------------------------------------------------------------------- 1 | def suma(a, b): 2 | print("Se suman dos números") 3 | resultado = a + b 4 | return resultado 5 | 6 | 7 | sumatoria = suma(1, 4) 8 | print(sumatoria) 9 | -------------------------------------------------------------------------------- /exercises/23_recorrerstringfor.py: -------------------------------------------------------------------------------- 1 | def run(): 2 | nombre = input("Escribe tu nombre: ") 3 | for letra in nombre: 4 | print(letra) 5 | 6 | 7 | if __name__ == "__main__": 8 | run() 9 | -------------------------------------------------------------------------------- /exercises/26_break.py: -------------------------------------------------------------------------------- 1 | def main(): 2 | for i in range(10000): 3 | print(i) 4 | if i == 5678: 5 | break 6 | 7 | 8 | if __name__ == "__main__": 9 | main() 10 | -------------------------------------------------------------------------------- /exercises/30_listas.py: -------------------------------------------------------------------------------- 1 | def run(): 2 | numeros = [1, 3, 4, 8, 9, 5, 7, 5, 5, 6, 8, 7, 8] 3 | for _ in numeros: 4 | print(numeros) 5 | 6 | 7 | if __name__ == "__main__": 8 | run() 9 | -------------------------------------------------------------------------------- /exercises/25_continue.py: -------------------------------------------------------------------------------- 1 | def main(): 2 | for contador in range(1000): 3 | if contador % 2 != 0: 4 | continue 5 | print(contador) 6 | 7 | 8 | if __name__ == "__main__": 9 | main() 10 | -------------------------------------------------------------------------------- /exercises/04_convertir-a-untipodiferente.py: -------------------------------------------------------------------------------- 1 | numero = input("Escribe un número: ") 2 | numero2 = input("Escribe otro número: ") 3 | 4 | numero = int(numero) 5 | numero2 = int(numero2) 6 | suma = numero + numero2 7 | 8 | print("La suma de los 2 número es", suma) 9 | -------------------------------------------------------------------------------- /exercises/09_mascondicionales.py: -------------------------------------------------------------------------------- 1 | numero = int(input("Escribe tu número favorito: ")) 2 | 3 | if numero > 5: 4 | print("Tu número favorito es mayor a 5") 5 | elif numero == 5: 6 | print("Tu numero favorito es 5!") 7 | else: 8 | print("Tú numero favorito es menor a 5") 9 | -------------------------------------------------------------------------------- /solveds/recorrer.py: -------------------------------------------------------------------------------- 1 | def run(): 2 | # nombre = input('Escribe tu nombre: ') 3 | # for letra in nombre: 4 | # print(letra) 5 | 6 | frase = input("Escribe una frase: ") 7 | for caracter in frase: 8 | print(caracter.upper()) 9 | 10 | 11 | if __name__ == "__main__": 12 | run() 13 | -------------------------------------------------------------------------------- /exercises/24_recorrerstrings.py: -------------------------------------------------------------------------------- 1 | def run(): 2 | frase = input("Escribe una frase: ") 3 | for caracter in frase: 4 | print(caracter.upper()) 5 | 6 | 7 | def nvim(): 8 | numeros = (1, 2, 3, 4) 9 | print(numeros) 10 | 11 | 12 | nvim() 13 | 14 | 15 | if __name__ == "__main__": 16 | run() 17 | -------------------------------------------------------------------------------- /exercises/19_bucles.py: -------------------------------------------------------------------------------- 1 | def main(): 2 | LIMITE = 10000 3 | 4 | contador = 0 5 | potencia_2 = 2 ** contador 6 | while potencia_2 < LIMITE: 7 | print("2 elevado a " + str(contador) + " es igual a: " + str(potencia_2)) 8 | contador = contador + 1 9 | potencia_2 = 2 ** contador 10 | 11 | 12 | if __name__ == "__main__": 13 | main() 14 | -------------------------------------------------------------------------------- /solveds/condicionales.py: -------------------------------------------------------------------------------- 1 | # edad = int(input("Escribe tu edad: ")) 2 | # if edad > 17: 3 | # print('Eres mayor de edad') 4 | # else: 5 | # print('Eres menor de edad') 6 | 7 | numero = int(input("Escribe un número: ")) 8 | 9 | if numero > 5: 10 | print("Es mayor a 5") 11 | elif numero == 5: 12 | print("Es igual a 5") 13 | else: 14 | print("Es menor a 5") 15 | -------------------------------------------------------------------------------- /solveds/for.py: -------------------------------------------------------------------------------- 1 | # print(1) 2 | # print(2) 3 | # print(3) 4 | # print(4) 5 | # print(5) 6 | 7 | # contador = 1 8 | # print(contador) 9 | # while contador < 1000: 10 | # contador += 1 11 | # print(contador) 12 | 13 | # a = list(range(1000)) 14 | # print(a) 15 | 16 | # for contador in range(1, 1001): 17 | # print(contador) 18 | 19 | for i in range(10): 20 | print(11 * i) 21 | -------------------------------------------------------------------------------- /exercises/31_tuplas.py: -------------------------------------------------------------------------------- 1 | def listas(): 2 | numeros = [1, 8, 9, 7, 4, 10] 3 | numeros2 = [11, 13, 589, 7556, 789] 4 | lista = numeros + numeros2 5 | return lista 6 | 7 | 8 | def tupla(): 9 | mi_tupla = (1, 2, 3, 6, 4, 8, 9, 7, 5, 5, 4546, 46, 45, 64, 64, 54, 4, 5, 7878) 10 | for numero in mi_tupla: 11 | print(numero) 12 | 13 | 14 | if __name__ == "__main__": 15 | tupla() 16 | -------------------------------------------------------------------------------- /exercises/32_diccionario.py: -------------------------------------------------------------------------------- 1 | def run(): 2 | poblacion_paises = { 3 | "Argentina": 44_938_712, 4 | "Brasil": 210_147_125, 5 | "Colombia": 50_372_424, 6 | } 7 | # print(poblacion_paises['Brasil']) 8 | for pais, poblacion in poblacion_paises.items(): 9 | print(pais + " tiene " + str(poblacion) + " habitantes") 10 | 11 | 12 | if __name__ == "__main__": 13 | run() 14 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Curso Basido de Python 2 | 3 | Este es un curso de Introducctorio al **lenguaje de Programación Python**. 4 | 5 | En este repositorio encontraras Los ejemplos del Profesor [aquí](./solveds), 6 | mientras que todos mis ejercicios estaran [aquí](./exercises). 7 | 8 | Las notas del curso estan [aquí](./notes.md). 9 | 10 | **Si es que este repositorio le fue util, o simplemente le gusto, 11 | considera darle una estrella.** 12 | -------------------------------------------------------------------------------- /exercises/02_variables.py: -------------------------------------------------------------------------------- 1 | """Las variables son unas cajas con identificadores""" 2 | 3 | # La Primera Variable 4 | numero = 3898 5 | print('La variable "numero" vale ', numero) 6 | 7 | # La Segunda Variable 8 | numero2 = 656 9 | print('La variable "numero2" vale', numero2) 10 | 11 | # La suma de Ambos 12 | print("La suma de las 2 variables es", numero + numero2) 13 | 14 | # La Resta de Ambos 15 | print("La resta de las 2 variables es", numero - numero2) 16 | -------------------------------------------------------------------------------- /exercises/03_tiposdatossencillos.py: -------------------------------------------------------------------------------- 1 | nombre = "Zero" 2 | 3 | nombredos = "Requiem" 4 | 5 | miNombre = nombre + " " + nombredos 6 | 7 | print(miNombre) 8 | 9 | nombreFacha = "Facundo" 10 | print(nombreFacha * 4) 11 | 12 | numeroDecimal = 3.56 13 | print(numeroDecimal) 14 | 15 | numeroentero = 4 16 | print(numeroentero) 17 | 18 | meGustaPython = True 19 | print("Me Gusta Python = ", meGustaPython) 20 | 21 | trabajo = False 22 | print("Yo trabajo = ", trabajo) 23 | -------------------------------------------------------------------------------- /exercises/17_megapalindromo.py: -------------------------------------------------------------------------------- 1 | def palindromo(palabra): 2 | palabra = palabra.replace(" ", "").lower() 3 | return True if (palabra == palabra[::-1]) else False 4 | 5 | 6 | def main(): 7 | palabra = input("Escribe una palabra: ") 8 | es_palindromo = palindromo(palabra) 9 | if es_palindromo == True: 10 | print("Es palindromo") 11 | else: 12 | print("No es palindromo") 13 | 14 | 15 | if __name__ == "__main__": 16 | main() 17 | -------------------------------------------------------------------------------- /exercises/06_conversor.py: -------------------------------------------------------------------------------- 1 | valorQueQuiereConvertir = input("A que moneda quieres convertir tus soles?: ") 2 | 3 | if valorQueQuiereConvertir == "dolar": 4 | soles = input("Ingresa la cantidad de soles que tienes: ") 5 | soles = float(soles) 6 | 7 | valorDolar = 3.61 8 | dolares = soles / valorDolar 9 | dolares = round(dolares, 2) 10 | dolares = str(dolares) 11 | 12 | print("Tienes $" + dolares) 13 | 14 | else: 15 | print("Busca en goole") 16 | -------------------------------------------------------------------------------- /solveds/break_continue.py: -------------------------------------------------------------------------------- 1 | def run(): 2 | # for contador in range(1000): 3 | # if contador % 2 != 0: 4 | # continue 5 | # print(contador) 6 | 7 | # for i in range(10000): 8 | # print(i) 9 | # if i == 5678: 10 | # break 11 | 12 | texto = input("Escribe un texto: ") 13 | for letra in texto: 14 | if letra == "o": 15 | break 16 | print(letra) 17 | 18 | 19 | if __name__ == "__main__": 20 | run() 21 | -------------------------------------------------------------------------------- /solveds/adivina_el_numero.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | 4 | def run(): 5 | numero_aleatorio = random.randint(1, 100) 6 | numero_elegido = int(input("Elige un número del 1 al 100: ")) 7 | while numero_elegido != numero_aleatorio: 8 | if numero_elegido < numero_aleatorio: 9 | print("Busca un número más grande") 10 | else: 11 | print("Busca un número más pequeño") 12 | numero_elegido = int(input("Elige otro número: ")) 13 | print("¡Ganaste!") 14 | 15 | 16 | if __name__ == "__main__": 17 | run() 18 | -------------------------------------------------------------------------------- /exercises/05_operadoreslógicosdecomparacion.py: -------------------------------------------------------------------------------- 1 | soyEstudiante = True 2 | print("Yo soy estudiante =", soyEstudiante) 3 | 4 | yoTrabajo = False 5 | print("Yo tabajo =", yoTrabajo) 6 | 7 | print(soyEstudiante and yoTrabajo) 8 | print(soyEstudiante or yoTrabajo) 9 | print(not yoTrabajo) 10 | 11 | numeroUno = 7777 12 | numeroDos = 7777 13 | print("Las 2 variables tienen el mismo valor?", numeroUno == numeroDos) 14 | 15 | numeroTres = 3333 16 | print( 17 | 'La variable "numeroDos" y la variable "numeroTres" son Diferentes?', 18 | numeroDos != numeroTres, 19 | ) 20 | -------------------------------------------------------------------------------- /solveds/palindromo.py: -------------------------------------------------------------------------------- 1 | def palindromo(palabra): 2 | palabra = palabra.replace(" ", "") 3 | palabra = palabra.lower() 4 | palabra_invertida = palabra[::-1] 5 | if palabra == palabra_invertida: 6 | return True 7 | else: 8 | return False 9 | 10 | 11 | def run(): 12 | palabra = input("Escribe una palabra: ") 13 | es_palindromo = palindromo(palabra) 14 | if es_palindromo == True: 15 | print("Es palíndromo") 16 | else: 17 | print("No es palíndromo") 18 | 19 | 20 | if __name__ == "__main__": 21 | run() 22 | -------------------------------------------------------------------------------- /solveds/prueba_primalidad.py: -------------------------------------------------------------------------------- 1 | def es_primo(numero): 2 | contador = 0 3 | 4 | for i in range(1, numero + 1): 5 | if i == 1 or i == numero: 6 | continue 7 | if numero % i == 0: 8 | contador += 1 9 | if contador == 0: 10 | return True 11 | else: 12 | return False 13 | 14 | 15 | def run(): 16 | numero = int(input("Escribe un número: ")) 17 | if es_primo(numero): 18 | print("Es primo") 19 | else: 20 | print("No es primo") 21 | 22 | 23 | if __name__ == "__main__": 24 | run() 25 | -------------------------------------------------------------------------------- /exercises/28_pruebadeprimalidad.py: -------------------------------------------------------------------------------- 1 | def es_primo(numero): 2 | contador = 0 3 | 4 | for i in range(1, numero + 1): 5 | if i == 1 or i == numero: 6 | continue 7 | if numero % i == 0: 8 | contador += 1 9 | if contador == 0: 10 | return True 11 | else: 12 | return False 13 | 14 | 15 | def main(): 16 | numero = int(input("Escribe un numero: ")) 17 | if es_primo(numero): 18 | print("Es primo") 19 | else: 20 | print("No es primo") 21 | 22 | 23 | if __name__ == "__main__": 24 | main() 25 | -------------------------------------------------------------------------------- /exercises/10_funciones.py: -------------------------------------------------------------------------------- 1 | def mensajeEspecial(): 2 | print("Mensaje Especial!") 3 | print("Estoy Aprendiendo Python!") 4 | 5 | 6 | # mensaje() 7 | 8 | 9 | def conversacion(mensaje): 10 | print("Hola!") 11 | print("Cómo estas?") 12 | print(mensaje) 13 | print("Adios") 14 | 15 | 16 | opcion = int(input("Elige una opcion (1, 2, 3,): ")) 17 | if opcion == 1: 18 | conversacion("Elegiste la Opción 1") 19 | elif opcion == 2: 20 | conversacion("Elegiste la opción 2") 21 | elif opcion == 3: 22 | conversacion("Elegiste la opción 3") 23 | else: 24 | print("No sabes leer?Solo 1, 2 o 3.") 25 | -------------------------------------------------------------------------------- /exercises/16_palíndromo.py: -------------------------------------------------------------------------------- 1 | # Un Palíndromo es una palabra que se escribe igual al revez o al derecho 2 | 3 | 4 | def palindromo(palabra): 5 | palabra = palabra.replace(" ", "") 6 | palabra = palabra.lower() 7 | palabra_invertida = palabra[::-1] 8 | if palabra == palabra_invertida: 9 | return True 10 | else: 11 | return False 12 | 13 | 14 | def main(): 15 | palabra = input("Escribe una palabra: ") 16 | es_palindromo = palindromo(palabra) 17 | if es_palindromo == True: 18 | print("Es palindromo") 19 | else: 20 | print("No es palindromo") 21 | 22 | 23 | if __name__ == "__main__": 24 | main() 25 | -------------------------------------------------------------------------------- /exercises/29_adivinaelnumero.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | 4 | def run(): 5 | numero_aleatorio = random.randint(1, 100) 6 | numero_elegido = int(input("Elige un numero del 1 al 100: ")) 7 | while numero_elegido != numero_aleatorio: 8 | if numero_elegido < numero_aleatorio: 9 | print("Busaca un numero mas grande") 10 | 11 | elif numero_elegido > 100: 12 | print("¡Elige un número del 1 al 100!") 13 | 14 | else: 15 | print("Busca un numero mas pequeño") 16 | numero_elegido = int(input("Elige otro número: ")) 17 | print("Ganaste!") 18 | 19 | 20 | if __name__ == "__main__": 21 | run() 22 | -------------------------------------------------------------------------------- /solveds/conversor.py: -------------------------------------------------------------------------------- 1 | def conversor(tipo_pesos, valor_dolar): 2 | pesos = input("¿Cuántos pesos " + tipo_pesos + " tienes?: ") 3 | pesos = float(pesos) 4 | dolares = pesos / valor_dolar 5 | dolares = round(dolares, 2) 6 | dolares = str(dolares) 7 | print("Tienes $" + dolares + " dólares") 8 | 9 | 10 | menu = """ 11 | Bienvenido al conversor de monedas 💰 12 | 13 | 1 - Pesos colombianos 14 | 2 - Pesos argentinos 15 | 3 - Pesos mexicanos 16 | 17 | Elige una opción: """ 18 | 19 | opcion = int(input(menu)) 20 | 21 | if opcion == 1: 22 | conversor("colombianos", 3875) 23 | elif opcion == 2: 24 | conversor("argentinos", 65) 25 | elif opcion == 3: 26 | conversor("mexicanos", 24) 27 | else: 28 | print("Ingresa una opción correcta por favor") 29 | -------------------------------------------------------------------------------- /exercises/33_generadorcontrasenas.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | 4 | def generate_password(): 5 | mayusculas = ["A", "B", "C", "D", "E"] 6 | minusculas = ["a", "b", "c", "d", "e", "i", "o", "u"] 7 | simbolos = ["!", '"', "#", "$", "%", "&", "/"] 8 | numeros = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"] 9 | 10 | caracters = mayusculas + minusculas + simbolos + numeros 11 | 12 | password = [] 13 | for i in range(15): 14 | caracter_random = random.choice(caracters) 15 | password.append(caracter_random) 16 | 17 | password = "".join(password) 18 | return password 19 | 20 | 21 | def run(): 22 | password = generate_password() 23 | print("Your new password is: " + password) 24 | 25 | 26 | if __name__ == "__main__": 27 | run() 28 | -------------------------------------------------------------------------------- /solveds/generador_contrasena.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | 4 | def generar_contrasena(): 5 | mayusculas = ["A", "B", "C", "D", "E", "F", "G"] 6 | minusculas = ["a", "b", "c", "d", "e", "f", "g"] 7 | simbolos = ["!", "#", "$", "&", "/", "(", ")"] 8 | numeros = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] 9 | 10 | caracteres = mayusculas + minusculas + simbolos + numeros 11 | 12 | contrasena = [] 13 | 14 | for i in range(15): 15 | caracter_random = random.choice(caracteres) 16 | contrasena.append(caracter_random) 17 | 18 | contrasena = "".join(contrasena) 19 | return contrasena 20 | 21 | 22 | def run(): 23 | contrasena = generar_contrasena() 24 | print("Tu nueva contraseña es: " + contrasena) 25 | 26 | 27 | if __name__ == "__main__": 28 | run() 29 | -------------------------------------------------------------------------------- /exercises/01_operadores matematicos.py: -------------------------------------------------------------------------------- 1 | import math 2 | 3 | 4 | def impresion(): 5 | # Hacer una suma: 6 | print(5 + 6 + 9 + 87) 7 | 8 | # Hacer una resta: 9 | print(46546 - 544) 10 | 11 | # Hacer una división: 12 | print(45645456 / 30) 13 | 14 | # Division sin decimales 15 | print(456 // 3) 16 | 17 | # Resto de la division: 18 | print(21 % 5) 19 | 20 | # Hacer una potencia 21 | print(2 ** 2) 22 | 23 | # Hacer una Raiz: 24 | print(9 ** 0.5) 25 | 26 | math.sqrt(9) 27 | 28 | 29 | if __name__ == "__main__": 30 | impresion() 31 | 32 | """ 33 | Python respeta la separación de términos, 34 | por lo que si escribimos 5 + 5 * 2 multiplicará primero 5 x 2. 35 | En el caso de que quisiéramos que primero sume 5 + 5 ponemos paréntesis: 36 | (5 + 5) * 2. 37 | """ 38 | -------------------------------------------------------------------------------- /solveds/diccionarios.py: -------------------------------------------------------------------------------- 1 | def run(): 2 | # mi_diccionario = { 3 | # 'llave1': 1, 4 | # 'llave2': 2, 5 | # 'llave3': 3, 6 | # } 7 | 8 | # print(mi_diccionario['llave1']) 9 | # print(mi_diccionario['llave2']) 10 | # print(mi_diccionario['llave3']) 11 | 12 | poblacion_paises = { 13 | "Argentina": 44938712, 14 | "Brasil": 210147125, 15 | "Colombia": 50372424, 16 | } 17 | 18 | # print(poblacion_paises['Bolivia']) 19 | 20 | # for pais in poblacion_paises.keys(): 21 | # print(pais) 22 | 23 | # for pais in poblacion_paises.values(): 24 | # print(pais) 25 | 26 | for pais, poblacion in poblacion_paises.items(): 27 | print(pais + " tiene " + str(poblacion) + " habitantes") 28 | 29 | 30 | if __name__ == "__main__": 31 | run() 32 | -------------------------------------------------------------------------------- /.github/workflows/codeql-analysis.yml: -------------------------------------------------------------------------------- 1 | name: "CodeQL" 2 | on: 3 | push: 4 | branches: [main] 5 | pull_request: 6 | branches: [main] 7 | schedule: 8 | - cron: "35 21 * * 1" 9 | jobs: 10 | analyze: 11 | name: Analyze 12 | runs-on: ubuntu-latest 13 | permissions: 14 | actions: read 15 | contents: read 16 | security-events: write 17 | strategy: 18 | fail-fast: false 19 | matrix: 20 | language: ["python"] 21 | steps: 22 | - name: Checkout repository 23 | uses: actions/checkout@v2 24 | - name: Initialize CodeQL 25 | uses: github/codeql-action/init@v1 26 | with: 27 | languages: ${{ matrix.language }} 28 | - name: Autobuild 29 | uses: github/codeql-action/autobuild@v1 30 | - name: Perform CodeQL Analysis 31 | uses: github/codeql-action/analyze@v1 32 | -------------------------------------------------------------------------------- /solveds/funciones.py: -------------------------------------------------------------------------------- 1 | # def imprimir_mensaje(): 2 | # print('Mensaje especial: ') 3 | # print('¡Estoy aprendiendo a usar funciones!') 4 | 5 | 6 | # imprimir_mensaje() 7 | # imprimir_mensaje() 8 | # imprimir_mensaje() 9 | 10 | 11 | # def conversacion(mensaje): 12 | # print('Hola') 13 | # print('Cómo estás') 14 | # print(mensaje) 15 | # print('Adios') 16 | 17 | 18 | # opcion = int(input('Elige una opción (1, 2, 3): ')) 19 | # if opcion == 1: 20 | # conversacion('Elegiste la opción 1') 21 | # elif opcion == 2: 22 | # conversacion('Elegiste la opción 2') 23 | # elif opcion == 3: 24 | # conversacion('Elegiste la opción 3') 25 | # else: 26 | # print('Escribe la opción correcta') 27 | 28 | 29 | def suma(a, b): 30 | print("Se suman dos números") 31 | resultado = a + b 32 | return resultado 33 | 34 | 35 | sumatoria = suma(1, 4) 36 | print(sumatoria) 37 | -------------------------------------------------------------------------------- /exercises/12_conversorfinal.py: -------------------------------------------------------------------------------- 1 | def currency_converter(currency_type, exchange_rate): 2 | currency = float(input("Cuantos " + currency_type + " tienes?")) 3 | dollars = currency / exchange_rate 4 | dollars = str(round(dollars, 2)) 5 | print("Tienes $" + dollars) 6 | 7 | 8 | menu = """ 9 | Conversor Facha por Zero 10 | Coloca un numero de acuerdo a la moneda que tengas: 11 | 12 | 1 - Pesos bolivianos 13 | 2 - Pesos Mexicanos 14 | 3 - Pesos Argentinos 15 | 4 - Soles 16 | 17 | Escoge una opcion: 18 | """ 19 | user_input = float(input(menu)) 20 | if user_input == 1: 21 | currency_converter("bolivianos", 6.86) 22 | elif user_input == 2: 23 | currency_converter("pesos mexicanos", 23.38) 24 | elif user_input == 3: 25 | currency_converter("pesos argentinos", 73.04) 26 | elif user_input == 4: 27 | currency_converter("soles", 3.5) 28 | else: 29 | print("Esa no es una opcion valida.") 30 | print("Salu2") 31 | -------------------------------------------------------------------------------- /exercises/18_sinbucles.py: -------------------------------------------------------------------------------- 1 | contador = 0 2 | print("2 elevado a " + str(contador) + " es igual a: " + str(2 ** contador)) 3 | 4 | contador = 1 5 | print("2 elevado a " + str(contador) + " es igual a: " + str(2 ** contador)) 6 | 7 | contador = 2 8 | print("2 elevado a " + str(contador) + " es igual a: " + str(2 ** contador)) 9 | 10 | contador = 3 11 | print("2 elevado a " + str(contador) + " es igual a: " + str(2 ** contador)) 12 | 13 | contador = 4 14 | print("2 elevado a " + str(contador) + " es igual a: " + str(2 ** contador)) 15 | 16 | contador = 5 17 | print("2 elevado a " + str(contador) + " es igual a: " + str(2 ** contador)) 18 | 19 | contador = 6 20 | print("2 elevado a " + str(contador) + " es igual a: " + str(2 ** contador)) 21 | 22 | contador = 7 23 | print("2 elevado a " + str(contador) + " es igual a: " + str(2 ** contador)) 24 | 25 | contador = 8 26 | print("2 elevado a " + str(contador) + " es igual a: " + str(2 ** contador)) 27 | -------------------------------------------------------------------------------- /exercises/14_cadenasdecaracteres.py: -------------------------------------------------------------------------------- 1 | nombre = input("¿Cuál es tu nombre?: ") 2 | nombre = nombre.capitalize().strip() 3 | 4 | print("Tu nombre capitalizado es " + nombre) 5 | 6 | indice = input("Escribe una palabra y te mostrare cual es su indice 2: ") 7 | print("El Indice 2 es '" + indice[2] + "'") 8 | 9 | """ 10 | variable.upper() = 'todos los caracteres en MAYÚSCULAS' 11 | variable.capitalize() = 'solo la primera en MAYÚSCULA' 12 | variable.lower() = 'todos los caracteres en minúscula' 13 | variable.strip() = 'eliminar espacios basura del string' 14 | variable.replace('caractera a cambiar', 'caracter por poner') = remplazar caracter 15 | """ 16 | 17 | # FUNCIONES BILT IN 18 | """Aquellas que son propias del lenguaje y que no tenemos que crearlas, solo invocarlas.""" 19 | # len() 20 | # print() 21 | # input() 22 | 23 | 24 | cadena = "Esta es una cadena de texto larga,bastante larga." 25 | print("La cadena de texto tiene " + str(len(cadena)) + " caracteres.") 26 | -------------------------------------------------------------------------------- /solveds/bucles.py: -------------------------------------------------------------------------------- 1 | # contador = 0 2 | # print('2 elevado a ' + str(contador) + ' es igual a: ' + str(2**contador)) 3 | 4 | # contador = 1 5 | # print('2 elevado a ' + str(contador) + ' es igual a: ' + str(2**contador)) 6 | 7 | # contador = 2 8 | # print('2 elevado a ' + str(contador) + ' es igual a: ' + str(2**contador)) 9 | 10 | # contador = 3 11 | # print('2 elevado a ' + str(contador) + ' es igual a: ' + str(2**contador)) 12 | 13 | # contador = 4 14 | # print('2 elevado a ' + str(contador) + ' es igual a: ' + str(2**contador)) 15 | 16 | # contador = 5 17 | # print('2 elevado a ' + str(contador) + ' es igual a: ' + str(2**contador)) 18 | 19 | 20 | def run(): 21 | LIMITE = 1000000 22 | 23 | contador = 0 24 | potencia_2 = 2 ** contador 25 | while potencia_2 < LIMITE: 26 | print("2 elevado a " + str(contador) + " es igual a: " + str(potencia_2)) 27 | contador = contador + 1 28 | potencia_2 = 2 ** contador 29 | 30 | 31 | if __name__ == "__main__": 32 | run() 33 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 Eliaz Bobadilla 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /exercises/22_tablasmultiplicar.py: -------------------------------------------------------------------------------- 1 | def tablas(numero): 2 | print("Esta es la tabla del " + str(numero) + ":") 3 | for i in range(1, 13): 4 | print(i * numero) 5 | 6 | 7 | menu = """ 8 | Las tablas de Multiplicar del al 12 9 | 10 | 1 - Tabla del 1 11 | 2 - Tabla del 2 12 | 3 - Tabla del 3 13 | 4 - Tabla del 4 14 | 5 - Tabla del 5 15 | 6 - Tabla del 6 16 | 7 - Tabla del 7 17 | 8 - Tabla del 8 18 | 9 - Tabla del 9 19 | 10 - Tabla del 10 20 | 11 - Tabla del 11 21 | 12 - Tabla del 12 22 | 23 | Escoge que tabla deseas ver: 24 | """ 25 | user_input = str(input(menu)) 26 | 27 | if user_input == "1": 28 | tablas(1) 29 | elif user_input == "2": 30 | tablas(2) 31 | elif user_input == "3": 32 | tablas(3) 33 | elif user_input == "4": 34 | tablas(4) 35 | elif user_input == "5": 36 | tablas(5) 37 | elif user_input == "6": 38 | tablas(6) 39 | elif user_input == "7": 40 | tablas(7) 41 | elif user_input == "8": 42 | tablas(8) 43 | elif user_input == "9": 44 | tablas(9) 45 | elif user_input == "10": 46 | tablas(10) 47 | elif user_input == "11": 48 | tablas(11) 49 | elif user_input == "12": 50 | tablas(12) 51 | -------------------------------------------------------------------------------- /exercises/07_conversorinverso.py: -------------------------------------------------------------------------------- 1 | def exchanges(moneda, cantidad): 2 | result = 0 3 | # Moneda chilena 4 | if moneda == 1: 5 | result = cantidad * 0.0013 6 | result = round(result, 2) 7 | print(f"Los {cantidad} pesos chilenos equivalen a {result} dólares") 8 | # Moneda colombiana 9 | elif moneda == 2: 10 | result = cantidad * 0.00027 11 | result = round(result, 2) 12 | print(f"Los {cantidad} pesos colombianos equivalen a {result} dólares") 13 | # Moneda Argentina 14 | elif moneda == 3: 15 | result = cantidad * 0.014 16 | result = round(result, 2) 17 | print(f"Los {cantidad} pesos argentinos equivalen a {result} dólares") 18 | # Moneda mexicana 19 | elif moneda == 4: 20 | result = cantidad * 0.044 21 | result = round(result, 2) 22 | print(f"Los {cantidad} pesos mexicanos equivalen a {result} dólares") 23 | # Moneda Peruana Cara Fachera 24 | elif moneda == 5: 25 | result = cantidad * 0.28 26 | result = round(result, 2) 27 | print(f"La {cantidad} soles equivalen a {result} dólares") 28 | # Otro 29 | else: 30 | print("Ingresa solo un numero de la lista") 31 | 32 | 33 | if __name__ == "__main__": 34 | try: 35 | moneda = int( 36 | input( 37 | """ 38 | Ingresa el indice de la moneda que quieres convertira dolar: 39 | [1] Moneda chilena(pesos) a Dólar 40 | [2] Moneda colombiana(pesos) a Dólar 41 | [3] Moneda argentida(pesos) a Dólar 42 | [4] Moneda mexicana(pesos) a Dólar 43 | [5] Moneda peruana(soles) a Dólar 44 | Selecciona: """ 45 | ) 46 | ) 47 | print("********************************") 48 | cantidad = int(input("Ingresa la cantidad que quieres convertir: ")) 49 | exchanges(moneda, cantidad) 50 | except: 51 | print("* * * * * * E R R O R * * * * * *") 52 | print("Por favor, Ingresa solo valores numericos") 53 | -------------------------------------------------------------------------------- /exercises/13_piedrapapeltijera.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | is_game = True 4 | 5 | 6 | def conversacion(mensaje): 7 | if mensaje == "piedra": 8 | return 1 9 | elif mensaje == "papel": 10 | return 2 11 | elif mensaje == "tijera": 12 | return 3 13 | else: 14 | return 0 15 | 16 | 17 | def quien_gano(oponente, ususario): 18 | if oponente == 1 and usuario == 2: 19 | return "Ganaste B)" 20 | elif oponente == 2 and usuario == 1: 21 | return "Perdiste,vuelve a intentarlo" 22 | elif oponente == 1 and usuario == 3: 23 | return "Perdiste,vuelve a intentarlo" 24 | elif oponente == 3 and usuario == 1: 25 | return "Ganaste B)" 26 | elif oponente == 2 and usuario == 3: 27 | return "Ganaste B)" 28 | elif oponente == 3 and usuario == 1: 29 | return "Perdiste,vuelve a intentarlo" 30 | elif oponente == usuario: 31 | return "Empate, salu2" 32 | elif oponente == 0 or usuario == 0: 33 | return "Esa no es una opcion valida,recuerda que tienes que poner las opciones en minusculas" 34 | else: 35 | return "Esa no es una opcion valida,recuerda que tienes que poner las opciones en minusculas" 36 | 37 | 38 | def seguir_jugando(respuesta): 39 | if respuesta == "si": 40 | return True 41 | else: 42 | return False 43 | 44 | 45 | bienvenida = """ 46 | ██████╗ ██╗███████╗██████╗ ██████╗ █████╗ 47 | ██╔══██╗██║██╔════╝██╔══██╗██╔══██╗██╔══██╗ 48 | ██████╔╝██║█████╗ ██║ ██║██████╔╝███████║ 49 | ██╔═══╝ ██║██╔══╝ ██║ ██║██╔══██╗██╔══██║ 50 | ██║ ██║███████╗██████╔╝██║ ██║██║ ██║ 51 | ╚═╝ ╚═╝╚══════╝╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ 52 | 53 | ██████╗ █████╗ ██████╗ ███████╗██╗ 54 | ██╔══██╗██╔══██╗██╔══██╗██╔════╝██║ 55 | ██████╔╝███████║██████╔╝█████╗ ██║ 56 | ██╔═══╝ ██╔══██║██╔═══╝ ██╔══╝ ██║ 57 | ██║ ██║ ██║██║ ███████╗███████╗ 58 | ╚═╝ ╚═╝ ╚═╝╚═╝ ╚══════╝╚══════╝ 59 | 60 | ██████╗ 61 | ██╔═══██╗ 62 | ██║ ██║ 63 | ██║ ██║ 64 | ╚██████╔╝ 65 | 66 | ████████╗██╗ ██╗███████╗██████╗ █████╗ 67 | ╚══██╔══╝██║ ██║██╔════╝██╔══██╗██╔══██╗ 68 | ██║ ██║ ██║█████╗ ██████╔╝███████║ 69 | ██║ ██║██ ██║██╔══╝ ██╔══██╗██╔══██║ 70 | ██║ ██║╚█████╔╝███████╗██║ ██║██║ ██║ 71 | ╚═╝ ╚═╝ ╚════╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝ 72 | ___________________________________________ 73 | 74 | """ 75 | 76 | print(bienvenida) 77 | 78 | while is_game: 79 | oponente = random.randint(1, 3) 80 | usuario = conversacion( 81 | input("Escribe piedra, papel o tijera segun lo que hayas escogido: ") 82 | ) 83 | 84 | print(quien_gano(oponente, usuario)) 85 | is_game = seguir_jugando(input("Quieres seguir jugando? ")) 86 | -------------------------------------------------------------------------------- /notes.md: -------------------------------------------------------------------------------- 1 | # Indice de las Notas 2 | 3 | - [Curso Básico de Python](#curso-básico-de-python) 4 | - [Modulo 1 Introduccion a la programacion con Python](#modulo-1-introduccion-a-la-programacion-con-python) 5 | - [Clase 1 EL arte de la programacion](#clase-1-el-arte-de-la-programacion) 6 | - [Clase 2 Por que Python](#clase-2-por-que-python) 7 | - [Clase 3 El núcleo de un programa: los algoritmos](#clase-3-el-núcleo-de-un-programa-los-algoritmos) 8 | - [Clase 4 Instalación de nuestras herramientas (en Windows)](#clase-4-instalación-de-nuestras-herramientas-en-windows) 9 | - [Clase 5 Instalacion de nuestras herramientas en Mac](#clase-5-instalacion-de-nuestras-herramientas-en-mac) 10 | - [Clase 6 Instalacion de nuestras herramientas en Ubuntu](#clase-6-instalacion-de-nuestras-herramientas-en-ubuntu) 11 | - [Clase 7 Tu mejor herramienta: la consola](#clase-7-tu-mejor-herramienta-la-consola) 12 | - [Modulo 2 Conceptos basicos de Python](#modulo-2-conceptos-basicos-de-python) 13 | - [Clase 8 Explorando Python: operadores aritméticos](#clase-8-explorando-python-operadores-aritméticos) 14 | - [Clase 9 Que es una variable](#clase-9-que-es-una-variable) 15 | - [Clase 10 Los primitivos: tipos de datos sencillos](#clase-10-los-primitivos-tipos-de-datos-sencillos) 16 | - [Clase 11 Convertir un dato a un tipo diferente](#clase-11-convertir-un-dato-a-un-tipo-diferente) 17 | - [Clase 12 Operadores logicos y de comparacion](#clase-12-operadores-logicos-y-de-comparacion) 18 | - [Clase 13 Tu primer programa: conversor de monedas](#clase-13-tu-primer-programa-conversor-de-monedas) 19 | - [Modulo 3 Herramientas para programar](#modulo-3-herramientas-para-programar) 20 | - [Clase 14 Construyendo el camino de un programa con condicionales](#clase-14-construyendo-el-camino-de-un-programa-con-condicionales) 21 | - [Clase 15 Varios paises en mi conversor de monedas](#clase-15-varios-paises-en-mi-conversor-de-monedas) 22 | - [Clase 16 Aprendiendo a no repetir codigo con funciones](#clase-16-aprendiendo-a-no-repetir-codigo-con-funciones) 23 | - [Clase 17 Modularizando nuestro conversor de monedas](#clase-17-modularizando-nuestro-conversor-de-monedas) 24 | - [Clase 18 Trabajando con texto: cadenas de caracteres](#clase-18-trabajando-con-texto-cadenas-de-caracteres) 25 | - [Clase 19 Trabajando con texto: slices](#clase-19-trabajando-con-texto-slices) 26 | - [Clase 20 Proyecto: palindromo](#clase-20-proyecto-palindromo) 27 | - [Modulo 4 Bucles](#modulo-4-bucles) 28 | - [Clase 21 Aprendiendo bucles](#clase-21-aprendiendo-bucles) 29 | - [Clase 22 El ciclo while](#clase-22-el-ciclo-while) 30 | - [Clase 23 Explorando un bucle diferente: el ciclo for](#clase-23-explorando-un-bucle-diferente-el-ciclo-for) 31 | - [Clase 24 Recorriendo un string con for](#clase-24-recorriendo-un-string-con-for) 32 | - [Clase 25 Interrumpiendo ciclos con break y continue](#clase-25-interrumpiendo-ciclos-con-break-y-continue) 33 | - [Clase 26 Proyecto: prueba de primalidad](#clase-26-proyecto-prueba-de-primalidad) 34 | - [Clase 27 Proyecto: videojuego](#clase-27-proyecto-videojuego) 35 | - [Modulo 5 Estructuras de datos](#modulo-5-estructuras-de-datos) 36 | - [Clase 28 Almacenar varios valores en una variable: listas](#clase-28-almacenar-varios-valores-en-una-variable-listas) 37 | - [Clase 29 Entendiendo cómo funcionan las tuplas](#clase-29-entendiendo-cómo-funcionan-las-tuplas) 38 | - [Clase 30 Que son los diccionarios](#clase-30-que-son-los-diccionarios) 39 | - [Clase 31 Proyecto: generador de contraseñas](#clase-31-proyecto-generador-de-contraseñas) 40 | 41 | ## Modulo 1 Introduccion a la programacion con Python 42 | 43 | ### Clase 1 EL arte de la programacion 44 | 45 | Programar es darle instrucciones a la computadora para que realce un trabajo especifico. 46 | 47 | ### Clase 2 Por que Python 48 | 49 | Antes de elegir un nuevo lenguaje para aprender debemos pensar primero que queremos lograr o realizar (ciencia de datos, backend, frontend, desarrollo de videojuegos, desarrollo movil, iot, DevOps, etc). 50 | 51 | Python esta en todos lados (google, spotify, platzi, etc) 52 | 53 | Ventajas: 54 | 55 | - Fácil 56 | - Elegante 57 | - Buenas practicas 58 | - Mucha Información en Internet 59 | 60 | ### Clase 3 El núcleo de un programa: los algoritmos 61 | 62 | Algoritmo se define por tener estas caracteristicas: 63 | 64 | - Una serie de pasos para resolver un problema 65 | - Finito 66 | - No ambiguo 67 | 68 | Para profundizar leer [aquí](https://github.com/EliazBobadilla/Basicos-de-Algoritmos-y-Pensamiento-Logico.) 69 | 70 | ### Clase 4 Instalación de nuestras herramientas (en Windows) 71 | 72 | 1.- Instalacion del editor de código de tu elección. (VScode) 73 | 2.- Uso de terminal, el profesor utiliza cmder (me quedo con ubuntu) 74 | 3.- Instalacion de python 3 75 | 76 | ### Clase 5 Instalacion de nuestras herramientas en Mac 77 | 78 | Nota: Si usas una mac el proceso es el mismo para instalar cualquier programa, descarga e instala VScode y python3. 79 | 80 | ### Clase 6 Instalacion de nuestras herramientas en Ubuntu 81 | 82 | Nota: Si usas una distro de linux el proceso es el mismo para instalar cualquier programa, descarga e instala VScode y python3. 83 | 84 | ### Clase 7 Tu mejor herramienta: la consola 85 | 86 | Comandos básicos Unix 87 | 88 | 1.- control+L (Limpieza a la consola) 89 | 2.- mkdir mi_carpeta (Crear carpeta) 90 | 3.- ls (Listar archivos y directorios del directorio actual) 91 | 4.- cd mi_carpeta (Ingresar a la nueva carpeta) 92 | 93 | Para profundizar en comandos (si eres nuevo usuario) mira el curso de termina y linea de comandos en platzi. 94 | 95 | 96 | ## Modulo 2 Conceptos basicos de Python 97 | 98 | ### Clase 8 Explorando Python: operadores aritméticos 99 | 100 | Usando la consola interactiva de python realizamos lo siguiente 101 | 102 | ```py 103 | #Suma (+) 104 | >>> 5+5 105 | 5 106 | 107 | #Resta (-) 108 | >>> 5-5 109 | 0 110 | 111 | #Multiplicación (#) 112 | >>> 5*5 113 | 25 114 | 115 | #División (/) 116 | >>> 21/5 117 | 4.2 118 | 119 | #División entera (//), Esta nos trae el numero entero de la division 120 | >>> 21 // 5 121 | 4 122 | 123 | #Modulo (%), Este nos trae el residuo de la division 124 | >>> 21 % 5 125 | 1 126 | 127 | #Potencia (**) 128 | >>> 2 ** 2 129 | 4 130 | 131 | #Python respeta las reglas matemáticas que dice 132 | >>> 5 + 5 * 2 133 | 15 134 | ``` 135 | 136 | Python siempre sigue el orden de las operaciones aritméticas, ante la duda siempre recuerda PEMDAS. 137 | 138 | **P**aréntesis 139 | **E**xponentes 140 | **M**ultiplicación 141 | **D**ivisión 142 | **A**dición 143 | **S**ustracción. 144 | 145 | ### Clase 9 Que es una variable 146 | 147 | Una variable es una caja donde puedes guardar un objeto, cada variable tiene un identificador en memoria 148 | 149 | ```py 150 | >>> numero = 3 151 | >>> print(numero) 152 | 3 153 | >>> numero2 = 5 154 | >>> numero3 = numero + numero2 155 | >>> print(numero) 156 | 8 157 | ``` 158 | 159 | Reglas para variables 160 | 161 | - nunca iniciar con números o símbolos 162 | - usar minúsculas si solo es una palabra 163 | - usar camel_case si son varias palabras 164 | 165 | ### Clase 10 Los primitivos: tipos de datos sencillos 166 | 167 | En python todo es un objeto 168 | 169 | Los tipos de datos primitivos en python: 170 | 171 | - int: entero (3) 172 | - float: números con punto flotante (4.0) 173 | - str: cadenas de texto o strings ('hola mundo') 174 | - bool: booleano (1 o 0), (True o False) 175 | 176 | ### Clase 11 Convertir un dato a un tipo diferente 177 | 178 | En python podemos convertir a conveniencia los tipos de datos primitivos 179 | 180 | ```py 181 | #Convertir un dato a un tipo diferente 182 | >>> nombre_variable = input( “Ingresa texto”) 183 | >>> numero1 = input(“Escribe un numero:”) 184 | 185 | >>> print(numero1) 186 | '4’ 187 | 188 | >>> numero2 = input(“Escribe un numero”) 189 | >>> print(2) 190 | '5’ 191 | 192 | 193 | #Si sumas 194 | >>> print(numero + numero 2) 195 | '45’ 196 | 197 | #PARA CONVERTIRLO A NUMERO 198 | >>> numero1 = int(numero1) 199 | >>> numero2 = int(numero2) 200 | 201 | >>> print(numero1 + numero2) 202 | 9 203 | 204 | #CONVERTIR DE NUMERO A TEXTO 205 | str(numero1) 206 | '4' 207 | ``` 208 | 209 | ### Clase 12 Operadores logicos y de comparacion 210 | 211 | - **and** para comparar si dos valores son verdaderos. 212 | - **or** para comparar si dos valores son falsos. 213 | - **not** para invertir el valor booleano. 214 | - **==** Compara dos valores y te dice si son iguales o no. 215 | - **!=** Compara dos valores y te dice sin son diferentes o no. 216 | - **>** Compara si es mayor que otro valor. 217 | - **>** Compara si es menor que otro valor. 218 | - **>=** igual o mayor que el valor a comparar. 219 | - **<=** igual o menor que el valor a comparar 220 | 221 | Ejemplos de la clase en consola interactiva de python 222 | 223 | ```py 224 | >>> es_estudiante = True 225 | >>> es_estudiante 226 | True 227 | >>> trabaja = False 228 | >>> es_estudiante and trabaja 229 | False 230 | >>> es_estudiante or trabaja 231 | True 232 | >>> not trabaja 233 | True 234 | >>> 235 | >>> numero1 = 5 236 | >>> numero2 = 5 237 | >>> numero1 238 | 5 239 | >>> numero2 240 | 5 241 | >>> numero1 == numero2 242 | True 243 | >>> numero3 = 7 244 | >>> numero1 == numero3 245 | False 246 | >>> numero1 != numero3 247 | True 248 | >>> numero1 > numero3 249 | False 250 | >>> numero1 < numero3 251 | True 252 | >>> numero1 >= numero3 253 | False 254 | >>> numero1 >= numero2 255 | True 256 | >>> numero1 <= numero2 257 | True 258 | >>> numero1 <= numero3 259 | True 260 | >>> 261 | ``` 262 | 263 | ### Clase 13 Tu primer programa: conversor de monedas 264 | 265 | ```py 266 | # Convertir pesos a dolares 267 | pesos = input("¿Cuántos pesos tienes? ") 268 | pesos = float(pesos) 269 | valor_dolar = 22.03 270 | dolares = pesos / valor_dolar 271 | dolares = round(dolares, 2) 272 | dolares = str(dolares) 273 | 274 | print("Tienes $" + dolares + " dolares") 275 | 276 | 277 | 278 | # Convertir dolares a pesos 279 | dolares = input("¿Cuántos dolares tienes? ") 280 | dolares = float(dolares) 281 | valor_pesos = 22.03 282 | pesos = dolares * valor_dolar 283 | pesos = round(pesos, 2) 284 | pesos = str(pesos) 285 | 286 | print("Tienes $" + pesos + "pesos")``` 287 | ``` 288 | 289 | ## Modulo 3 Herramientas para programar 290 | 291 | ### Clase 14 Construyendo el camino de un programa con condicionales 292 | 293 | ```py 294 | # # Ejemplo 1 295 | # edad = int(input ("Escribe tu edad :")) 296 | # if edad > 17: 297 | # print("Eres mayor de edad") 298 | # else: 299 | # print("Eres menor de edad") 300 | 301 | # Ejemplo 2 302 | numero = int(input("Escribe un numero : ")) 303 | 304 | if numero > 5: 305 | print("Es mayor a 5") 306 | elif numero == 5: 307 | print("Es igual a 5") 308 | elif numero < 5: 309 | print("Es menor a 5") 310 | 311 | ``` 312 | 313 | ### Clase 15 Varios paises en mi conversor de monedas 314 | 315 | ```py 316 | # conversor de pesos a dolares 317 | 318 | menu = """ 319 | Bienvenido al conversor de monedas 320 | 321 | 1 - Pesos Colombianos 322 | 2 - Pesos Argentinos 323 | 3 - Pesos Mexicanos 324 | 325 | Elige una opción: """ 326 | 327 | opcion = int(input(menu)) 328 | 329 | if opcion == 1: 330 | pesos = input("¿Cantos pesos colombianos tienes?: ") 331 | pesos = float(pesos) 332 | valor_dolar = 3679 333 | dolares = pesos / valor_dolar 334 | dolares = round(dolares, 2) 335 | dolares = str(dolares) 336 | print("Tienes $" + dolares + " dólares") 337 | elif opcion == 2: 338 | pesos = input("¿Cantos pesos argentinos tienes?: ") 339 | pesos = float(pesos) 340 | valor_dolar = 65 341 | dolares = pesos / valor_dolar 342 | dolares = round(dolares, 2) 343 | dolares = str(dolares) 344 | print("Tienes $" + dolares + " dólares") 345 | elif opcion == 3: 346 | pesos = input("¿Cantos pesos argentinos tienes?: ") 347 | pesos = float(pesos) 348 | valor_dolar = 24 349 | dolares = pesos / valor_dolar 350 | dolares = round(dolares, 2) 351 | dolares = str(dolares) 352 | print("Tienes $" + dolares + " dólares") 353 | ``` 354 | 355 | ### Clase 16 Aprendiendo a no repetir codigo con funciones 356 | 357 | ```py 358 | # def imprimir_mensaje(): 359 | # print("Mensaje Especial : ") 360 | # print("¡Estoy aprendiendo a usar funciones!") 361 | 362 | # imprimir_mensaje() 363 | # imprimir_mensaje() 364 | # imprimir_mensaje() 365 | 366 | def conversacion(mensaje): 367 | print("Hola") 368 | print("Como estas") 369 | print(mensaje) 370 | print("a Dios!") 371 | 372 | 373 | 374 | opcion = int(input("Elije una opcion: (1,2,o 3) ")) 375 | if opcion == 1: 376 | conversacion("Elegiste la opcion 1") 377 | elif opcion == 2: 378 | conversacion("Elegiste la opcion 2") 379 | elif opcion == 3: 380 | conversacion("Elegiste la opcion 3") 381 | else: 382 | print("Escribe la opcion correcta") 383 | ``` 384 | 385 | ### Clase 17 Modularizando nuestro conversor de monedas 386 | 387 | Esta clase hace la introduccion del keyword return, retorna el valor de una funcion. 388 | 389 | ```py 390 | #Este programa convierte una cantidad de dolares a pesos mexicanos 391 | 392 | #Primero definimos nuestras funciones 393 | def conversor(tipo_pesos,valor_dolar): 394 | pesos = input("¿Cuantos pesos " + tipo_pesos + " convertirás? ") 395 | pesos = float(pesos) 396 | dolares = pesos / valor_dolar 397 | dolares = round(dolares,2) 398 | dolares = str(dolares) 399 | pesos = input("Tienes " + dolares + " dolares") 400 | 401 | 402 | # Pedimos al usuario la cantidad que solares a convertir 403 | menu = """ Bienvenido al conversor de monedas 💰 404 | 405 | 1 - Pesos colombianos 406 | 2 - Pesos argentinos 407 | 3 - Pesos mexicanos 408 | 409 | Elije una opciones : """ 410 | 411 | opcion = int(input(menu)) 412 | if opcion == 1: 413 | conversor("colimbianos",3875) 414 | elif opcion == 2: 415 | conversor("argentinos",65) 416 | elif opcion == 3: 417 | conversor("mexicanos",24) 418 | else: 419 | print("Opcion incorrecta, Gracias por participar") 420 | ``` 421 | 422 | ### Clase 18 Trabajando con texto: cadenas de caracteres 423 | 424 | **Método:** es una funcion especial para un tipo de dato en particular. 425 | 426 | ```py 427 | #METODOS: 428 | variable.upper() #Todos los caracteres en MAYÚSCULAS 429 | variable.capitalize() #solo la primera en MAYÚSCULA 430 | variable.lower() = 'todos los caracteres en minúscula' 431 | variable.strip() = #eliminar espacios basura del string al inicio y final 432 | variable.replace('caracter_a_cambiar', 'caracter_por_poner') #remplazar caracter 433 | 434 | #FUNCIONES BILT-IN 435 | aquellas que son propias del lenguaje y que no tenemos que crearlas, solo invocarlas. 436 | 437 | len() 438 | print() 439 | input() 440 | 441 | #Indices 442 | # Siempre podemos acceder a los caracteres de un string por su indice 443 | >>> nombre='rusbel' 444 | >>> nombre[0] 445 | 'r' 446 | 447 | >>> nombre[1] 448 | 'u' 449 | 450 | >>> nombre[2] 451 | 's' 452 | ``` 453 | 454 | ### Clase 19 Trabajando con texto: slices 455 | 456 | Los slices o rebanadas son una extension de los indices, usando el key ":" permite indicar a python del string dame la información desde el indice uno hasta el indice 10 [1:10], podemos agregar pasos para ir de dos en dos, dos en tres [1:10:2] o al revés [1:10:-1] 457 | 458 | ```py 459 | >>> nombre = "Francisco" 460 | >>> nombre 461 | 'Francisco' 462 | >>> nombre[0] 463 | 'F' 464 | >>> nombre[1] 465 | 'r' 466 | >>> nombre[0:3] 467 | 'Fra' 468 | >>> nombre[:3] 469 | 'Fra' 470 | >>> nombre[3:] 471 | 'ncisco' 472 | >>> nombre[1:7] 473 | 'rancis' 474 | >>> nombre[1:7:2] 475 | 'rni' 476 | >>> nombre[ :: ] 477 | 'Francisco' 478 | >>> nombre[1::3] 479 | 'rcc' 480 | >>> nombre[::-1] 481 | 'ocsicnarF' 482 | >>> 483 | ``` 484 | 485 | ### Clase 20 Proyecto: palindromo 486 | 487 | ```py 488 | def palindromo(palabra): 489 | palabra = palabra.lower() 490 | palabra = palabra.replace(' ', '') 491 | if palabra == palabra[::-1]: 492 | returnTrue 493 | else: 494 | returnFalse 495 | 496 | 497 | def run(): 498 | palabra = input("Por favor, ingresa una frase o palabra: ") 499 | if palindromo(palabra): 500 | print("Es un palíndromo") 501 | else: 502 | print("No es un palíndromo") 503 | 504 | 505 | if __name__ == '__main__': 506 | run() 507 | ``` 508 | 509 | `if __name__ == '__main__'` es el entry-point de los programas en python, si internamente el nombre de este programa es main, ejecuta el codigo debajo de este, los modulos de python (programas de python en carpetas llamados por el script principal) no tienen esta instrucción. 510 | 511 | ## Modulo 4 Bucles 512 | 513 | ### Clase 21 Aprendiendo bucles 514 | 515 | Un bucle es un ciclo continuo en todos los lenguajes de programacion, que nos permite iterar sobre nuestros pasos, imagina un contador cíclico (1,2,3,4,5,6...) donde puedes agregar un paso mas sobre tu programa principal. 516 | 517 | Un bucle de la vida real 518 | 519 | - Despertar 520 | - Estudiar en platzi 521 | - Comer 522 | - Dormir 523 | 524 | Cuando repetimos estas acciones en ese orden, durante un tiempo determinado o infinito estamos hablando de un bucle. 525 | 526 | ### Clase 22 El ciclo while 527 | 528 | ```py 529 | def run(): 530 | LIMITE = 1000000 531 | contador = 0 532 | potencia_2 = 2**contador 533 | while potencia_2 < LIMITE: 534 | print('2 elevado a ' + str(contador) + 535 | ' es igual a: ' + str(potencia_2)) 536 | contador = contador + 1 537 | potencia_2 = 2**contador 538 | 539 | if __name__ == "__main__": 540 | run() 541 | ``` 542 | 543 | ### Clase 23 Explorando un bucle diferente: el ciclo for 544 | 545 | ```py 546 | def imprimir_numero(inicio, fin): 547 | for inicio in range(fin+1): 548 | print(f'Numero: {inicio}') 549 | 550 | 551 | def imprimir_numero_while(inicio, fin): 552 | while inicio <= fin: 553 | print(f'Numero: {inicio}') 554 | inicio += 1 555 | 556 | def run(): 557 | 558 | 559 | while True: 560 | print('') 561 | print('*********************************************************') 562 | print('*******************N U M E R O S**********************') 563 | print('') 564 | inicio = int(input('Digite el número inicial para la secuencial: ')) 565 | print('') 566 | fin = int(input('Digite el número final para la secuencial: ')) 567 | print('') 568 | 569 | if inicio < fin: 570 | imprimir_numero(inicio,fin) 571 | else: 572 | print(f'El numero inicial {inicio} debe ser ser menor al numero final {fin}.') 573 | 574 | 575 | 576 | if __name__ == "__main__": 577 | run() 578 | ``` 579 | 580 | ### Clase 24 Recorriendo un string con for 581 | 582 | Ejemplo 1 583 | 584 | ```py 585 | def run(): 586 | ## Este ejemplo imprime cada caracter de tu nombre 587 | nombre = input("Escribe tu nombre :") 588 | for letra in nombre: 589 | print(letra) 590 | 591 | if __name__ == "__main__": 592 | run() 593 | 594 | ``` 595 | 596 | Ejemplo 2 597 | 598 | ```py 599 | def run(): 600 | frase = input("Escribe una frase : ") 601 | for caracter in frase: 602 | print(caracter.upper()) 603 | 604 | 605 | 606 | if __name__ == "__main__": 607 | run() 608 | 609 | ``` 610 | 611 | ### Clase 25 Interrumpiendo ciclos con break y continue 612 | 613 | Ejemplo1 614 | 615 | ```py 616 | def run(): 617 | for i in range(10000): 618 | print(i) 619 | if i == 5678: 620 | break 621 | 622 | if __name__ == '__main__': 623 | run() 624 | ``` 625 | 626 | ejemplo 2 627 | 628 | ```py 629 | def run(): 630 | for contador in range(1000): 631 | if contador % 2 != 0: 632 | continue 633 | print(contador) 634 | 635 | if __name__ == '__main__': 636 | run() 637 | ``` 638 | 639 | ejemplo 3 640 | 641 | ```py 642 | def run(): 643 | texto= input('Escribe un texto: ') 644 | for letra in texto: 645 | if letra == 'o': 646 | break 647 | print(letra) 648 | 649 | if __name__ == '__main__': 650 | run() 651 | ``` 652 | 653 | ### Clase 26 Proyecto: prueba de primalidad 654 | 655 | ```py 656 | def es_primo(numero): 657 | if numero == 1: 658 | return False 659 | else: 660 | contador = 0 661 | for i in range(1 , numero+1): 662 | if i == 1 or i == numero: 663 | continue 664 | if numero % i == 0: 665 | contador += 1 666 | if contador == 0: 667 | return True 668 | else: 669 | return False 670 | 671 | 672 | def run(): 673 | numero = int(input("Escribe un número: ")) 674 | if es_primo(numero): 675 | print(str(numero) + " es primo") 676 | else: 677 | print(str(numero) + " NO es primo") 678 | 679 | 680 | if __name__ == "__main__": 681 | run() 682 | ``` 683 | 684 | ### Clase 27 Proyecto: videojuego 685 | 686 | ```py 687 | import random 688 | 689 | def run(): 690 | numero_aleatorio = random.randint(1, 100) 691 | numero_elegido = int(input("Elije un numero del 1 al 100 :")) 692 | while numero_elegido != numero_aleatorio: 693 | if numero_elegido < numero_aleatorio: 694 | print("Busca un numero mas grande ") 695 | else: 696 | print("Busca un numero mas pequeño ") 697 | numero_elegido = int(input("Elije otro numero :")) 698 | print("Ganaste!") 699 | 700 | 701 | if __name__ == "__main__": 702 | run() 703 | ``` 704 | 705 | ## Modulo 5 Estructuras de datos 706 | 707 | ### Clase 28 Almacenar varios valores en una variable: listas 708 | 709 | Las listas pertenecen a las estructuras de datos en python, pueden almacenar distintos tipos de primitivos u otras estructuras de datos dentro de una misma lista 710 | 711 | ```py 712 | #declarar lista 713 | my_lista = [] 714 | my_lista = list() 715 | 716 | #unir listas 717 | my_lista = [1] 718 | my_lista2 = [2,3,4] 719 | my_lista3 = my_lista + my_lista2 720 | my_lista3 # [1,2,3,4] 721 | 722 | #partir listas como slices 723 | my_lista = [1,2,3] 724 | my_lista[1:] = [2,3] 725 | 726 | #extender una lista 727 | my_lista = [1] 728 | my_lista2 = [2,3,4] 729 | my_lista.extend(my_lista2) # [1,2,3,4] 730 | 731 | #multiplicar listas 732 | my_lista = ['a'] 733 | my_lista2 = my_lista * 5 734 | my_lista2 # ['a','a','a','a','a'] 735 | 736 | #eliminar ultimo elemento de la lista 737 | my_lista = [1,2,3,4,5] 738 | my_lista = my_lista.pop() 739 | my_lista # [1,2,3,4] 740 | 741 | #ordenar lista 742 | my_lista = [2,1,5,4,3] 743 | my_lista = my_lista.sort() 744 | my_lista # [1,2,3,4,5] 745 | 746 | #eliminar un elemento 747 | my_lista = [1,2,3,4,5] 748 | del my_lista[0] 749 | my_lista # [2,3,4,5] 750 | 751 | #eliminar si conocemos su valor 752 | my_lista = [1,2,3,4,5] 753 | my_lista.remove(3) 754 | my_lista #[1,2,4,5] 755 | 756 | #saber que metodos hay dentro de un elemento 757 | my_lista = [1,2,3,4,5] 758 | dir(my_lista) # ['__add__', '__class__', '__contains__', ... 759 | 760 | #modificar un elemento 761 | my_lista = [1,2,3,4,5] 762 | my_lista[0] = 100 763 | my_lista # [100,2,3,4,5] 764 | 765 | #añadir un elemento al final 766 | my_lista = [1,2,3,4,5] 767 | my_lista.append(6) 768 | my_lista # [1,2,3,4,5,6] 769 | 770 | #organizar una lista 771 | my_lista = [2,5,1,3,4] 772 | my_lista.sort() #[1,2,3,4,5] 773 | 774 | ``` 775 | 776 | ALgunos metodos adicionales 777 | 778 | ```py 779 | .sorted() # También ordena como sort() pero modifica la lista inicial 780 | .clear() # vaciá la lista 781 | .count() # Cuenta las veces que esta un elemento en lista 782 | .index() #--> Indica la posición donde esta un elemento de la lista 783 | .insert() #--> Inserta un elemento en una posición dada ej: lista.insert(posición,item) 784 | .reverse() #--> Le da la vuelta a una lista 785 | ``` 786 | 787 | ### Clase 29 Entendiendo cómo funcionan las tuplas 788 | 789 | Las tuplas son estructuras de datos inmutables es decir, no puedes modificar una tupla "a" agregando o quitando un valor, lo único que puedes hacer es definir de nuevo esa tupla "a". Los objetos inmutables (como los strings) son tipos de datos para python que apuntan a un lugar especifico en memoria y que su contenido no puede ser cambiado, al cambiar el contenido predefiniendo el contenido de la variable "a" entonces cambiara su posición en memoria. 790 | 791 | ```py 792 | #declarar tupla 793 | mi_tupla = () 794 | mi_tupla = (1,2,3) 795 | 796 | #generar una tupla de 1 solo valor (Obligatorio la ,) 797 | mi_tupla = (1,) 798 | 799 | #acceder a un indice de la tupla 800 | mi_tupla = (1,2,3) 801 | mi_tupla[0] #1 802 | mi_tupla[1] #2 803 | mi_tupla[2] #3 804 | 805 | #reasignar una tupla 806 | mi_tupla = (1,2,3) 807 | mi_otra_tupla = (4,5,6) 808 | mi_tupla =+ mi_otra_tupla 809 | 810 | #metodos de las tuplas 811 | mi_tupla = (1,1,1,2,2,3) 812 | mi_tupla.count(1) #3 el numero 1 aparece 3 veces en la tupla 813 | mi_tupla.index(3) #5 indice de la primera instancia donde se encuentra un elemento 814 | mi_tupla.index(1) #0 815 | mi_tupla.index(2) #3 816 | ``` 817 | 818 | ### Clase 30 Que son los diccionarios 819 | 820 | ```py 821 | # Definir función principal 822 | def run(): 823 | # Defino el diccionario, agrego los valores. 824 | mi_diccionario = { 825 | 'llave1' : 1, 826 | 'llave2' : 2, 827 | 'llave3' : 3, 828 | } 829 | 830 | 831 | # Imprimo las llaves del diccionario utilizando una bucle for 832 | # Con '.keys()' estoy llamando a imprimir las llaves, no los valores. 833 | for llave in mi_diccionario.keys(): 834 | print(llave) 835 | 836 | # Imprimo los valores del diccionario utilizando una bucle for 837 | # Con '.values()' estoy llamando a imprimir los valores. 838 | for valores in mi_diccionario.values(): 839 | print(valores) 840 | 841 | # Imprimir las llaves y los valores utilizando '.items()' 842 | # Para esto, coloco las variables llave e items 843 | for llave, items in mi_diccionario.items(): 844 | print("La llave: '" + llave + "' contiene el item: " + str(items)) 845 | 846 | 847 | if __name__ == '__main__': 848 | run() 849 | ``` 850 | 851 | ### Clase 31 Proyecto: generador de contraseñas 852 | 853 | ```py 854 | def generar_contrasena(): 855 | mayusculas = ["A","B","C","D","E","F","G","H"] 856 | minusculas = ["a","b","c","d","e","f","g","h"] 857 | simbolos = ["!","@","#","$","%","&","/"] 858 | numeros = ["1","2","3","4","5","6","7","8","9","0"] 859 | caracteres = mayusculas + minusculas + simbolos + numeros 860 | contrasena = [] 861 | for i in range(15): 862 | caranter_ramdom = random.choice(caracteres) 863 | contrasena.append(caranter_ramdom) 864 | # convertir una lista a string 865 | contrasena = "".join(contrasena) 866 | return contrasena 867 | 868 | def run(): 869 | contrasena = generar_contrasena() 870 | print("Tu nueva contraseña es: " + contrasena) 871 | 872 | 873 | if __name__ == "__main__": 874 | run() 875 | ``` --------------------------------------------------------------------------------