├── 00-ejercicios └── Ejercicio1.py ├── 01-holamundo ├── comentarios.py └── holamundo.py ├── 02-variables-y-tipos ├── curiosidades.py ├── tipos.py └── variables.py ├── 03-operadores ├── aritmeticos.py └── asignacion.py ├── 04-entrada-salida └── main.py ├── 05-condicionales └── main.py ├── 06-bucles ├── bucle_for.py └── bucle_while.py ├── 07-funciones ├── curiosidades.py ├── main.py ├── predefinidas.py └── variables.py ├── 08-listas ├── main.py └── metodos_predefinidos.py ├── 09-sets-diccionarios ├── diccionarios.py └── sets.py ├── 10-modulos ├── __pycache__ │ └── modulo.cpython-39.pyc ├── main.py └── modulo.py ├── 11-paquetes ├── main.py └── mipaquete │ ├── __init__.py │ ├── __pycache__ │ ├── __init__.cpython-39.pyc │ ├── herramientas.cpython-39.pyc │ └── pruebas.cpython-39.pyc │ ├── herramientas.py │ └── pruebas.py ├── 12-sistema-archivos ├── directorios.py ├── fichero_texto.txt └── ficheros.py ├── 13-manejo-errores └── main.py ├── 14-POO-clases └── main.py ├── 15-POO-constructor ├── __pycache__ │ └── coche.cpython-39.pyc ├── coche.py └── main.py ├── 16-POO-herencia ├── __pycache__ │ └── clases.cpython-39.pyc ├── clases.py └── main.py ├── 17-bases-datos ├── main.py ├── pruebas.db └── sqlite.py ├── 18-proyecto-python ├── basedatos.sql ├── main.py ├── notas │ ├── __init__.py │ ├── __pycache__ │ │ ├── __init__.cpython-39.pyc │ │ ├── acciones.cpython-39.pyc │ │ └── nota.cpython-39.pyc │ ├── acciones.py │ └── nota.py └── usuarios │ ├── __init__.py │ ├── __pycache__ │ ├── __init__.cpython-39.pyc │ ├── acciones.cpython-39.pyc │ ├── conexion.cpython-39.pyc │ └── usuario.cpython-39.pyc │ ├── acciones.py │ ├── conexion.py │ └── usuario.py ├── README.md └── image.png /00-ejercicios/Ejercicio1.py: -------------------------------------------------------------------------------- 1 | def multiplos_tres(): 2 | return [n for n in range(1, 91) if not n % 4] 3 | 4 | print(multiplos_tres()) -------------------------------------------------------------------------------- /01-holamundo/comentarios.py: -------------------------------------------------------------------------------- 1 | # Esto me mostrara el texto Hola por la consola 2 | print("Hola") 3 | print("Mundo") 4 | print("!!") -------------------------------------------------------------------------------- /01-holamundo/holamundo.py: -------------------------------------------------------------------------------- 1 | print("Hola Mundo") -------------------------------------------------------------------------------- /02-variables-y-tipos/curiosidades.py: -------------------------------------------------------------------------------- 1 | mi_texto = "Hola" 2 | mi_texto2 = "\"Mundo\"" 3 | 4 | texto_unido = mi_texto + " " + mi_texto2 5 | print(texto_unido) -------------------------------------------------------------------------------- /02-variables-y-tipos/tipos.py: -------------------------------------------------------------------------------- 1 | nada = None #indica vacio, no tiene nada 2 | cadena = "Hola" 3 | entero = 10 4 | flotante = 10.0 5 | booleano = True 6 | lista = [10,20,30,100,200] 7 | listaString = [44, "cuatro", 10] 8 | tuplaNoCambia = ("Master", "en", "Python") 9 | diccionario = { 10 | "nombre": " Miguel", 11 | "Apellido": "Hidalgo", 12 | "curso": "Master en python" 13 | } 14 | rango = range(9) 15 | dato_byte = b"probando" 16 | 17 | # imprimir variable 18 | print(nada) 19 | print(cadena) 20 | print(entero) 21 | print(flotante) 22 | print(booleano) 23 | print(lista) 24 | print(listaString) 25 | print(tuplaNoCambia) 26 | print(diccionario) 27 | print(rango) 28 | print(dato_byte) 29 | 30 | print("___________________________") 31 | # mostrar tipo de dato 32 | print(type(nada)) 33 | print(type(cadena)) 34 | print(type(entero)) 35 | print(type(flotante)) 36 | print(type(booleano)) 37 | print(type(lista)) 38 | print(type(listaString)) 39 | print(type(tuplaNoCambia)) 40 | print(type(diccionario)) 41 | print(type(rango)) 42 | print(type(dato_byte)) -------------------------------------------------------------------------------- /02-variables-y-tipos/variables.py: -------------------------------------------------------------------------------- 1 | """ 2 | Una variables es un contenedor de informacion 3 | que dentro guardara un dato, se pueden crear 4 | muchas variablesy que cada una tenga un dato distinto. 5 | """ 6 | 7 | # Crear variables y darles un valor 8 | texto = "Master en python" 9 | texto2 = "con Miguel Hidalgo" 10 | numero = 10 11 | decimal = 1.0 12 | 13 | #mostrar valor de las variables 14 | print(texto) 15 | print(texto2) 16 | print(numero) 17 | print(decimal) 18 | 19 | #cambiando valores de las variables 20 | numero = 77 21 | decimal = 2.0 22 | 23 | 24 | print("----------------------") 25 | 26 | # concatenacion 27 | nombre = "Miguel" 28 | apellido = "Hidalgo" 29 | print(nombre + " " + apellido) 30 | print(f"{nombre} {apellido}") 31 | print("Hola me llamo {} y mi apellido es {}".format(nombre, apellido)) 32 | 33 | 34 | print("----------------------") 35 | -------------------------------------------------------------------------------- /03-operadores/aritmeticos.py: -------------------------------------------------------------------------------- 1 | # Operadores aritmeticos 2 | numero1 = 77 3 | Numero2 = 44 # operador asignacion 4 | 5 | resta = numero1 - Numero2 6 | multiplicacion = numero1 * Numero2 7 | division = numero1 / Numero2 8 | residuo = numero1 % Numero2 9 | 10 | print("**************** Calculadora ****************") 11 | print(f"la suma es: {numero1 + Numero2}") 12 | print(f"la resta es: {resta}") 13 | print(f"La multiplicacion es: {multiplicacion}") 14 | print(f"La division es: {division}") 15 | print(f"El residuo de la division es: {residuo}") -------------------------------------------------------------------------------- /03-operadores/asignacion.py: -------------------------------------------------------------------------------- 1 | # Operadores de asignacion 2 | edad = 55 3 | print(edad) 4 | 5 | edad += 5 # edad = edad + 5 6 | edad -= 5 # edad = edad - 5 7 | print(edad) 8 | 9 | 10 | #Operadores incremento y decremento 11 | year = 2021 12 | 13 | # incremento 14 | year = year + 1 15 | print(year) 16 | 17 | # decremento 18 | year = year - 1 19 | print(year) 20 | -------------------------------------------------------------------------------- /04-entrada-salida/main.py: -------------------------------------------------------------------------------- 1 | # Entrada 2 | nombre = input("Introduce tu nombre: ") 3 | edad = input("¿Cual es tu edad? ") 4 | # Salida 5 | print(f"Tu nombre es: {nombre}") 6 | print(f"Tienes {edad} años de edad") -------------------------------------------------------------------------------- /05-condicionales/main.py: -------------------------------------------------------------------------------- 1 | """ 2 | # Condicional IF 3 | 4 | SI se_cumple_esta_condicion: 5 | Ejecutar grupo de instrucciones 6 | SI NO: 7 | Se ejecutan otro grupo de instrucciones 8 | 9 | if condicion: 10 | instrucciones 11 | else: 12 | otras instrucciones 13 | 14 | 15 | # Operadores de comparacion 16 | 17 | == igual 18 | != diferente 19 | < menor que 20 | > mayor que 21 | <= menor o igual que 22 | >= mayor o igual que 23 | 24 | # Operadores logicos 25 | 26 | and = y 27 | or = o 28 | ! = negacion 29 | not = no 30 | """ 31 | 32 | # Ejemplo 1 33 | print("################ EJEMPLO 1 ################") 34 | color = "negro" 35 | #color = input("Adivina mi color favorito: ") 36 | 37 | if color == "rojo": 38 | print("El color es ROJO") 39 | else: 40 | print("El color NO es CORRECTO") 41 | 42 | 43 | # Ejemplo 2 44 | print("################ EJEMPLO 2 ################") 45 | year = 2019 46 | #year = int(input("Introduce un año: ")) 47 | 48 | if year >= 2021: 49 | print("Estamos de 2021 en adelante") 50 | else: 51 | print("Es un año anterior a 2021") 52 | 53 | 54 | # Ejemplo 3 55 | print("################ EJEMPLO 3 ################") 56 | nombre = "Miguel Hidalgo" 57 | ciudad = "Panamá" 58 | continente = "America" 59 | edad = 17 60 | mayoria_edad = 18 61 | 62 | if edad >= mayoria_edad: 63 | print(f"{nombre} es mayor de edad !!") 64 | if continente != "America": 65 | print("El usuario no es Americano") 66 | else: 67 | print(f"Es Americano de {ciudad}") 68 | else: 69 | print(f"{nombre} NO es mayor de edad") 70 | 71 | 72 | # Ejemplo 4 73 | print("################ EJEMPLO 4 ################") 74 | dia = 1 75 | 76 | if dia == 1: 77 | print("Es Lunes") 78 | elif dia == 2: 79 | print("Es Martes") 80 | elif dia == 3: 81 | print("Es Miercoles") 82 | elif dia == 4: 83 | print("Es Jueves") 84 | elif dia == 5: 85 | print("Es Viernes") 86 | else: 87 | print("Es fin de semana") 88 | -------------------------------------------------------------------------------- /06-bucles/bucle_for.py: -------------------------------------------------------------------------------- 1 | """ 2 | # FOR 3 | 4 | for variable in elemento_iterable (lista, rango, etc) 5 | BLOQUE DE INSTRUCCIONES 6 | 7 | """ 8 | 9 | contador = 0 10 | for contador in range(0, 5): 11 | print(f"voy por el {contador}") 12 | 13 | 14 | -------------------------------------------------------------------------------- /06-bucles/bucle_while.py: -------------------------------------------------------------------------------- 1 | """ 2 | # WHILE 3 | Estructura de conttrol que itera la ejecucion de una serie de una 4 | Seria de instrucciones tantas veces como sea necesario, hasta que deje de cumplirse la condicion 5 | 6 | while condicion: 7 | bloque de instrucciones 8 | actualizacion de contador 9 | 10 | """ 11 | contador = 1 12 | muestrame = str(0) 13 | while contador <= 100: 14 | muestrame = muestrame + " , " + str(contador) 15 | contador+=1 16 | print(muestrame) -------------------------------------------------------------------------------- /07-funciones/curiosidades.py: -------------------------------------------------------------------------------- 1 | nombre = "Miguel" 2 | apellido = "Hidalgo" 3 | 4 | print("Hola Mundo") 5 | print(f"Bienvenido: {nombre}") -------------------------------------------------------------------------------- /07-funciones/main.py: -------------------------------------------------------------------------------- 1 | """ 2 | FUNCIONES: 3 | Una funcion es un conjunto de instrucciones agrupadas bajo un nombre concreto 4 | que pueden reutilizarse invocando a la funcion tantas veces como sea necesario. 5 | 6 | def nombre_de_funcion(parametros): 7 | # BLOQUE / INSTRUCCIONES 8 | 9 | nombre_defuncion(mi_parametro) 10 | 11 | 12 | 13 | # Ejemplo1 14 | def muestraNombres(): 15 | print("Miguel") 16 | print("Delvis") 17 | print("Oscar") 18 | print("Martin") 19 | print("Maruchan") 20 | print("\n") 21 | 22 | muestraNombres() 23 | 24 | 25 | # Ejemplo 2 - Parametros Opcionales 26 | print("###### Parametros Opcionales ######") 27 | 28 | def getempleado(nombre, dni = None): 29 | print("EMPLEADO") 30 | print(f"Nombre: {nombre}") 31 | if dni != None: 32 | print(f"DNI: {dni}") 33 | 34 | getempleado("Miguel Hidalgo") 35 | 36 | 37 | # Ejemplo 3 - Parametros Opcionales y return 38 | print("###### Return ######") 39 | def saludame(nombre): 40 | saludo = f"Hola, Saludos {nombre}" 41 | 42 | return saludo 43 | 44 | print(saludame("Miguel Hidalgo")) 45 | """ 46 | 47 | # Ejemplo 4 - Funciones lambda 48 | print("###### Funciones Lambda ######") 49 | dime_year = lambda year: f"El año es {year}" 50 | print(dime_year(2021)) 51 | -------------------------------------------------------------------------------- /07-funciones/predefinidas.py: -------------------------------------------------------------------------------- 1 | nombre = "MIguel Hidalgo" 2 | 3 | #* Funciones Generales 4 | print(type(nombre)) 5 | print("\n") 6 | 7 | #* Detectar el tipado 8 | comprobar = isinstance(nombre, str) 9 | if comprobar: 10 | print("La variables es un String") 11 | else: 12 | print("No es un String") 13 | print("\n") 14 | 15 | #* Limpiar espacios 16 | frase = " Hola " 17 | print(frase) 18 | print(frase.strip()) 19 | print("\n") 20 | 21 | #* Eliminar variables 22 | year = 2021 23 | print(year) 24 | del year 25 | print("\n") 26 | 27 | #* Comprobar variables vacia 28 | texto = " ff " 29 | if len(texto) <= 0: 30 | print("Variable vacia") 31 | else: 32 | print("La variable tiene contenido", len(texto)) 33 | print("\n") 34 | 35 | #* Encontrar caracteres 36 | frase = "La vida es bella" 37 | print(frase.find("vida")) 38 | print("\n") 39 | 40 | #* Reemplazar palabras en un string 41 | nueva_frase = frase.replace("bella", "hermosa") 42 | print(nueva_frase) 43 | print("\n") 44 | 45 | #* Mayusculas y Minusculas 46 | print(nombre) 47 | print(nombre.lower()) #? Minuscula 48 | print(nombre.upper()) #? Mayuscula -------------------------------------------------------------------------------- /07-funciones/variables.py: -------------------------------------------------------------------------------- 1 | """ 2 | * Variable Local: Se define dentro de la funcion, si quieres hacerla #!Global 3 | * Entonces usa la funcion "global" 4 | 5 | ? Variable Globales: Se declaran fuera de las funciones 6 | ? estan disponibles fuera y dentro de ellas. 7 | """ 8 | 9 | # *Variable Global 10 | frase = "Ni los genios son tan genios, ni los mediocres tan mediocres" 11 | 12 | def holaMundo(): 13 | frase = "Hola Mundo" #* Variable Local 14 | print(frase) 15 | -------------------------------------------------------------------------------- /08-listas/main.py: -------------------------------------------------------------------------------- 1 | peliculas = ["batman", "SpiderMan", "Coco"] 2 | cantantes = list(("2pac", "Drake", "Jennifer Lopez")) 3 | 4 | # Indices: 5 | print(peliculas) 6 | print(peliculas[1]) 7 | print(peliculas[1:3]) 8 | print(peliculas[2:]) 9 | 10 | # Añadir elementos a las listas: 11 | cantantes.append("BadBunny") 12 | print(cantantes) 13 | 14 | # recorrer lista: 15 | print("************** LISTADO PELICULAS****************") 16 | for pelicula in peliculas: 17 | print(pelicula) 18 | -------------------------------------------------------------------------------- /08-listas/metodos_predefinidos.py: -------------------------------------------------------------------------------- 1 | cantantes = ["2pac", "Drake", "Jennifer Lopez"] 2 | numeros = ["1", "0", "2"] 3 | 4 | # Ordenar: 5 | print(numeros) 6 | numeros.sort() 7 | print(numeros) 8 | 9 | # Añadir elementos: 10 | cantantes.append("BadBunny") 11 | print(cantantes) 12 | 13 | cantantes.insert(1,"Boza") 14 | print(cantantes) 15 | 16 | # eliminar elementos: 17 | cantantes.pop(1) 18 | print(cantantes) 19 | 20 | cantantes.remove("Drake") 21 | print(cantantes) 22 | 23 | # Dar la vuelta: 24 | numeros.reverse() 25 | print(numeros) 26 | 27 | # Buscar dentro de una lista: 28 | print("2pac" in cantantes) 29 | 30 | # contar elementos: 31 | print(len(cantantes)) 32 | 33 | # cuantas veces se repite un elemento: 34 | print(numeros.count("2")) 35 | 36 | # obtener indice: 37 | print(cantantes.index("2pac")) 38 | 39 | # Unir listas: 40 | cantantes.extend(numeros) 41 | print(cantantes) -------------------------------------------------------------------------------- /09-sets-diccionarios/diccionarios.py: -------------------------------------------------------------------------------- 1 | """ 2 | Diccionario: tipo de dato que almacena un conjunto 3 | de datps. en formato clase > valor. 4 | Es parecido a un array asociativo o un objeto json. 5 | 6 | """ 7 | 8 | persona = { 9 | "nombre": "Miguel De Jesus", 10 | "Apellidos": "Hidalgo Rodriguez", 11 | "web": "bytec.com" 12 | } 13 | 14 | print(type(persona)) 15 | print(persona) 16 | 17 | 18 | # lista con diccionarios 19 | contactos = [ 20 | { 21 | 'nombre': "Miguel", 22 | 'email': "miguel@miguel.com" 23 | }, 24 | { 25 | "nombre": "Juan", 26 | "email": "juan@juan.com" 27 | }, 28 | { 29 | "nombre": "salvador", 30 | "email": "salvador@salvador.com" 31 | } 32 | ] 33 | 34 | print(contactos[0]["nombre"]) 35 | 36 | print("\nlista de contactos:") 37 | print("--------------------------------------------------------") 38 | 39 | for contacto in contactos: 40 | print(f"Nombre de contacto: {contacto['nombre']}") #! importante solo se acepta las comillas simples. 41 | print(f"Email de contacto: {contacto['email']}") #! importante solo se acepta las comillas simples. 42 | print("--------------------------------------------------------") -------------------------------------------------------------------------------- /09-sets-diccionarios/sets.py: -------------------------------------------------------------------------------- 1 | """ 2 | SET: es un tipo de datos para tener una coleccion de valores, no tiene ni indice 3 | ni orden. 4 | """ 5 | 6 | persona = { 7 | "victor", 8 | "Manolo", 9 | "Francisco" 10 | } 11 | 12 | persona.add("Miguel") 13 | print(type(persona)) 14 | print(persona) -------------------------------------------------------------------------------- /10-modulos/__pycache__/modulo.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/10-modulos/__pycache__/modulo.cpython-39.pyc -------------------------------------------------------------------------------- /10-modulos/main.py: -------------------------------------------------------------------------------- 1 | """ 2 | Modulos: son funcionalidades ya hechas para reutilizar. 3 | en python hay muchos por defectos en: #* https://docs.python.org/3/py-modindex.html 4 | 5 | Podemos conseguir modulos que ya vienen en el lenguaje, modulos en internet y tambien 6 | podemos crear nuestros modulos. 7 | 8 | """ 9 | 10 | # importar mi propio modulo 11 | import modulo 12 | 13 | print(modulo.holamundo("Miguel")) 14 | print("-----------------------------------------------") 15 | 16 | 17 | # Modulo fechas 18 | import datetime 19 | print(datetime.date.today()) 20 | 21 | fecha_completa = datetime.datetime.now() 22 | print(fecha_completa) 23 | print(fecha_completa.year) 24 | print(fecha_completa.time()) 25 | 26 | fecha_personalizada = fecha_completa.strftime("%d/%m/%Y, %H:%M") #! formateando fecha 27 | print(f"Fecha Personalizada: {fecha_personalizada}") 28 | print("-----------------------------------------------") 29 | 30 | 31 | # Modulo de matematica 32 | import math 33 | 34 | print("Raiz Cuadrada de 10: ", math.sqrt(10)) 35 | print("NUmero PI: ", math.pi) 36 | print("Redondear: ", math.ceil(6.56789)) 37 | print("-----------------------------------------------") 38 | 39 | 40 | # Modulo Randon 41 | import random 42 | 43 | print(f"Numro Aleatorio 15 - 67: {random.randint(15, 67)}") 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /10-modulos/modulo.py: -------------------------------------------------------------------------------- 1 | def holamundo(nombre): 2 | return f"hola que tal estas {nombre}" 3 | -------------------------------------------------------------------------------- /11-paquetes/main.py: -------------------------------------------------------------------------------- 1 | print("Probando paquetes") 2 | 3 | from mipaquete import pruebas 4 | from mipaquete import herramientas 5 | 6 | pruebas.proobando() 7 | herramientas.NombreCompleto("Carlos", "Perez") 8 | -------------------------------------------------------------------------------- /11-paquetes/mipaquete/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/11-paquetes/mipaquete/__init__.py -------------------------------------------------------------------------------- /11-paquetes/mipaquete/__pycache__/__init__.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/11-paquetes/mipaquete/__pycache__/__init__.cpython-39.pyc -------------------------------------------------------------------------------- /11-paquetes/mipaquete/__pycache__/herramientas.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/11-paquetes/mipaquete/__pycache__/herramientas.cpython-39.pyc -------------------------------------------------------------------------------- /11-paquetes/mipaquete/__pycache__/pruebas.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/11-paquetes/mipaquete/__pycache__/pruebas.cpython-39.pyc -------------------------------------------------------------------------------- /11-paquetes/mipaquete/herramientas.py: -------------------------------------------------------------------------------- 1 | from queue import PriorityQueue 2 | 3 | 4 | def NombreCompleto(nombre, apellido): 5 | print(f"{nombre} {apellido}") -------------------------------------------------------------------------------- /11-paquetes/mipaquete/pruebas.py: -------------------------------------------------------------------------------- 1 | def proobando(): 2 | print("Esto es una prueba de un modulo de un paquete...") -------------------------------------------------------------------------------- /12-sistema-archivos/directorios.py: -------------------------------------------------------------------------------- 1 | import os, shutil 2 | 3 | # Crear carptea 4 | if not os.path.isdir("./12-sistema-archivos/mi_carpeta"): 5 | os.mkdir("./12-sistema-archivos/mi_carpeta") 6 | else: 7 | print("La carpeta ya existe") 8 | 9 | """ 10 | # Copiar 11 | ruta_original = "./12-sistema-archivos/mi_carpeta" 12 | ruta_nueva = "./12-sistema-archivos/mi_carpeta_copiada" 13 | 14 | shutil.copytree(ruta_original, ruta_nueva) 15 | """ 16 | 17 | 18 | # Eliminar 19 | """ 20 | os.rmdir("./12-sistema-archivos/mi_carpeta_copiada") 21 | """ -------------------------------------------------------------------------------- /12-sistema-archivos/fichero_texto.txt: -------------------------------------------------------------------------------- 1 | ****** Soy un texto usando python ******** 2 | ****** Soy un texto usando python ******** 3 | ****** Soy un texto usando python ******** 4 | ****** Soy un texto usando python ******** 5 | ****** Soy un texto usando python ******** 6 | ****** Soy un texto usando python ******** 7 | ****** Soy un texto usando python ******** 8 | ****** Soy un texto usando python ******** 9 | ****** Soy un texto usando python ******** 10 | -------------------------------------------------------------------------------- /12-sistema-archivos/ficheros.py: -------------------------------------------------------------------------------- 1 | from io import open 2 | import pathlib 3 | import shutil 4 | """ 5 | # Abrir archivo 6 | #ruta = str(pathlib.Path().absolute()) + "/fichero_texto.txt" 7 | #archivo = open(ruta, "a") 8 | 9 | # Escribir 10 | #archivo.write("****** Soy un texto usando python ********\n") 11 | 12 | # Cerrar archivo 13 | #archivo.close() 14 | 15 | # Abrir archivo 16 | ruta = str(pathlib.Path().absolute()) + "/fichero_texto.txt" 17 | archivo_lectura = open(ruta, "r") 18 | 19 | # Leer contenido 20 | #contenido = archivo_lectura.read() 21 | #print(contenido) 22 | 23 | # Leer contenido y guardarlo en lista 24 | lista = archivo_lectura.readlines() 25 | archivo_lectura.close() 26 | 27 | for elemento in lista: 28 | print(elemento) 29 | 30 | 31 | # Copiar archivos usando libreria shutil 32 | ruta_original = str(pathlib.Path().absolute()) + "/fichero_texto.txt" 33 | ruta_nueva = str(pathlib.Path().absolute()) + "/fichero_copiado.txt" 34 | #ruta_alternativa = "./01-holamundo/fichero_texto.txt" 35 | shutil.copyfile(ruta_original, ruta_nueva) 36 | 37 | 38 | # Mover archivo 39 | ruta_original = str(pathlib.Path().absolute()) + "/fichero_copiado.txt" 40 | ruta_nueva = str(pathlib.Path().absolute()) + "/fichero_copiado_NUEVO.txt" 41 | shutil.move(ruta_original, ruta_nueva) 42 | 43 | 44 | # Eliminar archivos 45 | import os 46 | ruta_nueva = str(pathlib.Path().absolute()) + "/fichero_copiado_NUEVO.txt" 47 | os.remove(ruta_nueva) 48 | """ 49 | 50 | # Comprobar si un archivo existe 51 | import os.path 52 | #print(os.path.abspath("./")) 53 | ruta_comprobar = os.path.abspath("./") + "/fichero_texto.txt" 54 | 55 | if os.path.isfile(ruta_comprobar): 56 | print("El archivo existe") 57 | else: 58 | print("El archivo no existe") 59 | -------------------------------------------------------------------------------- /13-manejo-errores/main.py: -------------------------------------------------------------------------------- 1 | # capturar excepciones y manejar errores en código 2 | # suscrptible a fallos/errores 3 | 4 | """ 5 | try: 6 | nombre = input("¿Cual es tu nombre?: ") 7 | 8 | if len(nombre) > 1: 9 | nombre_user = f"el nombre es {nombre}" 10 | 11 | print(nombre_user) 12 | 13 | except: 14 | print("Ha ocurrido un error, coloca un nombre...") 15 | else: 16 | print("Todo ha funcionado correctamente...") 17 | finally: 18 | print("fin de la iteracion try...") 19 | 20 | """ 21 | 22 | 23 | # Manejar multiples excepciones 24 | 25 | """try: 26 | numero = int(input("Numero para elevarlo al cuadrado: ")) 27 | print(f"el cuadrado es: {str(numero*numero)}") 28 | 29 | except TypeError: 30 | print("Debes convertir tus cadenas a enteros...") 31 | #except ValueError: 32 | #print("Introduce un numero o valor correcto...") 33 | except Exception as e: 34 | 35 | print(f"Ha ocurrido un error: {type(e).__name__}") 36 | 37 | """ 38 | 39 | # Excepciones personalizadas o Lanzar excepcion 40 | 41 | try: 42 | nombre = input("¿Cual es tu nombre?: ") 43 | edad = int(input("Introduce tu edad: ")) 44 | 45 | if edad < 5 or edad > 110: 46 | raise ValueError(" La edad introducida no es real") 47 | 48 | elif len(nombre) <= 1: 49 | raise ValueError("El Nombre no esta completo") 50 | 51 | else: 52 | print(f"Bienvenido {nombre}") 53 | 54 | except ValueError: 55 | print("Introduce los datos correctamente...") 56 | 57 | -------------------------------------------------------------------------------- /14-POO-clases/main.py: -------------------------------------------------------------------------------- 1 | # programacion orientada a objetos (POO o OOP) 2 | 3 | # Definir una clase (molde para crear mas objetos de ese tipo 4 | # (Coche) con caracteristicas similares). 5 | 6 | class Coche: 7 | 8 | # Atributos o propiedades (variables) 9 | # Caracteristicas del coche 10 | color = "rojo" 11 | marca = "Honda" 12 | modelo = "CRV" 13 | velocidad = 230 14 | caballaje = 140 15 | asientos = 5 16 | 17 | # Metodos, son acciones que hace el objeto (coche) (son funciones) 18 | def acelerar(self): 19 | self.velocidad += 1 20 | 21 | def frenar(self): 22 | self.velocidad -= 1 23 | 24 | def setcolor(self, color): 25 | self.color = color 26 | 27 | def setmodelo(self, modelo): 28 | self.modelo = modelo 29 | 30 | def getmodelo(self): 31 | return self.modelo 32 | 33 | def getcolor(self): 34 | return self.color 35 | 36 | def getvelocidad(self): 37 | return self.velocidad 38 | 39 | # fin definicion clase 40 | 41 | # Crear objetos o instanciar la clase 42 | 43 | coche = Coche() 44 | print(f"COCHE 1:") 45 | 46 | coche.setcolor("amarillo") 47 | coche.setmodelo("HRV") 48 | 49 | print(coche.marca, coche.getmodelo() ,coche.getcolor()) 50 | print(f"velocidad actual: {coche.getvelocidad()}") 51 | 52 | coche.acelerar() 53 | print(f"velocidad nueva actual: {coche.getvelocidad()}") 54 | 55 | coche.frenar() 56 | print(f"velocidad nueva actual: {coche.getvelocidad()}") 57 | 58 | print("--------------------------------------------") 59 | # Crear mas objetos 60 | coche2 = Coche() 61 | print(f"COCHE 2:") 62 | 63 | coche2.setcolor("verde") 64 | coche2.setmodelo("CIVIC") 65 | 66 | print(coche2.marca, coche2.getmodelo() ,coche2.getcolor()) 67 | 68 | -------------------------------------------------------------------------------- /15-POO-constructor/__pycache__/coche.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/15-POO-constructor/__pycache__/coche.cpython-39.pyc -------------------------------------------------------------------------------- /15-POO-constructor/coche.py: -------------------------------------------------------------------------------- 1 | # Definir una clase (molde para crear mas objetos de ese tipo 2 | # (Coche) con caracteristicas similares). 3 | 4 | from operator import mod 5 | from statistics import mode 6 | 7 | 8 | class Coche: 9 | 10 | # Atributos o propiedades (variables) 11 | # Caracteristicas del coche 12 | color = "rojo" 13 | marca = "Honda" 14 | modelo = "CRV" 15 | velocidad = 230 16 | caballaje = 140 17 | asientos = 5 18 | 19 | soy_publico = "Hola soy un atributo publico" 20 | __soy_privado = "Hola soy un atributo privado" 21 | 22 | def __init__(self, color, marca, modelo, velocidad, caballaje, asientos): #! Así se define un constructor! 23 | self.color = color 24 | self.marca = marca 25 | self.modelo = modelo 26 | self.velocidad = velocidad 27 | self.caballaje = caballaje 28 | self.asientos = asientos 29 | 30 | # Metodos, son acciones que hace el objeto (coche) (son funciones) 31 | def acelerar(self): 32 | self.velocidad += 1 33 | 34 | def frenar(self): 35 | self.velocidad -= 1 36 | 37 | def setcolor(self, color): 38 | self.color = color 39 | 40 | def setmodelo(self, modelo): 41 | self.modelo = modelo 42 | 43 | def setmarca(self, marca): 44 | self.marca = marca 45 | 46 | def getmarca(self): 47 | return self.marca 48 | 49 | def getmodelo(self): 50 | return self.modelo 51 | 52 | def getcolor(self): 53 | return self.color 54 | 55 | def getvelocidad(self): 56 | return self.velocidad 57 | 58 | def getprivado(self): 59 | return self.__soy_privado 60 | 61 | def getInfo(self): 62 | info = "--- Informacion del coche ---" 63 | info += f"\n Color: { self.getcolor()}" 64 | info += f"\n Marca: {self.getmarca()}" 65 | info += f"\n Modelo: {self.getmodelo()}" 66 | info += f"\n Velocidad: {self.getvelocidad()}" 67 | return info 68 | 69 | 70 | 71 | # fin definicion clase -------------------------------------------------------------------------------- /15-POO-constructor/main.py: -------------------------------------------------------------------------------- 1 | from coche import Coche 2 | 3 | carro = Coche("amarillo", "toyota", "Hilux", 200, 290, 5) 4 | carro1 = Coche("blanco", "toyota", "Hilux", 200, 280, 5) 5 | carro2 = Coche("verde", "toyota", "Hilux", 200, 240, 5) 6 | carro3 = Coche("negro", "toyota", "Hilux", 200, 275, 5) 7 | 8 | print(carro.getInfo()) 9 | print(carro1.getInfo()) 10 | print(carro2.getInfo()) 11 | print(carro3.getInfo()) 12 | 13 | # Detectar tipado 14 | if type(carro3) == Coche: 15 | print("Es un objeto correcto...") 16 | else: 17 | print("No es un objeto") 18 | 19 | # visibilidad (atributos publcios o privados) 20 | print(f"-----------------------") 21 | print(carro.soy_publico) 22 | print(carro.getprivado()) -------------------------------------------------------------------------------- /16-POO-herencia/__pycache__/clases.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/16-POO-herencia/__pycache__/clases.cpython-39.pyc -------------------------------------------------------------------------------- /16-POO-herencia/clases.py: -------------------------------------------------------------------------------- 1 | # HERENCIA: Es la posibilidad de compartir atributos y metodos entre clases 2 | # y que diferentes clases hereden de otras. 3 | 4 | class persona: 5 | """ 6 | nombres 7 | apellidos 8 | altura 9 | edad 10 | """ 11 | 12 | # Setter y getter 13 | def getnombre(self): 14 | return self.nombre 15 | 16 | def getapellido(self): 17 | return self.apellido 18 | 19 | def getaltura(self): 20 | return self.altura 21 | 22 | def getedad(self): 23 | return self.edad 24 | 25 | def setnombre(self, nombre): 26 | self.nombre = nombre 27 | 28 | def setapellido(self, apellido): 29 | self.apellido = apellido 30 | 31 | def setaltura(self, altura): 32 | self.altura = altura 33 | 34 | def setedad(self, edad): 35 | self.edad = edad 36 | 37 | # Metodos o funciones de persona 38 | def hablar(self): 39 | return "Estoy hablando..." 40 | 41 | def caminar(self): 42 | return "Estoy caminando..." 43 | 44 | def dormir(self): 45 | return "Estoy durmiendo..." 46 | 47 | class Informatico(persona): 48 | """ 49 | Lenguajes 50 | experiencia 51 | """ 52 | def __init__(self): 53 | self.lenguajes = "Go, C++, JS, Python" 54 | self.experiencia = 5 55 | 56 | def getlenguajes(self): 57 | return self.lenguajes 58 | 59 | def aprender(self, lenguajes): 60 | self.lenguajes = lenguajes 61 | return self.lenguajes 62 | 63 | def programar(self): 64 | return "estoy programando" 65 | 66 | def repararPC(self): 67 | return "He reparado tu ordenador..." 68 | 69 | class tecnicoRedes(Informatico): 70 | 71 | def __init__(self): 72 | super().__init__() #! Esta linea llama al constructor de la clase padre informatico, para usar sus atributos. 73 | self.auditarRedes = "Experto" 74 | self.experienciaRedes = 15 75 | 76 | def auditar(self): 77 | return "Estoy auditando una red..." 78 | -------------------------------------------------------------------------------- /16-POO-herencia/main.py: -------------------------------------------------------------------------------- 1 | import clases 2 | 3 | persona = clases.persona() 4 | persona.setnombre("Miguel") 5 | persona.setapellido("Rodriguez") 6 | persona.setaltura("175cm") 7 | persona.setedad("22 años") 8 | 9 | print(f"La persona es: {persona.getnombre()} {persona.getapellido()}") 10 | print(persona.hablar()) 11 | 12 | print(f"-------------------------------------") 13 | 14 | informatico = clases.Informatico() 15 | informatico.setnombre("Carlos") 16 | informatico.setapellido("Martinez") 17 | print(f"El informatico es: {informatico.getnombre()} {informatico.getapellido()} ") 18 | print(informatico.getlenguajes()) 19 | print(informatico.experiencia) 20 | 21 | print(f"-------------------------------------") 22 | 23 | tecnico = clases.tecnicoRedes() 24 | tecnico.setnombre("Manolo") 25 | print(tecnico.auditarRedes, tecnico.getnombre(), tecnico.getlenguajes()) 26 | 27 | print(f"-------------------------------------") 28 | 29 | -------------------------------------------------------------------------------- /17-bases-datos/main.py: -------------------------------------------------------------------------------- 1 | import mysql.connector 2 | 3 | 4 | # Conexion 5 | database = mysql.connector.connect( 6 | host="localhost", 7 | user="root", 8 | passwd="", 9 | database="master_python" 10 | ) 11 | 12 | # ¿La conexion ha sido correcta? 13 | #print(database) #! 14 | 15 | 16 | # Crear cursos para generar consultas o Queries 17 | cursor = database.cursor() 18 | 19 | # Crear base de datos 20 | cursor.execute("CREATE DATABASE IF NOT EXISTS master_python") 21 | 22 | """ 23 | # Ver base de datos 24 | cursor.execute("SHOW DATABASES") 25 | for db in cursor: 26 | print(db) 27 | 28 | """ 29 | 30 | #Crear tablas 31 | cursor.execute(""" 32 | CREATE TABLE IF NOT EXISTS vehiculos( 33 | id int(10) auto_increment not null, 34 | marca varchar(40) not null, 35 | modelo varchar(40) not null, 36 | precio float(10,2) not null, 37 | CONSTRAINT pk_vehiculo PRIMARY KEY(id) 38 | ) 39 | """) 40 | """ 41 | cursor.execute("SHOW TABLES") 42 | for table in cursor: 43 | print(table) 44 | 45 | """ 46 | 47 | 48 | # Insertat datos 49 | #cursor.execute("INSERT INTO vehiculos VALUES(null, 'Opel', 'Astra', 18500)") 50 | #database.commit() 51 | 52 | # Insertar datos masivos 53 | """ 54 | coches = [ 55 | ('seat', 'Ibiza', '5000'), 56 | ('Toyota', 'Hilux', '29000'), 57 | ('Honda', 'CRV', '30000'), 58 | ('Nissan', 'L200', '27000'), 59 | ] 60 | cursor.executemany("INSERT INTO vehiculos VALUES(null,%s, %s, %s)", coches) 61 | database.commit() 62 | 63 | """ 64 | 65 | # Sacar informacion de la base de datos 66 | cursor.execute("SELECT * FROM vehiculos") 67 | resultado = cursor.fetchall() 68 | 69 | print("---- Todos los coches ----") 70 | for coche in resultado: 71 | print(coche) 72 | 73 | # Borrar datos 74 | cursor.execute("DELETE FROM vehiculos WHERE marca = 'Opel'") 75 | database.commit() 76 | print(cursor.rowcount, "borrados!!") 77 | 78 | # Actualizar datos 79 | cursor.execute("UPDATE vehiculos SET modelo='L200 X' WHERE marca='Nissan'") 80 | database.commit() 81 | print(cursor.rowcount, "Actualizado!!") 82 | 83 | 84 | database.close() 85 | -------------------------------------------------------------------------------- /17-bases-datos/pruebas.db: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/17-bases-datos/pruebas.db -------------------------------------------------------------------------------- /17-bases-datos/sqlite.py: -------------------------------------------------------------------------------- 1 | # Importar modulo 2 | import sqlite3 3 | 4 | 5 | # Conexion 6 | conexion = sqlite3.connect('./17-bases-datos/pruebas.db') 7 | 8 | 9 | # Crear cursor 10 | cursor = conexion.cursor() #! el cursor me permite ejecutar consultas 11 | 12 | 13 | # Crear tabla #! execute me permite ejecutar consultas 14 | cursor.execute(""" 15 | CREATE TABLE IF NOT EXISTS productos( 16 | id INTEGER PRIMARY KEY AUTOINCREMENT, 17 | titulo VARCHAR(255), 18 | descripcion TEXT, 19 | precio int(255) 20 | ); 21 | """) 22 | 23 | 24 | # Guardar cambios 25 | conexion.commit() #! commit me permite guardar-actualizar cambios 26 | 27 | 28 | # Insertat datos 29 | #cursor.execute("INSERT INTO productos VALUES (null, 'primer producto', 'descripcion de mi producto', 550)") 30 | #conexion.commit() #! commit me permite guardar-actualizar cambios 31 | 32 | 33 | # Borrar datos 34 | #cursor.execute("DELETE FROM productos") 35 | #conexion.commit() 36 | 37 | 38 | # Insertat muchos registros 39 | productos = [ 40 | ("Ordenador Portatil", "Buen PC", 700), 41 | ("telefono movil", "Buen telefono", 100), 42 | ("Motherboard", "Buena motherboard", 200), 43 | ("tablet", "Buena tablet", 400), 44 | ] 45 | #cursor.executemany("INSERT INTO productos VALUES (null,?,?,?)", productos) 46 | #conexion.commit() 47 | 48 | 49 | # Update 50 | cursor.execute("UPDATE productos SET precio=300 WHERE precio=400") #! UPDATE para actualizar un campo 51 | 52 | 53 | # Listar o leer datos 54 | cursor.execute("SELECT * FROM productos WHERE precio >= 300;") 55 | productos = cursor.fetchall() 56 | 57 | for producto in productos: 58 | print(producto) #! se puede acceder al campo especifico como una lista 59 | 60 | 61 | # Cerrar conexion 62 | conexion.close() -------------------------------------------------------------------------------- /18-proyecto-python/basedatos.sql: -------------------------------------------------------------------------------- 1 | CREATE DATABASE IF NOT EXISTS master_python; 2 | USE master_python; 3 | 4 | CREATE TABLE usuarios( 5 | id INT(25) AUTO_INCREMENT NOT NULL, 6 | nombre VARCHAR(100), 7 | apellidos VARCHAR(255), 8 | email VARCHAR(255) NOT NULL, 9 | password VARCHAR(255) NOT NULL, 10 | fecha DATE NOT NULL, 11 | CONSTRAINT pk_usuarios PRIMARY KEY(id), 12 | CONSTRAINT uq_email UNIQUE(email) 13 | )ENGINE=InooDb; 14 | 15 | CREATE TABLE notas( 16 | id INT(25) AUTO_INCREMENT NOT NULL, 17 | usuario_id INT(25) NOT NULL, 18 | titulo VARCHAR(255) NOT NULL, 19 | descripcion MEDIUMTEXT, 20 | fecha DATE NOT NULL, 21 | CONSTRAINT pk_notas PRIMARY KEY(id) 22 | CONSTRAINT fk_usuario FOREIGN KEY(usuario_id) REFERENCES usuarios(id) 23 | )ENGINE=InooDb; -------------------------------------------------------------------------------- /18-proyecto-python/main.py: -------------------------------------------------------------------------------- 1 | """ 2 | Proyecto Python y MySQL: 3 | 4 | - Abrir asistente 5 | - Login o registro 6 | - Si elegimos registro, creará un usuario en la base de datos 7 | - Si elegimos login, identifica al usuario y nos preguntará 8 | - Crear nota, mostrar nota, borrar nota. 9 | 10 | """ 11 | 12 | from usuarios import acciones 13 | 14 | 15 | print(""" 16 | Acciones disponibles: 17 | - Registro 18 | - Logins 19 | """) 20 | 21 | hazEl = acciones.Acciones() 22 | accion = input(f"¿Qué quieres hacer?: ") 23 | 24 | if accion == "registro": 25 | # Agregar accion registro de la clase Acciones() 26 | hazEl.registro() 27 | 28 | elif accion == "login": 29 | # Agregar la accion login de la clase Acciones() 30 | hazEl.login() -------------------------------------------------------------------------------- /18-proyecto-python/notas/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/18-proyecto-python/notas/__init__.py -------------------------------------------------------------------------------- /18-proyecto-python/notas/__pycache__/__init__.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/18-proyecto-python/notas/__pycache__/__init__.cpython-39.pyc -------------------------------------------------------------------------------- /18-proyecto-python/notas/__pycache__/acciones.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/18-proyecto-python/notas/__pycache__/acciones.cpython-39.pyc -------------------------------------------------------------------------------- /18-proyecto-python/notas/__pycache__/nota.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/18-proyecto-python/notas/__pycache__/nota.cpython-39.pyc -------------------------------------------------------------------------------- /18-proyecto-python/notas/acciones.py: -------------------------------------------------------------------------------- 1 | import notas.nota as modelo 2 | 3 | class Acciones: 4 | 5 | def crear(self, usuario): 6 | print(f"\nOk {usuario[1]}!! Vamos a crear una nueva nota...") 7 | titulo = input("Introduce el titulo de tu nota: ") 8 | descripcion = input("Mete el contenido de tu nota: ") 9 | 10 | nota = modelo.Nota(usuario[0], titulo, descripcion) 11 | guardar = nota.guardar() 12 | 13 | if guardar[0] >= 1: 14 | print(f"\nPerfecto has guardado la nota: {nota.titulo}") 15 | 16 | else: 17 | print(f"No se ha guardado la nota, lo siento {usuario[1]}") 18 | 19 | def mostrar(self, usuario): 20 | print(f"Vale {usuario[1]}!! Aquí tienes tus notas: ") 21 | 22 | nota = modelo.Nota(usuario[0], "", "") 23 | notas = nota.listar() 24 | 25 | for nota in notas: 26 | print("\n---------------------------------------------") 27 | print(nota[2]) 28 | print(nota[3]) 29 | 30 | def borrar(self, usuario): 31 | print(f"\nOk {usuario[1]}!! Vamos a borrar notas") 32 | 33 | titulo = input("Introduce el titulo de la nota a borrar: ") 34 | 35 | nota = modelo.Nota(usuario[0], titulo, "") 36 | eliminar = nota.eliminar() 37 | 38 | if eliminar[0] >= 1: 39 | print(f"\nHemos borrado la nota {nota.titulo}") 40 | 41 | else: 42 | print("\nNo se ha borrado la nota prueba luego...") -------------------------------------------------------------------------------- /18-proyecto-python/notas/nota.py: -------------------------------------------------------------------------------- 1 | import usuarios.conexion as conexion 2 | 3 | connect = conexion.conectar() 4 | database = connect[0] 5 | cursor = connect[1] 6 | 7 | class Nota: 8 | 9 | def __init__(self, usuario_id, titulo, descripcion): 10 | self.usuario_id = usuario_id 11 | self.titulo = titulo 12 | self.descripcion = descripcion 13 | 14 | def guardar(self): 15 | sql = "INSERT INTO notas VALUES(NULL, %s, %s, %s, NOW())" 16 | nota = (self.usuario_id, self.titulo, self.descripcion) 17 | 18 | cursor.execute(sql, nota) 19 | database.commit() 20 | 21 | return [cursor.rowcount, self] 22 | 23 | def listar(self): 24 | sql = f"SELECT * FROM notas WHERE usuario_id = {self.usuario_id}" 25 | 26 | cursor.execute(sql) 27 | result = cursor.fetchall() 28 | 29 | return result 30 | 31 | def eliminar(self): 32 | sql = f"DELETE FROM notas WHERE usuario_id = {self.usuario_id} AND titulo LIKE '%{self.titulo}%' " 33 | 34 | cursor.execute(sql) 35 | database.commit() 36 | 37 | return [cursor.rowcount, self] -------------------------------------------------------------------------------- /18-proyecto-python/usuarios/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/18-proyecto-python/usuarios/__init__.py -------------------------------------------------------------------------------- /18-proyecto-python/usuarios/__pycache__/__init__.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/18-proyecto-python/usuarios/__pycache__/__init__.cpython-39.pyc -------------------------------------------------------------------------------- /18-proyecto-python/usuarios/__pycache__/acciones.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/18-proyecto-python/usuarios/__pycache__/acciones.cpython-39.pyc -------------------------------------------------------------------------------- /18-proyecto-python/usuarios/__pycache__/conexion.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/18-proyecto-python/usuarios/__pycache__/conexion.cpython-39.pyc -------------------------------------------------------------------------------- /18-proyecto-python/usuarios/__pycache__/usuario.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/18-proyecto-python/usuarios/__pycache__/usuario.cpython-39.pyc -------------------------------------------------------------------------------- /18-proyecto-python/usuarios/acciones.py: -------------------------------------------------------------------------------- 1 | import usuarios.usuario as modelo 2 | import notas.acciones 3 | 4 | class Acciones: 5 | 6 | def registro(self): 7 | 8 | print(f"Ok!! vamos a registrarte en el sistema...") 9 | 10 | nombre = input("¿Cual es tu nombre?: ") 11 | apellidos = input("¿Cuales son tus apellidos?: ") 12 | email = input("Introduce tu email: ") 13 | password = input("Introduce tu contraseña: ") 14 | 15 | # Le enviamos a la clase Usuario() los datos de los atributos. 16 | usuario = modelo.Usuario(nombre, apellidos, email, password) 17 | registro = usuario.registrar() 18 | 19 | if registro[0] >= 1: 20 | #print(registro[0]) 21 | print(f"\nPerfecto {registro[1].nombre} te has registrado con el email {registro[1].email}") 22 | else: 23 | print("\nNo te has registrado correctamente!!!") 24 | 25 | 26 | def login(self): 27 | 28 | print(f"Ok!! Identificate en el sistema...") 29 | 30 | try: 31 | email = input("Introduce tu email: ") 32 | password = input("Introduce tu contraseña: ") 33 | 34 | usuario = modelo.Usuario('', '', email, password) 35 | login = usuario.identificar() 36 | 37 | if email == login[3]: 38 | print(f"Bienvenido {login[1]}, te has registrado en el sistema el {login[5]}\n") 39 | self.proximasAcciones(login) 40 | 41 | except Exception as e: 42 | #print(type(e)) 43 | #print(type(e).__name__) 44 | print(f"Email ó Contraseña incorrectos...") 45 | 46 | def proximasAcciones(self, usuario): 47 | print(""" 48 | Acciones disponibles: 49 | - Crear nota (crear) 50 | - Mostrar tus notas (mostrar) 51 | - Eliminar nota (eliminar) 52 | - Salir (salir) 53 | """) 54 | 55 | accion = input("¿Que quieres hacer?: ") 56 | hazEl = notas.acciones.Acciones() 57 | 58 | if accion == "crear": 59 | hazEl.crear(usuario) 60 | self.proximasAcciones(usuario) 61 | 62 | elif accion == "mostrar": 63 | hazEl.mostrar(usuario) 64 | self.proximasAcciones(usuario) 65 | 66 | elif accion == "eliminar": 67 | hazEl.borrar(usuario) 68 | self.proximasAcciones(usuario) 69 | 70 | elif accion == "salir": 71 | print(f"Hasta pronto {usuario[1]}") 72 | exit() 73 | 74 | return None 75 | -------------------------------------------------------------------------------- /18-proyecto-python/usuarios/conexion.py: -------------------------------------------------------------------------------- 1 | from sqlite3 import Cursor 2 | import mysql.connector 3 | 4 | 5 | def conectar(): 6 | database = mysql.connector.connect( 7 | host="localhost", 8 | user="root", 9 | passwd="", 10 | database="master_python", 11 | port=3306 12 | ) 13 | 14 | cursor = database.cursor(buffered=True) 15 | 16 | return [database, cursor] # El return devuelve una lista. 17 | -------------------------------------------------------------------------------- /18-proyecto-python/usuarios/usuario.py: -------------------------------------------------------------------------------- 1 | import datetime 2 | import hashlib 3 | import usuarios.conexion as conexion 4 | 5 | connect = conexion.conectar() 6 | database = connect[0] 7 | cursor = connect[1] 8 | 9 | class Usuario: 10 | 11 | def __init__(self, nombre, apellidos, email, password): 12 | 13 | self.nombre = nombre 14 | self.apellidos = apellidos 15 | self.email = email 16 | self.password = password 17 | 18 | def registrar(self): 19 | fecha = datetime.datetime.now() 20 | 21 | # Cifrar contraseña 22 | cifrado = hashlib.sha256() 23 | cifrado.update(self.password.encode('utf8')) # Encode me permite convertir a bte mi string 24 | 25 | sql = "INSERT INTO usuarios VALUES(null,%s,%s,%s,%s,%s)" 26 | usuario = (self.nombre, self.apellidos, self.email, cifrado.hexdigest(), fecha) # cifrado.hexdigest me guarda el hexadecimal recibido del update(). 27 | 28 | try: 29 | cursor.execute(sql, usuario) 30 | database.commit() 31 | result = [cursor.rowcount, self] # El return devuelve una lista 32 | 33 | except: 34 | result = [0, self] # El return devuelve una lista 35 | 36 | return result 37 | 38 | 39 | 40 | def identificar(self): 41 | # Consulta para comprobar que existe el usuario 42 | sql = "SELECT * FROM usuarios WHERE email = %s AND password = %s" 43 | 44 | # Cifrar contraseña 45 | cifrado = hashlib.sha256() 46 | cifrado.update(self.password.encode('utf8')) # Encode me permite convertir a bte mi string 47 | 48 | usuario = (self.email, cifrado.hexdigest()) 49 | 50 | cursor.execute(sql, usuario) 51 | result = cursor.fetchone() 52 | 53 | return result 54 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Master-Python 2 | 3 | ![](https://github.com/YESUBZERO/Master-Python/blob/master/image.png) 4 | ## Aprende a programar desde cero con Python 3 5 | 6 | 7 | Hay muchas razones para usar Python: puede compilar muchos tipos diferentes de programas con él, es relativamente fácil de usar, tiene un ecosistema enriquecido y mucho más. 8 | 9 | ### Puede compilar muchos tipos de programas. 10 | El lenguaje de programación Python permite compilar muchos tipos de programas, como los siguientes: 11 | Aplicaciones empresariales para capturar, analizar y procesar datos. 12 | Aplicaciones web dinámicas a las que puede acceder un explorador web. 13 | Juegos, tanto en 2D como en 3D. 14 | Aplicaciones financieras y científicas. 15 | Aplicaciones basadas en la nube. 16 | Aplicaciones móviles. 17 | 18 | ### Fácil de usar. 19 | En lo que respecta a los lenguajes de programación, Python es relativamente sencillo de usar, a la vez que potente. Esta combinación probablemente ha contribuido a su enorme popularidad. 20 | 21 | ### Tiene muchas bibliotecas. 22 | Además del propio lenguaje de programación, Python cuenta con una gran cantidad de bibliotecas que pueden reducir tareas complejas a unas pocas líneas de código. 23 | 24 | -------------------------------------------------------------------------------- /image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NinjaDevOps0831/Python-Master/593886cc0295e455eb4897ad0610c9abbb505163/image.png --------------------------------------------------------------------------------