Python - Módulos

Página anteriorPróxima página
Um módulo permite que você organize logicamente seu código Python. Agrupar código relacionado em um módulo torna o código mais fácil de entender e usar. Um módulo é um objeto Python com atributos nomeados arbitrariamente que você pode vincular e referenciar.

Simplesmente, um módulo é um arquivo que consiste em código Python. Um módulo pode definir funções, classes e variáveis. Um módulo também pode incluir código executável.

Exemplo

O código Python para um módulo chamado aname normalmente reside em um arquivo chamado aname.py . Aqui está um exemplo de um módulo simples, support.py

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

A importação Declaração

Você pode usar qualquer arquivo de origem do Python como um módulo executando uma instrução de importação em algum outro arquivo de origem do Python. A importação tem a seguinte sintaxe -

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

Quando o interpretador encontra uma instrução de importação, ele importa o módulo se o módulo estiver presente no caminho de pesquisa. Um caminho de pesquisa é uma lista de diretórios que o interpretador pesquisa antes de importar um módulo. Por exemplo, para importar o módulo support.py, você precisa colocar o seguinte comando no topo do script −

#!/usr/bin/python

# Import module support
import support

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

Quando o código acima é executado, ele produz o seguinte resultado -

Hello : Zara

Um módulo é carregado apenas uma vez, independentemente do número de vezes que é importado. Isso evita que a execução do módulo aconteça repetidamente se ocorrerem várias importações.

A de...importação Declaração

de do Python A instrução permite importar atributos específicos de um módulo para o namespace atual. A de...importação tem a seguinte sintaxe -

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

Por exemplo, para importar a função fibonacci do módulo fib, use a seguinte instrução −

from fib import fibonacci

Esta instrução não importa o módulo inteiro fib para o namespace atual; ele apenas introduz o item fibonacci do módulo fib na tabela de símbolos global do módulo importador.

A de...importação * Declaração

Também é possível importar todos os nomes de um módulo para o namespace atual usando a seguinte instrução de importação −

from modname import *

Isso fornece uma maneira fácil de importar todos os itens de um módulo para o namespace atual; no entanto, esta declaração deve ser usada com moderação.

Localizando Módulos

Quando você importa um módulo, o interpretador Python procura o módulo nas seguintes sequências −

• 
  O diretório atual.
  
• 
  Se o módulo não for encontrado, o Python pesquisará cada diretório na variável de shell PYTHONPATH.
  
• 
  Se tudo mais falhar, o Python verifica o caminho padrão. No UNIX, esse caminho padrão é normalmente /usr/local/lib/python/.
  

O caminho de pesquisa do módulo é armazenado no módulo do sistema sys como sys.path variável. A variável sys.path contém o diretório atual, PYTHONPATH, e o padrão dependente da instalação.

O PYTHONPATH Variável

O PYTHONPATH é uma variável de ambiente, que consiste em uma lista de diretórios. A sintaxe de PYTHONPATH é a mesma da variável de shell PATH.

Aqui está um PYTHONPATH típico de um sistema Windows -

set PYTHONPATH = c:\python20\lib;

E aqui está um PYTHONPATH típico de um sistema UNIX -

set PYTHONPATH = /usr/local/lib/python

Espaços de nomes e escopo

Variáveis ​​são nomes (identificadores) que mapeiam para objetos. Um namespace é um dicionário de nomes de variáveis ​​(chaves) e seus objetos correspondentes (valores).

Uma instrução Python pode acessar variáveis ​​em um espaço de nomes local e no espaço de nomes global . Se uma variável local e uma global tiverem o mesmo nome, a variável local ocultará a variável global.

Cada função tem seu próprio namespace local. Os métodos de classe seguem a mesma regra de escopo que as funções comuns.

Python faz suposições educadas sobre se as variáveis ​​são locais ou globais. Ele assume que qualquer variável atribuída a um valor em uma função é local.

Portanto, para atribuir um valor a uma variável global em uma função, você deve primeiro usar a instrução global.

A declaração global VarName diz ao Python que VarName é uma variável global. O Python para de pesquisar o namespace local pela variável.

Por exemplo, definimos uma variável Money no namespace global. Dentro da função Dinheiro , atribuímos Dinheiro um valor, portanto, Python assume Money como uma variável local. No entanto, acessamos o valor da variável local Money antes de configurá-lo, então um UnboundLocalError é o resultado. Descomentar a instrução global corrige o problema.

#!/usr/bin/python

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

print Money
AddMoney()
print Money

A função dir( )

A função interna dir() retorna uma lista ordenada de strings contendo os nomes definidos por um módulo.

A lista contém os nomes de todos os módulos, variáveis ​​e funções definidas em um módulo. A seguir está um exemplo simples -
Demonstração ao vivo

#!/usr/bin/python

# Import built-in module math
import math

content = dir(math)
print content

Quando o código acima é executado, ele produz o seguinte 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']

Aqui, a variável de string especial __name__ é o nome do módulo e __file__ é o nome do arquivo do qual o módulo foi carregado.

Os globais() e locals() Funções

Os globais() e locals() As funções podem ser usadas para retornar os nomes nos namespaces globais e locais dependendo do local de onde são chamados.

Se locals() for chamado de dentro de uma função, ele retornará todos os nomes que podem ser acessados ​​localmente a partir dessa função.

Se globals() for chamado de dentro de uma função, ele retornará todos os nomes que podem ser acessados ​​globalmente a partir dessa função.

O tipo de retorno de ambas as funções é dicionário. Portanto, os nomes podem ser extraídos usando a função keys().

O recarregar() Função

Quando o módulo é importado para um script, o código na parte de nível superior de um módulo é executado apenas uma vez.

Portanto, se você deseja reexecutar o código de nível superior em um módulo, você pode usar o reload() função. A função reload() importa novamente um módulo importado anteriormente. A sintaxe da função reload() é esta −

reload(module_name)

Aqui, module_name é o nome do módulo que você deseja recarregar e não a string que contém o nome do módulo. Por exemplo, para recarregar hello módulo, faça o seguinte -

reload(hello)

Pacotes em Python

Um pacote é uma estrutura hierárquica de diretórios de arquivos que define um único ambiente de aplicativo Python que consiste em módulos e subpacotes e subpacotes e assim por diante.

Considere um arquivo Pots.py disponível em Telefone diretório. Este arquivo tem a seguinte linha de código-fonte -

#!/usr/bin/python

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

De maneira semelhante, temos outros dois arquivos com funções diferentes com o mesmo nome acima -

• 
  Telefone/Isdn.py arquivo com função Isdn()
  
• 
  Telefone/G3.py arquivo com a função G3()
  

Agora, crie mais um arquivo __init__.py em Telefone diretório -

• Telefone/__init__.py

Para disponibilizar todas as suas funções ao importar o telefone, você precisa colocar instruções de importação explícitas em __init__.py da seguinte forma −

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

Depois de adicionar essas linhas a __init__.py, você terá todas essas classes disponíveis ao importar o pacote Phone.

#!/usr/bin/python

# Now import your Phone Package.
import Phone

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

Quando o código acima é executado, ele produz o seguinte resultado -

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

No exemplo acima, tomamos como exemplo uma única função em cada arquivo, mas você pode manter várias funções em seus arquivos. Você também pode definir diferentes classes Python nesses arquivos e, em seguida, criar seus pacotes a partir dessas classes.