Python pt-br:Modulos

[edit] Introdução

Você viu como pode reutilizar códigos em seu programa através da definição apenas uma vez de funções. Que tal se você quisesse reutilizar um certo número de funções em outros programas que você escrever? Como você poderia ter adivinhado, a resposta está em módulos. Um módulo é basicamente um arquivo contendo todas as funções e variáveis que você definiu.

Para reutilizar o módulo em outros programas, o nome do módulo deve ter uma extensão .py.

Um módulo pode ser importado por um outro programa pra fazer uso da sua funcionalidade. Assim é também como nós podemos usar a biblioteca padrão de Python. Primeiro, nós veremos como utilizar os módulos da biblioteca padrão.

Exemplo:

#!/usr/bin/python
# Nome do arquivo: using_sys.py
 
import sys
 
print('Os argumentos da linha de comando são:')
for i in sys.argv:
    print(i)
 
print('\n\nO PYTHONPATH é', sys.path, '\n')

Saída:

   $ python using_sys.py nos somos argumentos
   Os argumentos da linha de comando são:
   test.py
   nos
   somos
   argumentos
   
   
   O PYTHONPATH é ['C:\\tmp', 'C:\\Python30\\python30.zip',
   'C:\\Python30\\DLLs', 'C:\\Python30\\lib', 'C:\\Python30\\lib\\plat-win',
   'C:\\Python30', 'C:\\Python30\\lib\\site-packages']

Como Funciona:

Primeiro nós importamos o módulo sys usando o comando import. Basicamente, isso se traduz em nós dizermos a Python que queremos empregar este módulo. O módulo sys contém funcionalidade relacionada ao interpretador de Python e o seu ambiente, ou seja, o systema.

Quando Python executa o comando import sys, procura pelo módulo sys.py em um dos diretórios listados na sua variável sys.path. Se o arquivo é encontrado, então os comandos do bloco principal (main) do módulo são executados e o módulo é tornado disponível para seu uso. Observe que a inicialização é realizada apenas a primeira vez que nós importamos o módulo.

A variável argv no módulo sys é acessada utilizando-se a notação por pontos (dotted) isto é sys.argv. Ela claramente indica que este nome é parte do módulo sys. Uma outra vantagem dessa abordagem é que o nome não colide com qualquer variável argv usada em seu programa.

A variável sys.argv é uma lista de strings (listas (lists) são explicadas em detalhes em um capítulo posterior). Especificamente, sys.argv contém a lista de argumentos da linha de comando, ou seja, os argumentos que são passados para o seu programa usando a linha de comando.

Se você estiver usando uma IDE para escrever e executar esses programas, procure por uma forma de especificar os argumentos da linha de comando ao seu programa nos menus.

Aqui, quando nós executamos python using_sys.py nos somos argumentos nós executamos o módulo using_sys.py com o comando python e as outras coisas que seguem são argumentos passados ao programa. Python guarda os argumentos da linha de comando na variável sys.argv para nosso uso.

Lembre-se, o nome do script que está em execução é sempre o primeiro argumento na lista sys.argv. assim, neste caso nós teremos 'using_sys.py' como sys.argv[0], 'nos' como sys.argv[1], 'somos' como sys.argv[2] e 'argumentos' como sys.argv[3]. Note que Python começa a contagem a partir de 0 e não de 1.

A variável sys.path contém a lista de nomes de diretórios de onde os módulos são importados. Observe que a primeira string em sys.path está vazia - esta string vazia indica que o diretório corrente é também parte de sys.path a qual é a mesma que a variável de ambiente PYTHONPATH. Isso significa que você pode importar diretamente módulos localizados no diretório corrente. Se não for o caso, você terá que colocar seu módulo em um dos diretórios listados em sys.path.

[edit] Arquivos .pyc Byte-compilados

A importação de módulos é uma ação relativamente custosa, de modo que Python realiza alguns truques para torná-la mais rápida. Uma maneira é a criação de arquivos byte-compilados com a extensão .pyc que é uma forma intermediária em que Python transforma o programa (lembre-se da seção de introdução em Como Python Funciona?). Este arquivo .pyc é útil quando você importar o módulo a próxima vez de um programa diferente - será muito mais rápido pois uma parte do procedimento requerido para a importação do módulo já está feita. Além disso, estes arquivos byte-compilados são independentes da plataforma.

