Python 3 - Módulos

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 nombrados arbitrariamente que puede vincular y hacer referencia.

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 Python para un módulo llamado aname normalmente reside en un archivo namedaname.py. Aquí hay un ejemplo de un módulo simple, support.py:

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

La declaración de importación

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

import module1[, module2[,... moduleN]

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 hello.py, debe colocar el siguiente comando en la parte superior del script:

#!/usr/bin/python3

# Import module support
import support

# Now you can call defined function that module as follows
support.print_func("Zara")

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

Hello : Zara

Un módulo se carga solo una vez, independientemente del número de veces que se importe. Esto evita que la ejecución del módulo ocurra repetidamente, si ocurren múltiples importaciones.

La declaración de ... importación

Python fromLa declaración le permite importar atributos específicos de un módulo al espacio de nombres actual. losfrom...import 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:

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
>>> from fib import fib
>>> fib(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Esta declaración no importa todo el módulo fib al 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 en el 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.

Ejecución de módulos como scripts

Dentro de un módulo, el nombre del módulo (como una cadena) está disponible como el valor de la variable global __name__. El código del módulo se ejecutará, como si lo hubiera importado, pero con el __name__ establecido en "__main__".

Agregue este código al final de su módulo -

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
if __name__ == "__main__":
   f = fib(100)
   print(f)

Cuando ejecute el código anterior, se mostrará el siguiente resultado.

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Localización de módulos

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

• El directorio actual.

• Si no se encuentra el módulo, Python busca cada directorio en la variable de shell PYTHONPATH.

• Si todo lo demás falla, Python comprueba la ruta predeterminada. En UNIX, esta ruta predeterminada es normalmente / usr / local / lib / python3 /.

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

La variable PYTHONPATH

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

Aquí hay un PYTHONPATH típico de un sistema Windows:

set PYTHONPATH = c:\python34\lib;

Y aquí hay un PYTHONPATH típico de un sistema UNIX:

set PYTHONPATH = /usr/local/lib/python

Espacios de nombres 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 correspondientes objetos (valores).

• Una declaración de Python puede acceder a 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 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 fundamentadas sobre si las variables son locales o globales. Asume que cualquier variable a la que se le asigne 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 la variable en el espacio de nombres local.

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

Sin embargo, accedimos al valor de la variable local Money antes de configurarlo, por lo que un UnboundLocalError es el resultado. Descomentar la declaración global soluciona el problema.

#!/usr/bin/python3

Money = 2000
def AddMoney():
   # Uncomment the following line to fix the code:
   # global Money
   Money = Money + 1

print (Money)
AddMoney()
print (Money)

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. A continuación se muestra un ejemplo simple:

#!/usr/bin/python3

# Import built-in module math
import math

content = dir(math)
print (content)

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 cual se cargó el módulo.

Las funciones globals () y locals ()

los globals() y locals() Las funciones 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 locals() se llama desde dentro de una función, devolverá todos los nombres a los que se puede acceder localmente desde esa función.

• Si globals() se llama 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 ambas funciones es diccionario. Por lo tanto, los nombres se pueden extraer utilizando elkeys() función.

La función reload ()

Cuando se importa un módulo a un script, el código de la parte de nivel 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 () vuelve a importar un módulo previamente importado. La sintaxis de la función reload () es la siguiente:

reload(module_name)

Aquí, module_name es el nombre del módulo que desea recargar y no la cadena que contiene el nombre del módulo. Por ejemplo, para volver a cargar el módulo de saludo, haga lo siguiente:

reload(hello)

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 sub-subpaquetes, etc.

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

#!/usr/bin/python3

def Pots():
print ("I'm Pots Phone")

De manera similar, tenemos otros dos archivos que tienen funciones diferentes con el mismo nombre que el anterior. Ellos son -

• Archivo Phone / Isdn.py con función Isdn ()

• Archivo Phone / G3.py con función G3 ()

Ahora, cree un archivo más __init__.py en el directorio telefónico -

• Phone/__init__.py

Para que todas sus funciones estén disponibles cuando haya importado Phone, debe colocar declaraciones 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, tendrá todas estas clases disponibles cuando importe el paquete Phone.

#!/usr/bin/python3

# Now import your Phone Package.
import Phone

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

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

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

En el ejemplo anterior, hemos tomado un ejemplo de una única 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.