Módulos Python: Organizando Seu Código para Clareza e Reutilização

Um módulo permite organizar 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.

Simplificando, um módulo é um arquivo consistindo de 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 Instrução import

Você pode usar qualquer arquivo fonte Python como módulo executando uma instrução import em outro arquivo fonte Python. A sintaxe do import é:

import modulo1[, modulo2[,... moduloN]]

Quando o interpretador encontra uma instrução import, ele importa o módulo se este estiver presente no caminho de busca. Um caminho de busca é uma lista de diretórios que o interpretador procura 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
# Importa o módulo support
import support

# Agora você pode chamar a função definida no módulo da seguinte forma
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 múltiplas importações.

A Instrução from...import

A instrução from do Python permite importar atributos específicos de um módulo para o namespace atual. A sintaxe do from...import é:

from modname import nome1[, nome2[, ... nomeN]]

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 fib inteiro para o namespace atual; ela apenas introduz o item fibonacci do módulo fib na tabela de símbolos global do módulo importador.

A Instrução from...import *

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 instruçã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 então procura cada diretório na variável de shell PYTHONPATH.

• Se tudo falhar, o Python verifica o caminho padrão. No UNIX, este caminho padrão é normalmente /usr/local/lib/python/.

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

A Variável PYTHONPATH

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

Aqui está uma PYTHONPATH típica de um sistema Windows:

set PYTHONPATH = c:\python20\lib;

E aqui está uma PYTHONPATH típica de um sistema UNIX:

set PYTHONPATH = /usr/local/lib/python

Namespaces 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 namespace local e no namespace global. Se uma variável local e uma global tiverem o mesmo nome, a variável local sombreia a global.

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

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

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

A instrução global NomeVar diz ao Python que NomeVar é uma variável global. O Python para de procurar a variável no namespace local.

Por exemplo, definimos uma variável Money no namespace global. Dentro da função Money, atribuímos um valor a Money, portanto o Python assume Money como variável local. No entanto, acessamos o valor da variável local Money antes de defini-la, resultando em um UnboundLocalError. Descomentando a instrução global resolve o problema.

#!/usr/bin/python
Money = 2000
def AddMoney():
    # Descomente a linha seguinte para corrigir o código:
    # global Money
    Money = Money + 1
    print(Money)

AddMoney()
print(Money)

A Função dir()

A função embutida 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 definidos em um módulo. Exemplo simples:

#!/usr/bin/python
# Importa o módulo embutido math
import math
content = dir(math)
print(content)

Quando o código acima é executado, 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 string especial __name__ é o nome do módulo, e __file__ é o nome do arquivo a partir do qual o módulo foi carregado.

As Funções globals() e locals()

As funções globals() e locals() podem ser usadas para retornar os nomes nos namespaces global e local, dependendo de onde são chamadas.

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

Se globals() for chamada dentro de uma função, ela 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().

A Função reload()

Quando o módulo é importado em um script, o código na porção de nível superior de um módulo é executado apenas uma vez.

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

reload(nome_modulo)

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

reload(hello)

Pacotes em Python

Um pacote é uma estrutura hierárquica de diretório de arquivos que define um único ambiente de aplicação Python consistindo de módulos, subpacotes e sub-subpacotes, e assim por diante.

Considere um arquivo Pots.py disponível no diretório Phone. Este arquivo tem a seguinte linha de código fonte:

#!/usr/bin/python
def Pots():
    print("I'm Pots Phone")

De forma similar, temos outros dois arquivos com funções diferentes com o mesmo nome:

• Phone/Isdn.py com a função Isdn()

• Phone/G3.py com a função G3()

Agora, crie mais um arquivo __init__.py no diretório Phone:

• Phone/__init__.py

Para tornar todas as suas funções disponíveis quando você importar Phone, você precisa colocar instruções de importação explícitas no __init__.py da seguinte forma:

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

Depois de adicionar essas linhas ao __init__.py, você tem todas essas classes disponíveis quando importa o pacote Phone.

#!/usr/bin/python
# Agora importe seu pacote Phone.
import Phone
Phone.Pots()
Phone.Isdn()
Phone.G3()

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

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

No exemplo acima, usamos o exemplo de uma única função em cada arquivo, mas você pode manter múltiplas funções em seus arquivos. Você também pode definir diferentes classes Python nesses arquivos e então criar seus pacotes a partir dessas classes.