Módulos de Python

Un módulo de Python (Module) es un archivo de Python que termina en .py y contiene definiciones de objetos de Python y sentencias de Python.

Los módulos te permiten organizar lógicamente tus segmentos de código Python.

Asignar código relacionado a un módulo hace que tu código sea más útil y fácil de entender.

Los módulos pueden definir funciones, clases y variables; también pueden contener código ejecutable.

Ejemplo

El siguiente ejemplo es un módulo simple support.py:

Módulo support.py:

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

Sentencia import

Introducción de módulos

Una vez definido el módulo, podemos usar la sentencia import para introducirlo. La sintaxis es la siguiente:

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

Por ejemplo, para referenciar el módulo math, puedes usar al principio del archivo:import mathpara introducirlo. Al llamar a las funciones del módulo math, debes referenciarlas de esta manera:

nombre del módulo.nombre de la función

Cuando el intérprete encuentra una sentencia import, si el módulo está en la ruta de búsqueda actual, será importado.

La ruta de búsqueda es una lista de todos los directorios que el intérprete buscará primero. Si quieres importar el módulo support.py, debes colocar el comando al principio del script:

Código del archivo test.py:

#!/usr/bin/python # -*- coding: UTF-8 -*- # Importar el módulo import support # Ahora se pueden llamar las funciones contenidas en el módulo support.print_func("Ejemplo")

El resultado del ejemplo anterior es:

Hello : Ejemplo

Un módulo solo se importa una vez, sin importar cuántas veces ejecutes import. Esto evita que el módulo importado se ejecute una y otra vez.


Sentencia from…import

La sentencia from de Python te permite importar una parte específica de un módulo al espacio de nombres actual. La sintaxis es la siguiente:

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

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

from fib import fibonacci

Esta declaración no importa todo el módulo fib al espacio de nombres actual; solo introduce la función fibonacci de fib en la tabla de símbolos global del módulo que ejecuta esta declaración.


Sentencia from…import *

También es posible importar todo el contenido de un módulo al espacio de nombres actual, solo usa la siguiente declaración:

from modname import *

Esto proporciona una forma sencilla de importar todos los elementos de un módulo. Sin embargo, esta declaración no debe usarse en exceso.

Por ejemplo, si queremos introducir todo del módulo math de una vez, la sentencia es la siguiente:

from math import *

Ruta de búsqueda

Cuando importas un módulo, el orden de búsqueda del analizador de Python para la ubicación del módulo es:

  • 1. Directorio actual
  • 2. Si no está en el directorio actual, Python busca en cada directorio bajo la variable de shell PYTHONPATH.
  • 3. Si no lo encuentra, Python revisa la ruta predeterminada. En UNIX, la ruta predeterminada suele ser /usr/local/lib/python/.

La ruta de búsqueda de módulos se almacena en la variable sys.path del módulo system. La variable contiene el directorio actual, PYTHONPATH y los directorios predeterminados determinados por el proceso de instalación.


Variable PYTHONPATH

Como variable de entorno, PYTHONPATH se compone de muchos directorios agrupados en una lista. La sintaxis de PYTHONPATH es la misma que la variable de shell PATH.

En sistemas Windows, un PYTHONPATH típico es el siguiente:

set PYTHONPATH=c:\python27\lib;

En sistemas UNIX, un PYTHONPATH típico es el siguiente:

set PYTHONPATH=/usr/local/lib/python

Espacios de nombres y ámbitos

Las variables son nombres (identificadores) que tienen objetos correspondientes. Un espacio de nombres es un diccionario que contiene los nombres de variables (claves) y sus respectivos objetos (valores).

Una expresión de Python puede acceder a variables en el 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 sobrescribirá a la global.

Cada función tiene su propio espacio de nombres. Las reglas de ámbito de los métodos de una clase son las mismas que las de las funciones normales.

Python adivina inteligentemente si una variable es local o global; asume que cualquier variable asignada dentro de una función es local.

Por lo tanto, si deseas asignar un valor a una variable global dentro de una función, debes usar la sentencia global.

