__main__ — Ambiente de código principal

---

Em Python, o nome especial __main__ é usado em duas construções importantes:

1. O nome do ambiente principal do programa, que pode ser verificado usando a expressão __name__ == '__main__'; e

2. o arquivo __main__.py em pacotes Python.

Ambas as formas estão relacionadas aos módulos Python; como os usuários interagem com eles e como eles interagem entre si. Eles serão explicados em detalhes abaixo. Se você ainda não conhece módulos Python, veja a seção Módulos para uma introdução.

__name__ == '__main__'

Quando um pacote ou módulo Python é importado, __name__ é definido como o nome do módulo. Normalmente, este é o nome do próprio arquivo Python sem a extensão .py:

>>> import configparser
>>> configparser.__name__
'configparser'

Caso o arquivo seja parte de um pacote, __name__ também incluirá o nome da pasta raiz do pacote.

>>> from concurrent.futures import process
>>> process.__name__
'concurrent.futures.process'

Porém, se o módulo for executado como o código principal, __name__ passa a ser definido como a string '__main__'

O que é o “ambiente de código principal”?

__main__ é o nome do ambiente principal no qual o código é executado. “Ambiente de código principal” é o primeiro módulo Python definido pelo usuário que começa a ser executado. É considerado principal porque ele importa todos os outros módulos que o programa precisa. As vezes, “ambiente principal” também pode ser chamado de “ponto de entrada” da aplicação.

O ambiente de código principal pode ser:

• o escopo de um prompt de comando interativo:

  >>> __name__
  '__main__'
  

• o módulo Python passado ao interpretador do Python como um argumento correspondente ao nome do arquivo:

  $ python helloworld.py
  Hello, world!
  

• o módulo ou pacote Python passado ao interpretador do Python com o argumento -m:

  $ python -m tarfile
  usage: tarfile.py [-h] [-v] (...)
  

• código Python lido pelo interpretador através da entrada padrão de linha de comando:

  $ echo "import this" | python
  The Zen of Python, by Tim Peters
  
  Beautiful is better than ugly.
  Explicit is better than implicit.
  ...
  

• código Python passado ao interpretador do Python com o argumento -c:

  $ python -c "import this"
  The Zen of Python, by Tim Peters
  
  Beautiful is better than ugly.
  Explicit is better than implicit.
  ...
  

Em cada uma destas situações, a variável especial __name__ passa a ser definida como '__main__'.

Como resultado, um módulo pode saber se está ou não sendo executado no ambiente principal verificando seu próprio __name__, que habilita um termo comum para executar código condicionalmente quando o módulo não é inicializado a partir de uma instrução de importação:

if __name__ == '__main__':
    # Executa quando o módulo não é inicializado por uma instrução de importação.
    ...

Ver também

Para uma visão mais detalhada sobre como __name__ é definido em todas as situações, veja a sessão Módulos.

Uso idiomático

Alguns módulos contém códigos que são específicos para serem usados como scripts, como análise de argumentos através de linha de comando ou leitura de dados da entrada padrão. Se um módulo como o citado for importado em um outro módulo diferente, por exemplo em testes unitários, o código do script também seria executado de forma indesejada.

É aqui onde o uso do trecho de código if __name__ == '__main__' revela-se útil. Os códigos dentro desta condicional não rodarão ao não ser que o módulo seja executado através do ambiente principal.

Colocar o mínimo de instruções possível no bloco abaixo de if __name__ == '__main__' pode melhorar a clareza e a precisão do código. Na maioria das vezes, uma função chamada de main encapsula o comportamento principal do programa:

# echo.py

import shlex
import sys

def echo(phrase: str) -> None:
   """Um invólucro fictício sobre print."""
   # com propósito de demonstração, imagine que existe
   # uma lógica reutilizável valiosa nesta função
   print(phrase)

def main() -> int:
    """Ecoa os argumentos de entrada para a saída padrão."""
    phrase = shlex.join(sys.argv)
    echo(phrase)
    return 0

if __name__ == '__main__':
    sys.exit(main())  # a próxima seção explica o uso de sys.exit

Repare quem se o módulo, ao invés de ter encapsulado o código dentro da função main, fosse colocado direto dentro do bloco if __name__ == '__main__', a variável phrase seria global para todo o módulo. Isto é suscetível à erros pois outras funções dentro do módulo poderiam inadvertidamente usar a variável global ao invés da local. A função main resolve este problema.

O uso da função main tem o benefício adicional de a própria função echo ser isolada e importável em outro lugar. Quando echo.py é importado, as funções echo e main serão definidas, mas nenhuma delas será chamada por conta do bloco __name__ != '__main__'.

Considerações sobre pacotes

main são funções frequentemente usadas ​para criar ferramentas de linha de comando especificando-as como pontos de entrada para scripts de console. Quando isto é feito, pip insere a chamada da função em um modelo de script, onde o valor de retorno de main é passado para sys.exit(). Por exemplo:

sys.exit(main())

Uma vez que a chamada à main está embutida dentro de sys.exit(), a expectativa é que a sua função retorne somente valores aceitável para sys.exit(); normalmente um inteiro ou None (retornado de forma implícita, caso a sua função não tenha uma instrução de retorno).

Seguindo proativamente essa convenção, nosso módulo terá o mesmo comportamento quando executado diretamente (ou seja, python echo.py) como terá também se posteriormente criarmos um pacote como um ponto de entrada de script de console em um pacote instalável via pip.

