Módulos de Python

En este tutorial vamos a explorar los módulos de Python, uno de los mecanismos que podemos usar en Python para la programación modular.

Programación modular

La programación modular es el proceso de dividir una tarea de programación grande y difícil de manejar en subtareas o módulos separados más pequeños y manejables. Las ventajas de modularizar el código en una aplicación grande son las siguientes:

• Simplicidad: en lugar de centrarse en todos los problemas que soluciona la aplicación, un módulo normalmente se centra en un problema específico. Si estás trabajando en un solo módulo, tendrás un problema más pequeño para entender. Esto hace que el desarrollo sea más fácil y menos propenso a errores.

• Capacidad de mantenimiento: si los módulos se escriben pensando en minimizar la dependencia con otros módulos, existe una menor probabilidad de que las modificaciones a un solo módulo tengan un impacto en otras partes del programa. Es posible que incluso pueda realizar cambios en un módulo sin tener ningún conocimiento de la aplicación fuera de ese módulo. Esto hace que sea más viable para un equipo de muchos programadores trabajar en colaboración en una aplicación grande.

• Reutilización: la funcionalidad definida en un solo módulo se puede reutilizar por otras partes de la aplicación. Esto elimina la necesidad de duplicar el código.

• Alcance: los módulos generalmente definen un espacio de nombres o namespace separado, lo que ayuda a evitar colisiones entre identificadores en diferentes áreas de un programa.

Módulos de Python: descripción general

En Python hay tres tipos de módulos:

1. Módulos escritos en Python.
2. Módulos escritos en C que son cargados dinámicamente en tiempo de ejecución, como el módulo re (expresión regular).
3. Módulos integrados o built-in que están intrínsecamente contenidos en el intérprete, como el módulo itertools.

Se accede al contenido de un módulo de la misma manera en los tres casos: con la declaración de importación import.

En este tutorial nos vamos a centrar en los módulos que están escritos en Python. Lo bueno de los módulos escritos en Python es que son extremadamente sencillos de construir. Todo lo que necesitas hacer es crear un archivo que contenga código Python y luego darle al archivo un nombre con extensión .py.

Por ejemplo: podemos crear un archivo llamado platzi_mod.py que contenga lo siguiente:

slogan = "Nunca pares de aprender."
prices = [39, 212, 244]

defprint_this(arg):
	print(f'platzi = {arg}')

classPlatzi:
	pass

Varios objetos se definieron en platzi-mod.py:

• slogan (una cadena)
• prices (una lista)
• print_this() (una función)
• Platzi (una clase)

Suponiendo que platzi-mod.py está en una ubicación adecuada, sobre la que aprenderás más en breve, se puede acceder a estos objetos importando el módulo de la siguiente manera usando el REPL de Python:

>>> import platzi_mod
>>> print(platzi_mod.slogan)
Nunca pares de aprender.
>>> platzi_mod.prices
[39, 212, 244]
>>> platzi_mod.print_this(['se', paga, 'solo'])
platzi = ['se', paga, 'solo']
>>> course = platzi_mod.Platzi()
>>> course
0x03C181F0>

¿Desde dónde se importan los módulos de Python?

Continuando con el ejemplo anterior, vamos a profundizar en lo que sucede cuando Python ejecuta la siguiente declaración:

import platzi_mod

Cuando el intérprete ejecuta la declaración de importación anterior, busca platzi-mod.py en una lista de directorios que obtiene a partir de las siguientes fuentes:

• El directorio desde el que se ejecutó el script de entrada o el directorio actual si el intérprete se ejecuta de forma interactiva
• La lista de directorios contenidos en la variable de entorno PYTHONPATH, si está configurada. El formato de PYTHONPATH depende del sistema operativo, pero debe imitar la variable de entorno PATH.
• Una lista de directorios configurada en el momento de instalar Python

Puedes acceder a la lista de directorios usados para la búsqueda de módulos en la variable de Python sys.path, que se obtiene de un módulo llamado sys.

El contenido exacto de sys.path depende de la instalación. Es casi seguro que el siguiente ejemplo se verá diferente en tu computadora.

>>> import sys
>>> sys.path
['', '/home/platzi/.pyenv/versions/3.8.11/lib/python3.8/site-packages']

Por lo tanto, para estar seguro de que el intérprete de Python encuentre tu módulo, debes realizar una de las siguientes acciones:

• Coloca platzi-mod.py en el directorio donde se encuentra el script de entrada o en el directorio actual si estás usando el intérprete de forma interactiva.
• Modifica la variable de entorno PYTHONPATH para que contenga el directorio donde se encuentra platzi-mod.py antes de iniciar el intérprete o coloca platzi-mod.py en uno de los directorios que ya están incluidos en la variable PYTHONPATH.
• Coloca platzi-mod.py en uno de los directorios dependientes de la instalación, al que puede o no tener acceso de escritura, según el sistema operativo

En realidad, hay una opción adicional: puedes colocar el archivo del módulo en cualquier directorio de tu elección y luego modificar sys.path en tiempo de ejecución para que contenga ese directorio. Por ejemplo, en este caso, podrías poner platzi-mod.py en el directorio C: \Users\platzi y luego ejecutar los siguientes comandos:

>>> sys.path.append(r'C:\Users\platzi)
>>> sys.path
['',  '/home/platzi/.pyenv/versions/3.8.11/lib/python3.8/site-packages', 'C:\\Users\\platzi']
>>>import platzi_mod

Una vez que se ha importado un módulo, puedes determinar la ubicación donde se encontró con el atributo __file__ del módulo:

>>> import mod
>>> mod.__file__'C:\\Users\\platzi'\\mod.py'

La parte del directorio del output de __file__ debe ser uno de los directorios listados por sys.path.

Conclusiones

En este tutorial se cubrieron los siguientes temas:

• Cómo crear un módulo de Python
• Ubicaciones donde el intérprete de Python busca un módulo

Espero que esto te permita comprender mejor cómo obtener acceso al mecanismo de módulos disponible en Python.

Da el siguiente paso en tu formación de Python con el curso de FastApi