Módulos y Paquetes en Python: Reutilización y Organización de Código
Resumen
¿Qué es un módulo en Python y por qué es importante?
El uso de módulos y paquetes en Python es una práctica esencial que potencia la organización y reutilización del código. Un módulo es un archivo .py que contiene definiciones y declaraciones de funciones, variables y clases que puedes reutilizar en diferentes partes de un proyecto e incluso en múltiples proyectos. Al dividir el código en módulos, se mejora no solo la organización, sino también la mantenibilidad de un proyecto. Este método, "divide y vencerás", resulta en un código más eficiente y fácil de manejar.
¿Cómo crear y usar módulos en Visual Studio Code?
Para entender realmente los módulos, es útil verlos en acción. Supongamos que tienes un proyecto que necesita generar informes de ventas y gastos. Puedes dividir esta funcionalidad en dos partes dentro de un módulo llamado reportes.py.
# reportes.pydefgenerar_informe_ventas(mes, ventas):returnf"Reporte del mes de {mes}: Total de ventas = ${ventas}"defgenerar_informe_gastos(mes, gastos):returnf"Reporte del mes de {mes}: Total de gastos = ${gastos}"
Una vez que las funciones están definidas, puedes consumirlas desde otro archivo en tu proyecto simplemente importándolas.
A veces, puede que solo necesites una o dos funciones de un módulo. En estos casos, conviene utilizar la declaración from import para traer solo esas partes necesarias, optimizando el rendimiento del programa.
Si necesitas importar más funciones, simplemente las añades en una lista separada por comas:
from reportes import generar_informe_ventas, generar_informe_gastos
reporte_ventas_nov = generar_informe_ventas("noviembre",12000)reporte_gastos_nov = generar_informe_gastos("noviembre",6000)print(reporte_ventas_nov)print(reporte_gastos_nov)
Este método no solo mejora la claridad del código, sino que también mantiene el tamaño de tu aplicación reducido, ya que solo importa aquello que realmente vas a utilizar.
¿Por qué es vital utilizar módulos en el desarrollo?
El uso de módulos en Python tiene varias ventajas cruciales:
Reutilización de código: Permite reutilizar fragmentos de código, facilitando la creación de aplicaciones consistentes y simplificando actualizaciones y mantenimientos futuros.
Organización: Ayuda a dividir el código en componentes bien definidos, lo que mejora la legibilidad y la estructura del proyecto.
Manteniabilidad: Facilita la extensión y modificación del código cuando es necesario, haciendo que el proyecto sea más accesible para otros desarrolladores.
¡Te animamos a implementar esta práctica! Intenta crear un módulo que gestione las finanzas de una empresa, calculando mes a mes el balance y determinando la rentabilidad. Esta actividad consolidará tus conocimientos sobre módulos y su aplicación, llevándote más lejos en tu viaje de aprendizaje en programación.
Continúa explorando este fascinante mundo, ¡cada línea de código que escribes es un paso hacia adelante en tu desarrollo como programador!
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
SI COMPAÑERO
Si, asi es en todos los lenguajes, por ejemplo en lenguajes de programación compilados, como en C o C++, también se tienen librerías o paquetes ya precompilados (en formato binario) lo que sería un archivito .dll no sé si los has llegado a ver en windows, en Linux es diferente, depende también mucho del entorno
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:
\# matematica.py
defsumar(a, b):  return a + bdefrestar(a, b):  return a - bdefmultiplicar(a, b):  return a \* bdefdividir(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:
Puedes importar funciones específicas o dar alias a las funciones o módulos para hacer el código más legible.
\# 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:
\# matematica.py
defsumar(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/geometria.py
def area\_cuadrado(lado):  return lado \* lado
#### main.py
\# 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.
Gracias por tu aporte
main.py
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
defcalculate_balance(income:float|int, expenses:float|int)->float|int:return income - expenses
defprofitable_banlace(balance:float|int)->bool:return balance >0
defcalculate_balance(income,expenses): balance = income - expenses
if balance <0:returnf'El balance es $ {balance} -> {False}'else:returnf'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->TrueEl balance es $ -500->False
Brutal, super sencillo y entendible el código!
"""
Implementar un módulo que contenga funciones para calcular el
balance de un mes (diferencia entre ingresos y gastos)
y determinar si el mes ha sido rentable.
"""# Calcula el balance de un mes.defcalculate_balance(income, expenses): balance = income - expenses
returnf"Month balance: ${balance}"# Determina si el mes ha sido rentable.defis_profitable(balance):if balance >0:returnf"Congratulations! You made a profit of ${balance} this month."elif balance ==0:returnf"You done enought {balance}"else:returnf"You made a loss of ${balance} this month."from finance import calculate_balance, is_profitable
print(calculate_balance(1000,500))print(is_profitable(500))
import asyncio
import concurrent.futures
import time
# --- LÓGICA DE FINANZAS (Antes estaba en el módulo) ---
Sinceramente siento que falta creatividad con los cursos, se que tambien debemos ser autodidactas e investigar por nuestra cuenta y asi, pero entonces cual es el caso de invertir en estas plataformas si de todas formas tenemos que buscarle por otro lado no juzgo los conocimientos de la profesora pero a partir de la clase 40 como que algo paso que perdi el interes y mejor investigue por mi cuenta y pues quise acabar el curso por no quedarme a medias pero nose, deberian ser como el Profe Ricardo Celis tambien docente de esta plataforma ya que todos sus cursos son bien llamativos sabe como mantenerte interesado y se le nota su pasion por dar clases no que unos profes bien de flojera con todo respeto, no es el caso de la profesara Carli que se ve motivada pero apresuro mucho las cosas saltandose conceptos y explicaciones y tenemos derecho a hacer saber estos puntos porque poco o mucho pero pagamos por estos cursos,... asi que quejas de otros compañeros que no esten de acuerdo conmigo son aceptadas pero pues cada quien no?
Me parece que inicialmente se concibieron como dos cursos distintos por separado, uno de fundamentos, y otro avanzado, que fueron grabados en momentos diferentes, terminaron pegando los dos contenidos.
Sin embargo, en mi caso, llegué sabiendo 0 de Python, y salgo sabiendo muchos fundamentos, conociendo cómo se construye un código, de aquí en adelante, toca seguir practicando. Las herramientas de hoy hacen diferente la experiencia de escribir código, lo importante es entender la lógica, y cómo es la arquitectura para generar buenas soluciones.
from finance import calcule_balance
income =12000expenses =8000balance, is_profitable =calcule_balance(income, expenses)print(f'Balance: {balance}')print(f'Is Profitable: {is_profitable}')
Módulo reports:
# Genera un informe de ventas para un mes específico.defgenerate_sales_report(month, sales):print(f'Sales Report - {month}: Total sales: ${sales}')return sales
# Genera un informe de gastos para un mes específico.defgenerate_expenses_report(month, expenses):print(f'Expenses Report - {month}: Total expenses: ${expenses}')return expenses
Módulo finance:
from reports import generate_expenses_report, generate_sales_report #importar partes de un modulodefgenerate_balance_report(month, sales, expenses): balance:float= generate_sales_report(month, sales)- generate_expenses_report(month, expenses)if balance <0:print(f'{month} has been a terrible month! balance: ${balance}')elif balance ==0:print(f'{month} has been an akward month! balance: ${balance}')else:print(f'{month} has been quite a month! balance: ${balance}')
Ejecución en app.py:
from finance import generate_balance_report
generate_balance_report('October',50000,2000)
Alguien hace las actividades?
Para manejar los métodos de una clase importada desde otro módulo, primero debes importar la clase especificando el módulo. Por ejemplo, si tienes una clase MiClase en un módulo llamado mi_modulo.py, lo harías así:
from mi_modulo import MiClase
# Crear una instancia de la claseinstancia = MiClase()# Llamar a un método de la claseinstancia.mi_metodo()
Esto te permite acceder a los métodos de MiClase directamente a través de la instancia creada. Si solo quieres un método específico, puedes usar la sintaxis from mi_modulo import MiClase.mi_metodo. Así, importas únicamente el método deseado, optimizando tu código.
La expresión from e import se utiliza en Python para importar funciones, clases o variables específicas desde un módulo e. Esto permite acceder directamente a esos elementos sin necesidad de referirse al nombre del módulo. Es útil para evitar la carga innecesaria de todo el módulo y mejorar la legibilidad del código.
Por ejemplo, si tienes un módulo llamado math y quieres usar solo la función sqrt, puedes hacerlo así:
from math import sqrt
Esto te permite llamar a sqrt(9) directamente, en vez de math.sqrt(9). Utilizar from import hace que tu código sea más limpio y específico.
modulo:```python
"""
Modulo para calcular el balance de un empresa en un mes especifico (diferencia entre ingresos y gastos)
y determinar si el mes ha sido rentable
"""
def calculate_balance(income, expenses):
balance = income - expenses
return balance
```js
import finance
# Calcular el balance y ver si el mes ha sido rentable
balance1 = finance.calculate_balance(6000, 4500)
balance2 = finance.calculate_balance(8700, 9000)
profitable1 = finance.profitable_month(balance1)
profitable2 = finance.profitable_month(balance2)
print(profitable1) # True
print(profitable2) # False
Aquí mi aporte:
Archivo JSON:
Tendrá 12 elementos, donde cada uno tendrá el mes, el ingreso y los gatos.
Será usando por la aplicación principal para poder iterar por cada mes y enviar a los métodos del módulo, sus respectivos ingresos y gastos.
En este caso, he creado el módulo dentro de la carpeta "modules". Cuando se llamando por el programa principal deberá ser llamada como "import modules.fynance"
Contiene los 2 métodos indicados en el reto: uno para calcular el balance y el otro para validar la rentabilidad.
## modules/fynance.py#Calcular el balance
def calculate_balance(income,expenses):return income - expenses
#Calcular la rentabilidad
def validate_profitability(balance):return(balance >0)
Programa principal
Importará al modulo "fynance.py"
Leerá el archivo .JSON para obtener los ingresos y gastos de los 12 meses.
Iterará por cada mes para calcular el abaleen y la rentabilidad.
import json
import modules.fynanceas fynance
ruta_archivo ="JSON/balance.json"# Leer el archivo Jsonwithopen(ruta_archivo,"r")asfile: meses = json.load(file)# Recorrer todos los meses y calcular su balance y rentabilidad
for mes inmeses:print('************************************')print(f'Análisis para el mes: {mes['mes']}') balance = fynance.calculate_balance(mes['incomes'],mes['expenses']) rentabilidad = fynance.validate_profitability(balance)print(f'El balance es: S/{balance} soles')if fynance.validate_profitability(balance):print(f'La rentabilidad es POSITIVA')else:print(f'La rentabilidad es NEGATIVA')
