Módulos¶

Escribir pequeños trozos de código puede resultar interesante para realizar determinadas pruebas. Pero a la larga, nuestros programas tenderán a crecer y será necesario agrupar el código en unidades manejables.
Los módulos son simplemente ficheros de texto que contienen código Python y representan unidades con las que evitar la repetición y favorecer la reutilización. 1
Importar un módulo¶
Para hacer uso del código de otros módulos usaremos la sentencia import
. Esto permite importar el código y las variables de dicho módulo para que estén disponibles en nuestro programa.
La forma más sencilla de importar un módulo es import <module>
donde module
es el nombre de otro fichero Python, sin la extensión .py
.
Supongamos que partimos del siguiente fichero (módulo):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | def addere(a, b):
'''Sum of input values'''
return a + b
def minuas(a, b):
'''Substract of input values'''
return a - b
def pullulate(a, b):
'''Product of input values'''
return a * b
def partitus(a, b):
'''Division of input values'''
return a / b
|
Desde otro fichero - en principio en la misma carpeta - podríamos hacer uso de las funciones definidas en arith.py
.
Importar módulo completo¶
Desde otro fichero haríamos lo siguiente para importar todo el contenido del módulo arith.py
:
1 2 3 4 | >>> import arith
>>> arith.addere(3, 7)
10
|
Nota
Nótese que en la línea 3 debemos anteponer a la función addere()
el espacio de nombres que define el módulo arith
.
Ruta de búsqueda de módulos¶
Python tiene 2 formas de encontrar un módulo:
En la carpeta actual de trabajo.
En las rutas definidas en la variable de entorno
PYTHONPATH
.
Para ver las rutas de búsqueda establecidas, podemos ejecutar lo siguiente en un intérprete de Python:
>>> import sys
>>> sys.path
['/path/to/.pyenv/versions/3.9.1/envs/aprendepython/bin',
'/path/to/.pyenv/versions/3.9.1/lib/python3.9',
'/path/to/.pyenv/versions/3.9.1/envs/aprendepython/lib/python3.9/site-packages',
'']
La cadena vacía que existe al final de la lista hace referencia a la carpeta actual.
Modificando la ruta de búsqueda¶
Si queremos modificar la ruta de búsqueda, existen dos opciones:
- Modificando directamente la variable
PYTHONPATH
Para ello exportamos dicha variable de entorno desde una terminal:
$ export PYTHONPATH=/tmp
Y comprobamos que se ha modificado en
sys.path
:>>> sys.path ['/path/to/.pyenv/versions/3.9.1/envs/aprendepython/bin', '/tmp', '/path/to/.pyenv/versions/3.9.1/lib/python3.9', '/path/to/.pyenv/versions/3.9.1/envs/aprendepython/lib/python3.9/site-packages', '']
- Modificando directamente la lista
sys.path
Para ello accedemos a lista que está en el módulo
sys
de la librería estandar:>>> sys.path.append('/tmp') # añadimos al final >>> sys.path ['/path/to/.pyenv/versions/3.9.1/envs/aprendepython/bin', '/path/to/.pyenv/versions/3.9.1/lib/python3.9', '/path/to/.pyenv/versions/3.9.1/envs/aprendepython/lib/python3.9/site-packages', '', '/tmp']
>>> sys.path.insert(0, '/tmp') # insertamos por el principio >>> sys.path ['/tmp', '/path/to/.pyenv/versions/3.9.1/envs/aprendepython/bin', '/path/to/.pyenv/versions/3.9.1/lib/python3.9', '/path/to/.pyenv/versions/3.9.1/envs/aprendepython/lib/python3.9/site-packages', '']
Truco
El hecho de poner nuestra ruta al principio o al final de
sys.path
influye en la búsqueda, ya que si existen dos (o más módulos) que se llaman igual en nuestra ruta de búsqueda, Python usará el primero que encuentre.
Importar partes de un módulo¶
Es posible que no necesitemos todo aquello que está definido en arith.py
. Supongamos que sólo vamos a realizar divisiones. Para ello haremos lo siguiente:
1 2 3 4 | >>> from arith import partitus
>>> partitus(5, 2)
2.5
|
Nota
Nótese que en la línea 3 ya podemos hacer uso directamente de la función partitus()
porque la hemos importado directamente. Este esquema tiene el inconveniente de la posible colisión de nombres, en aquellos casos en los que tuviéramos algún objeto con el mismo nombre que el objeto que estamos importando.
Importar usando un alias¶
Hay ocasiones en las que interesa, por colisión de otros nombres o por mejorar la legibilidad, usar un nombre diferente del módulo (u objeto) que estamos importando. Python nos ofrece esta posibilidad a través de la sentencia as
.
Supongamos que queremos importar la función del ejemplo anterior pero con otro nombre:
>>> from arith import partitus as mydivision
>>> mydivision(5, 2)
2.5
Paquetes¶
Un paquete es simplemente una carpeta que contiene ficheros .py
. Además permite tener una jerarquía con más de un nivel de subcarpetas anidadas.
Para ejemplificar este modelo vamos a crear un paquete llamado mymath
que contendrá 2 módulos:
arith.py
para operaciones aritméticas (ya visto anteriormente).logic.py
para operaciones lógicas.
El código del módulo de operaciones lógicas es el siguiente:
1 2 3 4 5 6 7 8 9 10 11 12 13 | def et(a, b):
'''Logic "and" of input values'''
return a & b
def uel(a, b):
'''Logic "or" of input values'''
return a | b
def vel(a, b):
'''Logic "xor" of input values'''
return a ^ b
|
Si nuestro código principal va a estar en un fichero main.py
(a primer nivel), la estructura de ficheros nos quedaría tal que así:
1 2 3 4 5 6 7 | .
├── main.py
└── mymath
├── arith.py
└── logic.py
1 directory, 3 files
|
- Línea 2
Punto de entrada de nuestro programa a partir del fichero
main.py
- Línea 3
Carpeta que define el paquete
mymath
.- Línea 4
Módulo para operaciones aritméticas.
- Línea 5
Módulo para operaciones lógicas.
Importar desde un paquete¶
Si ya estamos en el fichero main.py
(o a ese nivel) podremos hacer uso de nuestro paquete de la siguiente forma:
1 2 3 4 5 6 7 | >>> from mymath import arith, logic
>>> arith.pullulate(4, 7)
28
>>> logic.et(1, 0)
0
|
- Línea 1
Importar los módulos
arith
ylogic
del paquetemymath
- Línea 3
Uso de la función
pullulate
que está definida en el móduloarith
- Línea 5
Uso de la función
et
que está definida en el módulologic
Programa principal¶
Cuando decidimos desarrollar una pieza de software en Python, normalmente usamos distintos ficheros para ello. Algunos de esos ficheros se convertirán en módulos, otros se englobarán en paquetes y existirá uno en concreto que será nuestro punto de entrada, también llamado programa principal.
Consejo
Suele ser una buena práctica llamar main.py
al fichero que contiene nuestro programa principal.
La estructura que suele tener este programa principal es la siguiente:
# imports de la librería estándar
# imports de librerías de terceros
# imports de módulos propios
# CÓDIGO PROPIO
# ...
# CÓDIGO PROPIO
if __name__ == '__main__':
# punto de entrada real
Importante
Si queremos ejecutar este fichero main.py
desde línea de comandos, tendríamos que hacer:
$ python3 main.py
if __name__ == '__main__'
¶
Esta condición permite, en el programa principal, diferenciar qué codigo se lanzará cuando el fichero se ejecuta directamente o cuando el fichero se importa desde otro lugar.

