O que se name == “main”: fazer?

https://stackoverflow.com/questions/419163

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 chamada math. Isto é equivalente a substituir import 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 chamada functionA.
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 chamada functionB.
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ção if.

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ê diz python 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__ em foo3.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

# 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ção main() 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__)

#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.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow

O que se name == “main”: fazer?

Código de exemplo

Variáveis ??especiais

execução de código do módulo

Por que isso funciona dessa maneira?

Food for Thought

O que o `if name == "main":` fazer?

Desenvolver e testar o seu código

O Problema

A Better Way

Uma maneira ainda melhor

O que `if name == "main":` fazer?

se nome == ' main ':

O que se __name__ == “__main__”: fazer?

Código de exemplo

Variáveis ??especiais

execução de código do módulo

Por que isso funciona dessa maneira?

Food for Thought

O que o if __name__ == "__main__": fazer?

Desenvolver e testar o seu código

O Problema

A Better Way

Uma maneira ainda melhor

O que if __name__ == "__main__": fazer?

se nome == ' main ':

O que se name == “main”: fazer?

O que o `if name == "main":` fazer?

O que `if name == "main":` fazer?