Nota

Esses arquivos .pyc são usualmente criados no mesmo diretório dos arquivos .py correspondentes. Se Python não tiver permissão para escrever arquivos naquele diretório, então os arquivos .pyc não serão criados.

[edit] O Comando from .. import

Se você quiser importar diretamente a variável argv no seu programa (para evitar ficar digitando sys. todas as vezes), então você pode usar o comando from sys import argv. Se você quiser importar todos os nomes usados no módulo sys, então você pode usar o oomando from sys import *. Isso funciona com qualquer módulo.

Em geral, você deve evitar o uso desse comando e, ao invés, utilizar o comando import, pois dessa forma você evitará colisão de nomes e seu programa ficará mais legível.

[edit] O __name__ de um Módulo

Todo módulo tem um nome e comandos em um módulo podem encontrá-lo. Isso é conveniente na situação particular em que se proecisa descobrir se o módulo está sendo executado por si só ou está sendo importado. Como mencionado anteriormente, quando um módulo é importado pela primeira vez, o bloco principal (main) daquele módulo é executado. Nó podemos usar esse conceito para executar o bloco apenas se o programa for usado por si só e não quando for importado por outro módulo. Isso pode ser alcançado usando o atributo __name__ do módulo.

Exemplo:

#!/usr/bin/python
# Nome do arquivo: using_name.py
 
if __name__ == '__main__':
    print('Este programa está sendo executado por si só')
else:
    print('Eu estou sendo importado de outro módulo')

Saída:

   $ python using_name.py
   Este programa está sendo executado por si só
   
   $ python
   >>> import using_name
   Eu estou sendo importado de outro módulo
   >>>

Como Funciona:

Todo módulo em Python tem o seu __name__ definido e se este é '__main__', isso implica que o módulo está semdo executado por si só pelo usuário e nós poderemos adotar as ações apropriadas.

[edit] Produzindo os Seus Próprios Módulos

A criação de seus próprios módulos é fácil, pois você já tem feito isso o tempo todo! Isso é porque todo programa em Python é também um módulo. Você apenas tem que se assegurar que possua a extensão .py. O próximo exemplo deve tornar isso claro.

Exemplo:

#!/usr/bin/python
# Nome do arquivo: mymodule.py
 
def sayhi():
    print('Olá, este é meu módulo falando.')
 
__version__ = '0.1'
 
# Fim de mymodule.py

O código acima é um módulo de amostra. Como você pode ver, não existe nada particularmente especial a respeito dele em comparação com os nossos programas usuais em Python. Veremos agora como usar este módulo em nossos outros programas em Python.

Lembre-se que os módulos devem ser colocados no mesmo diretório que o programa que os importa, ou então deve estar em um dos diretórios listados em sys.path.

#!/usr/bin/python
# Nome do arquivo: mymodule_demo.py
 
import mymodule
 
mymodule.sayhi()
print 'Versão', mymodule.__version__

Saída:

   $ python mymodule_demo.py
   Olá, este é mymodule falando.
   Versão 0.1

Como Funciona:

Note que nós empregamos a notação dos pontos para acessar os membros do módulo. Python utiliza bastante a mesma notação que lhe dá a característica 'Pythonica' a ela, e modo que não temos que ficar aprendendo novas maneiras de fazer as coisas.

Aqui está a versão utilizando a sintaxe from..import.

#!/usr/bin/python
# Nome do arquivo: mymodule_demo2.py
 
from mymodule import sayhi, __version__
# Alternativa:
# from mymodule import *
 
sayhi()
print('Versão', __version__)

A saída de mymodule_demo2.py é a mesma que a saída de mymodule_demo.py.

Note que já houvesse um nome __version__ declarado no módulo que importa mymodule, haveria uma colisão. Isso é altamente provável pois é prática comum para cada módulo declarar-se a sua versão usando esse nome. Daí é sempre recomendado optar pelo comando import, mesmo se tornar o seu programa um pouco mais longo.

