Creación de módulos en Python

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

```js #app.py import finance balance = finance.calculate_balance('Enero', 7000, 6000) profitable_balance1 = finance.profitable_balance('Enero', balance) ```finance.py````python #Calcula la diferencia entre ingresos y gastos def calculate_balance(month: str, income: float|int, expenses: float|int): return income / expenses #Calcula el balance de un mes def profitable_balance (month, balance): if balance>0: True print(f'En el mes de: {month} el balance {balance} es positivo') else: print(f'En el mes de: {month} el balance {balance} es negativo') False ```#Calcula la diferencia entre ingresos y gastos def calculate\_balance(month: str, income:  float|int, expenses: float|int):    return income / expenses \#Calcula el balance de un mes def profitable\_balance (month, balance):    if balance>0:        True        print(f'En el mes de: {month} el balance {balance} es positivo')    else:        print(f'En el mes de:  {month} el balance {balance} es negativo')        False ````

Muy interesante la creación de módulos y como esto puede facilitar la reutilización de funciones y desconocía que eran simplemente archivos .py

Compañeros les comparto el codigo del reto: Modulo Finance.py: \#Función que calcula el balance de la emprea.def calculate\_balance(income, expenses):        return income - expenses \#Función que determina si el balance es negativo o positivo.def report\_balance(month, income, expenses):                balance = calculate\_balance(income, expenses)               if income > expenses:            return month, balance, True  #devuelve una tupla con tres valores: (month, balance, True/False).        else:            return month, balance, False  #devuelve una tupla con tres valores: (month, balance, True/False). App que lo importa y lo llama app.balance.py: from finance import report\_balance month, balance, is\_positive = report\_balance('Abril', 6000, 5000)   if is\_positive:    print(f'El mes de {month} tuvo un balance positivo de $: {balance}')else:    print(f'El mes de {month} tuvo un balance negativo de $: {balance}') def example1():    return 'Abril', 1000, True  # Sin paréntesis def example2():    return ('Abril', 1000, True)  # Con paréntesis

```python from main import expense_check import random Months =[ ["January", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ["February", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ["March", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ["April", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ["May", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ["June", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ["July", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ["August", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ["September", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ["October", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ["November", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ["December", expense_check(random.randint(1000, 2000), random.randint(900, 1900))], ] def month_check(): index = 0 while index <= 11: print(f'{Months[index][0]} is {Months[index][1]}') index += 1 month_check() ```from main import expense\_check import random Months =\[ \["January", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], \["February", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], \["March", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], \["April", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], \["May", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], \["June", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], \["July", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], \["August", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], \["September", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], \["October", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], \["November", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], \["December", expense\_check(random.randint(1000, 2000), random.randint(900, 1900))], ] def month\_check(): index = 0 while index <= 11: print(f'{Months\[index]\[0]} is {Months\[index]\[1]}') index += 1 month\_check()

Solucion al reto: ```python """ Crea un modulo llamado finance.py que contenga funciones para calcular el balance de un mes (diferencia entre ingresos y gastos) y determinar si el mes ha sido rentable 1. la función calculate_balance(income,expenses) debe devolver la diferencia entre ingresos y gastos 2. devolver True si el balance es positivo, False si es negativo mes a mes. """ import finance def balance_month(month, income, expenses): balance_report = finance.calculate_balance(income, expenses) if balance_report: print(f'El balance del mes {month} ha sido positivo, con: \nTotal de ingresos: ${income}. \nTotal de egresos: ${expenses} ') else: print(f'El balance del mes {month} ha sido negativo, con: \nTotal de ingresos: ${income}. \nTotal de egresos: ${expenses} ') balance_month('Enero',25000,10000) balance_month('Febrero',15000,30000) ```Y en la pagina finance.py ```python def calculate_balance(income, expenses): if income > expenses: return True else: False ```

 ## Modulo finance.py : ```python """ Reto: crear un modulo llamado finance.py que contenga funciones para calcular el valance de un mes (diferencia entre ingresos y gastos) y determinar si el mes ha sido rentable o no. funciones: 1. calculate_balance(income, expenses): debe devolver la diferencia entre ingresos y gastos 2. is_profitable(balance): debe devolver True si el balance es positivo, False en caso contrario. """ def calculate_balance(income, expenses): return income - expenses def is_profitable(balance): return balance > 0 def total_income(income): return sum(income) def total_expenses(expenses): return sum(expenses) ``` Archivo app.py : ```python """ segunda parte del reto: usar el modulo creado en la primera parte para hacer un balance de ingresos y gstos de una empresa """ from random import randint import finance as f income = [randint(1000, 10000) for _ in range(12)] expenses = [randint(100, 10000) for _ in range(12)] total_income = f.total_income(income) total_expenses = f.total_expenses(expenses) balance = f.calculate_balance(total_income, total_expenses) is_profitable = f.is_profitable(balance) def print_report(income, expenses, total_income, total_expenses, balance, is_profitable): print("Income: ", income) print("Expenses: ", expenses) print("Total income: ", total_income) print("Total expenses: ", total_expenses) print("Balance: ", balance) print("Is profitable: ", is_profitable) print_report(income, expenses, total_income, total_expenses, balance, is_profitable) ``` ---

En el archivo finance.py: ```js class Financial_analysis: def __init__(self, income: float, expenses: float): self.income = income self.expenses = expenses self.balance = 0 @property def calculate_balance(self) -> float: self.balance = self.income - self.expenses return self.balance @property def is_profitable(self) -> bool: return True if self.balance > 0 else False ``` En otro archivo: ```js from finance import Financial_analysis incomes = 145000 expenses = 146000 financial_analysis = Financial_analysis(incomes, expenses) print(f'Balance: {financial_analysis.calculate_balance}') print(f'¿Fue rentable?') print(f'{"El cielo es la cima papá :)" if financial_analysis.is_profitable else "No, todo está perdidijillo"}') ```

```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?


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! ```