Imagine a seguinte situação: você abre um email do seu chefe com o título de "urgente". Nele diz:

Ei, Fulano

Nosso programador Mark escreveu um trecho de código no módulo pessoas/clientes.py, mas ele possui um bug. Para resolver ele, você deve procurar por um módulo chamado financeiro.py e importar dele a função imposto_de_renda, usando ela no lugar daquela atrocidade que o Mark fez.

Me avise quando tudo estiver terminado.

A princípio, parece ser uma tarefa trivial. Mas o que são módulos. Como eu posso usar eles? E importar? Como se importa um módulo?

O que são módulos?

Pense em módulos como se fossem pequenos conjuntos de códigos que você pode adicionar a seu programa para executar determinadas tarefas. O módulo os, por exemplo, serve para acessar funções do sistema operacional, como ler e escrever em arquivos, enquanto o módulo math serve para fazer diversas operações matemáticas.

Esses são alguns módulos que já vem por padrão no Python:

Além desses, ainda existem alguns milhares de bibliotecas contendo diversos módulos inclusos para você adicionar nos seus programas para as mais diversas funcionalidades.

Para que servem esses módulos?

No início da sua carreira como programador, você deve ter feito programas de 10, 15, 20 linhas, talvez até 30, sendo bem pessimista. Mas isso se deve apenas ao fato de você ter feito tarefas simples, quando um projeto aumenta ele também aumenta a quantidade de linhas para o implementar. Imagine agora que você está implementando o jogo World of Warcraft, que tem mais de 30GB de tamanho: você pretende colocar toda a programação em um único arquivo? Isso vai ser quase impossível de dar manutenção depois. É aí que entra o módulo.

Um módulo será uma forma simples de dividir o seu código em pedaços menores, como um arquivo com algumas funções genéricas, ou até um certo conjunto de classes que você decida usar.

Seu primeiro módulo

Um módulo tem o nome de seu arquivo sem a extensão .py, então criaremos o módulo fibonacci. No arquivo fibonacci.py insira o seguinte código:

# escreve na tela todos os números da série de Fibonacci até n
def fib(n):
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    print()

# retorna uma lista com os números da série de Fibonacci até o n
def fib2(n):
    result = []
    a, b = 0, 1
    while a < n:
        result.append(a)
        a, b = b, a+b
    return result

Salve o arquivo e abra o Python no terminal:

$ python3

Agora você importará o arquivo no terminal e o executará com o valor que você quiser:

>>> import fibonacci
>>> fibonacci.fib(10)
0 1 1 2 3 5 8 
>>> fibonacci.fib2(10)
[0, 1, 1, 2, 3, 5, 8]
>>> fibonacci.__name__
'fibonacci'

Você também pode dar nomes aos módulos que importa, ou importar apenas uma função de um módulo:

>>> from fibonacci import fib
>>> import numpy as np
>>> from fibonacci import fib2 as fibonacci
>>>
>>> fib(10)
0 1 1 2 3 5 8
>>> fibonacci(10)
[0, 1, 1, 2, 3, 5, 8]

Tornando um módulo executável

Você também pode adicionar um trecho executável ao módulo (mas que não será executado em caso de ) inserindo um comportamento caso ele seja executado como main. Adicione isso no final do nosso módulo fibonacci:

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

O __main__ é o nome dado ao programa quando ele é executado. Se você executa o arquivo fibonacci.py, por exemplo, o nome dele durante a execução será __main__, enquanto todos os outros receberão seus respectivos nomes.

Com esse trecho de código você poderá executar o programa diretamente como se não fosse usado aquele if, chamando a função fib usando um parâmetro passado como argumento, mas ele não será executado caso você o importe em um programa:

$ python3 fibo.py 50
0 1 1 2 3 5 8 13 21 34

Módulos pré compilados

Os módulos Python são pré compilados para aumentar sua velocidade quando são importados. Eles ficarão guardados em diretórios chamados __pycache__, com o nome modulo.versao.pyc. Por exemplo, no Python 3.3, a versão compilada de spam.py ficará salva como __pycache__/spam.cpython-33.pyc. Essa convenção é usada para permitir que existam diferentes versões de um mesmo módulo salvos em uma mesma pasta, compilados para diferentes versões do Python.

O Python verifica a data de compilação do arquivo de tempos em tempos para saber se eles precisam ser recompilados. Assim como em Java, o arquivo gerado pela compilação funciona da mesma forma que um bytecode, e é completamente independente da plataforma, possibilitando que um mesmo módulo compilado funcione corretamente independente de plataforma e arquitetura.

Se quiser, pode ler mais sobre módulos na documentação do Python.

Você também pode estudar a apostila de Python da Caelum.

Mas e então? O que achou? Restou alguma dúvida? Deixa sua opinião aí nos comentários.