Zen de Python

Um dos princípios-guia de Python é que 'Explicito é melhor do que implícito'. Execute import this para aprender mais.

[edit] A Função dir

Você pode usar a função interna (built-in) dir para listar os indetificadores que um objeto define. Por exemplo, para um módulo, os identificadores incluem as funções, classes e variáveis definidas naquele módulo.

Quando você fornece o nome do módulo à função dir(), ela retorna a lista dos nomes definidos naquele módulo. Quando nenhum argumento é fornecido, ela retorna a lista de nomes definidos no módulo corrente.

Exemplo:

$ python
 
>>> import sys # Obtenha a lista de atributos, neste caso, do módulo sys
 
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__s
tderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_compact_freelists',
'_current_frames', '_getframe', 'api_version', 'argv', 'builtin_module_names', '
byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle'
, 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable',
'exit', 'flags', 'float_info', 'getcheckinterval', 'getdefaultencoding', 'getfil
esystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof',
 'gettrace', 'getwindowsversion', 'hexversion', 'intern', 'maxsize', 'maxunicode
', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platfor
m', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'setrecursionlimit
', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_in
fo', 'warnoptions', 'winver']
 
>>> dir() # obtenha a lista dos atributos do módulo corrente
['__builtins__', '__doc__', '__name__', '__package__', 'sys']
 
>>> a = 5 # cria uma nova variável 'a'
 
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'a', 'sys']
 
>>> del a # delete/remove um nome
 
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'sys']
 
>>>

Como Funciona:

Primeiro nós vemos o uso de dir sobre o módulo importado. Podemos ver a enorme lista de atributos que ele contém.

Em seguida, nós vemos a função dir sem nenhum parâmetro passado a ela. Por padrão, ela retorna a lista dos atributos do módulo corrente. Note que a lista dos módulos importados também faz parte dessa lista.

A fim de observar a ação de dir, nós definimos uma nova variável e atribuímos um valor a ela e então verificamos que existe um valor adicional na lista, com o mesmo nome da variável. Nós removemos a variável/atributo do módulo corrente usando o comando del e a alteração é refletida novamente na saída da função dir.

Uma nota sobre del - este comando é usado para deletar a variável/nome e depois de executado o comando, neste caso del a, voce não poderá acessar a variável a - é como se ela nunca tivesse existido antes.

Note que a função dir() funciona para qualquer objeto. Por exemplo, execute dir(print) para conhecer os atributos da função print, ou dir(str) para os atributos da classe str.

[edit] Packages

Nesse ponto, você já deve ter começado a observar a hierarquia da organização de seus programas. As variáveis usualmente vão dentro das funções. Funções e variáveis globais usualmente vão dentro dos módulos. Que tal se você quisesse organizar os módulos? Este o momento em que entram em cena as packages (pacotes).

Packages são apenas pastas contendo módulos com um arquivo __init__.py que indica a Python que esta pasta é especial porque contém módulos de Python.

Vamos dizer que você quer criar uma package denominada 'world' com as subpackages 'asia', 'africa', etc. e estas subpackages por sua vez contêm módulos como 'india', 'madagascar', etc.

Esta é como você estruturaria as pastas:

   - <alguma pasta presente em the sys.path>/
       - world/
           - __init__.py
           - asia/
               - __init__.py
               - india/
                   - __init__.py
                   - foo.py
           - africa/
               - __init__.py
               - madagascar/
                   - __init__.py
                   - bar.py

Packages são apenas uma conveniência para organizar módulos hierarquicamente. Nós veremos muitos exemplos disso em biblioteca padrão.

[edit] Resumo

Da mesma forma que funções são partes reutilizáveis de programas, os módulos são programas reutilizáveis. Packages são uma outra hierarquia para organizar módulos. A biblioteca padrão que vem com Python representa um exemplo de tais conjuntos de packages e módulos.

Nós vimos como usar esses módulos e criar os nossos próprios módulos.

A seguir, aprenderemos sobre interessantes conceitos denominados estruturas de dados.