Dado o código a seguir, o que if __name__ == "__main__":faz?

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

Sempre que o interpretador Python lê um arquivo de origem, ele faz duas coisas:

• ele define algumas variáveis ​​especiais como __name__e, em seguida,

• ele executa todo o código encontrado no arquivo.

Vamos ver como isso funciona e como se relaciona à sua pergunta sobre as __name__verificações que sempre vemos nos scripts Python.

Amostra de código

Vamos usar um exemplo de código um pouco diferente para explorar como as importações e os scripts funcionam. Suponha que o seguinte esteja 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 interpretador Python lê um arquivo de origem, primeiro define algumas variáveis ​​especiais. Nesse caso, nos preocupamos com a __name__variável.

Quando o seu módulo é o programa principal

Se você estiver executando seu módulo (o arquivo de origem) como o programa principal, por exemplo,

python foo.py

o intérprete atribuirá a string codificada "__main__"à __name__variável, ou seja,

# 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 outro módulo seja o programa principal e importe seu módulo. Isso significa que há uma declaração como essa no programa principal ou em algum outro módulo que o programa principal importa:

# Suppose this is in some other main program.
import foo

O intérprete pesquisará seu foo.pyarquivo (juntamente com algumas outras variantes) e, antes de executar esse módulo, atribuirá o nome "foo"da instrução de importação à __name__variável, ou seja,

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Executando o código do módulo

Depois que as variáveis ​​especiais são configuradas, o intérprete executa todo o código do módulo, uma instrução de cada vez. Convém abrir outra janela ao lado com o exemplo de código para poder seguir essa explicação.

Sempre

1. Imprime a string "before import"(sem aspas).

