Criando seu próprio módulo

Separar funções em um arquivo próprio

Até agora o seu código morava em um arquivo só. Isso funciona para exercícios pequenos, mas em um programa de verdade você quer separar as coisas: as funções de cálculo em um lugar, o programa que as usa em outro. Fazer isso é simples. Você cria um arquivo com um nome descritivo, coloca as funções lá dentro e, em outro arquivo, importa esse primeiro. O nome do módulo é o nome do arquivo, sem a extensão .py. Veja um módulo de cálculos financeiros bem enxuto.

# arquivo: financas.py

def juros_simples(capital, taxa, meses):
    """Retorna os juros simples do periodo."""
    return capital * (taxa / 100) * meses

def montante(capital, taxa, meses):
    """Retorna o total (capital + juros)."""
    return capital + juros_simples(capital, taxa, meses)

financas.py guarda apenas as funções, sem nada que rode sozinho.

# arquivo: app.py (na mesma pasta)
import financas

total = financas.montante(1000, 2, 12)
print(f"Total apos 12 meses: R$ {total:.2f}")
# Total apos 12 meses: R$ 1240.00

app.py importa financas e usa suas funções. Repare: import financas, sem o .py.

Pronto: você tem um módulo seu. O arquivo financas.py pode ser importado por quantos programas você quiser, e cada função fica com uma responsabilidade clara. Essa separação é o começo da organização que dá nome ao nível intermediário. Mas surge uma dúvida prática: e se eu quiser testar as funções dentro do próprio financas.py enquanto escrevo, sem que esse teste rode toda vez que outro arquivo importar o módulo? É aí que entra o if __name__ == "__main__".

O if __name__ == "__main__" sem susto

Essa linha assusta quem vê pela primeira vez, mas a ideia por trás é simples. Todo arquivo Python tem uma variável especial chamada __name__, criada automaticamente. O valor dela depende de como o arquivo está sendo usado. Quando você executa o arquivo direto, com python financas.py, o Python coloca __name__ igual ao texto "__main__". Quando o arquivo é importado por outro, com import financas, o __name__ vale "financas", o nome do módulo. Ou seja: o próprio arquivo consegue saber se está sendo rodado direto ou importado.

# arquivo: financas.py (versao completa)

def juros_simples(capital, taxa, meses):
    return capital * (taxa / 100) * meses

def montante(capital, taxa, meses):
    return capital + juros_simples(capital, taxa, meses)

# So roda quando o arquivo e executado direto (python financas.py).
# NAO roda quando outro arquivo faz import financas.
if __name__ == "__main__":
    print("Testando o modulo financas:")
    print(juros_simples(1000, 2, 12))  # 240.0
    print(montante(1000, 2, 12))       # 1240.0

O bloco do if só roda ao executar financas.py direto, nunca ao importá-lo.

Traduzindo a linha para o português: se este arquivo está sendo executado diretamente, então rode o bloco de dentro. Do contrário, ignore esse bloco. É por isso que ele é o lugar perfeito para colocar testes rápidos, exemplos de uso ou o ponto de entrada do programa. Quem importar o seu módulo recebe só as funções limpas, sem os prints de teste atrapalhando. É um padrão que você vai ver em quase todo arquivo Python profissional, e agora ele deixa de ser um mistério.

Organizando um projeto em vários arquivos

Com módulos próprios e o guarda do __main__, você já tem o suficiente para organizar um projeto pequeno de forma profissional. A regra prática é: cada arquivo cuida de um assunto. Um módulo para regras de cálculo, outro para entrada e saída de dados, e um arquivo principal que junta tudo e é o que você executa. O arquivo principal costuma ser o único com um bloco if __name__ == "__main__" grande, chamando as funções dos outros. Assim, cada peça é testável isoladamente e reaproveitável.

Essa organização parece exagero para três funções, e para um exercício de uma linha realmente é. Mas o hábito de separar por assunto paga cedo. Quando o programa cresce, você encontra cada coisa no lugar esperado, testa uma parte sem rodar o resto e reaproveita um módulo em outro projeto sem copiar e colar. É a diferença entre um monte de código e um projeto. No módulo do projeto final do curso, você vai montar exatamente assim uma agenda de contatos.