Latest web development tutorials

módulo python3

En las secciones anteriores de la secuencia de comandos es intérprete de Python nos programar, si sale y entra desde el intérprete de Python, entonces todos los métodos y variables que se definen habrá desaparecido.

Python proporciona una manera de hacer esto, estas definiciones almacenadas en un archivo para algunas secuencias de comandos o intérprete interactivo ejemplo, este archivo se denomina un módulo.

Módulo es una definición de todos los archivos que contiene funciones y variables cuyo sufijo .py nombre. Los módulos pueden ser introducidos en otros programas para utilizar este módulo de funciones y otras funciones. Este es también el uso de la biblioteca estándar Python.

Aquí es un ejemplo de los módulos de la biblioteca estándar de Python utilizados. 

#!/usr/bin/python3
# 文件名: using_sys.py

import sys

print('命令行参数如下:')
for i in sys.argv:
   print(i)

print('\n\nPython 路径为：', sys.path, '\n')

Aplicación de los resultados son los siguientes: 

$ python using_sys.py 参数1 参数2
命令行参数如下:
using_sys.py
参数1
参数2


Python 路径为： ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
  • 1, sys importación establecidos en el módulo de pitón sys.py biblioteca estándar, lo que es la introducción de un enfoque módulo.
  • 2, sys.argv es una lista de modificadores de línea de comandos están incluidos.
  • 3, sys.path incluye un intérprete de Python encontrar automáticamente la ruta de la lista de módulos necesarios.

declaración de importación

Se desea utilizar el archivo fuente de Python, basta con realizar otra declaración de importación en el archivo de origen, la sintaxis es la siguiente: 

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

Cuando el intérprete se encuentra con la declaración de importación, si el módulo se importará en la ruta de búsqueda actual.

La ruta de búsqueda es un intérprete buscará primero una lista de todos los directorios. A medida que desea importar el soporte de módulos, tiene que pedir en la parte superior de la secuencia de comandos:

código del archivo support.py es: 

#!/usr/bin/python3
# Filename: support.py

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

test.py introdujo módulo de soporte: 

#!/usr/bin/python3
# Filename: test.py
 
# 导入模块
import support
 
# 现在可以调用模块里包含的函数了
support.print_func("w3big")

Los ejemplos de la salida anterior: 

$ python3 test.py 
Hello :  w3big

Un módulo sólo se importará una vez, no importa cuántas veces se ejecuta importación. Esto evita que el módulo de importación se ejecuta una y otra vez.

Cuando usamos la declaración de importación cuando, Python intérprete es cómo encontrar el archivo correspondiente que?

Esto implica la ruta de búsqueda de Python, la ruta de búsqueda se compone de una serie de nombres de directorio, intérprete de Python se apartará de estos directorios para buscar módulos introducidos.

Esto se ve como una variable de entorno, de hecho, puede ser determinado por la definición del entorno de la ruta de búsqueda de forma variable.

Ruta de búsqueda es el compilador de Python o instalación determinada, instalar nueva biblioteca también debe ser modificado. La ruta de búsqueda se almacena en la variable de ruta del módulo sys, hacer un simple experimento en intérprete interactivo, introduzca el siguiente código: 