Em particular, tenha cuidado ao retornar strings de sua função main. sys.exit() interpretará um argumento de string como uma mensagem de falha, então seu programa terá um código de saída 1, indicando falha, e a string será escrita em sys.stderr. O exemplo anterior de echo.py exemplifica o uso da convenção sys.exit(main()).

Ver também

O Guia de Usuário para Empacotamento de Python contém uma coleção de tutoriais e referências sobre como distribuir e instalar pacotes Python com ferramentas modernas.

__main__.py em pacotes Python

Se você não estiver familiarizado com pacotes Python, veja a seção Pacotes do tutorial. Mais comumente, o arquivo __main__.py é usado para fornecer uma interface de linha de comando para um pacote. Considere o seguinte pacote hipotético, “bandclass”:

bandclass
  ├── __init__.py
  ├── __main__.py
  └── student.py

__main__.py será executado quando o próprio pacote for invocado diretamente da linha de comando usando o sinalizador -m. Por exemplo:

$ python -m bandclass

Este comando fará com que __main__.py seja executado. Como você utiliza esse mecanismo dependerá da natureza do pacote que você está escrevendo, mas neste caso hipotético, pode fazer sentido permitir que o professor procure alunos:

# bandclass/__main__.py

import sys
from .student import search_students

student_name = sys.argv[1] if len(sys.argv) >= 2 else ''
print(f'Estudante encontrado(a): {search_students(student_name)}')

Observe que from .student import search_students é um exemplo de importação relativa. Esse estilo de importação pode ser usado ao fazer referência a módulos em um pacote. Para mais detalhes, veja Referências em um mesmo pacote na seção Módulos do tutorial.

Uso idiomático

O conteúdo do __main__.py normalmente não é protegido por um bloco if __name__ == '__main__' . Em vez disso, esses arquivos são mantidos curtos e importa funções para serem executados a partir de outros módulos. Esses outros módulos podem então ter suas unidades facilmente testadas e são adequadamente reutilizáveis.

Se usado, o bloco condicional if __name__ == '__main__' ainda funcionará como esperado para o arquivo __main__.py dentro de um pacote, pois seu atributo __name__ incluirá o caminho do pacote se importado:

>>> import asyncio.__main__
>>> asyncio.__main__.__name__
'asyncio.__main__'

Porém, isso não funcionará para arquivos __main__.py no diretório raiz de um arquivo .zip. Portanto, para consistência, é preferível um __main__.py mínimo sem uma verificação de __name__.

Ver também

Veja venv, da biblioteca padrão, para um exemplo de pacote com um __main__.py minimalista. Ele não contém um bloco if __name__ == '__main__'. Você pode invocá-lo com python -m venv [directory].

Veja runpy para mais detalhes sobre o sinalizador -m para o executável do interpretador.

Veja zipapp para saber como executar aplicativos compactados como arquivos .zip. Nesse caso, o Python procura um arquivo __main__.py no diretório raiz do arquivo.

import __main__

Independentemente do módulo com o qual um programa Python foi iniciado, outros módulos executados no mesmo programa podem importar o escopo do ambiente principal (espaço de nomes) importando o módulo __main__. Isso não faz a importação de um arquivo __main__.py, mas sim qualquer módulo que recebeu o nome especial '__main__'.

Aqui está um módulo de exemplo que consome o espaço de nomes __main__:

# namely.py

import __main__

def did_user_define_their_name():
    return 'my_name' in dir(__main__)

def print_user_name():
    if not did_user_define_their_name():
        raise ValueError('Defina a variável `my_name`!')

    if '__file__' in dir(__main__):
        print(__main__.my_name, "encontrado no arquivo", __main__.__file__)
    else:
        print(__main__.my_name)

Exemplo de uso deste módulo pode ser como abaixo:

# start.py

import sys

from namely import print_user_name

# my_name = "Dinsdale"

def main():
    try:
        print_user_name()
    except ValueError as ve:
        return str(ve)

if __name__ == "__main__":
    sys.exit(main())

Agora, se iniciarmos nosso programa, o resultado seria assim:

$ python start.py
Defina a variável `my_name`!

O código de saída do programa seria 1, indicando um erro. Descomentar a linha com my_name = "Dinsdale" corrige o programa e agora ele sai com o código de status 0, indicando sucesso:

$ python start.py
Dinsdale encontrado no arquivo /path/to/start.py

Observe que a importação de __main__ não causa nenhum problema com a execução involuntária de código principal destinado ao uso de script que é colocado no bloco if __name__ == "__main__" do módulo start. Por que isso funciona?

O Python insere um módulo __main__ vazio em sys.modules na inicialização do interpretador e o preenche executando o código principal. Em nosso exemplo, este é o módulo start que executa linha por linha e importa namely. Por sua vez, namely importa __main__ (que é realmente start). Isso é um ciclo de importação! Felizmente, como o módulo __main__ parcialmente preenchido está presente em sys.modules, o Python o passa para namely. Veja Considerações especiais sobre __main__ na referência do sistema de importação para detalhes sobre como isso funciona.

O REPL do Python é outro exemplo de um “ambiente principal”, então qualquer coisa definida no REPL se torna parte do escopo do __main__:

>>> import namely
>>> namely.did_user_define_their_name()
False
>>> namely.print_user_name()
Traceback (most recent call last):
...
ValueError: Defina a variável `my_name`!
>>> my_name = 'Jabberwocky'
>>> namely.did_user_define_their_name()
True
>>> namely.print_user_name()
Jabberwocky

Note que neste caso o escopo __main__ não contém um atributo __file__, pois é interativo.

O escopo __main__ é usado na implementação de pdb e rlcompleter.