├── 1. Fundamentos Avanzados ├── FC │ ├── calculator.py │ └── squares.py ├── Variables │ ├── global_var.py │ ├── inner_outer.py │ ├── local.py │ └── nonlocal.py ├── anotations │ ├── anotations_1.py │ ├── anotations_2.py │ ├── anotations_3.py │ ├── anotations_4.py │ └── anotations_5.py ├── docstrings │ ├── area.py │ └── promedio.py └── validaciones │ └── divide_1.py ├── 2. Decoradores └── decorators │ ├── circule.py │ ├── decorator_2.py │ ├── decorator_3.py │ └── decorators_1.py ├── 3. Metodos y Estructuras ├── Magic Methods │ ├── calculator.py │ ├── multiplierFactory.py │ └── person.py ├── args kargs │ ├── args.py │ ├── desempaquetado.py │ ├── employee.py │ └── kwargs.py ├── metodos privados │ ├── private.py │ └── protected.py ├── propiedades │ └── employee.py └── static y class │ ├── order.py │ └── order_1.py ├── 4. Concurrencia & Asincronía ├── concurrencia.py └── paralelismo.py ├── 5. Módulos y paquetes ├── modulos │ ├── __pycache__ │ │ └── reports.cpython-312.pyc │ ├── app.py │ ├── app2.py │ └── reports.py └── paquetes │ ├── ecommerce │ ├── __init__.py │ ├── __pycache__ │ │ ├── __init__.cpython-312.pyc │ │ ├── inventory.cpython-312.pyc │ │ └── sales.cpython-312.pyc │ ├── inventory.py │ └── sales.py │ └── main.py ├── 6. Proyecto ├── Plantilla │ ├── hotel_management │ │ ├── __init__.py │ │ ├── customers.py │ │ ├── payments.py │ │ ├── reservations.py │ │ └── rooms.py │ └── main.py └── Solución │ ├── hotel_management │ ├── __init__.py │ ├── customers.py │ ├── payments.py │ ├── reservations.py │ └── rooms.py │ └── main.py └── README.md /1. Fundamentos Avanzados/FC/calculator.py: -------------------------------------------------------------------------------- 1 | class Calculator: 2 | def add_numbers(self, first_number, second_number): 3 | result = first_number + second_number 4 | return result 5 | 6 | calc = Calculator() 7 | 8 | print(calc.add_numbers(5, 3)) 9 | -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/FC/squares.py: -------------------------------------------------------------------------------- 1 | numbers = [1, 2, 3, 4, 5] 2 | 3 | squares = [] 4 | 5 | for number in numbers: 6 | square = number ** 2 7 | squares.append(square) 8 | 9 | print(squares) 10 | 11 | numbers = [1, 2, 3, 4, 5] 12 | 13 | squares = [x**2 for x in numbers] 14 | print(squares) 15 | -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/Variables/global_var.py: -------------------------------------------------------------------------------- 1 | x = 5 #Variable global 2 | 3 | def modify_global(): 4 | global x 5 | x+=3 6 | print(f'Valor modificado: {x}') 7 | 8 | modify_global() 9 | print(x) -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/Variables/inner_outer.py: -------------------------------------------------------------------------------- 1 | x = 'global' #Variable global 2 | 3 | #Función externa 4 | def outer_function(): 5 | x = 'enclosing' 6 | #Función interna 7 | def inner_function(): 8 | x = 'local' #Variable local 9 | print(x) 10 | 11 | inner_function() 12 | print(x) 13 | 14 | outer_function() 15 | print(x) -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/Variables/local.py: -------------------------------------------------------------------------------- 1 | x = 100 #variable global 2 | 3 | def local_function(): 4 | x = 10 #Variable local 5 | print(f'El valor de la variable es {x}') 6 | 7 | def show_global(): 8 | print(f'El valor de la variable global es {x}') 9 | 10 | #local_function() 11 | print(x) -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/Variables/nonlocal.py: -------------------------------------------------------------------------------- 1 | def outer_function(): 2 | x = 'enclosing' 3 | def inner_function(): 4 | nonlocal x 5 | x = 'modified' 6 | print(f'El valor en inner es: {x}') 7 | inner_function() 8 | print(f'El valor outer: {x}') 9 | outer_function() -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/anotations/anotations_1.py: -------------------------------------------------------------------------------- 1 | #IDs de empleados 2 | id1: int = 101 3 | id2: int = 102 4 | 5 | #Sumar los IDs 6 | total_id: int = id1 + id2 7 | 8 | #Mostrar resultado 9 | print(total_id) -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/anotations/anotations_2.py: -------------------------------------------------------------------------------- 1 | def add_employee_ids(id1: int, id2:int) -> int: 2 | return id1+id2 3 | 4 | print(add_employee_ids(201,202)) 5 | -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/anotations/anotations_3.py: -------------------------------------------------------------------------------- 1 | class Employee: 2 | name: str 3 | age: int 4 | salary: float 5 | 6 | def __init__(self, name: str, age: int, salary: float): 7 | self.name = name 8 | self.age = age 9 | self.salary = salary 10 | 11 | def introduce(self) -> str: 12 | return f"Hola, me llamo {self.name}, tengo {self.age}" 13 | 14 | employee1 = Employee('Carlos', 30, 3500.0) 15 | print(employee1.introduce()) -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/anotations/anotations_4.py: -------------------------------------------------------------------------------- 1 | from typing import Optional 2 | 3 | def find_employee(employee_ids: list[int], employee_id: int) -> Optional[int]: 4 | """ 5 | Busca un ID de empleado en una lista de IDs y devuelve el valor si existe. 6 | 7 | Parámetros: 8 | employee_ids (list[int]): Lista de IDs de empleados. 9 | employee_id (int): ID a buscar. 10 | 11 | Retorna: 12 | Optional[int]: El ID encontrado o None si no existe en la lista. 13 | """ 14 | if employee_id in employee_ids: 15 | return employee_id 16 | return None -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/anotations/anotations_5.py: -------------------------------------------------------------------------------- 1 | from typing import Union 2 | 3 | def process_salary(salary: Union[int, float]) -> float: 4 | """ 5 | Procesa un salario que puede ser entero o flotante y lo devuelve como flotante. 6 | 7 | Parámetros: 8 | salary (Union[int, float]): Un salario que puede ser un entero o flotante. 9 | 10 | Retorna: 11 | float: El salario convertido a flotante. 12 | """ 13 | return float(salary) -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/docstrings/area.py: -------------------------------------------------------------------------------- 1 | def calculate_area(base,height): 2 | """ 3 | Calcula el área de un triángulo 4 | """ 5 | return (base * height) / 2 -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/docstrings/promedio.py: -------------------------------------------------------------------------------- 1 | def calculate_average(numbers): 2 | """ 3 | Calcula el promedio de una lista de números. 4 | 5 | Parámetros: 6 | numbers (list): Una lista de números enteros o flotantes 7 | 8 | Retorna: 9 | float: El promedio de los números en la lista 10 | """ 11 | return sum(numbers) / len(numbers) 12 | 13 | # Imprimiendo el resultado de la función 14 | print(calculate_average([1,2,3,4,5])) # Imprimiendo el resultado de la función -------------------------------------------------------------------------------- /1. Fundamentos Avanzados/validaciones/divide_1.py: -------------------------------------------------------------------------------- 1 | def divide(a: int, b: int) -> float: 2 | #validar qeu ambos parametros sean enteros 3 | if not isinstance(a,int) or not isinstance(b, int): 4 | raise TypeError('Ambos parámetros deben ser enteros.') 5 | 6 | #Verificamos que el divisor no sea cero 7 | if b ==0: 8 | raise ValueError('El divisor no puede ser cero.') 9 | 10 | return a/b 11 | 12 | #Ejemplo de uso 13 | try: 14 | res = divide(10,'2') #Error de tipo 15 | print(res) 16 | except TypeError as e: 17 | print(f'Error: {e}') 18 | 19 | #Ejemplo de uso 20 | try: 21 | res = divide(10,0) #Error de división por cero 22 | print(res) 23 | except ValueError as e: 24 | print(f'Error: {e}') 25 | 26 | #Ejemplo de uso 27 | try: 28 | res = divide(10,2) #División correcta 29 | print(res) 30 | except (ValueError, TypeError) as e: 31 | print(f'Error: {e}') 32 | -------------------------------------------------------------------------------- /2. Decoradores/decorators/circule.py: -------------------------------------------------------------------------------- 1 | class Circle: 2 | 3 | def __init__(self, radius:float): 4 | self._radius = radius 5 | 6 | @property 7 | def area(self) -> float: 8 | return 3.1416 * (self._radius **2) 9 | 10 | @property 11 | def radius(self) -> float: 12 | return self._radius 13 | 14 | @radius.setter 15 | def radius(self, value: float): 16 | if value < 0: 17 | raise ValueError('El radio no puede ser negativo') 18 | self._radius = value 19 | 20 | circle = Circle(5) 21 | #print(circle.area) 22 | circle.radius = -10 23 | print(circle.area) -------------------------------------------------------------------------------- /2. Decoradores/decorators/decorator_2.py: -------------------------------------------------------------------------------- 1 | def check_access(func): 2 | def wrapper(employee): 3 | # Comprobar si el empleado tiene rol 'admin' 4 | if employee.get('role') == 'admin': 5 | return func(employee) 6 | else: 7 | print('ACCESO DENEGADO. Solo los administradores pueden acceder.') 8 | return wrapper 9 | 10 | @check_access 11 | def delete_employee(employee): 12 | print(f'Elempleado {employee['name']} ha sido eliminado.') 13 | 14 | admin = {'name': 'Carlos', 'role': 'admin'} 15 | employee = {'name': 'Ana', 'role': 'employee'} 16 | 17 | 18 | #delete_employee(admin) 19 | delete_employee(employee) -------------------------------------------------------------------------------- /2. Decoradores/decorators/decorator_3.py: -------------------------------------------------------------------------------- 1 | #Decorador que comprueba si un empleado tiene un rol específico 2 | def check_access(required_role): 3 | def decorator(func): 4 | def wrapper(employee): 5 | #Si el rol de lempleado coincide con el rol requerido 6 | if employee.get('role') == required_role: 7 | return func(employee) 8 | else: 9 | print(f'ACCESO DENEGAGO. Solo {required_role} pueden realizar esta acción') 10 | return wrapper 11 | return decorator 12 | 13 | def log_action(func): 14 | def wrapper(employee): 15 | print(f'Registrando acción para el empleado {employee['name']}') 16 | return func(employee) 17 | return wrapper 18 | 19 | @check_access('admin') 20 | @log_action 21 | def delete_employee(employee): 22 | print(f'El empleado {employee['name']}, ha sido eliminado') 23 | 24 | admin = {'name': 'Carlos', 'role': 'admin'} 25 | employee = {'name': 'Ana', 'role': 'employee'} 26 | 27 | #delete_employee(admin) 28 | delete_employee(employee) -------------------------------------------------------------------------------- /2. Decoradores/decorators/decorators_1.py: -------------------------------------------------------------------------------- 1 | def log_transaction(func): 2 | def wrapper(): 3 | print('1 Log de la transacción...') 4 | func() 5 | print('3 Log terminado...') 6 | return wrapper 7 | 8 | 9 | @log_transaction 10 | def process_payment(): 11 | print('2 Procesando pago....') 12 | 13 | process_payment() -------------------------------------------------------------------------------- /3. Metodos y Estructuras/Magic Methods/calculator.py: -------------------------------------------------------------------------------- 1 | # Función que suma dos números 2 | def add(a, b): 3 | return a + b 4 | 5 | # Función que resta dos números 6 | def subtract(a, b): 7 | return a - b 8 | 9 | # Función que multiplica dos números 10 | def multiply(a, b): 11 | return a * b 12 | 13 | # Función que divide dos números 14 | def divide(a, b): 15 | if b == 0: 16 | raise ValueError("No se puede dividir entre 0") 17 | return a / b 18 | 19 | if __name__ == "__main__": 20 | print('Operaciones') 21 | res_1 = add(3,4) 22 | print(f'Suma: {res_1}') 23 | print(divide(10,7)) -------------------------------------------------------------------------------- /3. Metodos y Estructuras/Magic Methods/multiplierFactory.py: -------------------------------------------------------------------------------- 1 | class MultiplierFactory: 2 | 3 | def __new__(cls, factor: int): 4 | print(f"Creando instancia con factor {factor}") 5 | return super(MultiplierFactory, cls).__new__(cls) 6 | 7 | def __init__(self, factor: int): 8 | print(f"Inicializando con factor {factor}") 9 | self.factor = factor 10 | 11 | def __call__(self, number: int) -> int: 12 | return number * self.factor 13 | 14 | multiplier = MultiplierFactory(5) 15 | 16 | result = multiplier(10) 17 | print(result) -------------------------------------------------------------------------------- /3. Metodos y Estructuras/Magic Methods/person.py: -------------------------------------------------------------------------------- 1 | class Persona: 2 | def __init__(self, nombre: str, edad: int): 3 | self.nombre = nombre 4 | self.edad = edad 5 | 6 | def __str__(self) -> str: 7 | # Devuelve una representación amigable para el usuario 8 | return f"Persona: {self.nombre}, {self.edad} años" 9 | 10 | def __repr__(self) -> str: 11 | # Devuelve una representación detallada del objeto para depuración 12 | return f"Persona(nombre='{self.nombre}', edad={self.edad})" 13 | 14 | def __eq__(self, otra_persona) -> bool: 15 | # Compara si dos personas son iguales en función del nombre y la edad 16 | return self.nombre == otra_persona.nombre and self.edad == otra_persona.edad 17 | 18 | def __lt__(self, otra_persona) -> bool: 19 | # Compara si una persona es "menor" que otra en función de la edad 20 | return self.edad < otra_persona.edad 21 | 22 | def __add__(self, otra_persona): 23 | # Sobrecarga el operador + para sumar las edades de dos personas 24 | return self.edad + otra_persona.edad 25 | 26 | # Crear instancias de Persona 27 | p1 = Persona("Ana", 28) 28 | p2 = Persona("Luis", 35) 29 | p3 = Persona("Ana", 28) 30 | 31 | # __str__: Representación legible 32 | #print(p1) # Output: Persona: Ana, 28 años 33 | 34 | # __repr__: Representación detallada 35 | #print(repr(p2)) # Output: Persona(nombre='Luis', edad=35) 36 | 37 | # __eq__: Comparación de igualdad 38 | 39 | #print(p1 == p3) # Output: True (son iguales en nombre y edad) 40 | 41 | # __lt__: Comparación "menor que" por edad 42 | #print(p1 < p2) # Output: True (porque 28 es menor que 35) 43 | 44 | # __add__: Sumar edades de dos personas 45 | print(p1 + p2) # Output: 63 (28 + 35) 46 | -------------------------------------------------------------------------------- /3. Metodos y Estructuras/args kargs/args.py: -------------------------------------------------------------------------------- 1 | def sum_numbers(*args): 2 | return sum(args) 3 | 4 | print(sum_numbers(1,2,3,4,5)) 5 | print(sum_numbers(1,2)) 6 | print(sum_numbers(1,2,3,4,5,7,8,9,10)) -------------------------------------------------------------------------------- /3. Metodos y Estructuras/args kargs/desempaquetado.py: -------------------------------------------------------------------------------- 1 | #Desempaquetado args 2 | def add(a, b, c): 3 | return a + b + c 4 | 5 | values = (1, 2, 3) 6 | print(add(*values)) 7 | 8 | def show_info(name, age): 9 | print(f"Name: {name}, Age: {age}") 10 | 11 | data = {"name": "Ana", "age": 28} 12 | show_info(**data) -------------------------------------------------------------------------------- /3. Metodos y Estructuras/args kargs/employee.py: -------------------------------------------------------------------------------- 1 | class Employee: 2 | def __init__(self, name, *args, **kwargs): 3 | self.name = name 4 | self.skills = args 5 | self.details = kwargs 6 | 7 | def show_employee(self): 8 | print(f'Employee: {self.name}') 9 | print('Skills', self.skills) 10 | print('Details', self.details) 11 | 12 | employee = Employee('Carlos', 'Python', 'Java', 'C++', age=30, city = 'Bogotá') 13 | employee.show_employee() -------------------------------------------------------------------------------- /3. Metodos y Estructuras/args kargs/kwargs.py: -------------------------------------------------------------------------------- 1 | def print_info(**kwargs): 2 | for key, value in kwargs.items(): 3 | print(f'{key}: {value}') 4 | 5 | print_info(name='Carlos', age=30, city='Bogotá') 6 | print_info(name='Carlos', age=30, city='Bogotá', country = 'Colombia') -------------------------------------------------------------------------------- /3. Metodos y Estructuras/metodos privados/private.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/platzi/python-avanzado/e0ef7102895a258451771a0cbd5580ff95d9b387/3. Metodos y Estructuras/metodos privados/private.py -------------------------------------------------------------------------------- /3. Metodos y Estructuras/metodos privados/protected.py: -------------------------------------------------------------------------------- 1 | class BaseClass: 2 | def __init__(self): 3 | self._protected_variable = 'Protected' 4 | self.__private_variable = 'Private' 5 | 6 | def _protected_method(self): 7 | print('Este es un metodo protegido') 8 | 9 | def __private_method(self): 10 | print('Esto es un metodo privado') 11 | 12 | def public_method(self): 13 | self.__private_method() 14 | 15 | base = BaseClass() 16 | #print(base._protected_variable) 17 | #base._protected_method() 18 | 19 | #base.public_method() 20 | print(base.__private_variable) -------------------------------------------------------------------------------- /3. Metodos y Estructuras/propiedades/employee.py: -------------------------------------------------------------------------------- 1 | class Employee: 2 | def __init__(self, name, salary): 3 | self.name = name 4 | self._salary = salary 5 | 6 | @property 7 | def salary(self): 8 | return self._salary 9 | 10 | @salary.setter 11 | def salary(self, new_salary): 12 | if new_salary < 0: 13 | raise ValueError("Salary cannot be negative") 14 | self._salary = new_salary 15 | 16 | @salary.deleter 17 | def salary(self): 18 | print(f"The salary of {self.name} has been deleted") 19 | del self._salary 20 | 21 | # Crear instancia de Employee 22 | employee = Employee("Ana", 5000) 23 | print(employee.salary) 24 | 25 | # Modificar el salario de forma controlada 26 | employee.salary = 6000 27 | print(employee.salary) 28 | 29 | # Intentar establecer un salario negativo 30 | #employee.salary = -1000 31 | 32 | # Eliminar el salario 33 | del employee.salary 34 | -------------------------------------------------------------------------------- /3. Metodos y Estructuras/static y class/order.py: -------------------------------------------------------------------------------- 1 | class Order: 2 | 3 | @staticmethod 4 | def calculate_tax(amount, tax_rate): 5 | return amount * (tax_rate / 100) 6 | 7 | print(Order.calculate_tax(1000, 18)) -------------------------------------------------------------------------------- /3. Metodos y Estructuras/static y class/order_1.py: -------------------------------------------------------------------------------- 1 | class Order: 2 | global_discount = 10 3 | 4 | def __init__(self,amount): 5 | self.amount = amount 6 | 7 | @classmethod 8 | def update_gloabal_discount(cls, new_discount): 9 | cls.global_discount = new_discount 10 | 11 | Order.update_gloabal_discount(15) 12 | print(Order.global_discount) 13 | 14 | 15 | -------------------------------------------------------------------------------- /4. Concurrencia & Asincronía/concurrencia.py: -------------------------------------------------------------------------------- 1 | import threading 2 | import time 3 | 4 | #función que simula el procesamiento de una solicitud 5 | def process_request(request_id): 6 | print(f'Procesando solicitud {request_id}') 7 | time.sleep(3) 8 | print(f'Solicitud {request_id} completada') 9 | 10 | threads = [] 11 | 12 | for i in range(3): 13 | #Crear nuevo hilo que ejecutará la función 14 | thread = threading.Thread(target=process_request, args=(i,)) 15 | threads.append(thread) 16 | thread.start() 17 | 18 | #Esperar a que todos los hilos terminen 19 | for thread in threads: 20 | #Asegura de el programa espere a que cada hilo termine 21 | thread.join() 22 | 23 | print('Todas las solicitudes completadas') -------------------------------------------------------------------------------- /4. Concurrencia & Asincronía/paralelismo.py: -------------------------------------------------------------------------------- 1 | import multiprocessing 2 | 3 | #Función que calcule el cuadrado de un número 4 | def calculate_square(n): 5 | return n*n 6 | 7 | if __name__ == '__main__': 8 | numbers = [1,2,3,4,5] 9 | 10 | #crear un pool 11 | with multiprocessing.Pool() as pool: 12 | results = pool.map(calculate_square, numbers) 13 | 14 | print(f'Resultados: {results}') -------------------------------------------------------------------------------- /5. Módulos y paquetes/modulos/__pycache__/reports.cpython-312.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/platzi/python-avanzado/e0ef7102895a258451771a0cbd5580ff95d9b387/5. Módulos y paquetes/modulos/__pycache__/reports.cpython-312.pyc -------------------------------------------------------------------------------- /5. Módulos y paquetes/modulos/app.py: -------------------------------------------------------------------------------- 1 | import reports 2 | 3 | # Generar reportes de ventas y gastos usando funciones del módulo 4 | sales_report = reports.generate_sales_report('Octobre', 10000) 5 | expense_report = reports.generate_expenses_report('Octubre', 5000) 6 | 7 | print(sales_report) 8 | print(expense_report) -------------------------------------------------------------------------------- /5. Módulos y paquetes/modulos/app2.py: -------------------------------------------------------------------------------- 1 | from reports import generate_sales_report, generate_expenses_report 2 | 3 | print(generate_sales_report('November', 12000)) 4 | print(generate_expenses_report('November', 3000)) -------------------------------------------------------------------------------- /5. Módulos y paquetes/modulos/reports.py: -------------------------------------------------------------------------------- 1 | # Genera un informe de ventas para un mes específico. 2 | def generate_sales_report(month, sales): 3 | return f'Sales Report - {month}: Total sales: ${sales}' 4 | 5 | # Genera un informe de gastos para un mes específico. 6 | def generate_expenses_report(month, expenses): 7 | return f'Expenses Report - {month}: Total expenses: ${expenses}' -------------------------------------------------------------------------------- /5. Módulos y paquetes/paquetes/ecommerce/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/platzi/python-avanzado/e0ef7102895a258451771a0cbd5580ff95d9b387/5. Módulos y paquetes/paquetes/ecommerce/__init__.py -------------------------------------------------------------------------------- /5. Módulos y paquetes/paquetes/ecommerce/__pycache__/__init__.cpython-312.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/platzi/python-avanzado/e0ef7102895a258451771a0cbd5580ff95d9b387/5. Módulos y paquetes/paquetes/ecommerce/__pycache__/__init__.cpython-312.pyc -------------------------------------------------------------------------------- /5. Módulos y paquetes/paquetes/ecommerce/__pycache__/inventory.cpython-312.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/platzi/python-avanzado/e0ef7102895a258451771a0cbd5580ff95d9b387/5. Módulos y paquetes/paquetes/ecommerce/__pycache__/inventory.cpython-312.pyc -------------------------------------------------------------------------------- /5. Módulos y paquetes/paquetes/ecommerce/__pycache__/sales.cpython-312.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/platzi/python-avanzado/e0ef7102895a258451771a0cbd5580ff95d9b387/5. Módulos y paquetes/paquetes/ecommerce/__pycache__/sales.cpython-312.pyc -------------------------------------------------------------------------------- /5. Módulos y paquetes/paquetes/ecommerce/inventory.py: -------------------------------------------------------------------------------- 1 | # agrega un producto al inventario 2 | def add_product(product_name, stock): 3 | print(f'Producto {product_name} agregando con {stock} unidades.') 4 | 5 | #elimina un producto del inventario 6 | def remove_product(product_name): 7 | print(f'Producto {product_name} eliminado del inventario.') -------------------------------------------------------------------------------- /5. Módulos y paquetes/paquetes/ecommerce/sales.py: -------------------------------------------------------------------------------- 1 | def process_sale(product_name, quantity): 2 | print(f'Venta procesada: {quantity} unidades de {product_name}') -------------------------------------------------------------------------------- /5. Módulos y paquetes/paquetes/main.py: -------------------------------------------------------------------------------- 1 | #Importa funciones de los modulos dentro del paquete 2 | from ecommerce.inventory import add_product, remove_product 3 | from ecommerce.sales import process_sale 4 | 5 | add_product('Laptop', 10) 6 | remove_product('Laptop') 7 | process_sale('Laptop', 2) -------------------------------------------------------------------------------- /6. Proyecto/Plantilla/hotel_management/ __init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/platzi/python-avanzado/e0ef7102895a258451771a0cbd5580ff95d9b387/6. Proyecto/Plantilla/hotel_management/ __init__.py -------------------------------------------------------------------------------- /6. Proyecto/Plantilla/hotel_management/customers.py: -------------------------------------------------------------------------------- 1 | class Customer: 2 | def __init__(): 3 | pass 4 | 5 | class CustomerManagement: 6 | def __init__(self): 7 | self.customers = {} 8 | 9 | def add_customer(self, customer): 10 | """Agrega un nuevo cliente al sistema.""" 11 | pass 12 | 13 | def get_customer(self, customer_id): 14 | """Obtiene la información de un cliente por ID.""" 15 | pass -------------------------------------------------------------------------------- /6. Proyecto/Plantilla/hotel_management/payments.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | import random 3 | 4 | async def process_payment(customer_name, amount): 5 | """Simula el procesamiento de un pago.""" 6 | pass 7 | 8 | -------------------------------------------------------------------------------- /6. Proyecto/Plantilla/hotel_management/reservations.py: -------------------------------------------------------------------------------- 1 | from collections import defaultdict 2 | from datetime import datetime 3 | 4 | class Reservation: 5 | def __init__(): 6 | pass 7 | 8 | class ReservationSystem: 9 | def __init__(self): 10 | pass 11 | 12 | def add_reservation(self, reservation): 13 | """Agrega una nueva reserva al sistema.""" 14 | 15 | 16 | def cancel_reservation(self, reservation_id): 17 | """Cancela una reserva existente por ID.""" 18 | pass 19 | 20 | 21 | -------------------------------------------------------------------------------- /6. Proyecto/Plantilla/hotel_management/rooms.py: -------------------------------------------------------------------------------- 1 | class Room: 2 | def __init__(): 3 | pass 4 | 5 | class RoomManagement: 6 | def __init__(self): 7 | pass 8 | 9 | def add_room(self, room): 10 | """Agrega una nueva habitación al sistema.""" 11 | pass 12 | 13 | def check_availability(self, room_number): 14 | """Verifica si una habitación está disponible.""" 15 | pass 16 | -------------------------------------------------------------------------------- /6. Proyecto/Plantilla/main.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | from hotel_management.reservations import Reservation, ReservationSystem 3 | from hotel_management.customers import Customer, CustomerManagement 4 | from hotel_management.rooms import Room, RoomManagement 5 | from hotel_management.payments import process_payment 6 | from datetime import datetime 7 | 8 | async def main(): 9 | # Inicializar sistemas 10 | 11 | # Crear habitaciones 12 | 13 | # Agregar clientes 14 | #customer1 = Customer(1, "Alice", "alice@example.com") 15 | #customer_mgmt.add_customer(customer1) 16 | 17 | # Verificar disponibilidad de habitaciones 18 | # Procesar pago asincrónicamente 19 | pass 20 | 21 | if __name__ == "__main__": 22 | asyncio.run(main()) 23 | 24 | -------------------------------------------------------------------------------- /6. Proyecto/Solución/hotel_management/ __init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/platzi/python-avanzado/e0ef7102895a258451771a0cbd5580ff95d9b387/6. Proyecto/Solución/hotel_management/ __init__.py -------------------------------------------------------------------------------- /6. Proyecto/Solución/hotel_management/customers.py: -------------------------------------------------------------------------------- 1 | class Customer: 2 | def __init__(self, customer_id, name, email): 3 | self.customer_id = customer_id 4 | self.name = name 5 | self.email = email 6 | 7 | class CustomerManagement: 8 | def __init__(self): 9 | self.customers = {} 10 | 11 | def add_customer(self, customer): 12 | """Agrega un nuevo cliente al sistema.""" 13 | self.customers[customer.customer_id] = customer 14 | print(f"Cliente {customer.name} agregado.") 15 | 16 | def get_customer(self, customer_id): 17 | """Obtiene la información de un cliente por ID.""" 18 | return self.customers.get(customer_id, "Cliente no encontrado.") 19 | 20 | -------------------------------------------------------------------------------- /6. Proyecto/Solución/hotel_management/payments.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | import random 3 | 4 | async def process_payment(customer_name, amount): 5 | """Simula el procesamiento de un pago.""" 6 | print(f"Procesando pago de {customer_name} por ${amount}...") 7 | await asyncio.sleep(random.randint(1, 3)) # Simula una operación de pago 8 | print(f"Pago de ${amount} completado para {customer_name}") 9 | return True 10 | 11 | -------------------------------------------------------------------------------- /6. Proyecto/Solución/hotel_management/reservations.py: -------------------------------------------------------------------------------- 1 | from collections import defaultdict 2 | from datetime import datetime 3 | 4 | class Reservation: 5 | def __init__(self, reservation_id, customer_name, room_number, check_in, check_out): 6 | self.reservation_id = reservation_id 7 | self.customer_name = customer_name 8 | self.room_number = room_number 9 | self.check_in = check_in 10 | self.check_out = check_out 11 | 12 | class ReservationSystem: 13 | def __init__(self): 14 | # Utilizamos defaultdict para gestionar las reservas 15 | self.reservations = defaultdict(list) 16 | 17 | def add_reservation(self, reservation): 18 | """Agrega una nueva reserva al sistema.""" 19 | self.reservations[reservation.room_number].append(reservation) 20 | print(f"Reserva creada para {reservation.customer_name} en la habitación {reservation.room_number}") 21 | 22 | def cancel_reservation(self, reservation_id): 23 | """Cancela una reserva existente por ID.""" 24 | for room, reservations in self.reservations.items(): 25 | for r in reservations: 26 | if r.reservation_id == reservation_id: 27 | reservations.remove(r) 28 | print(f"Reserva {reservation_id} cancelada") 29 | return 30 | print("Reserva no encontrada") -------------------------------------------------------------------------------- /6. Proyecto/Solución/hotel_management/rooms.py: -------------------------------------------------------------------------------- 1 | class Room: 2 | def __init__(self, room_number, room_type, price): 3 | self.room_number = room_number 4 | self.room_type = room_type 5 | self.price = price 6 | self.available = True 7 | 8 | class RoomManagement: 9 | def __init__(self): 10 | self.rooms = {} 11 | 12 | def add_room(self, room): 13 | """Agrega una nueva habitación al sistema.""" 14 | self.rooms[room.room_number] = room 15 | print(f"Habitación {room.room_number} agregada.") 16 | 17 | def check_availability(self, room_number): 18 | """Verifica si una habitación está disponible.""" 19 | room = self.rooms.get(room_number) 20 | if room and room.available: 21 | print(f"Habitación {room_number} está disponible.") 22 | return True 23 | print(f"Habitación {room_number} no está disponible.") 24 | return False 25 | 26 | -------------------------------------------------------------------------------- /6. Proyecto/Solución/main.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | from hotel_management.reservations import Reservation, ReservationSystem 3 | from hotel_management.customers import Customer, CustomerManagement 4 | from hotel_management.rooms import Room, RoomManagement 5 | from hotel_management.payments import process_payment 6 | from datetime import datetime 7 | 8 | async def main(): 9 | # Inicializar sistemas 10 | reservation_system = ReservationSystem() 11 | customer_mgmt = CustomerManagement() 12 | room_mgmt = RoomManagement() 13 | 14 | # Crear habitaciones 15 | room_mgmt.add_room(Room(101, "Single", 100)) 16 | room_mgmt.add_room(Room(102, "Double", 150)) 17 | 18 | # Agregar clientes 19 | customer1 = Customer(1, "Alice", "alice@example.com") 20 | customer_mgmt.add_customer(customer1) 21 | 22 | customer2 = Customer(2, "Bob", "bob@example.com") 23 | customer_mgmt.add_customer(customer2) 24 | 25 | # Verificar disponibilidad de habitaciones 26 | if room_mgmt.check_availability(101): 27 | reservation = Reservation(1, "Alice", 101, datetime.now(), datetime.now()) 28 | reservation_system.add_reservation(reservation) 29 | 30 | # Procesar pago asincrónicamente 31 | await process_payment("Alice", 100) 32 | 33 | if room_mgmt.check_availability(102): 34 | reservation = Reservation(2, "Bob", 102, datetime.now(), datetime.now()) 35 | reservation_system.add_reservation(reservation) 36 | 37 | # Procesar pago asincrónicamente 38 | await process_payment("Bob", 150) 39 | 40 | if __name__ == "__main__": 41 | asyncio.run(main()) 42 | 43 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Curso de Python Avanzado 2 | 3 | ¡Hola! Soy tu profesora Carli Code y te doy la bienvenida al **Curso de Python Avanzado**. Este curso está diseñado para llevarte más allá de los fundamentos y proporcionarte las herramientas y técnicas avanzadas necesarias para trabajar en proyectos Python de alto rendimiento y escalabilidad. A lo largo del curso, aprenderás a diseñar código limpio y eficiente, utilizar decoradores, manejar concurrencia, crear módulos reutilizables, y mucho más. Puedes acceder al curso completo en [Python Avanzado](https://platzi.com/cursos/python-avanzado/). 4 | 5 | ## Módulo 1: Fundamentos Avanzados de Python 6 | En este módulo, exploraremos cómo escribir **código Pythonico**, siguiendo las mejores prácticas y convenciones del lenguaje. Aprenderás a utilizar la **PEP 8** y a implementar **comentarios y docstrings** efectivos para documentar tu código. Además, discutiremos el uso de **variables locales y globales** y cómo las **anotaciones de tipo** pueden mejorar la legibilidad y el mantenimiento de tus proyectos. 7 | 8 | ## Módulo 2: Decoradores 9 | Los **decoradores** son una poderosa herramienta en Python que permite modificar el comportamiento de funciones y métodos. En este módulo, aprenderás a crear tus propios decoradores, cómo anidarlos y cómo utilizarlos en clases y métodos. Esto te permitirá escribir código más modular y flexible. 10 | 11 | ## Módulo 3: Métodos y Estructura de Clases en Python 12 | La **Programación Orientada a Objetos (POO)** es fundamental para escribir código limpio y reutilizable en Python. En este módulo, profundizaremos en el uso de **métodos mágicos** como `__str__`, `__repr__`, y `__eq__`, y aprenderás a **sobrecargar operadores** para crear clases más poderosas y personalizadas. También discutiremos la implementación de `if __name__ == "__main__":` y la **metaprogramación** en Python. 13 | 14 | ## Módulo 4: Programación Concurrente y Asincrónica 15 | La concurrencia y el paralelismo son claves para mejorar el rendimiento de tus aplicaciones. En este módulo, aprenderás a usar **threading** y **multiprocessing** para ejecutar tareas en paralelo. Además, nos sumergiremos en la **programación asincrónica con `asyncio`**, que te permitirá gestionar múltiples tareas sin bloquear el flujo principal de tu programa. 16 | 17 | ## Módulo 5: Creación de Módulos y Paquetes 18 | Uno de los aspectos más importantes de un desarrollador avanzado es la capacidad de crear código reutilizable. En este módulo, aprenderás a organizar tu código en **módulos y paquetes**, y cómo **publicar paquetes en PyPI** para compartir tu trabajo con la comunidad Python. 19 | 20 | ## Módulo 6: Proyecto Final 21 | En el proyecto final, aplicarás todo lo aprendido para implementar un **sistema completo** en Python. Este proyecto te desafiará a crear una solución robusta y eficiente, utilizando técnicas avanzadas como la concurrencia, la POO, y el manejo de excepciones. 22 | 23 | --- 24 | 25 | ## Requisitos 26 | Antes de comenzar, asegúrate de haber completado el [Curso de Python](https://platzi.com/cursos/python/) para tener una base sólida. 27 | 28 | ## Manual de Instalación de Python 29 | 30 | Para poder seguir este curso, debes tener **Python** instalado en tu sistema. Aquí te dejo una guía rápida para la instalación: 31 | 32 | ### **Paso 1: Descargar Python** 33 | - Ve a [python.org](https://python.org) y descarga la última versión de Python compatible con tu sistema operativo. 34 | 35 | ### **Paso 2: Instalar Python** 36 | - Ejecuta el instalador. **Asegúrate de marcar la opción "Agregar Python al PATH"** durante la instalación. 37 | 38 | ### **Paso 3: Verificar Instalación** 39 | - Una vez instalado, abre tu terminal (Command Prompt en Windows, Terminal en macOS/Linux). 40 | 41 | ## Derechos Reservados 42 | 43 | Este contenido es propiedad de Platzi. Todos los derechos reservados. El uso de este material está sujeto a los términos y condiciones de Platzi. --------------------------------------------------------------------------------