Programación Modular en Python
La programación modular es una técnica de diseño de software que
enfatiza la separación de la funcionalidad de un programa en módulos
independientes e intercambiables.1 Cada módulo contiene todo lo
necesario para ejecutar solo un aspecto de la funcionalidad deseada. Este
enfoque promueve la organización, la reutilización del código y la facilidad
de mantenimiento.
Definición de Módulos
En Python, un módulo es simplemente un archivo que contiene definiciones
y declaraciones de Python. El nombre del archivo es el nombre del módulo 2
con el sufijo .py agregado. Dentro de un módulo,3 puedes definir funciones,
clases y variables. Un módulo también puede incluir código ejecutable.
Agrupar código relacionado en un módulo hace que el código sea más fácil
de entender y usar.
Diferencias con las Librerías de Python
A menudo, los términos "módulo" y "librería" se usan indistintamente, pero
tienen una distinción sutil:
● Módulo: Es un único archivo (o algo que Python trata como un único
archivo) que contiene código Python. Puedes importar un módulo en otro
módulo o en el intérprete interactivo.
● Librería (o Paquete): Generalmente, una librería es una colección de
módulos relacionados. Un paquete en Python es una forma de
estructurar el espacio de nombres de los módulos de Python utilizando
"nombres de módulo con puntos". Por ejemplo, la librería NumPy
contiene muchos módulos para la computación numérica. En esencia,
una librería es un conjunto de herramientas más amplio, mientras que un
módulo es una herramienta específica.
Podríamos decir que los módulos son los bloques de construcción, y las
librerías son conjuntos de estos bloques organizados para un propósito más
amplio.
Estructura de un Módulo
Un módulo de Python típico tiene la siguiente estructura (aunque no todos
los elementos son obligatorios):
1. Shebang (opcional): #!/usr/bin/env python3 (usado para scripts
ejecutables en sistemas Unix-like).
2. Docstring del módulo (recomendado): Una cadena de texto
encerrada en triples comillas ("""Docstring del módulo""") al principio del
archivo que describe el propósito y contenido del módulo.
3. Declaraciones de importación: Sentencias import para usar otros
módulos.
4. Constantes globales: Variables que se espera que permanezcan sin
cambios.
5. Definiciones de clases.
6. Definiciones de funciones.
7. Código principal (opcional): A menudo dentro de un bloque if
__name__ == "__main__":. Este bloque se ejecuta solo cuando el archivo
se ejecuta directamente como un script, no cuando se importa como un
módulo en otro script.
Python
#!/usr/bin/env python3
"""
Este es un ejemplo de módulo llamado mi_modulo.py
Contiene una función de saludo y una constante.
"""
import math # Importación de un módulo de la librería estándar
MI_CONSTANTE = 3.1416
def saludar(nombre):
"""Función para saludar a alguien."""
return f"Hola, {nombre}! Bienvenido al módulo."
class MiClase:
"""Una clase de ejemplo."""
def __init__(self, valor):
[Link] = valor
def mostrar_valor(self):
print(f"El valor es: {[Link]}")
if __name__ == "__main__":
# Este código se ejecuta solo cuando el módulo se ejecuta directamente
print("El módulo mi_modulo.py se está ejecutando directamente.")
print(saludar("Usuario"))
objeto = MiClase(10)
objeto.mostrar_valor()
print(f"El valor de PI aproximado es: {MI_CONSTANTE}")
print(f"El valor de PI de math es: {[Link]}")
Tipos y Clases de Módulos
Los módulos en Python se pueden clasificar en términos generales en:
1. Módulos Incorporados (Built-in Modules):
○ Escritos en C y precompilados con el intérprete de Python.
○ Proporcionan acceso a funcionalidades básicas del sistema o a
operaciones eficientes.
○ Ejemplos: sys, os, math, time.
○ Se importan directamente sin necesidad de instalación.
2. Módulos de la Librería Estándar (Standard Library Modules):
○ Escritos en Python y vienen con la instalación estándar de Python.
○ Ofrecen una amplia gama de funcionalidades, como manejo de
cadenas, redes, protocolos de internet, etc.
○ Ejemplos: random, datetime, json, [Link].
○ No necesitan instalación, solo importación.
3. Módulos de Terceros (Third-party Modules):
○ Desarrollados por la comunidad de Python o empresas.
○ Se instalan usando administradores de paquetes como pip.
○ Amplían enormemente las capacidades de Python para tareas
específicas.
○ Ejemplos: NumPy (computación científica), Pandas (análisis de datos),
Requests (solicitudes HTTP), Django (desarrollo web), TensorFlow
(aprendizaje automático).
4. Módulos Definidos por el Usuario (User-defined Modules):
○ Son los módulos que tú creas para organizar tu propio código.
○ Permiten estructurar proyectos grandes en partes más pequeñas y
manejables.
Modulación de Aplicaciones en Python
La modulación de aplicaciones consiste en dividir una aplicación grande en
módulos más pequeños y cohesivos. Los beneficios incluyen:
● Simplicidad: Los módulos más pequeños son más fáciles de entender y
gestionar.
● Mantenibilidad: Los cambios en un módulo tienen menos probabilidad
de afectar otras partes de la aplicación. Es más fácil depurar y actualizar
módulos individuales.
● Reusabilidad: Un módulo bien diseñado puede ser reutilizado en
diferentes partes de la aplicación o incluso en otros proyectos.
● Espacio de Nombres: Los módulos crean espacios de nombres
separados, lo que ayuda a evitar colisiones de nombres entre
identificadores.
● Colaboración: Diferentes desarrolladores pueden trabajar en diferentes
módulos simultáneamente.
Estrategias para la modulación:
● Cohesión: Agrupa funcionalidades relacionadas dentro del mismo
módulo. Un módulo debe tener una única responsabilidad bien definida.
● Acoplamiento Bajo: Minimiza las dependencias entre módulos. Los
módulos deben interactuar a través de interfaces bien definidas
(funciones y clases públicas).
● Abstracción: Oculta los detalles internos de implementación de un
módulo y expón solo lo necesario.
Uso de Módulos en Python
Para usar las funciones, clases o variables definidas en un módulo, primero
debes importarlo en tu script o sesión interactiva. Hay varias formas de
hacerlo:
1. Importar el módulo completo:
Python
import nombre_del_modulo
# Para usar algo del módulo:
nombre_del_modulo.funcion()
variable = nombre_del_modulo.MI_CONSTANTE
2. Importar con un alias:
Python
import nombre_del_modulo as alias
# Para usar algo del módulo:
[Link]()
Esto es común con módulos de nombres largos, como import numpy as
np.
3. Importar elementos específicos del módulo:
Python
from nombre_del_modulo import funcion_especifica, OtraClase
# Para usar algo del módulo (sin el prefijo del nombre del módulo):
funcion_especifica()
mi_objeto = OtraClase()
4. Importar todo el contenido del módulo (generalmente
desaconsejado):
Python
from nombre_del_modulo import *
# Para usar algo del módulo (sin el prefijo del nombre del módulo):
funcion()
Esto puede llevar a colisiones de nombres y hacer que el código sea
menos legible, ya que no está claro de dónde provienen ciertos nombres.
Python busca módulos en el siguiente orden:
1. El directorio que contiene el script de entrada (o el directorio actual si es
interactivo).
2. Los directorios listados en la variable de entorno PYTHONPATH.
3. Los directorios de instalación por defecto (donde está instalada la librería
estándar).
Puedes ver la ruta de búsqueda de módulos usando [Link].
Ejemplos Prácticos
Matemáticas
Supongamos que creamos un módulo operaciones_matematicas.py:
Python
# operaciones_matematicas.py
"""Módulo para operaciones matemáticas básicas."""
PI = 3.1415926535
def sumar(a, b):
"""Retorna la suma de a y b."""
return a+b
def restar(a, b):
"""Retorna la resta de b de a."""
return a-b
def area_circulo(radio):
"""Calcula el área de un círculo dado su radio."""
return PI * radio ** 2
Uso del módulo operaciones_matematicas.py:
Python
# script_principal_mat.py
import operaciones_matematicas as opm
num1 = 10
num2 = 5
print(f"Suma: {[Link](num1, num2)}")
print(f"Resta: {[Link](num1, num2)}")
print(f"Área de un círculo con radio 3: {opm.area_circulo(3)}")
print(f"Valor de PI usado: {[Link]}")
Física
Imaginemos un módulo [Link] para cálculos de cinemática:
Python
# [Link]
"""Módulo para cálculos de cinemática."""
GRAVEDAD_TIERRA = 9.81 # m/s^2
def velocidad_final_caida_libre(velocidad_inicial, tiempo):
"""Calcula la velocidad final en caída libre (sin resistencia del aire)."""
return velocidad_inicial + GRAVEDAD_TIERRA * tiempo
def posicion_mru(posicion_inicial, velocidad, tiempo):
"""Calcula la posición en Movimiento Rectilíneo Uniforme."""
return posicion_inicial + velocidad * tiempo
Uso del módulo [Link]:
Python
# script_principal_fis.py
import cinematica
# Calcular velocidad final de un objeto que cae desde el reposo por 2 segundos
vf = cinematica.velocidad_final_caida_libre(0, 2)
print(f"Velocidad final en caída libre: {vf:.2f} m/s")
# Calcular posición de un objeto que parte de 5m con velocidad constante de 10 m/s por 3
segundos
pos = cinematica.posicion_mru(5, 10, 3)
print(f"Posición final en MRU: {pos} m")
print(f"Constante de gravedad usada: {cinematica.GRAVEDAD_TIERRA} m/s^2")
Química
Podemos crear un módulo conversion_temperatura.py:
Python
# conversion_temperatura.py
"""Módulo para convertir temperaturas entre Celsius, Fahrenheit y Kelvin."""
def celsius_a_fahrenheit(celsius):
"""Convierte Celsius a Fahrenheit."""
return (celsius * 9/5) + 32
def fahrenheit_a_celsius(fahrenheit):
"""Convierte Fahrenheit a Celsius."""
return (fahrenheit - 32) * 5/9
def celsius_a_kelvin(celsius):
"""Convierte Celsius a Kelvin."""
return celsius + 273.15
def kelvin_a_celsius(kelvin):
"""Convierte Kelvin a Celsius."""
return kelvin - 273.15
Uso del módulo conversion_temperatura.py:
Python
# script_principal_qui.py
from conversion_temperatura import celsius_a_fahrenheit, celsius_a_kelvin
temp_celsius = 25
temp_fahrenheit = celsius_a_fahrenheit(temp_celsius)
temp_kelvin = celsius_a_kelvin(temp_celsius)
print(f"{temp_celsius}°C es equivalente a {temp_fahrenheit:.2f}°F")
print(f"{temp_celsius}°C es equivalente a {temp_kelvin:.2f} K")
Estos ejemplos ilustran cómo la programación modular ayuda a organizar el
código en archivos lógicos y reutilizables, haciendo que los proyectos sean
más manejables y escalables.
Fuentes
1. [Link]
2. [Link]
3. [Link]