La expresión global VarName le dice a Python que VarName es una variable global, de modo que Python no buscará esta variable en el espacio de nombres local.

Por ejemplo, definimos una variable Money en el espacio de nombres global. Luego asignamos un valor a Money dentro de una función, y Python asumirá que Money es una variable local. Sin embargo, no declaramos una variable local Money antes de accederla, por lo que aparecerá un error UnboundLocalError. Descomentar la sentencia global puede resolver este problema.

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
Money = 2000
def AddMoney():
   # 想改正代码就取消以下注释:
   # global Money
   Money = Money + 1
 
print Money
AddMoney()
print Money

Función dir()

La función dir() devuelve una lista ordenada de cadenas, cuyo contenido son los nombres definidos en un módulo.

La lista devuelta contiene todos los módulos, variables y funciones definidos en un módulo. A continuación un ejemplo simple:

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 导入内置math模块
import math
 
content = dir(math)
 
print content;

El resultado del ejemplo anterior es:

['__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 especial de cadena __name__ apunta al nombre del módulo, y __file__ apunta al nombre del archivo de importación de dicho módulo.


Funciones globals() y locals()

Según el lugar donde se llamen, las funciones globals() y locals() se pueden usar para devolver los nombres en los espacios de nombres global y local.

Si se llama a locals() dentro de una función, devuelve todos los nombres a los que se puede acceder en esa función.

Si se llama a globals() dentro de una función, devuelve todos los nombres globales a los que se puede acceder en esa función.

El tipo de retorno de ambas funciones es un diccionario. Por lo tanto, los nombres pueden extraerse con la función keys().


Función reload()

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

Por lo tanto, si deseas volver a ejecutar el código de la parte superior del módulo, puedes usar la función reload(). Esta función reimporta el módulo que fue importado anteriormente. La sintaxis es la siguiente:

reload(module_name)

Aquí, module_name debe ser directamente el nombre del módulo, no una cadena. Por ejemplo, si quieres recargar el módulo hello, hazlo así:

reload(hello)

Paquetes en Python

Un paquete es una estructura de directorios de archivos jerárquica que define un entorno de aplicación de Python compuesto por módulos, subpaquetes, y subpaquetes dentro de subpaquetes, etc.

En términos simples, un paquete es una carpeta, pero debe existir un archivo __init__.py en esa carpeta; el contenido de este archivo puede estar vacío.__init__.pySe utiliza para identificar que la carpeta actual es un paquete.

Considera unpackage_ejemploen el directorioejemplo1.py、ejemplo2.py、__init__.py archivo; test.py es el código para probar la llamada al paquete. La estructura de directorios es la siguiente:

test.py
package_ejemplo
|-- __init__.py
|-- ejemplo1.py
|-- ejemplo2.py
El código fuente es el siguiente:

package_ejemplo/ejemplo1.py

#!/usr/bin/python # -*- coding: UTF-8 -*- def ejemplo1(): print "I'm in ejemplo1"

package_ejemplo/ejemplo2.py

#!/usr/bin/python # -*- coding: UTF-8 -*- def ejemplo2(): print "I'm in ejemplo2"

Ahora, enpackage_ejemplocrea en el directorio__init__.py：

package_ejemplo/__init__.py

#!/usr/bin/python # -*- coding: UTF-8 -*- if __name__ == '__main__': print 'como programa principal' else: print 'Inicialización de package_ejemplo'

Luego, enpackage_ejemplo el directorio del mismo nivelcreamos test.py para llamarpackage_ejemploPaquete

test.py

#!/usr/bin/python # -*- coding: UTF-8 -*- # Importar el paquete Phone from package_ejemplo.ejemplo1 import ejemplo1 from package_ejemplo.ejemplo2 import ejemplo2 ejemplo1() ejemplo2()

El resultado del ejemplo anterior es:

package_ejemplo 初始化
I'm in ejemplo1
I'm in ejemplo2

Como arriba, para el ejemplo, solo colocamos una función en cada archivo, pero en realidad puedes colocar muchas funciones. También puedes definir clases de Python en estos archivos y luego crear un paquete para esas clases.

Otras extensiones