Módulos

Você viu como você pode reutilizar o código em seu programa definindo as funções uma vez. E se você quisesse reutilizar uma série de funções em outros programas que você escreve? Como você pode ter adivinhado, a resposta é módulos.

Existem vários métodos de escrita de módulos, mas a maneira mais simples é criar um arquivo com um .py extensão que contém funções e variáveis.

Outro método é escrever os módulos no idioma nativo em que o próprio intérprete de Python foi escrito. Por exemplo, você pode escrever módulos no C linguagem de programação e quando compilados, eles podem ser usados a partir do seu código Python ao usar o interpretador Python padrão.

Um módulo pode ser importado por outro programa para usar suas funcionalidades. É assim que podemos usar a biblioteca padrão do Python também. Primeiro, veremos como usar os módulos de biblioteca padrão.

Exemplo (salvar como module_using_sys.py):

import sys

print('The command line arguments are:')
for i in sys.argv:
    print(i)

print('\n\nThe PYTHONPATH is', sys.path, '\n')

Saida:

$ python module_using_sys.py we are arguments    # each arg is separated by white space
The command line arguments are:
module_using_sys.py
we
are
arguments


The PYTHONPATH is ['/tmp/py',
# many entries here, not shown here
'/Library/Python/2.7/site-packages',
'/usr/local/lib/python2.7/site-packages']

Como funciona

Nós primeiro importamos o sys módulo usando o import declaração. Basicamente, isso se traduz em dizer a Python que queremos usar esse módulo. O sys O módulo contém funcionalidades relacionadas ao interpretador Python e seu ambiente, ou seja, o sistema.

Quando o Python executa o import sys declaração, ele procura o sys módulo. Neste caso, é um dos módulos internos e, portanto, Python sabe onde encontrá-lo.

Se não fosse um módulo compilado, ou seja, um módulo escrito em Python, o intérprete de Python procurará por ele nos diretórios listados em seu sys.path variável. Se o módulo for encontrado, as declarações no corpo desse módulo serão executadas eo módulo será feito. disponivel para você usar. Observe que a inicialização é feita apenas primeiro tempo que importamos um módulo.

A variavel argv no modulo sys O módulo é acessado usando a notação pontilhada, isto é, sys.argv. Indica claramente que este nome faz parte do sys módulo. Outra vantagem desta abordagem é que o nome não choca com nenhum argv variável usada em seu programa.

A variavel sys.argv é uma list de cordas (as listas são explicadas em detalhes em capítulo posterior). Especificamente, o sys.argv contém a lista de argumentos de linha de comando ou seja, os argumentos passados para o seu programa usando a linha de comando.

Se você estiver usando um IDE para escrever e executar esses programas, procure uma maneira de especificar argumentos de linha de comando para o programa nos menus.

Aqui, quando executamos python module_using_sys.py we are arguments, nós executamos o módulo module_using_sys.py com o comando python e as outras coisas que se seguem são argumentos passados para o programa. Python armazena os argumentos da linha de comando no sys.argv variável para uso.

Lembre-se, o nome do script em execução é sempre o primeiro elemento no sys.argv Lista. Então, neste caso, teremos 'module_using_sys.py' como sys.argv[0], 'we' como sys.argv[1], 'are' como sys.argv[2] and 'arguments' como sys.argv[3]. Observe que o Python começa a contar de 0 e não 1.

A sys.path contem a lista dos nomes dos diretórios dos quais os módulos são importados. Observe que a primeira corda em sys.path está vazio - esta seqüência vazia indica que o diretório atual também faz parte do sys.path que é o mesmo que o PYTHONPATH variável de ambiente. Isso significa que você pode importar diretamente os módulos localizados no diretório atual. Caso contrário, você terá que colocar seu módulo em um dos diretórios listados em sys.path.

Observe que o diretório atual é o diretório do qual o programa é iniciado. Execute import os; print(os.getcwd()) para descobrir o diretório atual do seu programa.

Arquivos .pyc compilados por byte

Importar um módulo é um assunto relativamente caro, então o Python faz alguns truques para torná-lo mais rápido. Uma maneira é criar byte-compiled arquivos com a extensão .pyc que é uma forma intermediária que o Python transforma o programa em (lembre-se do seção de introdução sobre como o Python funciona?). Este .pyc arquivo é útil quando você importa o módulo na próxima vez de um programa diferente - será muito mais rápido já que uma parte do processamento necessário na importação de um módulo já está concluída. Além disso, esses arquivos compilados por bytes são independentes da plataforma.

NOTA: Esses arquivos .pyc geralmente são criados no mesmo diretório que o correspondente .py. Se o Python não tiver permissão para gravar em arquivos nesse diretório, então o .pyc não sera criado.

A declaração from ..import

Se você deseja importar diretamente o argv variável em seu programa (para evitar digitar o sys. todas as vezes para isso), então você pode usar a declaração from sys import argv.

AVISO: Em geral, evite usar o from..import, use a declaração import em vez disso. Isso ocorre porque seu programa evitará conflitos de nomes e será mais legível.

Exemplo:

from matematica import sqrt
print("Square root of 16 is", sqrt(16))

Um modulo __name__

Todo módulo possui um nome e instruções em um módulo para descobrir o nome do módulo. Isso é útil para o propósito específico de descobrir se o módulo está sendo executado autônomo ou sendo importado. Conforme mencionado anteriormente, quando um módulo é importado pela primeira vez, o código que ele contém é executado. Podemos usar isso para fazer com que o módulo se comporte de maneiras diferentes, dependendo se ele está sendo usado sozinho ou sendo importado de outro módulo. Isso pode ser alcançado usando o __name__ atributo do módulo.

Exemplo (salvar como module_using_name.py):

if __name__ == '__main__':
    print('This program is being run by itself')
