Vídeo:Módulos de Python

¿Qué son los módulos en Python?

Los módulos hacen referencia a un archivo que contiene sentencias y definiciones de Python.

Un archivo que contiene código de Python, por ejemplo:example.py , se llama módulo, y su nombre de módulo sería example .

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

Podemos definir nuestras funciones más utilizadas en un módulo e importarlo, en lugar de copiar sus definiciones en diferentes programas.

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

# Python Module example

def add(a, b):
   """This program adds two
   numbers and return the result"""

   result = a + b
   return result

Aquí, hemos definido una función add() dentro de un módulo llamado example . La función toma dos números y devuelve su suma.

¿Cómo importar módulos en Python?

Podemos importar las definiciones dentro de un módulo a otro módulo o al intérprete interactivo en Python.

Usamos el import palabra clave para hacer esto. Para importar nuestro módulo previamente definido example , escribimos lo siguiente en el indicador de Python.

>>> import example

Esto no importa los nombres de las funciones definidas en example directamente en la tabla de símbolos actual. Solo importa el nombre del módulo example allí.

Usando el nombre del módulo podemos acceder a la función usando el punto . operador. Por ejemplo:

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

Python tiene toneladas de módulos estándar. Puede consultar la lista completa de módulos estándar de Python y sus casos de uso. Estos archivos están en el directorio Lib dentro de la ubicación donde instaló Python.

Los módulos estándar se pueden importar de la misma manera que importamos nuestros módulos definidos por el usuario.

Hay varias formas de importar módulos. Se enumeran a continuación..

Declaración de importación de Python

Podemos importar un módulo usando el import declaración y acceda a las definiciones dentro de ella usando el operador de punto como se describe arriba. Aquí hay un ejemplo.

# import statement example
# to import standard module math

import math
print("The value of pi is", math.pi)

Cuando ejecute el programa, la salida será:

The value of pi is 3.141592653589793

Importar con renombrar

Podemos importar un módulo renombrándolo de la siguiente manera:

# import module by renaming it

import math as m
print("The value of pi is", m.pi)

Hemos renombrado el math módulo como m . Esto puede ahorrarnos tiempo de tipeo en algunos casos.

Tenga en cuenta que el nombre math no se reconoce en nuestro ámbito. Por lo tanto, math.pi no es válido, y m.pi es la implementación correcta.

Python de... declaración de importación

Podemos importar nombres específicos de un módulo sin importar el módulo como un todo. Aquí hay un ejemplo.

# import only pi from math module

from math import pi
print("The value of pi is", pi)

Aquí, importamos solo el pi atributo del math módulo.

En tales casos, no usamos el operador punto. También podemos importar múltiples atributos de la siguiente manera:

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

Importar todos los nombres

Podemos importar todos los nombres (definiciones) de un módulo usando la siguiente construcción:

# import all names from the standard module math

from math import *
print("The value of pi is", pi)

Aquí, hemos importado todas las definiciones del módulo matemático. Esto incluye todos los nombres visibles en nuestro alcance, excepto aquellos que comienzan con un guión bajo (definiciones privadas).

Importar todo lo que tenga el símbolo de asterisco (*) no es una buena práctica de programación. Esto puede conducir a definiciones duplicadas para un identificador. También dificulta la legibilidad de nuestro código.

Ruta de búsqueda del módulo de Python

Al importar un módulo, Python busca en varios lugares. Interpreter primero busca un módulo integrado. Luego (si no se encuentra el módulo incorporado), Python busca en una lista de directorios definidos en sys.path . La búsqueda es en este orden.

• El directorio actual.
• PYTHONPATH (una variable de entorno con una lista de directorios).
• El directorio predeterminado dependiente de 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-packages']

Podemos agregar y modificar esta lista para agregar nuestra propia ruta.

Recargar un módulo

El intérprete de Python importa un módulo solo una vez durante una sesión. Esto hace que las cosas sean más eficientes. Aquí hay un ejemplo para mostrar cómo funciona esto.

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

# This module shows the effect of
#  multiple imports and reload

print("This code got executed")

Ahora vemos el efecto de múltiples importaciones.

>>> import my_module
This code got executed
>>> import my_module
>>> import my_module

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

Ahora bien, si nuestro módulo cambió durante el transcurso del programa, tendríamos que volver a cargarlo. Una forma de hacerlo es reiniciar el intérprete. Pero esto no ayuda mucho.

Python proporciona una forma más eficiente de hacer esto. Podemos usar el reload() función dentro del imp módulo para recargar un módulo. Podemos hacerlo de las siguientes formas:

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

La función integrada dir()

Podemos usar el dir() función para encontrar nombres que están definidos dentro de un módulo.

Por ejemplo, hemos definido una función add() en el módulo example que teníamos al principio.

Podemos usar dir en example módulo de la siguiente manera:

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

Aquí, podemos ver una lista ordenada de nombres (junto con add ). Todos los demás nombres que comienzan con un guión bajo son atributos predeterminados de Python asociados con el módulo (no definidos por el usuario).

Por ejemplo, el __name__ atributo contiene el nombre del módulo.

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

Todos los nombres definidos en nuestro espacio de nombres actual se pueden encontrar utilizando el dir() función sin argumentos.

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