Módulos en Python

En este artículo, aprenderá cómo crear e importar módulos personalizados en Python. Además, descubrirá las diferentes técnicas para importar y usar módulos personalizados y integrados en Python.

¿Qué es un módulo en Python?

Un módulo es un archivo que contiene instrucciones y definiciones de Python.

Los archivos que contienen código de Python, como example.py, se llaman módulos y tienen el nombre de módulo example.

Usamos módulos para dividir programas grandes en archivos pequeños y gestionables. Además, los módulos proporcionan la reutilización de código.

Podemos definir las funciones más utilizadas en el módulo y importarlas, en lugar de copiar su definición a otros programas.

Vamos a crear un módulo. Ingresa lo siguiente y guárdalo como example.py.

# Ejemplo de módulo de Python
def add(a, b):
　　　"""Este programa suma dos números"
　　　　　　　y devuelve el resultado de la suma ""
　　　result = a　+　b
　　　return result

Aquí, definimos una función add() en un módulo llamado exampleFunción. Esta función acepta dos números y devuelve su suma.

¿Cómo importar módulos en Python?

Podemos importar definiciones internas del módulo a otro módulo o al intérprete interactivo de Python.

Usamos la palabra clave import para lograr esto. Para importar el módulo definido anteriormente, escribimos lo siguiente en el prompt de Python.

>>> import example

Esto no ingresa directamente el nombre de la función definida en example al símbolo actual de la tabla. Solo ingresa el nombre del módulo aquí.

Con el nombre del módulo, podemos usar el operador de punto. Por ejemplo:

>>> example.add(4,5.5)
9.5

Python tiene una gran cantidad de módulos estándar disponibles.

Puede verMódulos estándar de Pythonlista completa y sus usos. Estos archivos se encuentran en el directorio Lib de la ubicación de instalación de Python.

Se pueden importar módulos estándar de la misma manera que los módulos definidos por el usuario.

Hay varios métodos para importar módulos. Se enumeran a continuación.

Declaración de importación de Python

Podemos usar la declaración import para importar módulos y acceder a sus definiciones internas con el operador de punto, como se mencionó anteriormente. Esto es un ejemplo.

# Ejemplo de declaración de importación
# Importar módulo estándar matemático
import math
print("valor de π", math.pi)

Al ejecutar este programa, la salida será:

valor de π　3.141592653589793

Renombrar el módulo

Podemos renombrar el módulo de la siguiente manera.

# Renombrar el módulo importado
import math as m
print("valor de π", m.pi)

Hemos renombrado el módulo math como m. En algunos casos, esto puede ahorrar tiempo en nuestra escritura.

Tenga en cuenta que el nombre math no es reconocible en nuestro ámbito. Por lo tanto, math.pi no es válido, y m.pi es la forma correcta de usarlo.

Enunciado from ... import de Python

Podemos importar nombres específicos del módulo sin importar el módulo completo. Este es un ejemplo.

# Importar solo pi del módulo matemático
from math import pi
print("El valor de π", pi)

Solo importamos la propiedad pi del módulo.

En este caso, no usamos el operador de punto. Podemos importar múltiples propiedades de la siguiente manera.

>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045

Importar todos los nombres

Podemos usar la siguiente construcción para importar todos los nombres (definiciones) del módulo.

# Importar todos los nombres del módulo estándar math
from math import　*
print("El valor de pi", pi)

Importamos todas las definiciones del módulo matemático. Esto hace que todos los nombres, excepto los que comienzan con guión bajo, sean visibles en nuestro ámbito.

Importar con un asterisco (*Todo lo contenido en el símbolo ) no es un buen hábito de programación. Esto puede llevar a la repetición de definiciones de identificadores. También afecta la legibilidad de nuestro código.

Ruta de búsqueda de módulos de Python

Al importar un módulo, Python verifica múltiples ubicaciones. El intérprete primero busca un módulo integrado, y luego (si no lo encuentra) entra en la lista de directorios definida en sys.path. La búsqueda se realiza en este orden.

• Directorio actual.

• PYTHONPATH (variable de entorno con lista de directorios).

• Directorios predeterminados relacionados con la instalación.

>>> import sys
>>> sys.path
['',
'C:\\Python33\\Lib\\idlelib',
'C:\\Windows\\system32\\python33.zip',
'C:\\Python33\\DLLs',
'C:\\Python33\\lib',
'C:\\Python33',
'C:\\Python33\\lib\\site-paquetes'

Podemos agregar modificar esta lista para agregar nuestra propia ruta.

Recargar el módulo

El intérprete de Python importa el módulo solo una vez durante la sesión. Esto hace que las cosas sean más eficientes. Este es un ejemplo que muestra cómo funciona.

Supongamos que en un módulo llamado my_module hay el siguiente código.

# Este módulo muestra
# Múltiples importaciones y reimportación
print("Este código se ejecutó")

Ahora hemos visto el efecto de las múltiples importaciones.

>>> import my_module
This code is executed
>>> import my_module
>>> import my_module

Podemos ver que nuestro código solo se ejecutó una vez. Esto significa que nuestro módulo se importó solo una vez.

Now, if our module changes during the execution of the program, we will have to reload it. One method is to restart the interpreter. But this is not very helpful.

Python provides a concise method. We can use the reload() function of the module and the imp function inside it to reload the module. How is this done.

>>> import imp
>>> import my_module
This code is executed
>>> import my_module
>>> imp.reload(my_module)
This code is executed
<module 'my_module' from '.\my_module.py'>

dir() built-in function

We can use the dir() function to find the names defined within the module.

For example, we defined an add() function in the starting module example.

>>> dir(example)
['__builtins__',
'__cached__',
'__doc__',
'__file__',
'__initializing__',
'__loader__',
'__name__',
'__package__',
'add'

Here, we can see a sorted list of names (including add). All other names starting with an underscore are default Python attributes associated with the module (we did not define them ourselves).

For example, the __name__ attribute contains the name of the module.

>>> import example
>>> example.__name__
'example'

You can use the dir() function without any parameters to find all the names defined in the current namespace.

>>> a =　1
>>> b = "hello"
>>> import math
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter']