O que a construção if __name__ == "__main__" faz em Python?

Em algumas linguagens de programação, o método main serve como o único ponto de entrada para a execução de um programa. Durante a transição de outras linguagens para Python, o idioma se __name__ == "__main__" pode parecer realizar a mesma tarefa. Em Python, esse não é o caso.

O se __name__ == "__main__" O idioma permite que um código específico seja executado quando o arquivo é executado como um script. Ele também garante que o mesmo código não seja executado quando você importa o arquivo como um módulo.

Compreendendo o comportamento da variável __name__

O __nome__ variável é construída em Python. Representa o nome do módulo ou script no qual é usado. Quando um script é executado como o programa principal, seu valor é definido como __principal__. Se você importar o script como um módulo, o valor da variável será definido com o nome real do módulo.

Isso pode ser confuso no começo, mas dê uma olhada no exemplo a seguir:

Criar um script e nomeá-lo saudações.py. Este script conterá uma função que cumprimenta um usuário e imprime o valor do __nome__ variável. Ele também solicitará que o usuário digite seu nome.

defsaudar(nome):
 imprimir(f"Olá, {nome}!")
imprimir("Valor de __name__:", __nome__)
se __nome__ == "__principal__":
 nome_usuário = entrada("Por favor, insira seu nome: ")
 saudar (user_name)
outro:
 imprimir("O módulo 'saudações' foi importado.")

Executando o saudações.py script exibirá a seguinte saída:

O valor do __nome__ variável retorna como __principal__ porque o script é executado diretamente.

Agora crie outro script e nomeie-o script2.py. Em seguida, importe o saudações script como um módulo.

importar saudações
imprimir("Executando o script de saudações...")
saudações.saudações("Alice")

Chamando o saudar função do saudações módulo dá a seguinte saída.

O valor do __nome__ variável muda para o nome real do módulo importado. Nesse caso, saudações.

Este valor é o que o idioma se __name__ == "__main__" procura determinar se um arquivo está sendo executado como um script ou é importado como um módulo.

Quando usar a construção if __name__ == "__main__"?

Você pode adicionar o se __name__ == "__main__" construir em qualquer script. Mas há alguns cenários em que usá-lo pode ser mais benéfico. Você aprenderá sobre esses cenários usando o programa de calculadora simples abaixo.

#calculator.py
defadicionar(a, b):
retornar a + b
defsubtrair(a, b):
retornar a-b
defmultiplicar(a, b):
retornar a * b
defdividir(a, b):
se b!= 0:
retornar a/b
outro:
retornar"Erro: divisão por zero!"
se __nome__ == "__principal__":
 imprimir("Bem-vindo à Calculadora!")
 imprimir("Selecione uma operação:")
 imprimir("1. Adicionar")
 imprimir("2. Subtrair")
 imprimir("3. Multiplicar")
 imprimir("4. Dividir")
 escolha = int (entrada("Digite sua escolha (1-4):"))
 num1 = flutuante (entrada("Digite o primeiro número: "))
 num2 = flutuante (entrada("Digite o segundo número: "))
se escolha == 1:
 resultado = adicionar (num1, num2)
 imprimir(f"A soma de {num1} e {num2} é: {resultado}")
elif escolha == 2:
 resultado = subtrair (num1, num2)
 imprimir(f"A diferença entre {num1} e {num2} é: {resultado}")
elif escolha == 3:
 resultado = multiplicar (num1, num2)
 imprimir(f"O produto de {num1} e {num2} é: {resultado}")
elif escolha == 4:
 resultado = dividir (num1, num2)
 imprimir(f"A divisão de {num1} por {num2} é: {resultado}")
outro:
 imprimir("Escolha inválida!")

O primeiro cenário é quando você deseja executar um script de forma independente e executar ações específicas. Isso permite que o script funcione como um programa independente. O se __name__ == "__main__" A construção permite que os usuários interajam com a calculadora usando a interface de linha de comando. Isso dá aos usuários a capacidade de usar a funcionalidade do programa sem ter que entender ou modificar o código subjacente.

Ainda é possível executar o programa sem o se __name__ == "__main__" construir e obter o mesmo resultado, mas seu código perderia a organização do código modular.

O segundo cenário é quando você quer que seu código para ter um design modular. Isso permite que outros programas importem seu script como um módulo e usem suas funções sem acionar funcionalidades desnecessárias.

No caso do programa calculadora, outros programas podem importar o calculadora módulo sem acionar a interface CLI e os prompts de entrada do usuário. Isso garante a reutilização do código e o design modular. Assim, permitindo que a calculadora seja perfeitamente integrada em aplicativos maiores.

importar calculadora
# Usando as funções do módulo calculadora
result_add = calculadora.add(5, 3)
imprimir("Resultado da adição:", result_add)
subtrair_resultado = calculadora.subtrair(10, 4)
imprimir("Resultado da subtração:", resultado_subtrair)

O terceiro cenário é quando você quer teste e depure seu script Python independentemente de quaisquer outros módulos ou scripts que possam importá-lo. No exemplo da calculadora, fica mais fácil focar no teste da funcionalidade da calculadora sem interferência de código externo.

importar calculadora
# Testando as funções da calculadora
se __nome__ == "__principal__":
# adição de teste
 resultado = calculadora.add(5, 3)
 imprimir("Resultado da adição:", resultado)
# Teste de subtração
 resultado = calculadora.subtrair(8, 4)
 imprimir("Resultado da Subtração:", resultado)
# Multiplicação de teste
 resultado = calculadora.multiplicar(2, 6)
 imprimir("Resultado da multiplicação:", resultado)

O código acima demonstra como depurar o script da calculadora de forma independente.

Quando é desnecessário usar a construção if __name__ == "__main__"?

Como você viu nos cenários acima, o uso do se __name__ == "__main__" A construção é diferenciar o script que você está executando como o programa principal e aquele que você está importando como um módulo. No entanto, existem alguns casos em que usá-lo é desnecessário.

O primeiro caso é quando seu script é simples e não possui funções ou módulos reutilizáveis ​​e você não pretende importá-lo. Nesse caso, você deve omitir essa construção, pois todo o script é executado quando executado. Isso é comum para scripts únicos que executam uma finalidade específica e não se destinam a reutilização ou importação.

O outro caso é quando você está trabalhando em uma sessão Python interativa, por exemplo. ao usar o Jupyter Notebook. Em uma sessão interativa, você digita e executa o código diretamente no prompt de comando ou em um shell Python interativo. Como o Python REPL (loop de leitura-avaliação-impressão). Isso permite que você experimente o código e teste pequenos trechos, fornecendo resultados imediatos.

Nesses ambientes interativos, o conceito de script executado como programa principal ou importado como módulo não se aplica. Você está executando trechos de código diretamente sem a necessidade de um ponto de entrada de script tradicional.

Como você se torna um mestre em Python?

Para se tornar um mestre em qualquer linguagem de programação, você precisa entender como funcionam os conceitos subjacentes das funções ou ferramentas. Assim como você aprendeu sobre a construção if __name__ == "__main__" neste artigo.

Compreender os conceitos subjacentes ajudará você a saber exatamente como seu programa se comportará quando você os usar. Não há pressa, aprender os conceitos um por vez o ajudará a mergulhar mais fundo em cada um deles.