Crear e importar módulos en Python

Un módulo le permite organizar lógicamente su código Python. Agrupar el código relacionado en un módulo hace que el código sea más fácil de entender y usar. Un módulo es un objeto de Python con atributos de nombres arbitrarios que puede enlazar y luego referenciar.

Simplemente, un módulo es un archivo que consta de código Python. Un módulo puede definir funciones, clases y variables. Un módulo también puede incluir código ejecutable.

Ejemplo

El código de Python para un módulo llamado aname normalmente reside en un archivo llamado aname.py. Aquí hay un ejemplo de un módulo simple, support.py

def print_func (par):
print "Hola:", par
   return

La declaración import

Puede usar cualquier archivo fuente de Python como módulo ejecutando una declaración de importación en algún otro archivo fuente de Python. La importación tiene la siguiente sintaxis:

import modulo1 [, modulo2 [, ... moduloN]

Cuando el intérprete encuentra una declaración de importación, importa el módulo si el módulo está presente en la ruta de búsqueda. Una ruta de búsqueda es una lista de directorios que el intérprete busca antes de importar un módulo. Por ejemplo, para importar el módulo support.py, debe colocar el siguiente comando en la parte superior de la secuencia de comandos:

#!/usr/bin/python

# Importar modulo support
import support

# Ahora puede llamar a la función definida de ese módulo de la siguiente manera
support.print_func ("Sara")

Cuando se ejecuta el código anterior, produce el siguiente resultado:

Hola Sara

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 declaración from

La declaración from de Python le permite importar atributos específicos de un módulo al espacio de nombres actual. La importación from … tiene la siguiente sintaxis:

from modname import name1 [, name2 [, ... nameN]]

Por ejemplo, para importar la función fibonacci del módulo fib, use la siguiente declaración:

from fib import fibonacci

Esta declaración no importa la totalidad del módulo fib en el espacio de nombres actual; simplemente introduce el elemento fibonacci del módulo fib en la tabla de símbolos globales del módulo de importación.

La declaración from … import *

También es posible importar todos los nombres de un módulo al espacio de nombres actual utilizando la siguiente declaración de importación:

from modname import *

Esto proporciona una manera fácil de importar todos los elementos de un módulo al espacio de nombres actual; sin embargo, esta declaración debe usarse con moderación.

Búsqueda de módulos

Cuando importa un módulo, el intérprete de Python busca el módulo en las siguientes secuencias:

1. El directorio actual.
2. Si no se encuentra el módulo, Python busca cada directorio en la variable de shell PYTHONPATH.
3. Si todo lo demás falla, Python comprueba la ruta predeterminada. En UNIX, esta ruta predeterminada es normalmente /usr/local/lib/python /.

La ruta de búsqueda del módulo se almacena en el módulo del sistema sys como la variable sys.path. La variable sys.path contiene el directorio actual, PYTHONPATH y el valor predeterminado dependiente de la instalación.

La variable PYTHONPATH

PYTHONPATH es una variable de entorno, que consiste en una lista de directorios. La sintaxis de PYTHONPATH es la misma que la de la variable de shell PATH.

Aquí hay una típica PYTHONPATH de un sistema Windows –

set PYTHONPATH = c:\python20\lib

Y aquí hay una típica PYTHONPATH de un sistema UNIX –

set PYTHONPATH =/usr/local/lib/python

Namespaces y alcance

Las variables son nombres (identificadores) que se asignan a objetos. Un espacio de nombres es un diccionario de nombres de variables (claves) y sus objetos (valores) correspondientes.

Una declaración 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 global tienen el mismo nombre, la variable local sobrescribe 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 declaración global.

La declaración global VarName le dice a Python que VarName es una variable global. Python deja de buscar el espacio de nombres local para la variable.

Por ejemplo, definimos una variable Dinero en el espacio de nombres global. Dentro de la función Dinero, asignamos un valor a Dinero, por lo tanto, Python asume que Dinero es una variable local.

Sin embargo, accedimos al valor de la variable local Dinero antes de configurarla, por lo que el resultado es UnboundLocalError. Si no se comenta la declaración global, se soluciona el problema.

#!/usr/bin/python

Dinero = 2000
def AddMoney ():
   # Descomente la siguiente línea para arreglar el código:
   # global Dinero
   Dinero = Dinero + 1

print Dinero
AddMoney()
print Dinero

La función dir()

La función incorporada dir() devuelve una lista ordenada de cadenas que contienen los nombres definidos por un módulo.

La lista contiene los nombres de todos los módulos, variables y funciones que se definen en un módulo. El siguiente es un ejemplo simple:

#!/usr/bin/python

# Importar módulo incorporado de matemáticas
import math

contenido = dir(math)
print contenido

Cuando se ejecuta el código anterior, produce el siguiente resultado:

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan',
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', ​​'exp',
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',
'sqrt', 'tan', 'tanh']

Aquí, la variable de cadena especial __name__ es el nombre del módulo, y __file__ es el nombre de archivo desde el que se cargó el módulo.

Las funciones globals() y locals()

Las funciones globals() y locals() se pueden usar para devolver los nombres en los espacios de nombres globales y locales dependiendo de la ubicación desde donde se llaman.

Si se llama a locals() desde dentro de una función, devolverá todos los nombres a los que se puede acceder localmente desde esa función.

Si se llama a globals() desde dentro de una función, devolverá todos los nombres a los que se puede acceder globalmente desde esa función.

El tipo de retorno de estas dos funciones es el diccionario. Por lo tanto, los nombres se pueden extraer utilizando la función keys().

La función reload()

Cuando el módulo se importa a una secuencia de comandos, el código en la parte superior de un módulo se ejecuta solo una vez.

Por lo tanto, si desea volver a ejecutar el código de nivel superior en un módulo, puede usar la función reload(). La función reload() importa de nuevo un módulo previamente importado. La sintaxis de la función reload() es esta:

reload(nombre_módulo)

Paquetes en Python

Un paquete es una estructura de directorio de archivos jerárquica que define un único entorno de aplicación de Python que consta de módulos y subpaquetes y subpaquetes, y así sucesivamente.

Considere un archivo Pots.py disponible en un directorio /Phone. Este archivo tiene la siguiente línea de código fuente:

#!/usr/bin/python

def Pots():
   print "Soy el telefono de Pots"

De manera similar, tenemos otros dos archivos que tienen diferentes funciones con el mismo nombre que el anterior:

Phone/Isdn.py archivo con la función Isdn()

Phone/G3.py archivo con la función G3()

Ahora crea un archivo __init__.py en el directorio /Phone

Phone/__init__.py

Para que todas sus funciones estén disponibles cuando haya importado el paquete, debe poner instrucciones de importación explícitas en __init__.py de la siguiente manera:

from Pots import Pots
from Isdn import Isdn
from G3 import G3

Después de agregar estas líneas a __init__.py, tiene todas estas clases disponibles cuando importa el paquete Phone.

#!/usr/bin/python

# Ahora importa tu paquete de teléfono.
importar telefono

Phone.Pots()
Phone.Isdn()
Phone.G3()

Cuando se ejecuta el código anterior, produce el siguiente resultado:

Soy el telefono de Pots
Soy el telefono de 3G
Soy el telefono de ISDN

En el ejemplo anterior, hemos tomado el ejemplo de una sola función en cada archivo, pero puede mantener múltiples funciones en sus archivos. También puede definir diferentes clases de Python en esos archivos y luego puede crear sus paquetes a partir de esas clases.

Written by Tutor