Fundamentos de Programación y Python

1

¿Por qué aprender Python?

2

Introducción a Python

3

Conceptos Básicos de Programación

4

Práctica: Te doy la bienvenida a los ejercicios interactivos

5

Manipulación de Cadenas de Texto en Python

6

Enteros, Flotantes y Booleanos

7

Todo lo que Debes Saber sobre print en Python

8

Operaciones Matemáticas en Python

9

Operaciones de Entrada/Salida en Consola

Colección y Procesamiento de Datos en Python

10

Listas

11

Método slice

12

Listas de más dimensiones y Tuplas

13

Aplicación de Matrices

14

Diccionarios

15

Comprehension Lists en Python (CLASE NUEVA)

Control de Flujo en Python

16

Estructuras condicionales

17

Bucles y Control de Iteraciones

18

Generadores e Iteradores

Funciones y Manejo de Excepciones en Python

19

Uso de Funciones en Python

20

Funciones Lambda y Programación Funcional en Python

21

¿Cómo realizar una función recursiva en Python?

22

Manejo de Excepciones y Uso de Pass (CLASE NUEVA)

Programación Orientada a Objetos en Python

23

Fundamentos de Programación Orientada a Objetos en Python

24

Ejercicio Biblioteca con POO

25

Herencia en POO con Python

26

Objetos heredados

27

Los 4 pilares de la programacion orientada a objetos

28

Uso de super() en Python (CLASE NUEVA)

29

Superando los Fundamentos de Programación Orientada a Objetos en Python

Lectura y escritura de archivos

30

Manejo de Archivos .TXT (CLASE NUEVA)

31

Manejo de Archivos CSV (CLASE NUEVA)

32

Manejo de Archivos JSON (CLASE NUEVA)

Biblioteca estándar de Python

33

Biblioteca estándar en Python (CLASE NUEVA)

34

Librería Os, Math y Random (CLASE NUEVA)

35

Librería Statistics y Análisis Estadístico (CLASE NUEVA)

36

Proyecto final: Guerra naval

Conceptos avanzados de Python

37

Recapitulación de lo aprendido hasta ahora

38

Escribir código Pythonico y profesional

39

Comentarios y Docstrings en Python

40

Scope y closures: variables locales y globales

41

Anotaciones de tipo

42

Validación de tipos en métodos

43

Librería Collections y Enumeraciones

Decoradores

44

Decoradores en Python

45

Decoradores anidados y con parámetros

46

Uso de Decoradores en clases y métodos

Métodos y estructura de clases en Python

47

Métodos mágicos

48

Sobrecarga de operadores

49

Implementación de `if __name__ == "__main__":`

50

Metaprogramación en Python

51

Uso de *args y **kwargs

52

Métodos privados y protegidos

53

Gestión avanzada de propiedades

54

Métodos estáticos y de clase avanzados

Programación concurrente y asíncrona

55

Introducción a la concurrencia y paralelismo

56

Threading y multiprocessing en Python

57

Asincronismo con asyncio

58

Asincronismo y concurrencia

Creación de módulos y paquetes

59

Creación de módulos en Python

60

Gestión de paquetes

61

Publicación de paquetes en PyPI

Proyecto final

62

Implementación de un sistema completo

63

Implementación de un Sistema Completo

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Python

Curso de Python

Carli Code

Carli Code

Creación de módulos en Python

59/63
Recursos

Aportes 19

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

La verdad superinteresante esta clase, yo antes me preguntaba como se creaban las librerías, como se accedían a ellas y como uno podía crear una y la respuesta es super sencilla, coherente y divertida, la verdad para mi una de las mejores clases
Crear módulos en Python es una manera de organizar y reutilizar el código, facilitando la mantenibilidad y claridad del proyecto. Un \*\*módulo\*\* es un archivo `.py` que contiene funciones, clases o variables que se pueden importar en otros archivos o módulos de un proyecto. \### 1. Creación de un Módulo Básico Imaginemos que queremos crear un módulo llamado `matematica.py` que contenga funciones matemáticas personalizadas. \*\*Paso 1:\*\* Crear el archivo del módulo. En el mismo directorio del proyecto, crea un archivo llamado `matematica.py` y añade funciones en él. Por ejemplo: ```python \# matematica.py def sumar(a, b): return a + b def restar(a, b): return a - b def multiplicar(a, b): return a \* b def dividir(a, b): if b == 0: raise ValueError("No se puede dividir por cero.") return a / b ``` \*\*Paso 2:\*\* Importar el módulo en otro archivo. En un archivo diferente, como `main.py`, importa el módulo y utiliza sus funciones: ```python \# main.py import matematica resultado\_suma = matematica.sumar(10, 5) resultado\_resta = matematica.restar(10, 5) print("Suma:", resultado\_suma) print("Resta:", resultado\_resta) ``` \### 2. Importación Específica y Alias Puedes importar funciones específicas o dar alias a las funciones o módulos para hacer el código más legible. ```python \# Importación específica from matematica import sumar, dividir print(sumar(3, 2)) print(dividir(10, 2)) \# Alias para un módulo o función import matematica as mat print(mat.multiplicar(3, 2)) ``` \### 3. Uso de `\_\_name\_\_ == "\_\_main\_\_"` El bloque `if \_\_name\_\_ == "\_\_main\_\_":` permite ejecutar pruebas o código dentro del propio módulo sin que se ejecute cuando el módulo es importado en otro archivo. En `matematica.py`: ```python \# matematica.py def sumar(a, b): return a + b \# Código de prueba if \_\_name\_\_ == "\_\_main\_\_": print(sumar(5, 7)) # Esto solo se ejecutará si ejecutas matematica.py directamente ``` \### 4. Creación de Paquetes Un \*\*paquete\*\* es una colección de módulos organizados en una estructura de carpetas. Para crear un paquete, crea una carpeta con un archivo `\_\_init\_\_.py` y coloca módulos en ella. Esto permite importar submódulos. Estructura de ejemplo de un paquete llamado `mi\_paquete`: ``` mi\_paquete/ \_\_init\_\_.py matematica.py geometria.py ``` En `matematica.py` puedes colocar las funciones matemáticas, y en `geometria.py` funciones relacionadas con la geometría. \*\*Uso del paquete en un archivo principal:\*\* ```python \# Importa el paquete y sus módulos from mi\_paquete import matematica, geometria print(matematica.sumar(3, 2)) print(geometria.area\_cuadrado(4)) ``` \### 5. Ejemplo Completo con el Paquete \#### Estructura de Archivos ``` mi\_paquete/ \_\_init\_\_.py matematica.py geometria.py main.py ``` \#### Contenido de `\_\_init\_\_.py` ```python \# mi\_paquete/\_\_init\_\_.py from .matematica import sumar, restar from .geometria import area\_cuadrado ``` \#### Contenido de `geometria.py` ```python \# mi\_paquete/geometria.py def area\_cuadrado(lado): return lado \* lado ``` \#### `main.py` ```python \# main.py from mi\_paquete import sumar, area\_cuadrado print("Suma:", sumar(3, 5)) print("Área del cuadrado:", area\_cuadrado(4)) ``` \### Resumen 1\. \*\*Módulo\*\*: Archivo `.py` con funciones, clases o variables reutilizables. 2\. \*\*Paquete\*\*: Carpeta con un archivo `\_\_init\_\_.py` que organiza múltiples módulos. 3\. \*\*Importación específica y alias\*\*: Personaliza la importación de módulos o funciones. 4\. \*\*Pruebas con `\_\_name\_\_ == "\_\_main\_\_"`\*\*: Permite probar el código en el módulo mismo sin que se ejecute al importarse. Estos conceptos son fundamentales para crear código bien organizado y fácil de mantener en Python.
main.py             ```python months = [ { "name": "Enero", "income": 2000, "expenses": 1800 }, { "name": "Febrero", "income": 2200, "expenses": 2300 }, { "name": "Marzo", "income": 2100, "expenses": 1950 }, { "name": "Abril", "income": 2500, "expenses": 2600 }, { "name": "Mayo", "income": 2300, "expenses": 2200 }, { "name": "Junio", "income": 2400, "expenses": 2500 }, { "name": "Julio", "income": 2600, "expenses": 2400 }, { "name": "Agosto", "income": 2700, "expenses": 2750 }, { "name": "Septiembre", "income": 2800, "expenses": 2900 }, { "name": "Octubre", "income": 3000, "expenses": 2850 }, { "name": "Noviembre", "income": 3200, "expenses": 3100 }, { "name": "Diciembre", "income": 3300, "expenses": 3400 } ] from mod import calculate_balance, profitable_banlace for month in months: balance = calculate_balance(month["income"], month["expenses"]) if profitable_banlace(balance): print(f"Balance rentable para el mes de {month['name']}: {balance}") else: print(f" No rentable para el mes de {month['name']}: {balance}") ``` mod.py ```python def calculate_balance(income:float|int, expenses:float|int) -> float|int: return income - expenses def profitable_banlace(balance:float|int) -> bool: return balance > 0 ```
```python def calculate_balance(income,expenses): balance = income - expenses if balance < 0: return f'El balance es $ {balance} -> {False}' else: return f'El balance es $ {balance} -> {True}' from reports import calculate_balance balance = calculate_balance(400,100) print(balance) balance_2 = calculate_balance(100,600) print(balance_2) ```El balance es $ 300 -> True El balance es $ -500 -> False
```python #main import reports print(reports.calculate_balance(2000, 200)) print(reports.validate_balance(reports.calculate_balance(2000, 200))) #reports def calculate_balance(income, expenses): return income - expenses def validate_balance(balance): if balance < 0: return False else: return True ```
\#Finance\_report.py \#Generar reporte de finanzas def calculate\_balance(month:str,income:float,expenses:float): balance = income - expenses if balance > 0: return True else: return False \#app\_balance.py \#Importa la funcion necesaria para el reporte from finance\_report import calculate\_balance \#Genera e imprime el reporte print(calculate\_balance('Septiembre',10000.00,9000.50)) # True print(calculate\_balance('Enero',10000.00,15000)) # False
```python def calculate_balance(income, expenses): return income - expenses def balance(income, expenses): total = calculate_balance(income, expenses) if total > 0: return True else: return False ```
que es ese __ pyccache__ y porque es generado?
![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202025-01-19%20131022-9d03ea97-82f0-4132-87a6-42f3062124f5.jpg)
Mi modulo finance.py ```python #1. La función calculate_balance(income, expenses) #debe devolver la diferencia entre ingresos y gastos def calculate_balance(income, expenses) -> float: return (income - expenses) #2. Devolver 'True' si el balance es positivo y 'False' si es negativo def rentabilidad(mes, income, expenses): if calculate_balance(income, expenses) > 0: return True else: return False ```Ahora, mi app.py que importa el módulo: ```python import finance # calcular el balance de un mes (diferencia entre ingresos y gastos) y mes = 'Diciembre' balance_mes = finance.calculate_balance(2000, 3000) # determinar si el mes ha sido rentable. rentabilidad = finance.rentabilidad(mes, 2000, 3000) print(f'El balance del mes {mes} es de: {balance_mes}' ) if rentabilidad: print(f'El balance del mes {mes} ha sido positivo' ) else: print(f'El balance del mes {mes} ha sido negativo' ) ```
```js def calculate_balance(income, expenses): balance = income - expenses print(f' {income} - {expenses} = {balance}') return balance def balance_result(balance): if balance > 0: print(f'The balance is positive') return True else: print(f'The balance is negative') return False ``````js import reports import finance sales_report = reports.generate_sales_report('Octubre', 500000) expense_report =reports.generate_expenses_report('Octubre', 10000000) print(sales_report) print(expense_report) balance = finance.calculate_balance(100000, 5000) state = finance.balance_result(balance) print(state) ```
```python def calculate_balance(income, expenses): balance = income - expenses return {"balance": balance, "is_positive": balance >= 0} # result = calculate_balance(1000, 300) # print(f"Balance: {result['balance']}, es positivo?: {result['is_positive']}") # from finance import calculate_balance def display_balance(monthly_result): balance_text = f"Balance {monthly_result['balance']}" is_positive_text = f"Is positive: {'Yes' if monthly_result['is_positive'] else 'No'}" print(balance_text) print(is_positive_text) if __name__ == '__main__': january_results = calculate_balance(2000, 500) display_balance(january_results) ```def calculate\_balance(income, expenses): balance = income - expenses return {"balance": balance, "is\_positive": balance >= 0} \# result = calculate\_balance(1000, 300)# print(f"Balance: {result\['balance']}, es positivo?: {result\['is\_positive']}") \# from finance import calculate\_balance def display\_balance(monthly\_result): balance\_text = f"Balance {monthly\_result\['balance']}" is\_positive\_text = f"Is positive: {'Yes' if monthly\_result\['is\_positive'] else 'No'}" print(balance\_text) print(is\_positive\_text) if \_\_name\_\_ == '\_\_main\_\_': january\_results = calculate\_balance(2000, 500) display\_balance(january\_results)
```js def calculate_balance(income: int, expenses: int) -> tuple[int, bool]: net_balance = income - expenses is_positive = net_balance > 0 return net_balance, is_positive ```def calculate\_balance(income: int, expenses: int) -> tuple\[int, bool]:    net\_balance = income - expenses    is\_positive = net\_balance > 0    return net\_balance, is\_positive
def calculate\_balance(income: int, expenses: int) -> tuple\[int, bool]:    net\_balance = income - expenses    is\_positive = net\_balance > 0    return net\_balance, is\_positive
Solución 1 al reto, fusionando el obtener si es positivo el mes o negativo y el balance al mismo tiempo: ```python #reports.py código donde se crean las funciones para modularizar. # Genera un informe de ventas para un mes específico. def generate_sales_report(month, sales): return f'Sales Report - {month}: Total sales: $ {sales}' #Genera un informe de gastos para un mes específico. def generate_expenses_report(month, expenses): return f"Expenses Report - {month}: Total expenses: $ {expenses}" def calculate_balance(income, expenses) -> bool | int: balance = income - expenses if income - expenses > -1: return True, balance else: return False, balance #app.py codigo que usa los módulos. import reports #generar reportes de ventas y gastos usando funciones del modulo mes, sales, expenses = "Octubre", 10000, 1000 sales_report = reports.generate_sales_report(mes, sales) expense_report = reports.generate_expenses_report(mes, expenses) calculate_balance = reports.calculate_balance(sales, expenses) print(sales_report) print(expense_report) print(calculate_balance) print(f"El balance actual es Positivo: {calculate_balance[1]}" if calculate_balance[0] else f"El balance actual es Negativo {calculate_balance[1]}") ```
finance.py```js Módulo para cálculos financieros def calculate_balance(income, expenses): """ Calcula el balance mensual como la diferencia entre ingresos y gastos. :param income: Ingresos del mes. :param expenses: Gastos del mes. :return: Balance mensual. """ return income - expenses def is_profitable(balance): """ Determina si el mes ha sido rentable. :param balance: Balance mensual. :return: True si el balance es positivo, False si es negativo. """ return balance > 0 ``` Uso del modulo```js from finance import calculate_balance, is_profitable # Datos de ejemplo ingresos = 14000 gastos = 13000 # Calcular el balance balance = calculate_balance(ingresos, gastos) print(f"Balance del mes: {balance}") # Determinar si el mes ha sido rentable rentable = is_profitable(balance) print(f"¿El mes fue rentable? {'True' if rentable else 'False'}") ```
En este caso, `__init__.py` puede estar vacío o contener código de inicialización para el paquete. Luego, en `main.py`, puedes importar el módulo así: ```python # main.py from modulos.mi_modulo import saludar, despedir nombre = "Carlos" print(saludar(nombre)) # Salida: ¡Hola, Carlos! print(despedir(nombre)) # Salida: Adiós, Carlos. ```
### Estructura de Carpetas; `mi_proyecto/` `│` `├── main.py` `└── modulos/` ` ├── __init__.py` ` └── mi_modulo.py`
### Importación Específica También puedes importar funciones específicas del módulo si no necesitas todo el contenido: ```python # main.py from mi_modulo import saludar nombre = "Carlos" print(saludar(nombre)) # Salida: ¡Hola, Carlos! ```