Cuando nuestro programa va creciendo, vamos a ver la necesidad de tenerlo lo mas ordenado posible. Una de las formas muy recomendables es que tengamos nuestro programa dividido en varios archivos. Lo que se conoce como paquete (package) o módulo.
En Python, los programas se escriben usando la extensión .py así que un módulo, tendrá esa misma extensión.
Un módulo o module en Python será un archivo .py que contiene un conjunto de funciones, variables o clases y que puede ser usado por otros módulos. Nos permiten reutilizar código y organizarlo mejor en namespaces.
Podemos definir un módulo llamado module.py en un archivo separado con dos funciones suma() y resta().
# module.py
def suma(a, b):
return a + b
def resta(a, b):
return a - b
Una vez definido el módulo puede ser importado desde otro archivo usando import
# programa.py
import module
print(module.suma(4, 3)) # 7
print(module.resta(10, 9)) # 1
En el ejemplo citado se importa todo el contenido del archivo. Pero puede importarse solamente las funciones que nos interese importar.
# programa.py
from module import suma, resta
print(suma(4, 3)) # 7
print(resta(10, 9)) # 1
Se importan funciones que vamos a utilizar separadas por coma y solo se importarán dichas funciones.
# programa.py
from module import *
print(suma(4, 3)) # 7
print(resta(10, 9)) # 1
Si importamos los módulos de la forma from modulo import no hace falta hacer explícito el llamado a la función con module.funcion().
Siempre que sea posible debemos importar solamente las funciones que vamos a utilizar.
En el ejemplo anterior, modulo.py y programa.py están ubicados en la misma carpeta. Pero es posible (y recomendable) tener los módulos ubicados en otra carpeta.
Por ejemplo, podemos tener la siguiente estructura:
curso
├── mods
│ ├── module.py
│ └── module_2.py
└── programa.py
Si queremos invocar a module.py desde nuestro programa debemos hacerlo de la siguiente manera:
from mods.module.py import *
print(suma(4, 3)) # 7
Es habitual importar módulos y renombrarlos internamente con un nombre mas corto. Supongamos que tenemos un módulo con un nombre largo.
# modulo_con_nombre_largo.py
saludo = "Hola"
En vez de invocarlo así:
import modulo_con_nombre_largo
print(modulo_con_nombre_largo.saludo)
Podríamos abreviarlo de la siguiente manera usando as
import modulo_con_nombre_largo as m
print(m.saludo)
Importar un módulo puede lanzar una excepción cuando se intenta importar un módulo que no ha sido encontrado. Dicha excepción es un ModuleNotFoundError.
Tal excepción es levantada porque un módulo no ha sido encontrado y debemos verificar si lo estamos invocando correctamente.
from mods.modulosas import *
ModuleNotFoundError: No module named 'mods.modulosas'
Un problema frecuente es que al crear un módulo e importarlo desde otro módulo tengamos código "suelto" (fuera de funciones), entonces al importarlo, el intérprete ejecutará ese código y probablemente no sea lo que deseamos. Ejemplo:
# modulo.py
def suma(a, b):
return a + b
print(f"La suma es {suma(3,99)}") # Código "suelto"
# programa.py
import modulo
# Output: La suma es 102
# ...
Dependiendo del caso, puede ser importante especificar que el código "suelto" se ejecute solamente si el módulo es ejecutado por sí mismo (y no si es importado desde otro módulo). Por lo tanto se dice que el módulo es el __main__
# modulo.py
def suma(a, b):
return a + b
if (__name__ == '__main__'):
print(f"La suma es {suma(3,99)}") # Código "suelto"
La variable __main__ es una variable auto-generada por el intérprete que se refiere al nombre del módulo actual.
El código dentro de __main__ suele usarse para "testear" el módulo con casos de prueba. Pero tales datos de prueba no se ejecutan si es importado por otro módulo.
Python (como muchos otros lenguajes) contiene tipos y funciones incorporadas (Built-in Functions) que siempre estarán disponibles para usarlas sin necesidad de acudir a import.
Puede consultar en la Documentación de Python para tener un listado completo.
Algunas ya las hemos usado en clase por lo que le pueden resultar familiar.
Una buena práctica cuando se escribe un módulo es definir que es lo que hace y como se usa. Se usa la notación de comentarios con triple comillas dobles.
"""Breve descripción del módulo
Puede contener instrucciones de como se usa
"""
def suma(a, b):
""" Retorna la suma de dos operandos enviados por parámetro
"""
return a + b
if (__name__ == '__main__'):
print(f"La suma es {suma(3,99)}") # Código "suelto"
Realice un módulo llamado calcular.py que contenga 4 funciones, sumar(x,y), restar(x,y), multiplicar(x,y), dividir(x,y).
Separe en un módulo, llamado pila.py que contenga el código del ejercicio 5 de la práctica 9. De manera que se pueda importar desde otro programa y se pueda usar.
Realice una pequeña documentación con lo que hace cada método.