>>> import sys
>>> sys.path
['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
>>>

sys.path es una lista de salida, el primero de los cuales es una cadena vacía '', representa el directorio actual (si se imprime desde un script, se puede ver más claramente en qué directorio), que se ejecuta intérprete de python directorio (si el guión es el directorio donde se ejecuta el script).

Así que si como yo existo en el directorio actual con el mismo nombre que el archivo a ser introducidos en el módulo, se introducirá el módulo de bloquear.

Comprender el concepto de la ruta de búsqueda, puede modificar sys.path en una secuencia de comandos para introducir alguna no en la ruta de búsqueda del módulo.

Ahora, en el directorio actual o un intérprete de directorio sys.path en el que desea crear un archivo fibo.py, de la siguiente manera: 

# 斐波那契(fibonacci)数列模块

def fib(n):    # 定义到 n 的斐波那契数列
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

def fib2(n): # 返回到 n 的斐波那契数列
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

A continuación, introduzca el intérprete de Python, utilice el siguiente comando para importar este módulo: 

>>> import fibo

Esto no está definido en fibo directamente en el nombre de la función se escribe en la tabla de símbolos, pero el nombre de módulo fibo escrito allí.

Puede usar el nombre del módulo de funciones de acceso: 

>>> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'

Si tiene intención de utilizar una función de la frecuencia con que se puede asignar a un nombre local: 

>>> fib = fibo.fib
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

de instrucción de importación ...

Python le permite importar una declaración de una parte específica del espacio de nombres actual del módulo, la sintaxis es la siguiente: 

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

Por ejemplo, para importar el fibo módulo de la función fib, utilice la siguiente declaración: 

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

Esta afirmación no es del todo el módulo fibo en el espacio de nombres actual, sólo se Fibo función fib carril introdujo en.


A partir de ... * instrucción de importación

Todos los contenidos de un módulo están todos en el espacio de nombres actual son posibles, sólo tiene que utilizar la siguiente instrucción: 

from modname import *

Esto proporciona una manera fácil de importar un módulo en todos los proyectos. Sin embargo, esta afirmación no debe ser demasiado para su uso.

módulo de profundidad

Además del módulo de definición del método también puede incluir código ejecutable. Estos códigos se utilizan generalmente para inicializar el módulo. Este código sólo se introduce la primera vez que va a ser ejecutado.

Cada módulo tiene su propia tabla de símbolos independientes, en el interior del equipo a utilizar para todas las funciones como una tabla de símbolos global.

Por lo tanto, el autor del módulo se puede utilizar con seguridad estas variables globales en el módulo sin tener que preocuparse por los otros usuarios para vincularse en una flor de variables globales.

Desde otro aspecto, cuando realmente sabe lo que está haciendo, también se puede acceder al módulo de funciones por modname.itemname dicha representación.

Los módulos se pueden importar otros módulos. En un módulo (o secuencia de comandos, o en otra parte) el uso más importante de importación para importar un módulo, por supuesto, esto es sólo una convención, y no obligatoria. El nombre del módulo importado se coloca en la tabla de símbolos de la operación actual del módulo.

También hay un método de importación, la importación se puede utilizar directamente en el nombre de módulo (función de variables) en el módulo de funcionamiento actual. Por ejemplo: 

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

Este método no importará el nombre del módulo se introduce en la tabla de caracteres actual (por lo que en este caso el interior, Fibo nombre no está definido).

Esta es también una manera de poner un módulo de una sola vez todas las funciones, variables (nombres) se importan en el módulo de la tabla de caracteres actual: 

>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

Esto importará todos los nombres están en, pero los de un solo guión bajo (_) nombre no aparece en este caso. En la mayoría de los casos, los programadores de Python no utilizan este método porque los nombres introducidos de otras fuentes, es probable que cubra la definición existente.

__name__ atributo

Cuando un módulo se introdujo por primera vez otro programa, el programa principal se ejecutará. Si queremos ser introducido en el módulo, el módulo no se ejecuta un bloque de programa, podemos utilizar el atributo __name__ para hacer de este bloque se ejecuta sólo en el módulo de tiempo de ejecución en sí. 

#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

Ejecute el siguiente resultado: 

$ python using_name.py

Propio programa se está ejecutando 

$ python
>>> import using_name
我来自另一模块
>>>

Descripción: Cada módulo tiene un atributo __name__, cuando su valor es '__main__', indica que el propio módulo se está ejecutando, de lo contrario, se está introduciendo.

función dir () 

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:
</p>
<pre>
>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)  
['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
 '__package__', '__stderr__', '__stdin__', '__stdout__',
 '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
 '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
 'call_tracing', 'callstats', 'copyright', 'displayhook',
 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
 'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
 'thread_info', 'version', 'version_info', 'warnoptions']

Si no se da ningún argumento, entonces la función dir () mostrará una lista de los nombres de todos definida actualmente: 

>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir() # 得到一个当前模块中定义的属性列表
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']
>>> a = 5 # 建立一个新的变量 'a'
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'sys']
>>>
>>> del a # 删除变量名a
>>>
>>> dir()
['__builtins__', '__doc__', '__name__', 'sys']
>>>

