Índice
3. arquivo __main__.py com python -m
if __name__ == '__main__'O entendimento simples é: se o módulo for executado diretamente, o bloco de código será executado e, se o módulo for importado, o bloco de código não será executado .
1. Entrada do programa
Para muitas linguagens de programação, o programa deve ter uma entrada, como C, C++ e linguagens de programação totalmente orientadas a objetosJava, C#, etc. Se você foi exposto a essas linguagens, deve ter um bom entendimento do conceito de entrada do programa.Tanto C quanto C++ precisam de uma função principal como entrada do programa, ou seja, o programa iniciará a partir da função principal. Da mesma forma, Java e C# devem ter uma classe principal contendo o método Main como ponto de entrada do programa.
Python é diferente, é uma linguagem de script , ao contrário de uma linguagem compilada que primeiro compila um programa em binário e depois o executa, mas interpreta dinamicamente e executa linha por linha. Ou seja, ele é executado a partir da primeira linha do script e não há entrada unificada.
Além de ser executado diretamente, um arquivo de código-fonte Python também pode ser importado (import) como um módulo (ou seja, uma biblioteca). Quer seja importado ou executado diretamente, o código superior será executado (Python usa indentação para distinguir os níveis de código). Na verdade, ao importar, existe uma parte do código que não queremos que seja executada.
Para dar um exemplo para ilustrar, suponha que temos um arquivo const.py com o seguinte conteúdo:
PI = 3.14
def main():
print "PI:", PI
main()
Definimos algumas constantes neste arquivo e, em seguida, escrevemos uma função principal para exibir as constantes definidas. Finalmente, executar a função principal é equivalente a verificar manualmente as definições para ver se os valores estão definidos corretamente. Em seguida, executamos diretamente o arquivo (python const.py), saída:
PI: 3.14
Agora, temos um arquivo area.py para calcular a área de um círculo, que precisa usar a variável PI no arquivo const.py, então importamos a variável PI de const.py para area.py:
from const import PI
def calc_round_area(radius):
return PI * (radius ** 2)
def main():
print "round area: ", calc_round_area(2)
main()
Execute area.py e gere o resultado:
PI: 3.14
round area: 12.56
Pode-se ver que a função main em const também foi executada. Na verdade, não queremos que seja executada. Main é fornecida apenas para testar a definição da constante. Neste momento, if __name__ == '__main__' veio a calhar. Altere const.py para:
PI = 3.14
def main():
print "PI:", PI
if __name__ == "__main__":
main()
Em seguida, execute area.py novamente, a saída é a seguinte:
round area: 12.56
Em seguida, execute const.py, a saída é a seguinte:
PI: 3.14
Este é o efeito que queremos.
if __name__ == '__main__' É equivalente à entrada do programa de simulação Python . O próprio Python não estipula escrever dessa maneira, é apenas um hábito de codificação. Devido à referência mútua entre os módulos, diferentes módulos podem ter tais definições, mas o programa de entrada pode ter apenas uma. Exatamente qual programa de entrada é selecionado depende do __name__ valor de .
2. __nome__
__name__ É uma variável interna usada para representar o nome do módulo atual e também refletir a estrutura de um pacote. Por exemplo, suponha que você tenha o seguinte pacote:
a
├── b
│ ├── c.py
│ └── __init__.py
└── __init__.py
O conteúdo de todos os arquivos py no diretório é:
print __name__
Executamos python -c "import a.b.c"e exibimos o resultado:
a
a.b
a.b.c
Pode-se ver que __name__ pode refletir claramente a hierarquia de um módulo no pacote. Na verdade, o chamado nome do módulo é o nome que precisa ser usado na importação, por exemplo:
import tornado
import tornado.web
Aqui tornado e tornado.web são chamados de nome do módulo do módulo.
Se um módulo for executado diretamente, ele não terá estrutura de pacote e seu __name__ valor será __main__. Por exemplo, no exemplo acima, executamos diretamente o arquivo c.py (python a/b/c.py) e a saída é a seguinte:
__main__
Portanto,
if __name__ == '__main__'nosso entendimento simples é: se o módulo for executado diretamente, o bloco de código será executado e, se o módulo for importado, o bloco de código não será executado .
Na verdade, essa questão também pode derivar alguns outros pontos de conhecimento, como parâmetros __main__.py de arquivo e Python -m .
3. arquivo __main__.py com python -m
Os parâmetros do Python -m são usados para executar um módulo ou pacote como um script, e __main__.py o arquivo é equivalente ao "programa de entrada" de um pacote.
Primeiro de tudo, precisamos olhar para a diferença python xxx.py entre e python -m xxx.py . A diferença entre as duas maneiras de executar um programa Python é que uma é executada diretamente e a outra é executada como um módulo.
Vejamos primeiro um exemplo simples. Suponha que haja um arquivo Python run.py com o seguinte conteúdo:
import sys
print sys.path
Iniciamos diretamente (python run.py) e exibimos o resultado (para ilustrar o problema, o resultado da saída intercepta apenas partes importantes, o mesmo abaixo):
['/home/huoty/aboutme/pythonstudy/main', ...]
Em seguida, execute-o como um módulo (python -m run.py):
['', ...]
/usr/bin/python: No module named run.py
Como a saída lista apenas as partes críticas, deve ser fácil ver as diferenças. Executar diretamente é colocar o diretório onde o arquivo run.py está localizado no atributo sys.path. Executar como um módulo é colocar o diretório onde você insere o comando (ou seja, o caminho de trabalho atual) no atributo sys.path. Outra diferença entre executar no modo de módulo é que há uma linha extra No module named run.py de erros. Na verdade, ao executar no modo de módulo, o Python executa import no run.py primeiro, então print sys.path ele é executado com sucesso e, em seguida, o Python tenta executar o módulo run.py, mas não há nenhum módulo run.py na variável de caminho, então um erro é relatado. E a maneira correta de executá-lo deve ser python -m run.
Este exemplo não ilustra claramente o problema. Então vamos ver __main__.py o efeito.
Ainda olhe para o exemplo primeiro, há o seguinte pacote:
package
├── __init__.py
└── __main__.py
- __init__.py
import sys
print "__init__"
print sys.path
- __main__.py
import sys
print "__main__"
print sys.path
Use python -m package o resultado da execução:
__init__
['', ...]
__main__
['', ...]
Use python package o resultado da execução:
__main__
['package', ...]
Então vamos resumir:
- 1. Quando o parâmetro -m for adicionado, o diretório de trabalho atual será adicionado a sys.path; se não for adicionado, o diretório onde o script está localizado será adicionado a sys.path .
- 2. Quando o parâmetro -m é adicionado, o Python primeiro importa o módulo ou pacote e, em seguida, executa
- 3. O arquivo __main__.py é o programa de entrada de um pacote ou diretório. O arquivo __main__.py é sempre executado independentemente de o tempo de execução ser usado
python packageou não .python -m package