else:
    print('I am being imported from another module')

Saida:

$ python module_using_name.py
This program is being run by itself

$ python
>>> import module_using_name
I am being imported from another module
>>>

Como funciona

Todo o módulo Python tem seu __name__ definido. Se isso é '__main__', isso implica que o módulo está sendo executado autônomo pelo usuário e podemos tomar as ações apropriadas.

Fazendo seus próprios módulos

Criar seus próprios módulos é fácil, você está fazendo isso o tempo todo! Isso ocorre porque cada programa Python é também um módulo. Você só precisa se certificar de que tem uma .py extensão. O exemplo a seguir deve deixar claro.

Exemplo (salvar como mymodule.py):

def say_hi():
    print('Hi, this is mymodule speaking.')

__version__ = '0.1'

O acima foi uma amostra modulo. Como você pode ver, não há nada particularmente especial em relação ao nosso programa habitual de Python. Em seguida, veremos como usar este módulo em nossos outros programas Python.

Lembre-se de que o módulo deve ser colocado no mesmo diretório que o programa do qual o importamos ou em um dos diretórios listados em sys.path.

Outro módulo (salvar como mymodule_demo.py):

import mymodule

mymodule.say_hi()
print('Version', mymodule.__version__)

Saida:

$ python mymodule_demo.py
Hi, this is mymodule speaking.
Version 0.1

Como funciona

Observe que usamos a mesma notação pontilhada para acessar os membros do módulo. Python faz uma boa reutilização da mesma notação para dar uma sensação distintiva "Pythonic" para que não tenhamos que seguir aprendendo novas maneiras de fazer coisas.

Aqui está uma versão que utiliza a sintaxe from..import (salve como mymodule_demo2.py):

from mymodule import say_hi, __version__

say_hi()
print('Version', __version__)

A produção de mymodule_demo2.py é o mesmo que a saída de mymodule_demo.py.

Observe que, se já houvesse um __version__ nome declarado no módulo que importa mymodule, haveria um choque. Isso também é provável porque é prática comum para cada módulo declarar seu número de versão usando esse nome. Por isso, é sempre recomendável preferir o import declaração, mesmo que possa tornar seu programa um pouco mais longo.

Você também pode usar:

from mymodule import *

Isso importará todos os nomes públicos, como say_hi mas não importaria __version__ porque ele começa com sublinhados duplos.

AVISO: lembre-se de que você deve evitar usar import-star, ou seja, from mymodule import *.

Zen of Python

Um dos princípios orientadores da Python é que "Explicit é melhor do que implícito". Execute import this in Python para aprender mais.

A função dir

Construídas em dir() A função retorna a lista de nomes definidos por um objeto. Se o objeto for um módulo, esta lista inclui funções, classes e variáveis, definidas dentro desse módulo.

Esta função pode aceitar argumentos. Se o argumento for o nome do módulo, a função retornará a lista dos nomes desse módulo especificado. Se não houver argumento, a função retorna a lista de nomes do módulo atual.

Exemplo:

$ python
>>> import sys

# get names of attributes in sys module
>>> dir(sys)
['__displayhook__', '__doc__',
'argv', 'builtin_module_names',
'version', 'version_info']
# only few entries shown here

# get names of attributes for current module
>>> dir()
['__builtins__', '__doc__',
'__name__', '__package__', 'sys']

# create a new variable 'a'
>>> a = 5

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'sys', 'a']

# delete/remove a name
>>> del a

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'sys']

Como funciona

Primeiro, vemos o uso de dir no módulo importado sys. Podemos ver a enorme lista de atributos que contém.

Em seguida, usamos o dir funcionam sem passar por parâmetros. Por padrão, ele retorna a lista de atributos para o módulo atual. Observe que a lista de módulos importados também faz parte desta lista.

Para observar o dir em ação, definimos uma nova variável a e atribua-lhe um valor e depois verifique dir e observamos que existe um valor adicional na lista do mesmo nome. Removemos a variável / atributo do módulo atual usando o del A declaração e a mudança se refletem novamente na saída do dir função.

Uma nota sobre del - esta declaração é usada para deletar uma variável / nome e depois que a instrução foi executada, neste caso del a, você não pode mais acessar a variável a - É como se nunca existisse antes.

Observe que o dir() função funciona em qualquer objeto. Por exemplo, execute dir(str) pelos atributos do str (string) classe.

Há também um vars() função que potencialmente pode dar-lhe os atributos e seus valores, mas não funcionará para todos os casos.

Pacotes

Até agora, você deve ter começado a observar a hierarquia de organizar seus programas. As variáveis geralmente entram nas funções. As funções e as variáveis globais costumam entrar nos módulos. E se você quisesse organizar módulos? É aí que os pacotes entram na imagem.

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

Digamos que você quer criar um pacote chamado 'mundo' com subpackages 'asia', 'africa', etc. e esses subpacotes, por sua vez, contêm módulos como 'india', 'madagascar', etc.

É assim que você estruturaria as pastas:

- <some folder present in the sys.path>/
    - world/
        - __init__.py
        - asia/
            - __init__.py
            - india/
                - __init__.py
                - foo.py
        - africa/
            - __init__.py
            - madagascar/
                - __init__.py
                - bar.py

Os pacotes são apenas uma conveniência para hierarquicamente organizar módulos. Você verá muitos exemplos disso na biblioteca padrão.

Resumo

Assim como as funções são partes reutilizáveis de programas, os módulos são programas reutilizáveis. Os pacotes são outra hierarquia para organizar módulos. A biblioteca padrão que vem com o Python é um exemplo de um conjunto de pacotes e módulos.

Vimos como usar esses módulos e criar nossos próprios módulos.

Em seguida, aprenderemos sobre alguns conceitos interessantes chamados estruturas de dados.