Módulos en Python: Organiza tu Código para Claridad y Reutilización

Un módulo te permite organizar lógicamente tu código en Python. Agrupar código relacionado en un módulo facilita su comprensión y uso. Un módulo es un objeto de Python con atributos de nombre arbitrario que puedes vincular y referenciar.

En términos simples, un módulo es un archivo que contiene código Python. Un módulo puede definir funciones, clases y variables. También puede incluir código ejecutable.

Ejemplo

El código Python para un módulo llamado aname normalmente reside en un archivo llamado aname.py. Aquí tienes un ejemplo de un módulo simple, support.py:

def print_func(par):
    print("Hello :", par)
    return

La Sentencia import

Puedes usar cualquier archivo de código fuente Python como módulo ejecutando una sentencia import en otro archivo fuente Python. La sintaxis de import es la siguiente:

import module1[, module2[,... moduleN]]

Cuando el intérprete encuentra una sentencia import, importa el módulo si este está presente en la ruta de búsqueda. Una ruta de búsqueda es una lista de directorios que el intérprete busca antes de importar un módulo. Por ejemplo, para importar el módulo support.py, debes colocar el siguiente comando al principio del script:

#!/usr/bin/python
# Importar módulo support
import support

# Ahora puedes llamar a la función definida en el módulo
support.print_func("Zara")

Al ejecutar el código anterior, se produce el siguiente resultado:

Hello : Zara

Un módulo se carga solo una vez, independientemente del número de veces que se importe. Esto evita que la ejecución del módulo ocurra repetidamente si hay múltiples importaciones.

La Sentencia from...import

La sentencia from de Python permite importar atributos específicos de un módulo al espacio de nombres actual. La sintaxis es:

from modname import name1[, name2[, ... nameN]]

Por ejemplo, para importar la función fibonacci del módulo fib, usa:

from fib import fibonacci

Esta sentencia no importa el módulo completo fib al espacio de nombres actual; solo introduce el elemento fibonacci del módulo fib en la tabla de símbolos global del módulo importador.

La Sentencia from...import *

También es posible importar todos los nombres de un módulo al espacio de nombres actual usando:

from modname import *

Esto proporciona una forma fácil de importar todos los elementos de un módulo; sin embargo, esta sentencia debe usarse con moderación.

Localización de Módulos

Cuando importas un módulo, el intérprete de Python lo busca en la siguiente secuencia:

• El directorio actual.

• Si no se encuentra, Python busca en cada directorio de la variable de entorno PYTHONPATH.

• Si todo falla, Python verifica la ruta predeterminada. En UNIX, suele ser /usr/local/lib/python/.

La ruta de búsqueda de módulos se almacena en el módulo del sistema sys como la variable sys.path. Esta variable contiene el directorio actual, PYTHONPATH y la ruta predeterminada dependiente de la instalación.

La Variable PYTHONPATH

PYTHONPATH es una variable de entorno que consiste en una lista de directorios. Su sintaxis es la misma que la de la variable de shell PATH.

Ejemplo típico en Windows:

set PYTHONPATH = c:\python20\lib;

Ejemplo típico en UNIX:

set PYTHONPATH = /usr/local/lib/python

Espacios de Nombres y Alcance (Scoping)

Las variables son nombres (identificadores) que se mapean a objetos. Un espacio de nombres es un diccionario de nombres de variables (claves) y sus objetos correspondientes (valores).

Una sentencia Python puede acceder a variables en un espacio de nombres local y en el espacio de nombres global. Si una variable local y una global tienen el mismo nombre, la variable local sombrea a la global.

Cada función tiene su propio espacio de nombres local. Los métodos de clase siguen las mismas reglas de alcance que las funciones ordinarias.

Python asume que cualquier variable a la que se asigne un valor en una función es local. Por tanto, para asignar un valor a una variable global dentro de una función, debes usar primero la sentencia global.

La sentencia global VarName le dice a Python que VarName es una variable global. Python deja de buscar la variable en el espacio de nombres local.

Por ejemplo, definimos una variable Money en el espacio de nombres global. Dentro de la función AddMoney, asignamos un valor a Money, por lo que Python asume que Money es local. Sin embargo, accedimos al valor de la variable local Money antes de establecerla, lo que resulta en un UnboundLocalError. Descomentar la sentencia global soluciona el problema.

#!/usr/bin/python
Money = 2000

def AddMoney():
    # Descomenta la siguiente línea para corregir el código:
    # global Money
    Money = Money + 1
    print(Money)

AddMoney()
print(Money)

La Función dir()

La función integrada dir() devuelve una lista ordenada de cadenas que contienen los nombres definidos por un módulo.

La lista contiene los nombres de todos los módulos, variables y funciones definidos en un módulo. Ejemplo simple:

#!/usr/bin/python
# Importar módulo integrado math
import math

content = dir(math)
print(content)

Resultado:

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log', 'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']

Aquí, la variable de cadena especial __name__ es el nombre del módulo, e __file__ es el nombre del archivo desde el cual se cargó el módulo.

Las Funciones globals() y locals()

Las funciones globals() y locals() pueden usarse para retornar los nombres en los espacios de nombres global y local, dependiendo de desde dónde se llamen.

Si locals() se llama desde dentro de una función, retorna todos los nombres accesibles localmente desde esa función. Si globals() se llama desde dentro de una función, retorna todos los nombres accesibles globalmente desde esa función. Ambas funciones retornan un diccionario.

La Función reload()

Cuando un módulo se importa en un script, el código en la porción de nivel superior del módulo se ejecuta solo una vez. Si quieres reejecutar el código de nivel superior, puedes usar la función reload(). Esta importa nuevamente un módulo ya importado.

reload(module_name)

Aquí, module_name es el nombre del módulo a recargar (no la cadena que lo contiene). Por ejemplo, para recargar el módulo hello:

reload(hello)

Paquetes en Python

Un paquete es una estructura jerárquica de directorios de archivos que define un entorno de aplicación Python único, consistente en módulos, subpaquetes, sub-subpaquetes, etc.

Considera un archivo Pots.py en el directorio Phone con el siguiente código:

#!/usr/bin/python
def Pots():
    print("I'm Pots Phone")

De forma similar, tenemos otros dos archivos con funciones del mismo nombre:

• Phone/Isdn.py con la función Isdn()

• Phone/G3.py con la función G3()

Crea un archivo __init__.py en el directorio Phone:

• Phone/__init__.py

Para que todas tus funciones estén disponibles al importar Phone, añade sentencias import explícitas en __init__.py:

from Pots import Pots
from Isdn import Isdn
from G3 import G3

Después de añadir estas líneas, tendrás todas estas clases disponibles al importar el paquete Phone:

#!/usr/bin/python
# Importar tu paquete Phone
import Phone

Phone.Pots()
Phone.Isdn()
Phone.G3()

Resultado:

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

En el ejemplo usamos una sola función por archivo, pero puedes mantener múltiples funciones y definir diferentes clases Python en esos archivos para crear tus paquetes.