Latest web development tutorials

módulo python3

Nas seções anteriores do script é interpretador Python para nos programar, se você sair e entrar do interpretador Python, então todos os métodos e variáveis ​​que definem terão desaparecido.

Python fornece uma maneira de fazer isso, essas definições armazenadas em um arquivo para alguns scripts ou instância interpretador interativo, esse arquivo é chamado um módulo.

Módulo é uma definição de todos os seus arquivos que contém funções e variáveis ​​cujos .py sufixo do nome. Os módulos podem ser introduzidos em outros programas para usar este funções do módulo e outras funções. Este é também o uso de python biblioteca padrão.

Aqui está um exemplo de módulos de biblioteca padrão do Python usado. 

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

import sys

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

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

Aplicação dos resultados são os seguintes: 

$ 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 importação instituídas módulo sys.py biblioteca padrão do Python; esta é a introdução de uma abordagem módulo.
  • 2, sys.argv é uma lista de opções de linha de comando estão incluídos.
  • 3, sys.path inclui um interpretador Python automaticamente encontrar o caminho da lista de módulos necessários.

declaração de importação

Quer usar o arquivo de origem Python, simplesmente executar outra instrução de importação no arquivo de origem, a sintaxe é a seguinte: 

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

Quando o interpretador encontra a instrução de importação, se o módulo será importado no actual caminho de pesquisa.

O caminho da busca é um intérprete irá primeiro procurar uma lista de todos os diretórios. Como você deseja importar o apoio módulo, você precisa de ordem no topo do script:

código de arquivo support.py é: 

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

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

test.py introduzido módulo de suporte: 

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

Exemplos de saída acima: 

$ python3 test.py 
Hello :  w3big

Um módulo só será importado uma vez, não importa quantas vezes você executar importação. Isso impede que o módulo de importação é executada uma e outra vez.

Quando usamos a declaração de importação quando, Python intérprete é como encontrar o arquivo correspondente é?

Isso envolve o caminho de pesquisa Python, o caminho de pesquisa é composto por uma série de nomes de diretório, Python intérprete se desviará esses diretórios para procurar módulos introduzidos.

Este parece ser uma variável de ambiente, de fato, pode ser determinada pela definição do ambiente de pesquisa caminho maneira variável.

Pesquisa caminho é o compilador Python ou instalação determinada, instalar nova biblioteca também deve ser modificado. O caminho de pesquisa é armazenado na variável caminho do módulo sys, fazer uma experiência simples no interpretador interativo, digite o seguinte 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 é uma lista de saída, a primeira das quais é uma cadeia vazia '', representa o diretório atual (se impresso a partir de um script, você pode ver mais claramente qual diretório), que executar interpretador Python Directory (se o script é o diretório onde o script é executado).

Então, se gosta de mim existe no diretório atual com o mesmo nome que o arquivo a ser introduzido no módulo, o módulo será introduzido para bloquear.

Compreender o conceito de caminho de pesquisa, você pode modificar sys.path em um script para introduzir alguns não no caminho de pesquisa do módulo.

Agora, no diretório atual ou um intérprete de diretório sys.path em que para criar um arquivo fibo.py, como segue: 

# 斐波那契(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

Em seguida, digite o interpretador Python, use o seguinte comando para importar este módulo: 

>>> import fibo

Este não é definido em fibo directamente em nome da função é escrita na tabela de símbolo corrente, mas o nome do módulo fibo escritos ali.

Você pode usar o nome do módulo para acessar funções: 

>>> 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'

Se você pretende usar uma função, muitas vezes você pode atribuí-lo a um nome local: 

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

a partir de ... instrução de importação

Python permite importar uma declaração de uma parte específica do namespace atual do módulo, a sintaxe é a seguinte: 

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

Por exemplo, para importar o fibo módulo da função FIB, use a seguinte declaração: 

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

Esta afirmação não é o módulo inteiro fibo no namespace atual, ela só vai fibo função FIB pista introduzido em.


A partir ... import * declaração

Todos os conteúdos de um módulo são todos no espaço de nomes atual são possíveis, basta usar a seguinte declaração: 

from modname import *

Isso fornece uma maneira fácil de importar um módulo em todos os projetos. No entanto, esta afirmação não deve ser demasiado de usar.

módulo de profundidade

Para além do módulo de definição método também pode incluir um código executável. Estes códigos são geralmente usados ​​para inicializar o módulo. Este código é apenas o primeiro tempo é introduzido será executada.

Cada módulo possui sua própria tabela de símbolo independente, dentro do módulo a ser usado para todas as funções como uma tabela de símbolos global.

Portanto, o autor do módulo de segurança pode usar essas variáveis ​​globais no módulo sem se preocupar com os outros usuários a se envolver em uma flores de variáveis ​​globais.

