Se você já viu Python por algum tempo, provavelmente encontrou algo assim:
if __name__ == "__main__":
main()
Esse trecho parece estranho no começo, mas a ideia é simples:
Ele serve para executar uma parte do código apenas quando aquele arquivo for executado diretamente.
Ou seja, ele ajuda a separar duas situações:
- Quando um arquivo Python é executado diretamente.
- Quando um arquivo Python é importado por outro arquivo.
E essa diferença importa bastante.
Primeiro: main.py não é a mesma coisa que "__main__"
Muita gente chama o arquivo principal de um projeto Python de main.py.
Por exemplo:
python main.py
Mas isso é só uma convenção.
O arquivo poderia se chamar:
python app.py
ou:
python calculadora.py
ou:
python sistema.py
O nome do arquivo não precisa ser main.py.
O ponto importante é:
O arquivo que você executa diretamente recebe o valor
"__main__"dentro da variável__name__.
Então "__main__" não vem do nome main.py.
Ele vem do fato de aquele arquivo ser o ponto de entrada da execução.
O que é __name__?
Todo arquivo Python tem uma variável especial chamada __name__.
Ela muda dependendo de como o arquivo está sendo usado.
Se o arquivo for executado diretamente, __name__ vale:
"__main__"
Se o arquivo for importado por outro arquivo, __name__ vale o nome do próprio módulo.
Vamos ver isso na prática.
Exemplo 1: executando o arquivo diretamente
Arquivo: calculadora.py
print(__name__)
Agora execute no terminal:
python calculadora.py
A saída será:
__main__
Por quê?
Porque o arquivo calculadora.py foi executado diretamente.
Naquele momento, para o Python, ele é o arquivo principal da execução.
Exemplo 2: importando o arquivo
Agora imagine outro arquivo.
Arquivo: app.py
import calculadora
Execute:
python app.py
A saída será:
calculadora
Agora o calculadora.py não foi executado diretamente.
Ele foi apenas importado pelo app.py.
Então, dentro de calculadora.py, o valor de __name__ não é "__main__".
É "calculadora".
Então o que significa if __name__ == "__main__"?
Significa:
"Execute esse bloco apenas se este arquivo for executado diretamente."
Veja este exemplo.
Arquivo: calculadora.py
def somar(a, b):
return a + b
if __name__ == "__main__":
print(somar(10, 5))
Se você executar:
python calculadora.py
A saída será:
15
Isso acontece porque calculadora.py foi executado diretamente.
Então, dentro dele:
__name__ == "__main__"
é verdadeiro.
Agora usando calculadora.py em outro arquivo
Arquivo: app.py
from calculadora import somar
resultado = somar(2, 3)
print(resultado)
Execute:
python app.py
A saída será:
5
Repare que o print(somar(10, 5)) que está dentro de calculadora.py não foi executado.
Por quê?
Porque agora quem foi executado diretamente foi o app.py, não o calculadora.py.
A situação fica assim:
Dentro de app.py
__name__ == "__main__"
Dentro de calculadora.py
__name__ == "calculadora"
Por isso este bloco não roda:
Arquivo: calculadora.py
if __name__ == "__main__":
print(somar(10, 5))
O calculadora.py foi importado.
Ele não foi o arquivo principal da execução.
O que acontece se eu não usar isso?
O problema é que código solto dentro de um arquivo Python pode rodar automaticamente quando esse arquivo é importado.
Veja este exemplo.
Arquivo: relatorio.py
def gerar_relatorio():
print("Gerando relatório...")
gerar_relatorio()
Agora outro arquivo importa esse módulo.
Arquivo: app.py
import relatorio
print("Sistema iniciado")
Execute:
python app.py
A saída será:
Gerando relatório...
Sistema iniciado
Mas repare: em app.py, você não chamou gerar_relatorio().
Mesmo assim, a função rodou.
Ela rodou porque estava solta dentro de relatorio.py.
Quando o Python importou relatorio.py, ele executou o código que estava no arquivo.
Por que isso é um problema?
Em um exemplo simples, isso só gera um print inesperado.
Mas em projetos reais, isso pode causar problemas maiores, como:
- chamadas de API acontecendo sem querer;
- consultas ao banco de dados só por causa de um import;
- arquivos sendo criados, lidos ou alterados no momento errado;
- funções rodando antes da hora;
- testes ficando confusos;
- código difícil de reaproveitar;
- comportamento inesperado na aplicação.
Ou seja, sem esse cuidado, importar um arquivo pode fazer mais coisa do que deveria.
A versão correta
Agora veja a versão melhorada.
Arquivo: relatorio.py
def gerar_relatorio():
print("Gerando relatório...")
if __name__ == "__main__":
gerar_relatorio()
Arquivo: app.py
import relatorio
print("Sistema iniciado")
Execute:
python app.py
A saída será:
Sistema iniciado
Agora o relatório não é gerado automaticamente.
Por quê?
Porque relatorio.py foi importado, não executado diretamente.
Se você quiser executar o relatório diretamente, aí sim:
python relatorio.py
A saída será:
Gerando relatório...
Nesse caso, relatorio.py virou o arquivo principal da execução.
Então, dentro dele:
__name__ == "__main__"
é verdadeiro.
E a função main()?
É muito comum ver este padrão:
Arquivo: main.py
def main():
print("Programa iniciado")
if __name__ == "__main__":
main()
A função main() não é obrigatória.
Ela é apenas uma forma organizada de concentrar o ponto inicial do programa.
Você poderia escrever assim:
Arquivo: main.py
print("Programa iniciado")
Isso funciona.
Mas em projetos maiores, geralmente fica melhor separar as coisas.
Exemplo:
Arquivo: main.py
def carregar_dados():
print("Carregando dados...")
def processar_dados():
print("Processando dados...")
def salvar_resultado():
print("Salvando resultado...")
def main():
carregar_dados()
processar_dados()
salvar_resultado()
if __name__ == "__main__":
main()
Esse padrão deixa claro qual é o fluxo principal do programa.
As funções ficam disponíveis para serem reutilizadas, mas a execução principal só acontece quando o arquivo é executado diretamente.
Então por que usar if __name__ == "__main__"?
Use quando um arquivo Python pode ser:
- Executado diretamente.
- Importado por outro arquivo.
Ele evita que código rode sem querer durante um import.
Na prática, ele diz:
"Essa parte aqui só deve rodar se este arquivo for o ponto de entrada da aplicação."
Regra prática
Se o arquivo só tem funções, classes ou constantes, talvez você não precise dele.
Exemplo:
Arquivo: operacoes.py
def somar(a, b):
return a + b
def subtrair(a, b):
return a - b
Esse arquivo só oferece funções para outros arquivos usarem.
Agora, se o arquivo também tem uma execução principal, use o if.
Arquivo: operacoes.py
def somar(a, b):
return a + b
def subtrair(a, b):
return a - b
if __name__ == "__main__":
print(somar(10, 5))
print(subtrair(10, 5))
Assim, se você executar diretamente:
python operacoes.py
A saída será:
15
5
Mas se outro arquivo importar operacoes.py, esses prints não vão rodar automaticamente.
Resumo direto
Quando você executa um arquivo diretamente:
python app.py
dentro de app.py, o Python define:
__name__ = "__main__"
Quando você importa um arquivo:
Arquivo: app.py
import calculadora
dentro de calculadora.py, o Python define:
__name__ = "calculadora"
Então este código:
Arquivo: calculadora.py
if __name__ == "__main__":
print("Rodando diretamente")
significa:
"Só execute esse bloco se o arquivo
calculadora.pyfor executado diretamente."
Se rodar:
python calculadora.py
o bloco executa.
Se fizer:
Arquivo: app.py
import calculadora
o bloco não executa.
Conclusão
O if __name__ == "__main__" existe para evitar execução acidental de código quando um arquivo Python é importado.
Ele separa bem duas intenções:
- importar um arquivo para usar suas funções, classes e variáveis;
- executar um arquivo como programa principal.
A ideia central é simples:
"__main__"é o nome que o Python dá ao arquivo que foi executado diretamente.
Então este padrão:
Arquivo: main.py
def main():
print("Programa iniciado")
if __name__ == "__main__":
main()
significa:
"Execute
main()apenas se este arquivo for o ponto de entrada do programa."
É simples, evita comportamento inesperado e deixa o código mais organizado.
SOCIAL SHARE CARD GENERATOR