O que se __name__ == “__main__”: fazer?
-
03-07-2019 - |
Pergunta
O que o if __name__ == "__main__":
fazer?
# Threading example
import time, thread
def myfunction(string, sleeptime, lock, *args):
while True:
lock.acquire()
time.sleep(sleeptime)
lock.release()
time.sleep(sleeptime)
if __name__ == "__main__":
lock = thread.allocate_lock()
thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
Solução
Sempre que o interpretador Python lê um arquivo de origem, ele faz duas coisas:
-
que define algumas variáveis ??especiais como
__name__
, e depois -
executa todo o código encontrado no arquivo.
Vamos ver como isso funciona e como se relaciona à sua pergunta sobre os __name__
cheques vemos sempre em scripts Python.
Código de exemplo
Vamos usar um exemplo de código ligeiramente diferente para explorar como as importações e scripts trabalho. Suponha que o seguinte é em um arquivo chamado foo.py
.
# Suppose this is foo.py.
print("before import")
import math
print("before functionA")
def functionA():
print("Function A")
print("before functionB")
def functionB():
print("Function B {}".format(math.sqrt(100)))
print("before __name__ guard")
if __name__ == '__main__':
functionA()
functionB()
print("after __name__ guard")
Variáveis ??especiais
Quando o interpeter Python lê um arquivo de origem, ele primeiro define algumas variáveis ??especiais. Neste caso, nós nos preocupamos com a variável __name__
.
Quando seu módulo é o programa principal
Se você estiver executando o seu módulo (arquivo de origem) como o programa principal, por exemplo.
python foo.py
o intérprete irá atribuir o "__main__"
cadeia de hard-coded para a variável __name__
, i.
# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__"
Quando seu módulo é importado por outro
Por outro lado, suponha que algum outro módulo é o programa principal e que importa seu módulo. Isto significa que há uma declaração como esta no programa principal, ou em algum outro módulo os principais produtos importados do programa:
# Suppose this is in some other main program.
import foo
Neste caso, o intérprete vai olhar para o nome do arquivo do módulo, foo.py
, tira fora do .py
, e atribuir essa seqüência à variável __name__
do módulo, i.
# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"
execução de código do módulo
Depois das variáveis ??especiais são criados, o intérprete executa todo o código no módulo, uma instrução de cada vez. Você pode querer abrir outra janela no lado com o exemplo de código para que você possa seguir junto com esta explicação.
Sempre
-
Ela imprime o
"before import"
string (sem aspas). -
Ele carrega o módulo
math
eo atribui a uma variável chamadamath
. Isto é equivalente a substituirimport math
com o seguinte (note que__import__
é uma função de baixo nível em Python que recebe uma string e aciona a importação real):
# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")
-
Ela imprime o
"before functionA"
string. -
Ele executa o bloco
def
, criando um objeto de função, em seguida, atribuir esse objeto função a uma variável chamadafunctionA
. -
Ela imprime o
"before functionB"
string. -
Ele executa o segundo bloco
def
, criando um outro objeto de função, em seguida, atribuí-la a uma variável chamadafunctionB
. -
Ela imprime o
"before __name__ guard"
string.
apenas quando o módulo é o programa principal
- Se o seu módulo é o programa principal, então ele vai ver que
__name__
foi de fato definido para"__main__"
e chama as duas funções, imprimindo o"Function A"
cordas e"Function B 10.0"
.
apenas quando o módulo é importado por outro
- ( em vez ) Se o seu módulo não é o programa principal, mas foi importado por outro, em seguida,
__name__
será"foo"
, não"__main__"
, e ele vai pular o corpo da declaraçãoif
.
Sempre
- Ele irá imprimir o
"after __name__ guard"
corda em ambas as situações.
Resumo
Em resumo, aqui está O que foi que ser impresso em dois casos:
# What gets printed if foo is the main program
before import
before functionA
before functionB
before __name__ guard
Function A
Function B 10.0
after __name__ guard
# What gets printed if foo is imported as a regular module
before import
before functionA
before functionB
before __name__ guard
after __name__ guard
Por que isso funciona dessa maneira?
Você pode naturalmente perguntar por que alguém iria querer isso. Bem, às vezes você quer escrever umaarquivo .py
que pode ser tanto usado por outros programas e / ou módulos como um módulo, e também pode ser executado como o próprio programa principal. Exemplos:
-
O módulo é uma biblioteca, mas você quer ter um modo de script, onde se executa alguns testes de unidade ou uma demo.
-
O módulo é utilizado apenas como um programa principal, mas tem alguns testes de unidade, e as obras framework de testes por importação de arquivos
.py
como seu script e executar funções de teste especiais. Você não quer que ele tente executar o script só porque está importando o módulo. -
O módulo é usado principalmente como um programa principal, mas também fornece uma API de programador amigável para usuários avançados.
Além desses exemplos, é elegante que a execução de um script em Python é apenas a criação de algumas variáveis ??de mágica e importar o script. "Running" o roteiro é um efeito colateral de importar o módulo do script.
Food for Thought
-
Pergunta: Posso ter múltiplos
__name__
verificando blocos? Resposta:. É estranho para fazê-lo, mas a linguagem não vai impedi-lo -
Suponha que o seguinte é em
foo2.py
. O que acontece se você dizpython foo2.py
na linha de comando? Por quê?
# Suppose this is foo2.py.
def functionA():
print("a1")
from foo2 import functionB
print("a2")
functionB()
print("a3")
def functionB():
print("b")
print("t1")
if __name__ == "__main__":
print("m1")
functionA()
print("m2")
print("t2")
- Agora, descobrir o que vai acontecer se você remover a seleção
__name__
emfoo3.py
:
# Suppose this is foo3.py.
def functionA():
print("a1")
from foo3 import functionB
print("a2")
functionB()
print("a3")
def functionB():
print("b")
print("t1")
print("m1")
functionA()
print("m2")
print("t2")
- O que isto vai fazer quando usado como um script? Quando importados como um módulo?
# Suppose this is in foo4.py
__name__ = "__main__"
def bar():
print("bar")
print("before __name__ guard")
if __name__ == "__main__":
bar()
print("after __name__ guard")
Outras dicas
Quando o script é executado, passando-a como um comando para o interpretador Python,
python myscript.py
todo o código que está no nível de recuo 0 é executado. Funções e classes que são definidas são, assim, definido, mas nenhum de seu código é executado. Ao contrário de outras línguas, não há nenhuma função main()
que é executado automaticamente - a função main()
é implicitamente todo o código no nível superior
Neste caso, o código de nível superior é um bloco if
. __name__
é uma variável embutida que resulta no nome do módulo de corrente. No entanto, se um módulo está a ser executado directamente (como em myscript.py
acima), em seguida, __name__
em vez disso é definida como a corda "__main__"
. Assim, você pode testar se o script está sendo executado diretamente ou sendo importado por outra coisa, testando
if __name__ == "__main__":
...
Se o seu script está sendo importado para outro módulo, suas várias definições de funções e de classe será importado e seu código de nível superior será executada, mas o código no seguida, o corpo da cláusula if
acima não terá prazo como a condição não for atendida. Como um exemplo básico, considere os dois scripts seguintes:
# file one.py
def func():
print("func() in one.py")
print("top-level in one.py")
if __name__ == "__main__":
print("one.py is being run directly")
else:
print("one.py is being imported into another module")
# file two.py
import one
print("top-level in two.py")
one.func()
if __name__ == "__main__":
print("two.py is being run directly")
else:
print("two.py is being imported into another module")
Agora, se você invocar o intérprete como
python one.py
A saída será
top-level in one.py
one.py is being run directly
Se você executar two.py
vez:
python two.py
Você começa
top-level in one.py
one.py is being imported into another module
top-level in two.py
func() in one.py
two.py is being run directly
Assim, quando o módulo one
é carregado, seu __name__
igual "one"
vez de "__main__"
.
A explicação mais simples para a variável __name__
(IMHO) é o seguinte:
Criar os seguintes arquivos.
# a.py
import b
e
# b.py
print "Hello World from %s!" % __name__
if __name__ == '__main__':
print "Hello World again from %s!" % __name__
Running deles vai chegar esta saída:
$ python a.py
Hello World from b!
Como você pode ver, quando um módulo é importado, Python define globals()['__name__']
neste módulo do nome do módulo. Além disso, na importação todo o código no módulo está sendo executado. Como os avalia declaração if
para False
esta parte não é executado.
$ python b.py
Hello World from __main__!
Hello World again from __main__!
Como você pode ver, quando um arquivo é executado, Python define globals()['__name__']
neste arquivo para "__main__"
. Desta vez, os avalia declaração if
para True
e está sendo executado.
O que o
if __name__ == "__main__":
fazer?
Para delinear o básico:
-
A variável global,
__name__
, no módulo que é o ponto de entrada para o seu programa, é'__main__'
. Caso contrário, é o nome que você importar o módulo. -
Assim, o código sob o bloco
if
só irá funcionar se o módulo é o ponto de entrada para o seu programa. -
Ele permite que o código no módulo a ser importable por outros módulos, sem executar o bloco de código abaixo na importação.
Por que precisamos disso?
Desenvolver e testar o seu código
Digamos que você está escrevendo um script Python projetado para ser usado como um módulo:
def do_important():
"""This function does something very important"""
Você poderia testar o módulo adicionando esta chamada da função para o fundo:
do_important()
e executá-lo (em um prompt de comando) com algo como:
~$ python important.py
O Problema
No entanto, se você quiser importar o módulo para outro script:
import important
Na importação, a função do_important
seria chamado, então você provavelmente comentar a sua chamada de função, do_important()
, na parte inferior.
# do_important() # I must remember to uncomment to execute this!
E então você tem que se lembrar ou não você já comentou a sua chamada de função de teste. E esta complexidade extra significa que você é provável que se esqueça, tornando o seu processo de desenvolvimento mais problemático.
A Better Way
As variáveis ??__name__
aponta para o namespace onde o interpretador Python passa a ser no momento.
Dentro de um módulo importado, é o nome desse módulo.
Mas dentro do módulo principal (ou uma sessão de Python interativo, ou seja Ler do intérprete, Eval, Imprimir Loop, ou REPL) está a executar tudo, desde a sua "__main__"
.
Então, se você verificar antes de executar:
if __name__ == "__main__":
do_important()
Com o acima, seu código irá executar somente quando você estiver executando-o como o módulo principal (ou intencionalmente chamá-lo de outro script).
Uma maneira ainda melhor
Há uma maneira Pythonic para melhorar isso, porém.
O que se deseja executar este processo de negócio a partir de fora do módulo?
Se colocar o código que queremos exercício à medida que desenvolvemos e teste em uma função como esta e, em seguida, fazer o nosso cheque de '__main__'
imediatamente após:
def main():
"""business logic for when running this module as the primary one!"""
setup()
foo = do_important()
bar = do_even_more_important(foo)
for baz in bar:
do_super_important(baz)
teardown()
# Here's our payoff idiom!
if __name__ == '__main__':
main()
Temos agora uma função final para o final do nosso módulo que será executado se executar o módulo como o módulo principal.
Ele permitirá que o módulo e suas funções e classes a ser importado para outros scripts sem executar a função main
, e também irá permitir que o módulo (e suas funções e classes) a ser chamado durante a execução de um módulo '__main__'
diferente, ou seja,
import important
important.main()
Esta expressão também podem ser encontradas na documentação do Python em uma explicação do módulo __main__
. Que texto afirma:
Este módulo representa o escopo (de outra forma anônima) no qual o principais executa programa do intérprete - comandos lida tanto do entrada padrão, a partir de um arquivo de script, ou a partir de um prompt interativo. isto é este ambiente no qual o idiomática “roteiro condicional” stanza faz com que um script para executar:
if __name__ == '__main__': main()
if __name__ == "__main__"
é a parte que é executado quando o script é executado a partir de (digamos) na linha de comando usando um comando como python myscript.py
.
O que
if __name__ == "__main__":
fazer?
__name__
é uma variável global (em Python, global realmente significa na módulo nível ) que existe em todos os namespaces. É tipicamente o nome do módulo (como um tipo str
).
Como o único caso especial, no entanto, em qualquer processo de Python é executado, como em mycode.py:
python mycode.py
namespace global outra forma anônima é atribuído o valor de '__main__'
à sua __name__
.
Assim, incluindo as linhas finais
if __name__ == '__main__':
main()
- no final do seu script mycode.py,
- quando é o módulo principal, ponto de entrada que é executado por um processo de Python,
fará com que a função main
definido exclusivamente do seu script para ser executado.
Outra vantagem de usar esta construção: você também pode importar seu código como um módulo em outro script e, em seguida, executar a função principal, se e quando o seu programa decide:
import mycode
# ... any amount of other code
mycode.main()
Há muitas tomadas diferentes aqui na mecânica do código em questão, o "como", mas para mim nada disso fazia sentido até que eu entendi o "porquê". Isto deve ser especialmente útil para novos programadores.
Tome arquivo "ab.py":
def a():
print('A function in ab file');
a()
E um arquivo de segundo "xy.py":
import ab
def main():
print('main function: this is where the action is')
def x():
print ('peripheral task: might be useful in other projects')
x()
if __name__ == "__main__":
main()
O que é este código realmente fazendo?
Quando você executa xy.py
, você import ab
. A declaração de importação é executado o módulo imediatamente na importação, por isso, as operações da ab
são executadas antes que o restante da xy
de. Uma vez terminado com ab
, ele continua com xy
.
O intérprete mantém o controle de quais scripts estão funcionando com __name__
. Quando você executar um script - não importa o que você nomeou-o -. O intérprete chama de "__main__"
, tornando-se o mestre ou script 'casa' que será retornado para depois de executar um script externo
Qualquer outro script que é chamado a partir deste roteiro "__main__"
é atribuído o seu nome como seu __name__
(por exemplo, __name__ == "ab.py"
). Assim, o if __name__ == "__main__":
linha é o teste do intérprete para determinar se ele está interpretando / analisar o script 'casa' que foi inicialmente executado, ou se é espreitar temporariamente em outro roteiro (externo). Isto dá a flexibilidade programador ter se comportam roteiro diferente se ele é executado diretamente vs. chamado externamente.
Vamos passo através do código acima para entender o que está acontecendo, concentrando-se primeiro nas linhas sem recuo e a ordem em que aparecem nos scripts. Lembre-se que a função - ou def
- blocos não fazem nada por si mesmos até que eles são chamados. O que o intérprete pode dizer se murmurou para si mesmo:
- xy.py Abrir como o arquivo 'home'; chamá-lo
"__main__"
na variável__name__
. - Importar e arquivo aberto com o
__name__ == "ab.py"
. - Oh, uma função. Vou me lembrar disso.
- Ok, função
a()
; Eu só aprendi isso. Imprimir ' Uma função no arquivo ab . - Fim do arquivo; volta para
"__main__"
! - Oh, uma função. Vou me lembrar disso.
- Outro.
-
x()
Função; ok, a impressão. ' tarefa periférica: pode ser útil em outros projetos ' - O que é isso? Uma declaração
if
. Bem, a condição foi cumprida (a__name__
variável foi definido para"__main__"
), então eu vou entrar na funçãomain()
e imprimir ' função principal: este é onde está a ação '
As duas linhas inferiores dizer: "Se este é o "__main__"
ou script 'casa', executar a função chamada main()
". É por isso que você verá um bloco def main():
em cima, que contém o fluxo principal da funcionalidade do script.
Por que implementar isso?
Lembre-se que eu disse anteriormente sobre as declarações de importação? Quando você importa um módulo não basta 'reconhecer'-lo e aguardar novas instruções - ele realmente executa todas as operações executáveis ??contidos no script. Então, colocando a carne do seu script para a função main()
efetivamente coloca em quarentena-lo, colocá-lo em isolamento para que ele não será executado imediatamente quando importado por outro script.
Mais uma vez, não haverá exceções, mas a prática comum é que main()
, normalmente, não são chamados externamente. Então você pode estar se perguntando mais uma coisa: se não estamos chamando main()
, por que estamos chamando o script em tudo? É porque muitas pessoas estruturar seus scripts com funções autônomas que são construídos para ser executado independente do resto do código no arquivo. Eles são, em seguida, mais tarde chamado em outro lugar no corpo do script. O que me traz a esta:
Mas as obras de códigosem ele
Sim, isso mesmo. Estas funções distintas pode ser chamado de um script in-line que não está contido dentro de uma função main()
. Se você está acostumado (como eu sou, em meus estágios iniciais de aprendizagem de programação) para a construção de scripts em linha que fazem exatamente o que você precisa, e você vai tentar descobrir isso novamente se você precisar que a operação novamente .. . bem, você não está acostumado a esse tipo de estrutura interna para o seu código, porque é mais complicado para construir e não é tão intuitivo para ler.
Mas isso é um script que provavelmente não pode ter suas funções chamado externamente, porque se ele fez isso iria começar imediatamente cálculo e atribuição de variáveis. E as chances são, se você está tentando re-utilizar uma função, o seu novo roteiro está relacionada de perto o suficiente para o velho que haverá variáveis ??conflitantes.
Na divisão de funções independentes, você ganha a habilidade de re-utilizar o seu trabalho anterior, chamando-os em outro script. Por exemplo, "example.py" pode importar "xy.py" e x()
chamada, fazendo uso da função 'x' de "xy.py". (Talvez seja capitalizando a terceira palavra de uma determinada sequência de texto, a criação de uma matriz NumPy de uma lista de números e em quadratura com eles;.. Ou detrending uma superfície 3D As possibilidades são ilimitadas)
(Como um aparte, esta questão contém uma resposta por @kindall que, finalmente, me ajudou a entender -. o porquê, não o quão Infelizmente tem sido marcada como uma duplicata de esta , que eu acho que é um erro.)
Quando há certas declarações em nosso módulo (M.py
) queremos ser executado quando ele vai ser executado como principal (e não importadas), podemos colocar essas declarações (estudos de casos, declarações de impressão), sob este bloco if
.
Como por padrão (quando o módulo de execução como principal, não importado) a variável __name__
está definido para "__main__"
, e quando ele vai ser importado a variável __name__
terá um valor diferente, mais provavelmente, o nome do módulo ('M'
) .
Isso é útil na execução de diferentes variantes de um módulos juntos, e separando as suas declarações de entrada e saída específicos e também se existem estudos de casos.
Em suma , use este bloco 'if __name__ == "main"
' para impedir que o código (certa) de ser executado quando o módulo é importado.
Vamos olhar a resposta de forma mais abstrata:
Suponha que tenhamos esse código em x.py:
...
<Block A>
if __name__ == '__main__':
<Block B>
...
Blocos A e B são executados quando estamos executando "x.py".
Mas só bloquear A (e não B) é executado quando estamos executando outro módulo, "y.py", por exemplo, em que xy é importado e o código é executado a partir daí (como quando uma função em "x. py" é chamado de y.py).
Simplificando, __name__
é uma variável definida para cada script que define se o script está sendo executado como o módulo principal ou ele está sendo executado como um módulo importado.
Então, se temos dois roteiros;
#script1.py
print "Script 1's name: {}".format(__name__)
e
#script2.py
import script1
print "Script 2's name: {}".format(__name__)
A saída de executar script1 é
Script 1's name: __main__
E a saída de executar script2 é:
Script1's name is script1
Script 2's name: __main__
Como você pode ver, __name__
nos diz qual o código é o módulo 'main'.
Isso é ótimo, porque você pode código Basta escrever e não ter que se preocupar com questões estruturais, como em C / C ++, onde, se um arquivo não implementar uma função 'main', então ele pode não ser compilado como um executável e se isso acontecer, ele não pode ser usado como uma biblioteca.
Say você escrever um script Python que faz algo grande e você implementar um barco cheio de funções que são úteis para outros fins. Se eu quiser usá-los eu só posso importar o script e usá-los sem executar o seu programa (dado que o código executa somente dentro do contexto if __name__ == "__main__":
). Enquanto que em C / C ++, você teria que parte para fora essas peças em um módulo separado que, em seguida, inclui o arquivo. Imagine a situação abaixo;
As setas são links de importação. Durante três módulos cada um tentando incluir o código módulos anterior há seis arquivos (nove, contando os arquivos de implementação) e cinco ligações. Isso torna difícil para incluir outro código em um projeto C a menos que ele é compilado especificamente como uma biblioteca. Agora imagine isso para Python:
Você escreve um módulo, e se alguém quiser usar o código que apenas importá-lo ea variável __name__
pode ajudar a separar a parte executável do programa da parte da biblioteca.
Quando você executar Python interativamente a variável __name__
local é atribuído um valor de __main__
. Da mesma forma, quando você executar um módulo Python na linha de comando, em vez de importá-lo para outro módulo, seu atributo __name__
é atribuído um valor de __main__
, em vez do nome real do módulo. Desta forma, os módulos podem olhar para o seu próprio valor __name__
para determinar por si mesmos como eles estão sendo usados, seja como suporte para outro programa ou como o principal aplicativo executado a partir da linha de comando. Assim, a seguinte expressão é bastante comum em módulos Python:
if __name__ == '__main__':
# Do something appropriate here, like calling a
# main() function defined elsewhere in this module.
main()
else:
# Do nothing. This module has been imported by another
# module that wants to make use of the functions,
# classes and other useful bits it has defined.
Considere o seguinte:
if __name__ == "__main__":
main()
Ele verifica se o atributo __name__
do script Python é "__main__"
. Em outras palavras, se o próprio programa é executado, o atributo será __main__
, de modo que o programa será executado (neste caso, a função main()
).
No entanto, se seu script Python é usado por um módulo, qualquer fora do código da declaração if
será executado, então if \__name__ == "\__main__"
é usado apenas para verificar se o programa é usado como um módulo ou não, e, portanto, decide se deseja executar o código.
Antes de explicar nada sobre if __name__ == '__main__'
é importante para entender o que __name__
é eo que ele faz.
O que é
__name__
?
__name__
é um DunderAlias ?? - pode ser pensado como uma variável global (acessível a partir de módulos) e funciona de forma semelhante ao global
.
É uma cadeia de (global como mencionado acima) como indicado pela type(__name__)
(originando <class 'str'>
), e é um padrão para ambos embutido Python 3 e Python 2 versões.
Onde:
Ele pode não só ser usado em scripts, mas também pode ser encontrado em ambos o intérprete e módulos / pacotes.
Intérprete:
>>> print(__name__)
__main__
>>>
Script:
test_file.py :
print(__name__)
Resultando em __main__
Módulo ou pacote:
somefile.py:
def somefunction():
print(__name__)
test_file.py:
import somefile
somefile.somefunction()
Resultando em somefile
Observe que, quando usado em um pacote ou módulo, __name__
leva o nome do arquivo. O caminho do módulo real ou caminho do pacote não é dado, mas tem a sua própria __file__
DunderAlias, que permite isso.
Você deve ver que, quando __name__
, onde é o arquivo principal (ou programa) irá sempre __main__
retorno, e se for um módulo / pacote, ou qualquer coisa que está sendo executado fora de alguma outra Python roteiro, irá retornar o nome do arquivo onde ele se originou.
Práticas:
Sendo um meio de variáveis ??que é valor pode ser substituído ( "podem" não significa "deveria"), substituindo o valor de __name__
irá resultar em uma falta de legibilidade. Portanto, não fazê-lo, por qualquer motivo. Se você precisar de uma variável definir uma nova variável.
Presume-se sempre que o valor de __name__
ser __main__
ou o nome do arquivo. Mais uma vez alterar este valor padrão irá causar mais confusão que ele vai fazer o bem, causando problemas ainda mais para baixo da linha.
exemplo:
>>> __name__ = 'Horrify' # Change default from __main__
>>> if __name__ == 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>
É considerada boa prática, em geral, para incluir o if __name__ == '__main__'
em scripts.
Agora, para responder
if __name__ == '__main__'
:
Agora sabemos que o comportamento das coisas __name__
tornar-se mais claro:
Um if
é uma declaração de controle de fluxo que contém o bloco de código será executado se o valor dado é verdadeiro. Vimos que __name__
pode tomar uma
__main__
ou o nome do arquivo que foi importado da.
Isto significa que se __name__
é igual a __main__
em seguida, o arquivo deve ser o arquivo principal e deve realmente ser executado (ou é o intérprete), não um módulo ou pacote importados para o script.
Se de fato __name__
leva o valor de __main__
então o que está nesse bloco de código será executado.
Isto diz-nos que, se o arquivo em execução é o arquivo principal (ou você está executando a partir do intérprete directamente), então esta condição deve executar. Se for um pacote, então não deveria, e o valor não será __main__
.
Módulos:
__name__
também pode ser usada em módulos para definir o nome de um módulo
Variantes:
Também é possível fazer outras, menos comuns, mas útil coisas com __name__
, alguns vou mostrar aqui:
Executar somente se o arquivo é um módulo ou pacote:
if __name__ != '__main__':
# Do some useful things
Running uma condição se o arquivo é o principal e outro se ele não é:
if __name__ == '__main__':
# Execute something
else:
# Do some useful things
Você também pode usá-lo para fornecer funções de ajuda executáveis ??/ utilitários em pacotes e módulos sem o uso elaborado de bibliotecas.
Ele também permite que os módulos para ser executado a partir da linha de comando como scripts principais, que podem ser também muito útil.
Eu acho que é melhor para quebrar a resposta em profundidade e em palavras simples:
__name__
: Cada módulo em Python tem um atributo especial chamado __name__
.
É uma variável interna que retorna o nome do módulo.
__main__
: Como outras linguagens de programação, Python também tem um ponto de entrada de execução, ou seja, a principal. '__main__'
é o nome do escopo em que executa o código de nível superior . Basicamente você tem duas maneiras de usar um módulo Python: executá-lo diretamente como um script, ou importá-lo. Quando um módulo é executado como um script, sua __name__
está definido para __main__
.
Assim, o valor do atributo __name__
está definido para __main__
quando o módulo é executado como o programa principal. Caso contrário, o valor de __name__
está definido para conter o nome do módulo.
É um especial para quando um arquivo Python é chamado a partir da linha de comando. Isso normalmente é usado para chamar um "main ()" função ou executar outro código de inicialização apropriado, como argumentos de linha de comando manipulação por exemplo.
Pode ser escrito de várias maneiras. Outra é:
def some_function_for_instance_main():
dosomething()
__name__ == '__main__' and some_function_for_instance_main()
Eu não estou dizendo que você deve usar isso em código de produção, mas serve para ilustrar que não há nada "mágico" sobre if __name__ == '__main__'
. É uma boa convenção para invocar uma função principal de arquivos Python.
Há uma série de variáveis ??que o sistema (interpretador Python) prevê arquivos de origem (módulos). Você pode obter seus valores sempre que quiser, por isso, vamos nos focar no __ nome __ variável / atributo:
Quando Python carrega um arquivo de código-fonte, ele executa todo o código encontrado nele. (Note que ele não chamar todos os métodos e funções definidas no arquivo, mas não defini-los.)
Antes do intérprete executa o arquivo de código fonte, porém, ele define algumas variáveis ??especiais para esse arquivo; __ nome __ é uma dessas variáveis ??especiais que Python define automaticamente para cada arquivo de código-fonte.
Se Python está a carregar esse arquivo de código fonte como o programa principal (ou seja, o arquivo é executado), em seguida, ele define o especial __ nome __ variável para este arquivo para ter um valor "__ main__" .
Se esta for importado de outro módulo, __ nome __ será definido como o nome desse módulo.
Assim, no seu exemplo em parte:
if __name__ == "__main__":
lock = thread.allocate_lock()
thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
significa que o bloco de código:
lock = thread.allocate_lock()
thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
será executado somente quando você executar o módulo diretamente; o bloco de código não será executado se outro módulo está chamando / importá-lo porque o valor de __ nome __ não igual a " main " nesse caso particular.
Espero que isso ajuda.
if __name__ == "__main__":
é basicamente o ambiente de script de nível superior, e especifica o intérprete que ( 'Tenho a maior prioridade a ser executada primeiro').
'__main__'
é o nome do escopo em que top-level executa o código. __name__
de um módulo é definido como igual a '__main__'
quando lido da entrada padrão, um script, ou a partir de um interativo prompt de.
if __name__ == "__main__":
# Execute only if run as a script
main()
A razão para
if __name__ == "__main__":
main()
é principalmente para evitar a bloqueio de importação problemas que surgem a partir importados diretamente . Você quer main()
para executar se o arquivo foi directamente invocada (que é o caso __name__ == "__main__"
), mas se o seu código foi importado, em seguida, o importador tem de introduzir o seu código do verdadeiro módulo principal para problemas de bloqueio evitar importação.
Um efeito colateral é que você automaticamente assinar para uma metodologia que suporta múltiplos pontos de entrada. Você pode executar o seu programa usando main()
como ponto de entrada, , mas você não tem que . Enquanto espera setup.py
main()
, outras ferramentas usar pontos de entrada alternativos. Por exemplo, para executar o arquivo como um processo gunicorn
, você define uma função app()
em vez de um main()
. Assim como com setup.py
, as importações gunicorn
seu código para que você não quer que ele faça nada enquanto ele está sendo importado (por causa do problema de bloqueio de importação).
Estive lendo muito ao longo das respostas nesta página. Eu diria que, se você sabe a coisa, com certeza você vai entender essas respostas, caso contrário, você ainda está confuso.
Para ser curto, você precisa saber vários pontos:
-
ação
import a
realmente executa tudo o que pode ser executado em "a" -
Por causa do ponto 1, você não pode querer tudo para ser executado em "a" quando importá-lo
-
Para resolver o problema no ponto 2, python permite que você coloque uma verificação de condição
-
__name__
é uma variável implícita em todos os módulos .py; quando a.py é importado, o valor de__name__
de módulo a.py está definido para seu nome de arquivo "a"; quando a.py é executado diretamente usando "a.py python", que significa a.py é o ponto de entrada, então o valor de__name__
de módulo a.py está definido como uma string__main__
-
Com base no mecanismo como python define a variável
__name__
para cada módulo, você sabe como atingir o ponto 3? A resposta é bastante fácil, certo? Coloque um se condição:if __name__ == "__main__": ...
; você pode até mesmo colocar se__name__ == "a"
dependendo de sua necessidade funcional
A coisa importante que python é especial na é ponto 4! O resto é a lógica básica.
Considere o seguinte:
print __name__
A saída para o acima é __main__
.
if __name__ == "__main__":
print "direct method"
A afirmação acima é verdadeira e impressões "método direto" . Suponha que se importaram esta classe em outra classe que não imprime "método direto" , porque, durante a importação, ele irá definir __name__ equal to "first model name"
.
Você pode fazer o utilizável arquivo como um roteiro , bem como um importable módulo .
fibo.py (um módulo chamado fibo
)
# Other modules can IMPORT this MODULE to use the function fib
def fib(n): # write Fibonacci series up to n
a, b = 0, 1
while b < n:
print(b, end=' ')
a, b = b, a+b
print()
# This allows the file to be used as a SCRIPT
if __name__ == "__main__":
import sys
fib(int(sys.argv[1]))
Referência: https://docs.python.org/3.5/tutorial/modules. html
Esta resposta é para programadores Java aprendizagem Python. Cada arquivo Java normalmente contém uma classe pública. Você pode usar essa classe de duas maneiras:
-
Chamada a classe de outros arquivos. Você apenas tem que importá-lo no programa de chamada.
-
Executar a classe ficar sozinho, para fins de teste.
Para este último caso, a classe deve conter um método public static void main (). Em Python este fim é servido pelo '__main__'
etiqueta definida globalmente.
Se este arquivo .py são importados por outros arquivos .py, o código sob "a instrução if" não será executada.
Se este .py são geridos pelos python this_py.py
sob shell, ou duplo clique no Windows. o código sob "a instrução if" será executada.
Normalmente é escrito para o teste.
Crie um arquivo, a.py :
print(__name__) # It will print out __main__
__name__
é sempre igual a __main__
sempre que esse arquivo é executado diretamente mostrando que este é o arquivo principal.
Criar outro arquivo, b.py , no mesmo diretório:
import a # Prints a
executá-lo. Ele irá imprimir a , ou seja, o nome do arquivo que é importado .
Assim, para mostrar dois comportamentos diferentes do mesmo arquivo , este é um truque comum:
# Code to be run when imported into another python file
if __name__ == '__main__':
# Code to be run only when run directly
se nome == ' main ':
Nós ver se __name__ == '__main__':
com bastante frequência.
Ele verifica se um módulo está sendo importado ou não.
Em outras palavras, o código dentro do bloco if
será executada somente quando o código é executado diretamente. Aqui meio directly
not imported
.
Vamos ver o que ele faz usando um código simples que imprime o nome do módulo:
# test.py
def test():
print('test module name=%s' %(__name__))
if __name__ == '__main__':
print('call test()')
test()
Se executar o código diretamente via python test.py
, o nome do módulo é __main__
:
call test()
test module name=__main__
Todas as respostas foram praticamente explicou a funcionalidade. Mas vou dar um exemplo de seu uso que poderia ajudar limpando o conceito mais longe.
Suponha que você tem dois arquivos Python, a.py e b.py. Agora, as importações a.py b.py. Nós executar o arquivo a.py, onde o código "importação b.py" é executado em primeiro lugar. Antes que o resto dos a.py código é executado, o código no b.py arquivo deve ser executado completamente.
No código b.py há algum código que é exclusivo para que b.py arquivo e não queremos que qualquer outro arquivo (diferente de arquivo b.py), que importou o arquivo b.py, a executá-lo.
Então é isso que esta linha de código verifica. Se ele é o arquivo principal (ou seja, b.py) de executar o código, que neste caso não é (a.py é o arquivo principal em execução), em seguida, apenas o código é executado.
Simplesmente, é o ponto de entrada para executar o arquivo como a função main
no C linguagem de programação.
Cada módulo em python tem um atributo que é chamado como nome . O valor de nome atributo é ' main ' quando o módulo run diretamente. Caso contrário, o valor de nome é o nome do módulo.
pequeno exemplo para explicar em suma.
#Script test.py
apple = 42
def hello_world():
print("I am inside hello_world")
if __name__ == "__main__":
print("Value of __name__ is: ", __name__)
print("Going to call hello_world")
hello_world()
Podemos executar este diretamente como
python test.py
saída
Value of __name__ is: __main__
Going to call hello_world
I am inside hello_world
Agora, suponha que chamamos acima de script de outro script
#script external_calling.py
import test
print(test.apple)
test.hello_world()
print(test.__name__)
Quando você executa esse
python external_calling.py
saída
42
I am inside hello_world
test
Assim, acima é auto-explicativo que quando você chamar teste de outro script, se laço nome em test.py não serão executados.