8.1. Módulos Python¶

Un módulo le permite a usted organizar lógicamente su código Python. Agrupando código relacionado dentro de un módulo hace el código más fácil de entender y usar. Un módulo es un objeto de Python con atributos con nombres arbitrarios que puede enlazar y hacer referencia.

Simplemente, un módulo es no es otra cosa sino un archivo con extensión .py. Un módulo puede definir funciones, clases y variables, también puede incluir código ejecutable.

El código Python para un módulo nombrado funciones normalmente reside un archivo llamado utilidades.py. A continuación un ejemplo de un simple módulo llamado utilidades.py:

1
2
3
4
5
6
7
8

""" Módulo para cálculos diversos """


def suma_total(monto=0):
    """Calcula la suma total"""
    calculo_suma = 20
    calculo_suma += monto
    return calculo_suma

8.1.1. Sentencia import¶

La sentencia import se utiliza para importar un módulo. Usted puede usar cualquier archivo de código Python como un módulo ejecutando esta sentencia en otro archivo de código Python. La sentencia import tiene la siguiente sintaxis:

>>> import os
>>> import re, datetime

Cuando el interprete encuentra una sentencia import, este importa el módulo si el mismo esta presente en la ruta de búsqueda. Una ruta de búsqueda es una lista de directorios que el interprete busca antes de importar un módulo.

Por ejemplo, al importar el módulo utilidades.py, usted necesita colocar la siguiente sentencia al tope del otro script Python. A continuación un ejemplo de un simple módulo, calculo_factura_pipo.py.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Importar el modulo llamado "utilidades"
import utilidades

print(
    "Importo el modulo '{}'\n".format(
        utilidades.__file__.replace(utilidades.__file__, "utilidades.pyc")
    )
)

print(
    "Función '{}' del módulo '{}' llamado y mostró:".format(
        utilidades.suma_total.__name__,
        utilidades.__file__.replace(utilidades.__file__, "utilidades.pyc"),
    )
)

# Usted puede llamar una función definida dentro del módulo
print(
    "Monto total a facturar: {} Bs (VES).".format(
        utilidades.suma_total(int(input("Ingrese un monto: ")))
    )
)

Cuando el código anterior es ejecutado, ese produce el siguiente resultado:

Importo el modulo ``utilidades.pyc``

Función ``suma_total`` del módulo ``utilidades.pyc`` llamado y mostró:
Ingrese un monto: 56987
Monto total a facturar: 57007 Bs (VES).

Un módulo se carga solo una vez, independientemente de la cantidad de veces que se importe. Esto evita que la ejecución del módulo ocurra una y otra vez si se producen múltiples importaciones.

La primera vez que un módulo es importado en un script de Python, se ejecuta su código una vez. Si otro módulo importa el mismo módulo este no se cargará nuevamente; los módulos son inicializados una sola vez.

Esto se debe al código objeto compilado que genera en el mismo directorio del módulo que cargo con la extensión de archivo .pyc, ejecutando las siguientes sentencias:

>>> import funciones, os
>>> archivos = os.listdir(
...     os.path.abspath(funciones.__file__).replace("/utilidades.pyc", "/")
... )
>>> print(filter(lambda x: x.startswith("funciones."), archivos))
['utilidades.py', 'utilidades.pyc']

De esta forma se comprueba que existe el archivo compilado de Python junto con el mismo módulo Python.

8.1.2. Localizando módulos¶

Cuando usted importa un módulo, el interprete Python busca por el módulo en la secuencia siguiente:

1. El directorio actual.

2. Si el módulo no es encontrado, Python entonces busca en cada directorio en la variable de entorno PYTHONPATH del sistema operativo.

3. Si todas las anteriores fallan, Python busca la ruta predeterminada. En UNIX/Linux, la ruta predeterminada normalmente esta /usr/local/lib/python/.

El ruta de búsqueda de módulo es almacenado en el módulo de system sys como la variable sys.path. La variable sys.path contiene el directorio actual, PYTHONPATH, y las predeterminadas dependencia de instalación.

8.1.3. PYTHONPATH¶

Es una variable de entorno del sistema operativo, consistiendo de una lista de directorios. La sintaxis de PYTHONPATH es la misma como la del shell de la variable PATH.

$ set PYTHONPATH = /usr/local/lib/python

> set PYTHONPATH = C:\Python37\lib;

8.1.4. Espacios de nombres y alcance¶

Las variables son nombres (identificadores) que se asignan a objetos.

Un espacio de nombres o namespace, es un diccionario de nombres de variables (claves) y sus objetos (valores) correspondientes.

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

Cada función tiene su propio espacio de nombres local. Los métodos de Clase siguen la misma regla de alcance que las funciones ordinarias.

Python hace conjeturas educadas sobre si las variables son locales o globales. Se supone que cualquier variable asignada a un valor en una función es local.

Por lo tanto, para asignar un valor a una variable global dentro de una función, primero debe usar la sentencia global.

>>> global nombre
>>> nombre
'Leonardo'

La sintaxis global nombre, le dice al interprete Python que la variable nombre es una variable global. Python deja de buscar la variable en el espacio de nombres local.

Por ejemplo, defina una variable Money en el espacio de nombres global. Dentro de la función Money, asigna un valor a Money, por lo tanto, Python asume que Money es una variable local. Sin embargo, accede al valor de la variable local Money antes de configurarlo, por lo que el resultado es una excepción UnboundLocalError. Si descomenta la sentencia global, se soluciona el problema.

leccion8/
├── utilidades.py
└── calculo_factura_pipo.py

$ python calculo_factura_pipo.py

¿Cómo puedo ayudar?

¡Mi soporte está aquí para ayudar!

Mi horario de oficina es de lunes a sábado, de 9 AM a 5 PM. GMT-4 - Caracas, Venezuela.

La hora aquí es actualmente 7:35 PM GMT-4.

Mi objetivo es responder a todos los mensajes dentro de un día hábil.

Contáctenos en la sección de soporte