2. Ele carrega o mathmódulo e o atribui a uma variável chamada math. Isso é equivalente a substituir import mathpelo seguinte (observe que __import__é uma função de baixo nível no Python que pega 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")

3. Imprime a string "before functionA".

4. Ele executa o defbloco, criando um objeto de função e atribuindo esse objeto de função a uma variável chamada functionA.

5. Imprime a string "before functionB".

6. Ele executa o segundo defbloco, criando outro objeto de função e atribuindo-o a uma variável chamada functionB.

7. Imprime a string "before __name__ guard".

Somente quando o seu módulo é o programa principal

8. Se o seu módulo é o programa principal, ele verá que __name__foi realmente definido como "__main__"e chama as duas funções, imprimindo as strings "Function A"e "Function B 10.0".

Somente quando seu módulo é importado por outro

8. (em vez disso ) Se o seu módulo não for o programa principal, mas foi importado por outro, então __name__será "foo", não "__main__"e ele ignorará o corpo da ifinstrução.

Sempre

9. Ele imprimirá a sequência "after __name__ guard"nas duas situações.

Sumário

Em resumo, eis o que seria impresso nos 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 se perguntar por que alguém iria querer isso. Bem, às vezes você quer escrever uma.py arquivo que possa ser usado por outros programas e / ou módulos como um módulo e também possa ser executado como o próprio programa principal. Exemplos:

• Seu módulo é uma biblioteca, mas você deseja ter um modo de script no qual ele executa alguns testes de unidade ou uma demonstração.

• Seu módulo é usado apenas como um programa principal, mas possui alguns testes de unidade, e a estrutura de teste funciona importando .py arquivos como seu script e executando funções especiais de teste. Você não quer que ele execute o script apenas porque está importando o módulo.

• Seu módulo é usado principalmente como um programa principal, mas também fornece uma API amigável para programadores para usuários avançados.

Além desses exemplos, é elegante que a execução de um script em Python esteja apenas configurando algumas variáveis ​​mágicas e importando o script. "Executar" o script é um efeito colateral da importação do módulo do script.

Alimento para o pensamento

• Pergunta: Posso ter vários __name__blocos de verificação? Resposta: é estranho fazê-lo, mas o idioma não o impede.

• Suponha que o seguinte é no foo2.py. O que acontece se você disser python foo2.pyna 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, descubra o que acontecerá se você remover o __name__check-in 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 isso fará quando usado como um script? Quando importado 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")

Quando seu script é executado, passando-o como um comando para o intérprete Python,

python myscript.py

todo o código que está no nível de indentação 0 é executado. Funções e classes definidas são, bem, definidas, mas nenhum código é executado. Ao contrário de outros idiomas, não há main()função que seja executada automaticamente - a main()função é implicitamente todo o código no nível superior.

Nesse caso, o código de nível superior é um ifbloco. __name__é uma variável interna que avalia o nome do módulo atual. No entanto, se um módulo estiver sendo executado diretamente (como myscript.pyacima), __name__será definido como a sequência "__main__". Portanto, você pode testar se seu script está sendo executado diretamente ou se está sendo importado por outra coisa testando

if __name__ == "__main__":
    ...

Se o seu script estiver sendo importado para outro módulo, suas várias definições de função e classe serão importadas e seu código de nível superior será executado, mas o código no corpo da ifcláusula acima não será executado conforme a condição não conheceu. Como um exemplo básico, considere os dois scripts a seguir:

# 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ê chamar 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:

python two.py

Você recebe

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, é __name__igual ao "one"invés de "__main__".

A explicação mais simples para a __name__variável (imho) é a seguinte:

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

Ao executá-los, você obtém esta saída:

$ python a.py
Hello World from b!

Como você pode ver, quando um módulo é importado, o Python define globals()['__name__']nesse módulo o nome do módulo. Além disso, na importação, todo o código do módulo está sendo executado. Como a ifinstrução é avaliada para Falseesta parte, não é executada.

$ python b.py
Hello World from __main__!
Hello World again from __main__!

Como você pode ver, quando um arquivo é executado, o Python define globals()['__name__']nesse arquivo como "__main__". Desta vez, a ifinstrução é avaliada Truee está sendo executada.

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

Para descrever 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 pelo qual você importa o módulo.

• Portanto, o código sob o ifbloco será executado apenas se o módulo for o ponto de entrada para o seu programa.

• Ele permite que o código no módulo seja importável por outros módulos, sem executar o bloco de código abaixo na importação.

Por que nós precisamos disso?

Desenvolvendo e testando seu código

Digamos que você esteja escrevendo um script Python projetado para ser usado como um módulo:

def do_important():
    """This function does something very important"""

Você pode testar o módulo adicionando esta chamada da função na parte inferior:

do_important()

e executá-lo (em um prompt de comando) com algo como:

~$ python important.py

O problema

No entanto, se você deseja importar o módulo para outro script:

import important

Na importação, a do_importantfunção seria chamada, então você provavelmente comentaria sua chamada de função,, do_important()na parte inferior.

# do_important() # I must remember to uncomment to execute this!

E então você terá que lembrar se comentou ou não sua chamada de função de teste. E essa complexidade extra significa que você provavelmente esquecerá, tornando seu processo de desenvolvimento mais problemático.

Uma maneira melhor

A __name__variável aponta para o espaço para nome onde quer que o intérprete Python esteja no momento.

Dentro de um módulo importado, é o nome desse módulo.

Mas dentro do módulo primário (ou uma sessão interativa do Python, ou seja, Read, Eval, Print Loop ou REPL do intérprete), você está executando tudo "__main__".

Portanto, se você verificar antes de executar:

if __name__ == "__main__":
    do_important()

Com o exposto acima, seu código só será executado quando você o estiver executando como módulo primário (ou intencionalmente o chamará de outro script).

Uma maneira ainda melhor

Há uma maneira pitônica de melhorar isso, no entanto.

E se quisermos executar esse processo de negócios de fora do módulo?

Se colocarmos o código que queremos exercitar à medida que desenvolvemos e testamos em uma função como essa e fazemos nossa verificação '__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()

Agora, temos uma função final para o final do nosso módulo que será executada se executarmos o módulo como o módulo principal.

Ele permitirá que o módulo e suas funções e classes sejam importados para outros scripts sem executar a mainfunção, e também permitirá que o módulo (e suas funções e classes) sejam chamados ao executar a partir de um '__main__'módulo diferente , ou seja,

import important
important.main()

Esse idioma também pode ser encontrado na documentação do Python em uma explicação do __main__módulo. Esse texto declara:

Este módulo representa o escopo (de outra forma anônimo) no qual o programa principal do intérprete executa - comandos lidos da entrada padrão, de um arquivo de script ou de um prompt interativo. É neste ambiente em que a estrofe idiomática do "script condicional" faz com que um script seja executado:

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__":faz?

__name__é uma variável global (em Python, global significa realmente no nível do módulo ) que existe em todos os namespaces. Normalmente, é o nome do módulo (como umstr tipo).

Como o único caso especial, no entanto, em qualquer processo Python que você execute, como em mycode.py:

python mycode.py

o namespace global outra forma anônima é atribuído o valor '__main__'da sua __name__.

Assim, incluindo as linhas finais

if __name__ == '__main__':
    main()

• no final do seu script mycode.py,
• quando é o módulo primário de ponto de entrada executado por um processo Python,

fará com que a mainfunção definida exclusivamente do seu script seja executada.

Outro benefício do uso dessa 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 seu programa decidir:

import mycode
# ... any amount of other code
mycode.main()

Existem várias abordagens diferentes aqui sobre a mecânica do código em questão, o "Como", mas para mim nada disso fazia sentido até eu entender o "Por que". Isso deve ser especialmente útil para novos programadores.

Tome o arquivo "ab.py":

def a():
    print('A function in ab file');
a()

E um segundo arquivo "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 esse código está realmente fazendo?

Quando você executa xy.py, você import ab. A instrução de importação executa o módulo imediatamente na importação, para que abas operações sejam executadas antes do restante das xy. Uma vez terminado ab, continua comxy .

O intérprete controla quais scripts estão sendo executados __name__. Quando você executa um script - não importa como você o nomeou - o intérprete o chama "__main__", tornando-o o script mestre ou 'home' que é retornado após a execução de um script externo.

Qualquer outro script chamado deste "__main__"script recebe seu nome de arquivo como __name__(por exemplo, __name__ == "ab.py"). Portanto, a linhaif __name__ == "__main__": é o teste do intérprete para determinar se está interpretando / analisando o script 'home' que foi executado inicialmente ou se está temporariamente espiando outro script (externo). Isso dá ao programador flexibilidade para que o script se comporte de maneira diferente se for executado diretamente e chamado externamente.

Vamos percorrer o código acima para entender o que está acontecendo, focando primeiro nas linhas não recortadas e na ordem em que elas aparecem nos scripts. Lembre-se de que funções ou defblocos não fazem nada sozinhos até serem chamados. O que o intérprete pode dizer se resmungar consigo mesmo:

• Abra o xy.py como o arquivo 'home'; chame-o "__main__"na __name__variável
• Importe e abra o arquivo com o __name__ == "ab.py".
• Oh, uma função. Vou me lembrar disso.
• Ok, função a(); Eu acabei de aprender isso. Imprimindo ' Uma função em um arquivo ab '.
• Fim do arquivo; de volta para "__main__"!
• Oh, uma função. Vou me lembrar disso.
• Outro.
• Função x(); ok, imprimir ' tarefa periférica: pode ser útil em outros projetos '.
• O que é isso? Uma ifdeclaração. Bem, a condição foi atendida (a variável __name__foi definida como "__main__"), então eu vou inserir a main()função e imprimir ' função principal: é aqui que está a ação '.

As duas linhas inferiores significam: "Se este for o "__main__"script ou 'home', execute a função chamada main()". É por isso que você verá um def main():bloco no topo, que contém o fluxo principal da funcionalidade do script.

Por que implementar isso?

Lembra do que eu disse anteriormente sobre instruções de importação? Quando você importa um módulo, ele não apenas o 'reconhece' e aguarda mais instruções - ele realmente executa todas as operações executáveis ​​contidas no script. Portanto, colocar a carne do seu script na main()função efetivamente o coloca em quarentena, colocando-o em isolamento para que não seja executado imediatamente quando importado por outro script.

Novamente, haverá exceções, mas a prática comum é que main()geralmente não é chamado externamente. Então você deve estar se perguntando mais uma coisa: se não estamos ligando main(), por que estamos chamando o script? Isso ocorre porque muitas pessoas estruturam seus scripts com funções independentes criadas para serem executadas independentemente do restante do código no arquivo. Mais tarde, eles são chamados em outro lugar no corpo do script. O que me leva a isso:

Mas o código funciona sem ele

Sim está certo. Essas funções separadas podem ser chamadas de um script em linha que não está contido em uma main()função. Se você está acostumado (como eu, nos estágios iniciais de aprendizado da programação) a criar scripts em linha que fazem exatamente o que você precisa, e tentará descobrir novamente se precisar dessa operação novamente. bem, você não está acostumado a esse tipo de estrutura interna no seu código, porque é mais complicado criar e não é tão intuitivo quanto a leitura.

Mas esse é um script que provavelmente não pode ter suas funções chamadas externamente, porque, se o fizesse, começaria imediatamente a calcular e atribuir variáveis. E é provável que, se você estiver tentando reutilizar uma função, seu novo script esteja relacionado o suficiente ao antigo para que haja variáveis ​​conflitantes.

Ao dividir funções independentes, você ganha a capacidade de reutilizar seu trabalho anterior, chamando-o para outro script. Por exemplo, "example.py" pode importar "xy.py" e chamar x(), usando a função 'x' de "xy.py". (Talvez esteja capitalizando a terceira palavra de uma determinada sequência de texto; criando uma matriz NumPy a partir de uma lista de números e quadriculando-os; ou prejudicando 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 um presente , que eu acho que é um erro.)

Quando há certas instruções em nosso módulo ( M.py) que queremos que sejam executadas quando estiverem sendo executadas como principais (não importadas), podemos colocar essas instruções (casos de teste, instruções de impressão) nesse ifbloco.

Como padrão (quando o módulo é executado como principal, não importado), a __name__variável é definida como "__main__"e, quando importada, a __name__variável terá um valor diferente, provavelmente o nome do módulo ( 'M'). Isso é útil para executar diferentes variantes de um módulo juntos, separar suas instruções específicas de entrada e saída e também se houver algum caso de teste.

Em resumo , use este if __name__ == "main"bloco ' ' para impedir que (certo) código seja executado quando o módulo for importado.

Simplificando, __name__é uma variável definida para cada script que define se o script está sendo executado como o módulo principal ou se está sendo executado como um módulo importado.

Então, se tivermos dois scripts;

#script1.py
print "Script 1's name: {}".format(__name__)

e

#script2.py
import script1
print "Script 2's name: {}".format(__name__)

A saída da execução do script1 é

Script 1's name: __main__

E a saída da execução do script2 é:

Script1's name is script1
Script 2's name: __main__

Como você pode ver, __name__nos diz qual código é o módulo 'principal'. Isso é ótimo, porque você pode escrever código e não precisa se preocupar com problemas estruturais, como no C / C ++, onde, se um arquivo não implementa uma função 'principal', ele não pode ser compilado como executável e, não pode então ser usado como uma biblioteca.

Digamos que você escreva um script Python que faça algo excelente e implemente um monte de funções úteis para outros fins. Se eu quiser usá-los, basta importar o seu script e usá-los sem executar o seu programa (considerando que seu código é executado apenas dentro do if __name__ == "__main__":contexto). Enquanto em C / C ++ você teria que dividir essas partes em um módulo separado que inclui o arquivo. Imagine a situação abaixo;

As setas são links de importação. Para três módulos, cada um tentando incluir o código dos módulos anteriores, existem seis arquivos (nove, contando os arquivos de implementação) e cinco links. Isso dificulta a inclusão de outro código em um projeto C, a menos que seja compilado especificamente como uma biblioteca. Agora imagine isso para Python:

Você escreve um módulo e, se alguém quiser usar seu código, basta importá-lo e a __name__variável pode ajudar a separar a parte executável do programa da parte da biblioteca.

Vejamos a resposta de uma maneira mais abstrata:

Suponha que tenhamos esse código em x.py:

...
<Block A>
if __name__ == '__main__':
    <Block B>
...

Os blocos A e B são executados quando estamos executando x.py.

Mas apenas o bloco A (e não B) é executado quando estamos executando outro módulo, y.pypor exemplo, no qual x.pyé importado e o código é executado a partir daí (como quando uma função in x.pyé chamada from y.py).

Quando você executa o Python interativamente, a __name__variável local recebe um valor de __main__. Da mesma forma, quando você executa um módulo Python a partir da linha de comando, em vez de importá-lo para outro módulo, seu __name__atributo recebe um valor de __main__, em vez do nome real do módulo. Dessa forma, os módulos podem analisar seu próprio __name__valor para determinar por si mesmos como estão sendo usados, seja como suporte para outro programa ou como o aplicativo principal executado na linha de comando. Portanto, o seguinte idioma é bastante comum nos 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.

Considerar:

if __name__ == "__main__":
    main()

Ele verifica se o __name__atributo do script Python é "__main__". Em outras palavras, se o próprio programa for executado, o atributo será __main__, então o programa será executado (neste caso, a main()função).

No entanto, se o script Python for usado por um módulo, qualquer código fora da ifinstrução será executado, portanto, if \__name__ == "\__main__"é usado apenas para verificar se o programa é usado como módulo ou não e, portanto, decide se o código deve ser executado.

Antes de explicar qualquer coisa if __name__ == '__main__', é importante entender o que __name__é e o que 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 maneira semelhante a global.

É uma string (global como mencionado acima), conforme indicado por type(__name__)(yield <class 'str'>), e é um padrão embutido para as versões Python 3 e Python 2 .

Onde:

Ele não pode ser usado apenas em scripts, mas também pode ser encontrado no interpretador e nos módulos / pacotes.

Intérprete:

>>> print(__name__)
__main__
>>>

Roteiro:

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 ou pacote real não é fornecido, mas possui seu próprio DunderAlias __file__, que permite isso.

Você deve ver que, onde __name__, onde está o arquivo principal (ou programa) sempre retornará __main__e, se for um módulo / pacote, ou qualquer coisa que esteja executando algum outro script Python, retornará o nome do arquivo onde está se originou de.

Prática:

Ser uma variável significa que seu valor pode ser substituído ("can" não significa "deveria"), substituindo o valor de__name__ resultará em falta de legibilidade. Portanto, não faça isso, por qualquer motivo. Se você precisar de uma variável, defina uma nova variável.

Sempre se assume que o valor de __name__to be __main__ou o nome do arquivo. Mais uma vez, alterar esse valor padrão causará mais confusão de que será bom, causando problemas mais adiante.

exemplo:

>>> __name__ = 'Horrify' # Change default from __main__
>>> if __name__ == 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>

É considerado uma boa prática em geral incluir os if __name__ == '__main__'scripts.

Agora, para responder if __name__ == '__main__':

Agora sabemos que o comportamento das __name__coisas se torna mais claro:

An ifé uma instrução de controle de fluxo que contém o bloco de código que será executado se o valor fornecido for verdadeiro. Vimos isso__name__ pode levar __main__ ou o nome do arquivo do qual foi importado.

Isso significa que se __name__é igual a__main__ , o arquivo deve ser o arquivo principal e realmente estar em execução (ou é o intérprete), não um módulo ou pacote importado para o script.

Se de fato __name__leva o valor de__main__ , o que estiver nesse bloco de código será executado.

Isso nos diz que, se o arquivo em execução é o arquivo principal (ou você está executando diretamente do intérprete), essa condição deve ser executada. Se for um pacote, não deve, e o valor não será __main__.

Módulos:

__name__ também pode ser usado em módulos para definir o nome de um módulo

Variantes:

Também é possível fazer outras coisas menos comuns, mas úteis __name__, algumas que mostrarei aqui:

Executando apenas se o arquivo for um módulo ou pacote:

if __name__ != '__main__':
    # Do some useful things 

Executando uma condição se o arquivo for o principal e outro se não for:

if __name__ == '__main__':
    # Execute something
else:
    # Do some useful things

Você também pode usá-lo para fornecer funções / utilitários de ajuda executáveis ​​em pacotes e módulos sem o uso elaborado de bibliotecas.

Ele também permite que os módulos sejam executados a partir da linha de comando como scripts principais, o que também pode ser muito útil.

Eu acho que é melhor quebrar a resposta em profundidade e em palavras simples:

__name__: Todo módulo no Python possui um atributo especial chamado __name__ . É uma variável interna que retorna o nome do módulo.

__main__: Como outras linguagens de programação, o Python também possui um ponto de entrada de execução, ou seja, principal. '__main__' é o nome do escopo no qual o código de nível superior é executado . Basicamente, você tem duas maneiras de usar um módulo Python: Execute-o diretamente como um script ou importe-o. Quando um módulo é executado como um script, __name__é definido como __main__.

Portanto, o valor do __name__atributo é definido como __main__quando o módulo é executado como o programa principal. Caso contrário, o valor de __name__ é definido para conter o nome do módulo.

É um especial para quando um arquivo Python é chamado na linha de comando. Isso geralmente é usado para chamar uma função "main ()" ou executar outro código de inicialização apropriado, como manipulação de argumentos de linha de comando, por exemplo.

Pode ser escrito de várias maneiras. Outro é:

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

Não estou dizendo que você deva usar isso no código de produção, mas serve para ilustrar que não há nada de "mágico" if __name__ == '__main__'. É uma boa convenção para invocar uma função principal nos arquivos Python.

Há várias variáveis ​​que o sistema (intérprete Python) fornece para arquivos de origem (módulos). Você pode obter os valores quando quiser, portanto, vamos nos concentrar na variável / atributo __name__ :

Quando o Python carrega um arquivo de código-fonte, ele executa todo o código encontrado nele. (Observe que ele não chama todos os métodos e funções definidos no arquivo, mas define-os.)

Antes que o intérprete execute o arquivo de código-fonte, ele define algumas variáveis ​​especiais para esse arquivo; __name__ é uma daquelas variáveis ​​especiais que o Python define automaticamente para cada arquivo de código-fonte.

Se o Python estiver carregando esse arquivo de código-fonte como o programa principal (ou seja, o arquivo que você executa), ele definirá a variável __name__ especial para que esse arquivo tenha o valor "__main__" .

Se isso estiver sendo importado de outro módulo, __name__ será definido como o nome desse módulo.

Então, 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 estiver chamando / importando porque o valor de __name__ não será igual a " main " nessa instância específica.

Espero que isso ajude.

if __name__ == "__main__": é basicamente o ambiente de script de nível superior e especifica o intérprete que ('Eu tenho a maior prioridade para ser executado primeiro').

'__main__'é o nome do escopo no qual o código de nível superior é executado. Um módulo __name__é definido igual a '__main__'quando lido da entrada padrão, de um script ou de um prompt interativo.

if __name__ == "__main__":
    # Execute only if run as a script
    main()

Eu tenho lido muito nas respostas desta página. Eu diria que, se você souber, certamente entenderá essas respostas; caso contrário, ainda estará confuso.

Para ser breve, você precisa conhecer vários pontos:

1. import a ação realmente executa tudo o que pode ser executado em "a"

2. Por causa do ponto 1, você pode não querer que tudo seja executado em "a" ao importá-lo

3. Para resolver o problema no ponto 2, python permite que você faça uma verificação de condição

4. __name__é uma variável implícita em todos os .pymódulos; Quando a.pyé importado, o valor de __name__do a.pymódulo é definido como seu nome de arquivo " a"; quando a.pyé executado diretamente usando " python a.py", o que significa que a.pyé o ponto de entrada, o valor __name__do a.pymódulo é definido como uma sequência__main__

5. Com base no mecanismo de como o python define a variável __name__para cada módulo, você sabe como alcançar o ponto 3? A resposta é bastante fácil, certo? Coloque um se condição: if __name__ == "__main__": ...; você pode até colocar se, __name__ == "a"dependendo da sua necessidade funcional

O importante no qual o python é especial é o ponto 4! O resto é apenas lógica básica.

Considerar:

print __name__

A saída para o acima é __main__.

if __name__ == "__main__":
  print "direct method"

A declaração acima é verdadeira e imprime "método direto" . Suponha que se eles importaram essa classe em outra classe, ela não imprime "método direto" porque, durante a importação, ela será configurada __name__ equal to "first model name".

Você pode tornar o arquivo utilizável como um script e também como um módulo importável .

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

A razão para

if __name__ == "__main__":
    main()

é principalmente para evitar os problemas de bloqueio de importação que surgiriam da importação direta de código . Você deseja main()executar se o seu arquivo foi chamado diretamente (esse é o __name__ == "__main__"caso), mas se o seu código foi importado, o importador deve inserir o código no módulo principal verdadeiro para evitar problemas de bloqueio de importação.

Um efeito colateral é que você assina automaticamente em uma metodologia que suporta vários pontos de entrada. Você pode executar seu programa usando main()como ponto de entrada, mas não precisa . Enquanto setup.pyespera main(), outras ferramentas usam pontos de entrada alternativos. Por exemplo, para executar seu arquivo como um gunicornprocesso, você define uma app()função em vez de a main(). Assim como setup.py, gunicornimporta o código para que você não queira fazer nada enquanto estiver sendo importado (devido ao problema do bloqueio de importação).

Esta resposta é para programadores Java aprendendo Python. Todo arquivo Java normalmente contém uma classe pública. Você pode usar essa classe de duas maneiras:

1. Chame a turma de outros arquivos. Você apenas precisa importá-lo no programa de chamada.

2. Execute a classe independente, para fins de teste.

Para o último caso, a classe deve conter um método público static void main (). No Python, esse objetivo é atendido pelo rótulo definido globalmente '__main__'.

O código abaixo if __name__ == '__main__': somente será executado se o módulo for chamado como um script .

Como exemplo, considere o seguinte módulo my_test_module.py:

# my_test_module.py

print('This is going to be printed out, no matter what')

if __name__ == '__main__':
    print('This is going to be printed out, only if user invokes the module as a script')

1ª possibilidade: importar my_test_module.pyem outro módulo

# main.py

import my_test_module

if __name__ == '__main__':
    print('Hello from main.py')

Agora, se você chamar main.py:

python main.py 

>> 'This is going to be printed out, no matter what'
>> 'Hello from main.py'

Observe que apenas a print()instrução de nível superior my_test_moduleé executada.

Segunda possibilidade: invocar my_test_module.pycomo script

Agora, se você executar my_test_module.pycomo um script Python, as duas print()instruções serão executadas:

python my_test_module.py

>>> 'This is going to be printed out, no matter what'
>>> 'This is going to be printed out, only if user invokes the module as a script'

Cada módulo em python tem um atributo chamado __name__. O valor do __name__ atributo é __main__ quando o módulo é executado diretamente, como python my_module.py. Caso contrário (como quando você diz import my_module), o valor de __name__ é o nome do módulo.

Pequeno exemplo para explicar em resumo.

#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 isso diretamente como

python test.py  

Resultado

Value of __name__ is: __main__
Going to call hello_world
I am inside hello_world

Agora, suponha que chamamos o script acima de outro script

#script external_calling.py

import test
print(test.apple)
test.hello_world()

print(test.__name__)

Quando você executa isso

python external_calling.py

Resultado

42
I am inside hello_world
test

Portanto, acima é auto-explicativo que quando você chama test de outro script, se o loop __name__in test.pynão for executado.

Se esse arquivo .py for importado por outros arquivos .py, o código em "a instrução if" não será executado.

Se esse arquivo .py for executado python this_py.pyno shell, clique duas vezes no Windows. o código em "a instrução if" será executado.

Geralmente é escrito para teste.

Se o intérprete python estiver executando um módulo específico, __name__a variável global terá valor"__main__"

  def a():
      print("a")
  def b():
      print("b")

  if __name__ == "__main__": 

          print ("you can see me" )
          a()
  else: 

          print ("You can't see me")
          b()

Quando você executa esse script, pode me ver

uma

Se você importar esse arquivo, diga A para o arquivo B e execute o arquivo B, if __name__ == "__main__"em seguida , o arquivo A se tornará falso, para que seja impresso Você não pode me ver

b

Todas as respostas explicaram bastante a funcionalidade. Mas vou fornecer um exemplo de seu uso que pode ajudar a esclarecer ainda mais o conceito.

Suponha que você tenha dois arquivos Python, a.py e b.py. Agora, o a.py importa o b.py. Executamos o arquivo a.py, onde o código "import b.py" é executado primeiro. Antes da execução do restante do código a.py, o código no arquivo b.py deve ser executado completamente.

No código b.py, há algum código exclusivo para esse arquivo b.py e não queremos outro arquivo (que não seja o arquivo b.py) que tenha importado o arquivo b.py para executá-lo.

Então é isso que essa linha de código verifica. Se for o arquivo principal (ou seja, b.py) executando o código, que neste caso não é (a.py é o arquivo principal em execução), somente o código será executado.

Crie um arquivo, a.py :

print(__name__) # It will print out __main__

__name__é sempre igual __main__sempre que esse arquivo é executado diretamente mostrando que esse é o arquivo principal.

Crie outro arquivo, b.py , no mesmo diretório:

import a  # Prints a

Executá-lo. Irá imprimir um , ou seja, o nome do arquivo que é importado .

Portanto, para mostrar dois comportamentos diferentes do mesmo arquivo , este é um truque comumente usado:

# Code to be run when imported into another python file

if __name__ == '__main__':
    # Code to be run only when run directly

se nome == ' principal ':

Vemos se com __name__ == '__main__':bastante frequência.

Ele verifica se um módulo está sendo importado ou não.

Em outras palavras, o código dentro do ifbloco será executado apenas quando o código for executado diretamente. Aqui directlysignificanot 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 executarmos o código diretamente via python test.py, o nome do módulo será __main__:

call test()
test module name=__main__

Simplesmente, é o ponto de entrada para executar o arquivo, como a mainfunção na linguagem de programação C.