De outro aspecto, quando você realmente sabe o que está fazendo, você também pode acessar o módulo de função por modname.itemname tal representação.

Os módulos podem importar outros módulos. Em um módulo (ou script, ou noutro local) o uso mais importante de importação para importar um módulo, é claro, isso é apenas uma convenção, e não obrigatória. O nome do módulo importado será colocado na tabela de símbolos da operação actual do módulo.

Há também um método de importação, a importação pode ser usado diretamente no nome do módulo (função de variáveis) em seu módulo operacional atual. Por exemplo: 

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

Este método não irá importar o nome do módulo é introduzido na tabela de caracteres atual (portanto, neste caso dentro, Fibo nome não é definido).

Esta é também uma maneira de colocar um módulo de uma só vez todos os (função, variável) nomes são importados para o módulo de mesa de caracteres atual: 

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

Isto irá importar todos os nomes são, mas aqueles de um único sublinhado (_) nome não é sobre este caso. Na maioria dos casos, os programadores Python, não use este método porque os nomes introduzidos a partir de outras fontes, é provável que cobrirão a definição existente.

__name__ atributo

Quando um módulo é introduzido pela primeira vez um outro programa, o programa principal será executado. Se queremos ser introduzido no módulo, o módulo não executa um bloco de programa, podemos usar __name__ atributo para fazer este bloco é executado somente no módulo de tempo de execução em si. 

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

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

Execute o seguinte resultado: 

$ python using_name.py

Programa em si está em execução 

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

Descrição: Cada módulo tem um atributo __name__, quando o seu valor é "__main__ ', indica que o módulo em si está em execução, caso contrário ele está sendo introduzido.

função 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']

Se nenhum argumento for dado, então a função dir () irá listar os nomes de todos definidos no momento: 

>>> 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 padrão

Python propriamente dito com alguma da biblioteca padrão de módulos no documento Python Library Reference serão introduzidas para (que está por trás do "Documento de Referência Library").

Alguns módulos são construídos diretamente no analisador, línguas embora não algumas características built-in, mas ele foi capaz de usar um muito eficiente, mesmo um nível de sistema de chamadas não são problema.

Estes componentes podem ser configurados de diferentes formas com base em diferentes sistemas operativos, tais como o módulo winreg estará disponível apenas para o sistema Windows.

Deve notar-se que existe uma sys módulo especial, que é construída em cada analisador Python. Variáveis ​​sys.ps1 e sys.ps2 através define a sequência correspondente prompt de prompt primário e secundário: 

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

pacote

O pacote está na forma de um módulo namespace gestão Python, usando "nomes de módulos pontilhadas."

Por exemplo, um nome de módulo é AB, em seguida, ele disse que um pacote Um sub-módulo B.

Se estiver usando o módulo, você não precisa se preocupar com variáveis ​​globais entre diferentes interação módulos, como o uso de nomes de módulos pontilhadas desta forma, não se preocupe o módulo caso entre bibliotecas diferentes com o mesmo nome.

De modo que diferentes autores podem fornecer módulo NumPy, ou Python biblioteca de gráficos.

Vamos supor que você deseja criar um módulo de processamento de voz unificada e um arquivo de dados (ou chamá-lo de um "pacote").

variedade existente de diferentes formatos de arquivos de áudio (basicamente distinguidas por extensão, por exemplo: .wav arquivo ,:: .aiff arquivo ,:: .au,), então você precisa ter um conjunto de aumentar módulo para entre diferentes formatos.

E para os dados de áudio, há muitas operações diferentes (tais como mistura, adicionando eco, aumentar a função de equalizador para criar o efeito estéreo artificial), que você também precisa de um conjunto de como terminar nunca módulos para lidar com essas operações.

Aqui está uma possível estrutura de pacote (em um sistema hierárquico de arquivos): 

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
              ...

Em Importar um pacote quando, Python sys.path diretórios com base no subdiretório para encontrar este pacote contém.

Apenas diretório contém um arquivo chamado __init__.py será considerado como um pacote, principalmente para evitar alguns dos abusos vulgar do nome (por exemplo, chamada string) descuidada afetam o caminho de busca a um módulo válido.

No caso mais simples, coloque um vazio: file: __ init__.py-lo. Naturalmente, este ficheiro pode também conter um código de inicialização ou é (será descrito mais tarde) __all__ variável.

Toda vez que o usuário pode importar apenas um módulo específico dentro do pacote, tais como: 

import sound.effects.echo

Isto irá importar sub-módulos: Sound.Effects.echo. Ele deve usar o nome completo para acessar: 

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

Outro método para a introdução dos sub-módulos são: 

from sound.effects import echo

Ele também irá importar sub-módulos: eco, e que ele não precisa aqueles longos prefixo, para que ele pudesse usar: 

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

