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çãoimport
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.