# `__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:

  >     $ python3 helloworld.py
  >     Hello, world!

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

  >     $ python3 -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" | python3
  >     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`:

  >     $ python3 -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__':
        # Execute when the module is not initialized from an import statement.
        ...

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:
       """A dummy wrapper around print."""
       # for demonstration purposes, you can imagine that there is some
       # valuable and reusable logic inside this function
       print(phrase)

    def main() -> int:
        """Echo the input arguments to standard output"""
        phrase = shlex.join(sys.argv)
        echo(phrase)
        return 0

    if __name__ == '__main__':
        sys.exit(main())  # next section explains the use of 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, `python3 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:

    $ python3 -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[2] if len(sys.argv) >= 2 else ''
    print(f'Found student: {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 de `__main__.py` normalmente não contém o bloco condicional `if __name__ == '__main__'`. Em vez disso, esses arquivos são curtos, apenas com funções a serem executadas a partir de outros módulos. Esses outros módulos podem ser facilmente testados com testes unitários e também são passíveis de reutilização.

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__'

Isso não funcionará para arquivos `__main__.py` no diretório raiz de um arquivo .zip. Portanto, para consistência, dê preferência para `__main__.py` minimalistas, como o `venv` mencionado abaixo.

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('Define the variable `my_name`!')

        if '__file__' in dir(__main__):
            print(__main__.my_name, "found in file", __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:

    $ python3 start.py
    Define the variable `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:

    $ python3 start.py
    Dinsdale found in file /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: Define the variable `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`.