Comportamiento de un programa principal al importarlo o ejecutarlo¶
1 2 3 4 5 6 7 8 9 10 11 | import blabla
def myfunc():
print('Inside myfunc')
blabla.hi()
if __name__ == '__main__':
print('Entry point')
myfunc()
|
import hello
El código se ejecuta siempre desde la primera instrucción a la última:
Línea 1: se importa el módulo
blabla
.Línea 4: se define la función
myfunc()
y estará disponible para usarse.Línea 9: esta condición no se cumple, ya que estamos importando y la variable especial
__name__
no toma ese valor. Con lo cual finaliza la ejecución.No hay salida por pantalla.
$ python3 hello.py
El código se ejecuta siempre desde la primera instrucción a la última:
Línea 1: se importa el módulo
blabla
.Línea 4: se define la función
myfunc()
y estará disponible para usarse.Línea 9: esta condición sí se cumple, ya que estamos ejecutando directamente el fichero (como programa principal) y la variable especial
__name__
toma el valor__main__
.Línea 10: salida por pantalla de la cadena de texto
Entry point
.Línea 11: llamada a la función
myfunc()
que muestra por pantallaInside myfunc
, además de invocar a la funciónhi()
del móduloblabla
.
AMPLIAR CONOCIMIENTOS
- 1
Foto original por Xavi Cabrera en Unsplash.