Tutorial sobre cómo trabajar con módulos en Python

Como principiante, empiezas a trabajar con Python en el intérprete, más adelante, cuando necesitas escribir programas más largos, empiezas a escribir scripts. A medida que tu programa aumente de tamaño, es posible que quieras dividirlo en varios archivos para facilitar el mantenimiento y la reutilización del código. La solución son los Módulos. Puedes definir tus funciones más utilizadas en un módulo e importarlo, en lugar de copiar sus definiciones en distintos programas. Un módulo puede ser importado por otro programa para hacer uso de su funcionalidad. Así también puedes utilizar la biblioteca estándar de Python.

En pocas palabras, un módulo es un archivo formado por código Python. Puede definir funciones, clases y variables, y también puede incluir código ejecutable. Cualquier archivo de Python puede referenciarse como módulo. Un archivo que contiene código Python, por ejemplo: test.py se denomina módulo, y su nombre sería test.

Existen varios métodos para escribir módulos, pero el más sencillo es crear un archivo con extensión .py que contenga funciones y variables.

Antes de empezar a escribir tus propios módulos, te recomiendo que eches un vistazo a nuestro curso Introducción a Python para la Ciencia de Datos, que cubre los aspectos básicos del lenguaje de programación Python.

• La sentencia import en Python
• Módulos de escritura
• Más sobre las declaraciones de importación
• Ruta de búsqueda del módulo
• Archivos compilados en Byte
• La función dir()

La import sentencia

Para utilizar la funcionalidad presente en cualquier módulo, tienes que importarlo a tu programa actual. Tienes que utilizar la palabra clave import junto con el nombre del módulo deseado. Cuando el intérprete se encuentra con una sentencia import, importa el módulo a tu programa actual. Puedes utilizar las funciones dentro de un módulo utilizando el operador dot(.) junto con el nombre del módulo. En primer lugar, vamos a ver cómo utilizar los módulos de la biblioteca estándar. En el ejemplo siguiente, el módulomath se importa en el programa para que puedas utilizar la función sqrt() definida en él.

import math             #You need to put this command,`import` keyword along with the name of the module you want to import
num = 4
print(math.sqrt(num))   #Use dot operator to access sqrt() inside module "math"

Por razones de eficacia, cada módulo sólo se importa una vez por sesión de interpretación. Por lo tanto, si cambias tus módulos, debes reiniciar el intérprete, si es sólo un módulo el que quieres probar interactivamente, utiliza reload(), por ejemplo: reload(module_name).

Módulos de escritura

Ahora que has aprendido a importar un módulo en tu programa, es el momento de escribir el tuyo propio y utilizarlo en otro programa. Escribir un módulo es como escribir cualquier otro archivo de Python. Empecemos escribiendo una función para sumar/restar dos números en un archivo calculation.py.

def add(x,y):
    return (x+y)
def sub(x,y):
    return (x-y)

Si intentas ejecutar este script en la línea de comandos, no ocurrirá nada porque no has ordenado al programa que haga nada. Crea otro script python en el mismo directorio con el nombre module_test.py y escribe en él el siguiente código.

import calculation            #Importing calculation module
print(calculation.add(1,2))   #Calling function defined in add module.

Si ejecutas module_test.py, verás "3" como resultado. Cuando el intérprete se encontró con la sentencia import, importó el módulo calculation en tu código y luego, utilizando el operador punto, pudiste acceder a la función add().

Más sobre las declaraciones de importación

Hay más formas de importar módulos:

• sentencia from .. import
• sentencia from .. import *
• cambiar el nombre del módulo importado

from .. import sentencia

La sentencia from..import te permite importar funciones/variables concretas de un módulo en lugar de importarlo todo. En el ejemplo anterior, cuando importaste calculation en module_test.py, se importaron las funciones add() y sub(). Pero, ¿y si sólo necesitaras la función add() en tu código?

He aquí un ejemplo para ilustrar el uso de from..import

from calculation import add
print(add(1,2))

En el ejemplo anterior, sólo se importa y utiliza la función add(). ¿Notas el uso de add()? Ahora puedes acceder a él directamente sin utilizar el nombre del módulo. También puedes importar varios atributos, separándolos con una coma en la sentencia de importación. Mira el siguiente ejemplo:

from calculation import add,sub

from .. import * sentencia

Puedes importar todos los atributos de un módulo utilizando esta sentencia. Esto hará que todos los atributos del módulo importado sean visibles en tu código.

He aquí un ejemplo para ilustrar el uso de from .. import *:

from calculation import *
print(add(1,2))
print(sub(3,2))

Ten en cuenta que, en el mundo profesional, debes evitar el uso de from..import y from..import*, ya que hace que tu código sea menos legible.

Cambiar el nombre del módulo importado

Puedes cambiar el nombre del módulo que estás importando, lo que puede ser útil en los casos en que quieras dar un nombre más significativo al módulo o el nombre del módulo sea demasiado grande para utilizarlo repetidamente. Puedes utilizar la palabra clave as para cambiarle el nombre. El siguiente ejemplo explica cómo utilizarlo en tu programa.

import calculation as cal
print(cal.add(1,2))

Te has ahorrado tiempo de escritura renombrando calculation como cal.
Ten en cuenta que ahora ya no puedes utilizar calculation.add(1,2), porque calculation ya no se reconoce en tu programa.

Ruta de búsqueda del módulo

Puede que necesites que tus módulos se utilicen en distintos programas/proyectos y su ubicación física en el directorio puede ser diferente. Si quieres utilizar un módulo que reside en algún otro directorio, tienes algunas opciones que te proporciona Python.
Cuando importas un módulo llamado calculation, el intérprete busca primero un módulo incorporado con ese nombre. Si no lo encuentra, busca un archivo llamado calculation.py en una lista de directorios dada por la variable sys.path.
sys.path contiene estas ubicaciones:

• el directorio que contiene el script de entrada (o el directorio actual).
• PYTHONPATH (una lista de nombres de directorios, con la misma sintaxis que el PATH de la variable shell).
• el valor por defecto dependiente de la instalación.

Supongamos que module_test.py está en el directorio /home/datacamp/, y que has movido calculation.py a /home/test/. Puedes modificar sys.path para incluir /home/test/ en la lista de rutas, en la que el intérprete de Python buscará el módulo. Para ello, tienes que modificar module_test.py de la siguiente manera:

import sys
sys.path.append('/home/test/')

import calculation
print(calculation.add(1,2))

Archivos compilados en Byte

Importar un módulo aumenta el tiempo de ejecución de los programas, por lo que Python tiene algunos trucos para acelerarlo. Una forma es crear archivos compilados en bytes con la extensión .pyc.
Internamente, Python convierte el código fuente en una forma intermedia llamada bytecode, luego lo traduce al lenguaje nativo de tu ordenador y después lo ejecuta. Este archivo .pyc es útil cuando importes el módulo la próxima vez desde un programa diferente: será mucho más rápido, ya que una parte del procesamiento necesario para importar un módulo ya está hecho. Además, estos archivos compilados en bytes son independientes de la plataforma.
Ten en cuenta que estos archivos .pyc suelen crearse en el mismo directorio que los archivos .py correspondientes. Si Python no tiene permiso para escribir en los archivos de ese directorio, no se crearán los archivos .pyc.

La dir() función

La función dir() sirve para averiguar todos los nombres definidos en un módulo. Devuelve una lista ordenada de cadenas que contienen los nombres definidos en un módulo.

import calculation
print(test.add(1,2))
print(dir(calculation))

En el resultado, puedes ver los nombres de las funciones que has definido en el módulo, add y sub. El atributo __name__ contiene el nombre del módulo. Todos los atributos que empiezan por guión bajo son atributos python por defecto asociados a un módulo.

Conclusión

Crear un módulo es necesario para gestionar mejor el código y reutilizarlo. Python te proporciona algunos módulos incorporados, que pueden importarse utilizando la palabra clave import. Python también te permite crear tus propios módulos y utilizarlos en tus programas. Te proporciona archivos compilados en bytes para superar el coste de utilizar módulos, lo que hace que la ejecución sea más rápida. Puedes utilizar dir() para conocer los atributos definidos en el módulo que se está utilizando en un programa, esto se puede utilizar tanto en módulos predefinidos como en módulos definidos por el usuario.

Si quieres aprender más sobre Python, puedes echar un vistazo a nuestro curso Python Intermedio para la Ciencia de Datos.