Módulo estándar

Python sí con algunos de la biblioteca estándar de módulos en el documento de Referencia de la Biblioteca serán introducidos a (es decir detrás del "Documento de Referencia de la Biblioteca").

Algunos módulos se construyen directamente en el analizador, idiomas aunque no algunas de las características incorporadas, pero pudo usar un muy eficiente, incluso a llamadas a nivel de sistema no son un problema.

Estos componentes se pueden configurar en diferentes formas sobre la base de diferentes sistemas operativos, tales como el módulo de winreg sólo estará disponible para el sistema Windows.

Cabe señalar que existe una sys módulo especial, que está integrado en cada analizador Python. Variables sys.ps1 y sys.ps2 define la cadena correspondiente símbolo del indicador primario y secundario: 

>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>

paquete

El paquete está en la forma de un módulo de espacio de nombres gestión Python, el uso de "nombres de los módulos de puntos."

Por ejemplo, un nombre de módulo es AB, entonces se dice que un paquete de un sub-módulo B.

Si se utiliza el módulo, usted no tiene que preocuparse acerca de las variables globales entre diferentes módulos de interacción, como el uso de los nombres de los módulos de puntos en esta forma, no se preocupe el módulo caso entre las diferentes bibliotecas del mismo nombre.

De manera que diferentes autores pueden proporcionar módulo NumPy, o biblioteca de gráficos Python.

Supongamos que usted quiere diseñar un módulo de procesamiento de voz unificada y un archivo de datos (o lo llaman un "paquete").

Existente variedad de diferentes formatos de archivo de audio (básicamente se distinguen por extensión, por ejemplo: archivo .wav ,:: .aiff archivo: .au, ,:), por lo que es necesario tener un conjunto de módulo para aumentar entre diferentes formatos.

Y para los datos de audio, hay muchas operaciones diferentes (tales como mezcla, añadiendo eco, aumentar la función de ecualizador para crear un efecto estéreo artificial), que también necesita un conjunto de módulos de cómo terminar nunca para manejar estas operaciones.

Aquí tenemos una posible estructura del paquete (en un sistema jerárquico de archivos): 

sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

En la importación de un paquete cuando, directorios Python sys.path basado en el subdirectorio para encontrar este paquete.

Sólo directorio contiene un archivo llamado __init__.py serán considerados como un paquete, sobre todo para evitar algunos de los abusos vulgar del nombre (por ejemplo, llamada cadena) descuidada afecta a la ruta de búsqueda a un módulo válido.

En el caso más simple, poner vacío: file: __ init__.py ella. Por supuesto, este archivo puede contener también algo de código de inicialización o está (se describirá más adelante) __all__ variable.

Cada vez que el usuario puede importar sólo un módulo específico dentro del paquete, tales como: 

import sound.effects.echo

Esto importará submódulos: Sonido.Efectos.eco. Se debe usar el nombre completo para acceder a: 

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

Otro método para la introducción de los sub-módulos son: 

from sound.effects import echo

También importará submódulos: eco, y que no necesita los prefijo largo, por lo que podría utilizar: 

echo.echofilter(input, output, delay=0.7, atten=4)

Otro cambio se introduce directamente en una función o variable: 

from sound.effects.echo import echofilter

Una vez más, este método va a importar submódulos: eco, y puede usar su función filtroeco ():

filtroeco (entrada, salida, retardo = 0,7, aten = 4)

Tenga en cuenta que cuando se utiliza de la partida de importación paquete en esta forma cuando el artículo correspondiente puede ser o bien dentro de la sub-módulo de paquete (paquetes de sub), u otros nombres dentro de la definición del paquete, como la función, clase o variable.

La sintaxis será la primera importar el nombre del elemento se define como un paquete, si no lo encuentra, entonces trató de seguir un módulo para importar. Si no lo encuentra, felicitaciones, a: exc: ImportError excepción es lanzada.

Por el contrario, si se utiliza esta forma como la importación item.subitem.subsubitem importar la forma, excepto el último, tiene que ser un paquete, pero el último puede ser un módulo o un paquete, pero no puede ser un nombre de clase, función o variable .