Outra mudança é introduzido diretamente uma função ou variável: 

from sound.effects.echo import echofilter

Mais uma vez, este método irá importar sub-módulos: eco, e pode usar sua função echofilter ():

echofilter (entrada, saída, delay = 0,7, atten = 4)

Note-se que ao utilizar from package import item nesta forma quando o item correspondente pode ser tanto dentro do sub-módulo de pacote (sub pacotes), ou outros nomes dentro da definição de pacote, como função, classe ou variável.

A sintaxe irá primeiro importar o nome do item definido como um pacote, se não for encontrado, em seguida, tentou seguir um módulo de importação. Se não for encontrado, parabéns, um: exc: exceção ImportError é lançada.

Por outro lado, se você utilizar este formulário como a importação item.subitem.subsubitem importar formulário, exceto o último, ele deve ser um pacote, mas o último pode ser um módulo ou um pacote, mas não pode ser um nome de classe, função ou variável .

Importar de um pacote *

Imagine se nós usamos a partir Sound.Effects import * O que vai acontecer?

Python vai entrar no sistema de arquivo, encontrar o pacote que todos os sub-módulos, um por um, todos eles a entrar em.

Mas, infelizmente, este método funciona na plataforma Windows não é muito bom, porque o Windows é um sistema de maiúsculas e minúsculas.

Nesta plataforma, ninguém pode atestar chamado arquivo ECHO.py importados como um eco módulo ou Eco ou ECHO.

(Por exemplo, o Windows 95 é muito irritante para capitalizar a primeira letra de cada arquivo é exibido) e DOS 8 + 3 convenção de nomenclatura vai lidar com a questão dos nomes longos não mais emaranhadas.

Para resolver este problema, o único problema o autor do pacote para fornecer um índice exacta do pacote.

declaração de importação seguintes regras: Se o arquivo de definição de pacote chamado __init__.py existe __all__ lista de variáveis, utilizando from package import * hora de colocar todos os nomes nesta lista como um conteúdo do pacote de importação.

Como o autor do pacote, não se esqueça, após o pacote de atualização para garantir __all__ ah também atualizado. Você diz que eu não vou fazer isso, eu não vou usar o Import * este uso, está bem, não há problema, por que não fazer o patrão. Aqui está um exemplo, em: file: sons / efeitos / __ init__.py contém o seguinte código: 

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

Isto significa que quando você usa esse uso de Sound.Effects importar *, você vai importar o pacote dentro das três sub-módulos.

Se __all__ realmente não está definido, em seguida, usar essa sintaxe de Sound.Effects importar * tempo, ele não importará todos os sub-módulos nos Sound.Effects pacote. Ele acabou de colocar todo o conteúdo do pacote e suas Sound.Effects definida dentro de entrar em (definida pode estar executando código de inicialização __init__.py).

Isto irá __init__.py que define todos os nomes a entrar em. E ele não vai destruir toda módulo explicitamente especificado antes que introduziu esta frase. Olhe para esta parte do código: 

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

Neste exemplo, antes da execução de ... importação, pacote Sound.Effects o eco e módulos de surround são importados para o namespace atual. (É claro que, mesmo se você definir __all__ nenhum problema)

Normalmente nós não defendemos o uso de * esse método para importar o módulo, porque muitas vezes esse método irá resultar em legibilidade reduzida. Mas esta é realmente uma combinação de teclas pode salvar um grande esforço, e alguns módulos são projetados para se tornar a única de importação através de um método particular.

Lembre-se, usando de pacote specific_submodule importação esse método nunca vai estar errado. Na verdade, este é o método recomendado. A menos que você deseja importar sub-módulos e sub-módulos pode ter outros pacotes com o mesmo nome.

Se a estrutura do pacote é um sub-pacote (como o exemplo para o pacote é som), e você deseja importar o pacote irmãos (mesmo pacote nível) você tem que usar o caminho absoluto importado para importar. Por exemplo, se você quiser usar módulos do pacote Sound.Filters.vocoder módulo Sound.Effects eco, você tem que escrever a partir Sound.Effects importar eco. 

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

Se importações relativos são implícitos ou explícitos a partir do início do módulo de corrente. Nome do módulo principal é sempre "__main__", o módulo principal de um aplicativo Python, você deve sempre usar um referências absolutas de caminho.

O pacote também fornece uma __path__ propriedade adicional. Esta é uma lista de diretórios, cada um dos quais tem um diretório que contém o pacote para este __init__.py serviço, você tem que ser executado antes de outros definido no __init__.py oh. Esta variável pode ser modificado para influência no interior do módulo incluído no pacote e o pacote de criança.

Este recurso não é comumente usado, normalmente usado para estender o pacote dentro do módulo.