Separar el código en módulos claros

Un único archivo puede servir para empezar pero acaba mezclando tareas que cambian por razones diferentes. En esta lección separarás reglas y ejecución en dos módulos pequeños. Después utilizarás el mismo criterio en el inventario. No hace falta construir una estructura empresarial para organizar una aplicación de unas pocas funciones.

Qué significa importar un módulo

Un módulo suele ser un archivo de Python cuyo contenido puedes utilizar desde otro. Al importarlo se ejecutan sus instrucciones de nivel superior. Las definiciones de funciones se registran pero sus cuerpos no se ejecutan hasta llamarlas. Si dejas un input fuera de una función la importación puede pedir datos de forma inesperada.

Crea una carpeta practica_modulos y guarda dentro reglas_demo.py. Esta función será independiente de la terminal: recibe un nombre y devuelve una versión aceptable. Todavía no representa toda la validación del proyecto final. Es una práctica mínima para comprender la organización.

def validar_nombre(texto):
    nombre = texto.strip()
    if not nombre:
        raise ValueError("El nombre no puede estar vacío")
    return nombre

Guarda al lado principal_demo.py. Mantén ambos archivos en la misma carpeta y ejecuta este segundo con el intérprete del curso. Python podrá encontrar reglas_demo al resolver la importación desde el directorio del programa.

def main(): nombre = validar_nombre(" Cuaderno ") print(nombre)

if __name__ == "__main__": main() «`

La condición final distingue la ejecución directa de la importación. Cuando ejecutas principal_demo.py como programa su nombre especial es __main__ y se llama a main. Si lo importas desde una prueba la función queda disponible pero no se inicia automáticamente. Es una frontera sencilla entre definir comportamientos y ponerlos en marcha.

Organizar por responsabilidad

El proyecto final tendrá modelo.py para las reglas de los artículos, intercambio.py para CSV, almacen.py para SQLite y app.py para los argumentos y mensajes. Cada archivo tendrá una razón clara para cambiar. Si modificas el formato CSV trabajarás principalmente en intercambio. Si cambias una validación buscarás modelo.

Esta distribución no equivale a poner una función en cada archivo. Un módulo puede reunir varias funciones relacionadas. Lo que queremos evitar es que para encontrar una regla tengas que abrir diez carpetas sin criterio. En un proyecto pequeño una estructura plana con cuatro archivos resulta suficiente y facilita copiar correctamente los ejemplos.

La dirección de las dependencias también importa. La interfaz puede llamar al almacenamiento y al intercambio. Ambos pueden utilizar el modelo. El modelo no necesita importar la interfaz. Esa dirección permite comprobar reglas sin arrancar el programa. Si modelo importara app y app importara modelo crearías una dependencia circular difícil de interpretar.

Dar nombres que no creen sorpresas

No utilices nombres de módulos estándar para tus archivos. Un archivo sqlite3.py en el proyecto puede impedir que importes el módulo auténtico. Tampoco añadas guiones a nombres de módulos que debas importar: utiliza guion bajo cuando necesites separar palabras. Los nombres de los artículos web pueden llevar guiones pero los archivos Python seguirán sus propias reglas.

Evita importaciones con asterisco. Una instrucción como from reglas_demo import validar_nombre muestra qué nombre incorporas. También puedes escribir import reglas_demo y llamar a reglas_demo.validar_nombre. Esta segunda opción conserva visible la procedencia. Elige una convención y mantenla, especialmente cuando varios módulos tengan funciones con nombres parecidos.

Preparar importaciones sin trucos de rutas

No modifiques sys.path para ocultar una estructura mal entendida. Durante este curso ejecutaremos la aplicación desde su carpeta y colocaremos juntos sus módulos. Más adelante podrás estudiar paquetes instalables pero no necesitas introducir esa complejidad todavía. Si Python no encuentra un archivo comprueba primero el nombre, la ubicación y la extensión real.

En algunos editores un archivo puede guardarse como principal_demo.py.txt sin que lo adviertas. Activa la visualización de extensiones en el explorador si tienes dudas. Otro problema es conservar dos copias del proyecto y editar una mientras ejecutas la otra. La ruta del error y la salida de sys.executable ayudan a reconstruir lo ocurrido.

Refactorizar manteniendo el comportamiento

Separar un archivo en módulos es una refactorización cuando conserva lo que el programa hace. Primero guarda una versión que funcione. Después mueve una responsabilidad y ejecuta las mismas comprobaciones. No aproveches el traslado para cambiar también las reglas de validación, los nombres de todos los campos y el formato de salida. Si falla algo no sabrás qué modificación lo provocó.

Puedes empezar extrayendo una sola función que ya hayas probado. Cambia su llamada para importarla desde el nuevo módulo y compara resultados. Cuando esa separación funciona continúa con la siguiente. Las modificaciones pequeñas permiten aprender del error y volver atrás con claridad. No necesitas rehacer todo el proyecto de una vez para mejorar su organización.

Errores habituales

Una importación no copia continuamente los cambios que haces en el editor a un proceso ya iniciado. Para esta práctica ejecuta el programa de nuevo después de guardar. Otro fallo consiste en dejar demostraciones y lecturas de archivos al nivel superior de un módulo que después utilizarás en pruebas. Sitúa esas demostraciones bajo la condición de ejecución directa.

Si dos módulos necesitan una regla compartida colócala en un tercer módulo pequeño del que ambos dependan. No hagas que se importen mutuamente para ahorrar unas líneas. El objetivo es que puedas seguir el recorrido de una operación desde app hasta sus reglas y su almacenamiento sin encontrar una cadena que vuelva sobre sí misma.

Lo que deberías recordar

• Importar ejecuta las instrucciones del nivel superior.
• main separa el arranque de las definiciones.
• Los módulos deben tener responsabilidades reconocibles.
• Evita dependencias circulares.

Ejercicio práctico

Crea reglas_demo.py y principal_demo.py exactamente en la misma carpeta. Ejecuta el segundo y comprueba que muestra Cuaderno. Después abre una sesión de Python desde esa carpeta e importa principal_demo. No debe imprimir el nombre ni solicitar datos. Anota qué diferencia produce la condición __name__.

Añade a reglas_demo una función que valide una cantidad entera no negativa. Llámala desde main con un valor válido. No introduzcas input dentro del módulo de reglas. Explica cómo podrías utilizar esa misma función desde una prueba automática sin tener que escribir nada en la terminal.

Dibuja en el cuaderno las dependencias previstas: app utiliza almacen e intercambio; ambos pueden utilizar modelo. Señala dónde colocarías un cambio de nombre permitido y dónde un cambio del separador CSV. La práctica estará completa cuando cada modificación tenga un lugar razonable sin necesidad de que modelo conozca la interfaz.

Siguiente: Tratar errores sin esconder problemas.

Volver al índice de Programar con Python.