if __name__ == "__main__" Python: Explicação completa

Compreensão __name__ e "__main__"

A expressão if __name__ == "__main__" é uma declaração if que verifica a igualdade.

O primeiro operando à esquerda do operador de igualdade == é o atributo __name__. Os nomes em Python com sublinhados duplos à esquerda e à direita são identificadores especiais. Cada módulo tem um atributo __name__. O Python define essa variável como o nome do módulo, que o sistema de importação do Python usa para identificar cada módulo de forma exclusiva.

No entanto, se o módulo estiver no ambiente de código de nível superior, o que significa que é o módulo usado como ponto de entrada para o programa, o Python define o atributo __name__ como a string "__main__".

Vamos dar uma olhada em alguns exemplos. Vamos criar um script chamado exploring_name_main.py:

# exploring_name_main.py
import random
print(__name__)
print(random.__name__)

Esse script pode ser executado diretamente usando o seguinte comando no terminal:

$ python exploring_name_main.py

__main__
random

O script exploring_name_main.py está no ambiente de código de nível superior, pois é o ponto de entrada do programa. Portanto, a variável __name__ é definida como a string "__main__".

No entanto, o módulo random é importado e não está no ambiente de código de nível superior. Seu atributo __name__ é definido como o nome do módulo.

Em seguida, criamos um novo script chamado more_exploration.py, que importa o primeiro script:

# more_exploration.py
import exploring_name_main

Execute esse script usando o seguinte comando no terminal:

$ python more_exploration.py

exploring_name_main
random

O código de um módulo é executado quando o módulo é importado. Portanto, ao executar more_exploration.py, o código exibe a saída das duas chamadas print() em exploring_name_main.py. Como exploring_name_main.py não é mais o ponto de entrada do programa, seu atributo __name__ é definido como o nome do script em vez de "__main__".

O if __name__ == "__main__" bloco condicional

A variável __name__ pode ser usada para determinar se um módulo é o ponto de entrada principal de um programa. Portanto, um módulo pode incluir código que só é executado quando você o executa diretamente como um script, mas não quando é importado. Qualquer código que deva ser executado somente quando o script for executado diretamente é incluído no bloco condicional if __name__ == "__main__":

# exploring_name_main.py
import random
print(__name__)
print(random.__name__)
number = random.randint(1, 10)
if __name__ == "__main__":
    print("This script is in the top-level code environment")
    print(f"The number is {number}")

O código em exploring_name_main.py agora inclui um bloco condicional if __name__ == "__main__". Vamos ver se isso faz diferença quando você executa o script:

$ python exploring_name_main.py

__main__
random
This script is in the top-level code environment
The number is 10

Quando o script é executado diretamente, a variável __name__ é definida como a string "__main__". Portanto, a condição na instrução if é avaliada como True, e o Python executa o código no bloco if.

Entretanto, quando o módulo é importado, __name__ é definido com o nome do módulo e o programa não executa o bloco if. Lembre-se de que o script more_exploration.py importa exploring_name_main:

$  python more_exploration.py

exploring_name_main
random

O programa não chama as funções print() em exploring_name_main.py. Elas estão no bloco condicional que não é executado, pois __name__ não é igual a "__main__".

Práticas recomendadas e dicas para você usar o Python if __name__ == "__main__"

A expressão if __name__ == "__main__" do Python é usada quando o código deve ser executado somente quando um arquivo é executado como um script em vez de ser importado como um módulo. A distinção entre os termos script e módulo está apenas na forma como o arquivo é usado. Ambos os termos se referem a arquivos com a extensão .py.

Um caso de uso comum é quando um script tem variáveis, funções e classes que podem ser usadas em outros programas. Aqui está um exemplo usando um script chamado shapes.py:

# shapes.py
import math
def find_area_of_circle(radius):
    return math.pi * radius ** 2
def find_area_of_rectangle(width, height):
    return width * height
if __name__ == "__main__":
    shape = int(input("Enter 1 for circle, 2 for rectangle: "))
    if shape == 1:
        radius = int(input("Enter radius: "))
        print(f"The area of the circle is {find_area_of_circle(radius)}")
    elif shape == 2:
        width = int(input("Enter width: "))
        height = int(input("Enter height: "))
        print(f"The area of the rectangle is {find_area_of_rectangle(width, height)}")

Enter 1 for circle, 2 for rectangle: 2
Enter width: 10
Enter height: 20
The area of the rectangle is 200

Esse código não precisa da expressão if __name__ == "__main__" se a intenção for sempre executá-lo como um script. Entretanto, a inclusão dessa instrução condicional permite que o código seja importado como um módulo sem executar as linhas no bloco if. Considere outro script chamado more_shapes.py:

# more_shapes.py
import shapes
radius = 5
print(f"The area of the circle defined in 'more_shapes.py' is: "
      f"{shapes.find_area_of_circle(radius)}")

The area of the circle defined in 'more_shapes.py' is: 78.53981633974483

Esse novo script, more_shapes.py, tem acesso às funções definidas em shapes.py por causa da instrução import. No entanto, o código no bloco if __name__ == "__main__" em shapes.py não é executado. Sem a instrução if em shapes.py, todo o código seria executado quando o módulo fosse importado.

O uso do bloco if __name__ == "__main__" para entrada do usuário é um caso de uso comum. A entrada do usuário é omitida se o arquivo for importado como um módulo, mas é incluída quando executada diretamente como código de nível superior.

Uso de uma main() função

A prática recomendada é incluir o menor número possível de instruções no bloco if __name__ == "__main__", pois isso torna o código mais legível. Uma maneira comum de conseguir isso é criar uma função, que é chamada no bloco condicional. É comum que essa função seja chamada de main(), mas qualquer nome de função é válido:

# shapes.py
import math
def find_area_of_circle(radius):
    return math.pi * radius ** 2
def find_area_of_rectangle(width, height):
    return width * height
def main():
    shape = int(input("Enter 1 for circle, 2 for rectangle: "))
    if shape == 1:
        radius = int(input("Enter radius: "))
        print(f"The area of the circle is {find_area_of_circle(radius)}")
    elif shape == 2:
        width = int(input("Enter width: "))
        height = int(input("Enter height: "))
        print(f"The area of the rectangle is {find_area_of_rectangle(width, height)}")
       
if __name__ == "__main__":
    main()

O código na função main() é o mesmo código que foi incluído diretamente no bloco if __name__ == "__main__" na versão anterior do código.

Em Python, a função main() não é necessária como o ponto de entrada principal do programa, ao contrário de outras linguagens de programação. Portanto, o uso de main() e da expressão if __name__ == "__main__" é opcional e só é necessário quando o código se destina a ser usado como um script autônomo e como um módulo.

Outro caso de uso comum para o if __name__ == "__main__" do Python é para incluir testes no script. Os testes serão executados quando o script for executado diretamente, mas não quando ele for importado de outro módulo. No entanto, embora essa abordagem seja adequada para casos simples, é melhor incluir testes em um módulo separado dedicado a testes.

Conclusão

O if __name__ == "__main__" do Python é útil para incluir código que é executado somente quando um script é executado diretamente, mas não quando é importado. O interpretador do Python define a variável __name__ como o nome do módulo se ele for importado e como a string "__main__" se o módulo for o ponto de entrada principal do programa.

Diferentemente de outras linguagens de programação, a função main() e a expressão if __name__ == "__main__" não são um requisito para executar o código Python, mas são uma ferramenta que o programador pode usar quando necessário.