Artigo original: Python if __name__ == __main__ Explained with Code Examples
Quando um interpretador de Python lê um arquivo em Python, ele primeiro define algumas variáveis especiais. Depois, ele executa o código do arquivo.
Uma dessas variáveis é chamada de __name__.
Se você seguir esse artigo passo a passo e ler seus trechos de código, aprenderá a usar if __name__ == "__main__" e saberá o porquê de isso ser tão importante.
Módulos em Python explicados
Os arquivos em Python são chamados de módulos e são identificados pela extensão .py. Um módulo pode definir funções, classes e variáveis.
Assim, quando o interpretador executa um módulo, a variável __name__ será definida como __main__ se o módulo que estiver sendo executado for o programa principal (main).
No entanto, se o código estiver importando o módulo de outro módulo, a variável __name__ será definida como o nome daquele módulo.
Vejamos um exemplo. Crie um módulo em Python chamado file_one.py e cole esse código de nível superior nele:
# módulo do primeiro arquivo em Python
print("__name__ no arquivo um está definido como: {}" .format(__name__))Ao executar esse arquivo, você verá exatamente sobre o que estamos falando. A variável __name__ para este módulo é definida como __main__:
__name__ no arquivo um está definido como: __main__Agora vamos adicionar outro módulo, file_two.py, e colar nele este código:
# module a ser importado em Python
print("__name__ no arquivo dois está definido como: {}" .format(__name__))
Além disso, vamos modificar o código em file_one.py para que possamos importar o módulo file_two dessa maneira:
# módulo a ser executado em Python
import file_two
print("__name__ no arquivo um está definido como: {}" .format(__name__))
Ao rodar nosso código file_one mais uma vez, veremos que a variável __name__ em file_one não mudou, continuando definida como __main__. Agora, no entanto, a variável __name__ em file_two está definida como seu nome de módulo, ou seja, file_two.
O resultado deverá ser algo assim:
__name__ no arquivo dois está definido como: file_two
__name__ no arquivo um está definido como: __main__
Porém, ao executar file_two diretamente, veremos que a variável __name__ está definida como __main__:
__name__ no arquivo dois está definido como: __main__
A variável __name__ para o arquivo/módulo que é executado será sempre __main__. Mas a variável __name__ para todos os outros módulos que são importados será definida com o próprio nome do módulo.
Convenções de nomes de arquivos em Python
A maneira comum de se usar __name__ e __main__ é assim:
if __name__ == "__main__":
Faça algo aqui
Vamos ver como isso funciona na vida real e como usaríamos essas variáveis de fato.
Modifique file_one e file_two para que tenham essa aparência:
file_one:
# módulo a ser executado em Python
import file_two
print("__name__ no arquivo um está definido como: {}" .format(__name__))
if __name__ == "__main__":
print("Arquivo um executado quando rodou diretamente")
else:
print("Arquivo um executado ao ser importado")
file_two:
# módulo a ser importado em Python
print("__name__ no arquivo dois está definido como: {}" .format(__name__))
if __name__ == "__main__":
print("Arquivo dois executado quando rodou diretamente")
else:
print("Arquivo dois executado ao ser importado")
Novamente, ao executar file_one, você verá que o programa reconheceu qual desses dois módulos é __main__ e executou o código de acordo com nossas primeiras instruções if else.
O resultado deve ter essa aparência:
__name__ no arquivo dois está definido como: file_two
Arquivo dois executado ao ser importado
__name__ no arquivo um está definido como: __main__
Arquivo um executado quando rodou diretamente
Agora, execute file_two e você verá que a variável __name__ está definida como __main__:
__name__ no arquivo dois está definido como: __main__
Arquivo dois executado quando rodou diretamente
Quando módulos assim são importados e executados, suas funções serão importadas e o código de nível superior será executada.
Para ver este processo em ação, modifique seus arquivos para terem essa aparência:
file_one:
# módulo a ser executado em Python
import file_two
print("__name__ no arquivo um está definido como: {}" .format(__name__))
def function_one():
print("Função um é executada")
def function_two():
print("Função dois é executada")
if __name__ == "__main__":
print("Arquivo um executado quando rodou diretamente")
else:
print("Arquivo um executado ao ser importado")
file_two:
# módulo a ser importado em Python
print("__name__ no arquivo dois está definido como: {}" .format(__name__))
def function_three():
print("Função três é executada")
if __name__ == "__main__":
print("Arquivo dois executado quando rodou diretamente")
else:
print("Arquivo dois executado ao ser importado")
Agora, as funções são carregadas, mas não executam.
Para executar uma dessas funções, modifique a parte if __name__ == "__main__" de file_one para que tenha essa aparência:
if __name__ == "__main__":
print("Arquivo um executado quando rodou diretamente")
function_two()
else:
print("Arquivo um executado ao ser importado")
Ao rodar file_one, o que você verá terá essa aparência:
__name__ no arquivo dois está definido como: file_two
Arquivo dois executado ao ser importado
__name__ no arquivo um está definido como: __main__
Arquivo um executado quando rodou diretamente
Função dois é executada
Além disso, você pode rodar as funções de arquivos importados. Para fazer isso, modifique a parte if __name__ == “__main__” de file_one para que tenha essa aparência:
if __name__ == "__main__":
print("Arquivo um executado quando rodou diretamente")
function_two()
file_two.function_three()
else:
print("Arquivo um executado ao ser importado")
Você pode esperar um resultado assim:
__name__ no arquivo dois está definido como: file_two
Arquivo dois executado ao ser importado
__name__ no arquivo um está definido como: __main__
Arquivo um executado quando rodou diretamente
Função dois é executada
Função três é executada
Digamos, agora, que o módulo file_two é realmente grande, com várias funções (duas, no nosso caso), e que você não quer importar todas elas. Modifique file_two para que tenha essa aparência:
# módulo a ser importado em Python
print("__name__ no arquivo dois está definido como: {}" .format(__name__))
def function_three():
print("Função três é executada")
def function_four():
print("Função quatro é executada")
if __name__ == "__main__":
print("Arquivo dois executado quando rodou diretamente")
else:
print("Arquivo dois executado ao ser importado")
Importe, também, as funções específicas do módulo, usando o bloco de importação from no arquivo file_one:
# módulo a ser executado em Python
from file_two import function_three
print("__name__ no arquivo um está definido como: {}" .format(__name__))
def function_one():
print("Função um é executada")
def function_two():
print("Função dois é executada")
if __name__ == "__main__":
print("Arquivo um executado quando rodou diretamente")
function_two()
function_three()
else:
print("Arquivo um executado ao ser importado")Conclusão
Existe um caso de uso bem interessante para a variável __name__, caso você queira que um arquivo seja executado como o programa principal (main) ou importado por outros módulos. Podemos usar um bloco if __name__ == "__main__" para permitir ou evitar que partes do código sejam executadas ao importar os módulos.
Quando o interpretador do Python lê um arquivo, a variável __name__ é definida como __main__ se o módulo que está sendo executado, ou como o nome do módulo se ele for importado. Ler o arquivo executará todo o código de nível superior, mas não as funções e classes (já que elas serão apenas importadas).
Bra gjort! (Isso significa "Muito bem" em sueco!)
Confira mais artigos como esse no perfil do freeCodeCamp ou no perfil no Medium do autor. Confira também as coisas interessantes que o autor criou em sua página do GitHub.