Importación de un paquete *

Imagínese si utilizamos de Sonido.Efectos importar * ¿Qué pasará?

Python entrará en el sistema de archivos, encontrar el paquete que todos los sub-módulos, uno por uno, todos ellos entren en.

Pero, por desgracia, este método funciona en la plataforma Windows no es muy buena, ya que Windows es un sistema de mayúsculas y minúsculas.

En esta plataforma, nadie puede dar fe de archivos llamado ECHO.py importado como un eco módulo o Eco o ECHO.

(Por ejemplo, Windows 95 es muy molesto para capitalizar la primera letra de cada archivo se muestra) y DOS 8 + 3 convención de nomenclatura se ocupará de la cuestión de los nombres de los módulos tiempo duran más enredado.

Para resolver este problema, el único problema el autor del paquete para proporcionar un índice preciso del paquete.

declaración de importación siguientes reglas: Si el archivo de definición de paquetes llamado __init__.py existe __all__ lista de variables, usando el paquete de importación * hora de poner todos los nombres en esta lista como un paquete de contenido de importación.

Como el autor del paquete, no se olvide después de que el paquete de actualización para asegurar __all__ ah también actualizada. Usted dice que no lo haré, no voy a utilizar la importación * este uso, está bien, no hay problema, ¿por qué no hacer el jefe. He aquí un ejemplo, en: file: sonidos / efectos / __ init__.py contiene el siguiente código: 

__all__ = ["echo", "surround", "reverse"]

Esto significa que cuando se utiliza este uso de Sonido.Efectos importar *, importará el paquete dentro de los tres sub-módulos.

Si __all__ realmente no se define, a continuación, utilizar esta sintaxis de import * Sonido.Efectos tiempo, no importa ningún sub-módulos en los Sonido.Efectos paquete. Se acaba de poner todos los contenidos del paquete y su Sonido.Efectos definida en el interior para entrar en (definido puede estar ejecutando el código de inicialización __init__.py).

Esto __init__.py que define todos los nombres de entrar en. Y no va a destruir toda módulo especificado explícitamente antes de que introdujimos esta frase. Mira esta parte del código: 

import sound.effects.echo
import sound.effects.surround
from sound.effects import *

En este ejemplo, antes de la ejecución de la importación ..., paquete Sonido.Efectos el eco y los módulos de sonido envolvente se importan en el espacio de nombres actual. (Por supuesto, incluso si se define __all__ no hay problema)

Normalmente no abogamos por el uso de este método * para importar el módulo, porque a menudo este método resultará en una reducción de legibilidad. Pero esto es realmente una combinación de teclas puede ahorrar una gran cantidad de esfuerzo, y algunos módulos están diseñados para convertirse en el único de importación a través de un método en particular.

Recuerde, el uso del paquete de importación specific_submodule este método nunca será mal. De hecho, este es el método recomendado. A menos que desee importar sub-módulos y submódulos pueden tener otros paquetes del mismo nombre.

Si la estructura del paquete es un sub-paquete (como el ejemplo para el paquete es de sonido), y que desea importar el paquete hermanos (el mismo paquete de nivel) usted tiene que utilizar la ruta absoluta de importación para importar. Por ejemplo, si desea utilizar los módulos del paquete sound.filters.vocoder módulo Sonido.Efectos eco, usted tiene que escribir desde Sonido.Efectos importar eco. 

from . import echo
from .. import formats
from ..filters import equalizer

Ya sea que las importaciones en relación implícitas o explícitas son desde el principio del módulo actual. Nombre del módulo principal es siempre "__main__", módulo principal de una aplicación Python, siempre se debe utilizar un absoluto referencias de ruta.

El paquete también proporciona una __path__ propiedad adicional. Esta es una lista de directorios, cada uno de los cuales tiene un directorio que contiene el paquete para este __init__.py servicio, usted tiene que ser ejecutado antes de que otro se define en __init__.py oh. Esta variable puede ser modificado por la influencia en el interior del módulo incluido en el paquete y el paquete secundario.

Esta característica no se usa comúnmente, típicamente usada para extender el paquete dentro del módulo.