Quando o seu programa é executado passando - o como um comando para o interpretador de Python,

python myscript.py

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

Neste caso, o código de topo é um bloco if. __name__ é um variável incorporada que avalia o nome do módulo actual. No entanto, se um módulo está sendo executado diretamente (como em myscript.py acima), então __name__ Em vez disso é definido para o texto "__main__". Assim, você pode testar se seu script está sendo executado diretamente ou sendo importado por outra coisa testando

if __name__ == "__main__":
    ...

Se o seu programa estiver a ser importado para outro módulo, as suas várias definições de função e classe serão importadas e o seu código de topo será executado, mas o código no então corpo da Cláusula if acima não será executada, uma vez que a condição não é cumprida. Como exemplo básico, considere os seguintes dois scripts:

# 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 invocar o intérprete como

python one.py

A saída será

top-level in one.py
one.py is being run directly

Se correr two.py em vez disso:

python two.py

Tu tens

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, o seu __name__ é igual a "one" em vez de "__main__".

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

Crie os seguintes ficheiros.

# a.py
import b

E

# b.py
print "Hello World from %s!" % __name__

if __name__ == '__main__':
    print "Hello World again from %s!" % __name__

Executá-los vai dar - te esta saída:

$ python a.py
Hello World from b!

Como pode ver, quando um módulo é importado, o Python configura globals()['__name__'] neste módulo para o nome do módulo.

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

Como pode ver, quando um ficheiro é executado, o Python configura globals()['__name__'] neste ficheiro para "__main__".

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

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

• Então, o código sob o bloco if só será executado 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.

---

Porque precisamos disto?

Desenvolver e testar o seu Código

Diz que estás a escrever um programa em Python desenhado para ser usado como módulo:

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

Você poderia testar o módulo adicionando esta chamada da função ao fundo:

do_important()

E executá-lo (num prompt de comando) com algo como:

~$ python important.py

O Problema

No entanto, se quiser importar o módulo para outro script:

import important

Na importação, a função do_important seria chamada, então você provavelmente comentaria a sua chamada de função, do_important(), No fundo.

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

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

Uma Maneira Melhor

A variável __name__ aponta para o espaço de nomes onde quer que o interpretador Python aconteça para estar neste momento.

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

Mas dentro do módulo primário (ou de uma sessão Interactiva em Python, isto é, a leitura, a avaliação, O Ciclo de impressão ou a REPL do interpretador) você está a correr tudo a partir do seu "__main__".

Por isso, se verificar antes de executar:

if __name__ == "__main__":
    do_important()

Com o acima, o seu código só será executado quando estiver a executá-lo como módulo primário (ou intencionalmente chamá-lo a partir de outro programa).

Um Par Melhor Maneira Mas há uma forma Pitónica de melhorar isto. E se quisermos executar este processo fora do módulo?

Se colocarmos o código que queremos exercer à medida que nos desenvolvemos e testamos numa função como esta e depois fazemos a nossa verificação para '__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 fim do nosso módulo que irá correr se executarmos o módulo como o módulo primário.

Ele vai permitir o módulo e o seu funções e classes a importar para outros programas sem executar a função main, e também permitirá que o módulo (e as suas funções e classes) seja chamado quando estiver a correr a partir de um módulo diferente '__main__', ou seja

import important
important.main()

Este idioma também pode ser encontrado na documentação Python em uma explicação do módulo __main__. esse texto diz:

Este módulo representa o âmbito (de outro modo anónimo) em que o o programa principal do interpretador executa - comandos ler de qualquer entrada padrão, a partir de um arquivo de script, ou de um prompt interativo. Ele é este ambiente em que a estrofe idiomática" condicional script" faz com que um programa corra:

if __name__ == '__main__':
    main()

if __name__ == "__main__" é a parte que corre quando o programa é executado a partir da (digamos) linha de comandos usando um comando como python myscript.py.

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

__name__ é uma variável global (em Python, global realmente significa no nível do módulo) que existe em todos os espaços de nomes. É tipicamente o nome do módulo (como um tipo str).

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

python mycode.py

Ao espaço de nomes global anónimo é atribuído o valor de '__main__' ao seu __name__.

Assim, incluindo o final linhas

if __name__ == '__main__':
    main()

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

Fará com que a função main do seu programa seja definida de forma única.

Outra vantagem de usar esta construção: também pode importar o seu código como um módulo noutro programa e executar a função principal se e quando o seu programa decidir:

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

[34]há muitas tomadas diferentes aqui sobre a mecânica do código em questão, o "como", mas para mim nada disso fazia sentido até que eu entendesse o"porquê". Isto deve ser especialmente útil para novos programadores. Toma o ficheiro .ab.py":

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

E um segundo ficheiro .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 é que este código está realmente a fazer?

Quando executares xy.py, tu import ab. A declaração de importação executa o módulo imediatamente na importação, por isso ab ' s as operações são executadas antes do restante de xy ' s. Uma vez terminado com ab, continua com xy.

O interpretador controla quais os programas que estão a correr com __name__. Quando você executa um script - não importa o nome que você lhe deu-o interpretador o chama "__main__", tornando-o o script principal ou 'home' que é devolvido depois de executar um script externo.

Qualquer outro script chamado a partir deste script "__main__" é atribuído seu nome de arquivo como seu __name__ (por exemplo, __name__ == "ab.py"). Assim, a linha if __name__ == "__main__": é o teste do interpretador para determinar se está interpretando/processando o script 'home' que foi inicialmente executado, ou se está temporariamente espreitando para outro script (externo). Isso dá ao programador flexibilidade para que o script se comporte de forma diferente se for executado diretamente contra chamado externamente.

Vamos passar pelo código acima para entender o que está acontecendo, concentrando-nos primeiro nas linhas não identificadas e na ordem que aparecem nos scripts. Lembrar essa função ou blocos não fazem nada sozinhos até serem chamados. O que o intérprete diria se murmurasse:

• abrir xy.py como o ficheiro' home'; chame-o "__main__" na variável __name__.
• importar e abrir um ficheiro com o __name__ == "ab.py".
Uma função. Vou lembrar-me disso.
• OK, função a(); acabei de aprender isso. A imprimir ' uma função no ficheiro ab '.
• fim do ficheiro; de volta a "__main__"!
Uma função. Vou lembrar-me disso. Mais um.
• função x(); OK, imprimir ' tarefa periférica: pode ser útil noutros projectos '.
O que é isto? Uma declaração. Bem, a condição foi cumprida (a variável __name__ foi definida para "__main__"), por isso vou introduzir a função main() e imprimir 'a função principal: é aqui que a acção é'.

As duas últimas linhas significam: "se este é o "__main__" ou 'home' script, execute a função chamada main()". É por isso que você vai ver um def main(): bloco acima, que contém o fluxo principal da funcionalidade do script.

Porquê implementar isto?

Lembras-te do que eu disse sobre declarações de importação? Quando você importa um módulo, ele não apenas "reconhece" ele e espera por mais instruções - ele realmente executa todas as operações executáveis contidas no script. Então, colocar a carne do seu script na função main() efetivamente coloca-a em quarentena, colocando-a isolado para que não funcione imediatamente quando importado por outro script. Mais uma vez, haverá exceções, mas a prática comum é que main() normalmente não é chamado externamente. Então você pode estar se perguntando mais uma coisa: se nós não estamos chamando main(), por que estamos chamando o roteiro em tudo? É porque muitas pessoas estruturam seus scripts com funções autônomas que são construídas para serem executadas independentemente do resto do código no arquivo. Mais tarde, são chamados para outro lugar. o corpo do guião. O que me leva a isto:

Mas o código funciona sem ele.

Sim, isso mesmo. Estas funções separadas podem ser chamadas de um script in-line que não está contido dentro de uma função main(). Se você está acostumado (como eu estou, em meus estágios iniciais de aprendizagem de programação) a construir scripts in-line que fazem exatamente o que você precisa, e você vai tentar descobrir novamente se você precisar dessa operação novamente ... bem, não estás habituado. para este tipo de estrutura interna ao seu código, porque é mais complicado de construir e não é tão intuitivo de ler.

Mas esse é um script que provavelmente não pode ter suas funções chamadas externamente, porque se ele fizesse isso iria imediatamente começar a calcular e atribuir variáveis. E as chances são de que se você está tentando reutilizar uma função, seu novo script está relacionado o suficiente com o antigo que haverá variáveis conflitantes.

Ao separarem-se independentes funções, você ganha a capacidade de reutilizar o seu trabalho anterior, chamando-os para outro script. Por exemplo, "example.py" importa "xy.py" e chamar x(), fazendo uso de um 'x' função de "xy.py". (Talvez aproveitando a terceira palavra de uma seqüência de caracteres de texto; criação de um NumPy matriz a partir 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 pergunta contém uma resposta de @kindall que finalmente ajudou - me a entender o porquê, não o como. Infelizmente foi marcado como um duplicado de este, o que eu acho que é um erro.)

Quando existem certas declarações no nosso módulo ({[[0]}) Queremos ser executados quando estiver a correr como principal (não importado), podemos colocar essas declarações (casos de teste, declarações de impressão) sob este bloco if.

Como por Omissão (Quando o módulo estiver a correr como principal, não importado) a variável __name__ está definida em "__main__", e quando for importada a variável __name__ irá obter um valor diferente, provavelmente o nome do Módulo ('M'). Isto é útil na execução de diferentes variantes de um módulos juntos, e separando suas declarações específicas de entrada e saída e também se houver algum teste-casos.

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

Vejamos a resposta de uma forma mais abstracta: Suponha que temos este código em x.py:

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

Os blocos A E B são executados quando estamos a correr. "x.py".

, Mas apenas bloquear Um (e não B) é executado quando estamos executando outro módulo, "y.py", por exemplo, em que x.y é importado e o código é executado a partir de lá (como quando uma função de x.py" é chamado de y.py).

Quando executar o Python interactivamente, à variável local __name__ é atribuído um valor de __main__. Da mesma forma, quando executa um módulo Python a partir da linha de comandos, em vez de o Importar para outro módulo, ao 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 estão a ser usados, quer como suporte para outro programa ou como a aplicação principal executada a partir do comando. Assim, o seguinte idioma é 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.

Simplificando, __name__ é uma variável definida para cada programa que define se o programa está a ser executado como o módulo principal ou se está a ser 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__)

O resultado da execução do script1 é

Script 1's name: __main__

E o resultado da execução do script2 é:

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

Como pode ver, __name__ diz-nos qual é o código do módulo 'main'. Isso é ótimo, porque você pode apenas escrever código e não tem que preocupar-se com questões estruturais como em C/C++, onde, se um arquivo não implementa uma função 'principal', então ele não pode ser compilado como um executável e se o fizer, ele não pode então ser usado como uma biblioteca.

Digamos que você escreve um script em Python que faz algo grande e você implementa uma carga de funções que são úteis para outros fins. Se eu quiser usá-los, posso apenas importar o seu script e usá-los sem executar o seu programa (dado que o seu código só executa dentro do if __name__ == "__main__": contexto). Considerando que em C/C++ Você teria que dividir essas peças em um módulo separado que, em seguida, inclui o arquivo. Imagine a situação abaixo;

As setas são ligações 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 torna difícil incluir outro código em um projeto C a menos que seja compilado especificamente como uma biblioteca. Agora imagine para Python:

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

Considere:

if __name__ == "__main__":
    main()

Verifica se o atributo __name__ do programa em Python é "__main__". Em outras palavras, se o programa em si for executado, o atributo será __main__, então o programa será executado (neste caso a função main()).

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

Antes de explicar qualquer coisa sobre if __name__ == '__main__' é importante entender o que __name__ é e o que ele faz.

O que é isso?

__name__ is a Dunderálias - can be thought of as a global variable (accessible from modules) and works in a similar way to global.

É uma cadeia (global como mencionado acima) como indicado por type(__name__) (rendendo <class 'str'>), e é um padrão inbuilt para ambos Python Versões 3 e Python 2.

Em que:

Não só pode ser usado em scripts, mas também pode ser encontrado no interpretador e módulos/pacotes.

Interpretador:

>>> print(__name__)
__main__
>>>

Programa:

test_file.py:

print(__name__)

Resultando em __main__

Módulo ou dimensão da:

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__ toma o nome do arquivo. O caminho do módulo real ou caminho do pacote não é dado, mas tem suas próprias Dunderálias __file__, que permite isso.

Você deve ver que, onde {[[8]}, onde é o arquivo principal (ou programa) vai Sempre retornar __main__, e se é um module / package, ou qualquer coisa que esteja a correr de algum outro script Python, irá devolver o nome do ficheiro de onde se originou.

Prática:

Ser uma variável significa que o seu valor pode ser substituído ("pode "não significa" deve"), sobrepor o valor de __name__ resultará numa falta de legibilidade. Por isso, não o faças, por nenhuma razão. Se precisar de uma variável, defina uma nova variável.

Presume-se sempre que o valor de __name__ a ser __main__ ou o nome do ficheiro. Mais uma vez, mudar este valor padrão vai causar mais confusão que ele vai fazer o bem, causando problemas mais ao longo da linha.

exemplo:

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

Considera-se boa prática em geral incluir o if __name__ == '__main__' em scripts.

Agora a Resposta if __name__ == '__main__':

agora sabemos o comportamento de __name__ as coisas tornam-se mais claras.:

if é um a declaração de controle de fluxo que contém o bloco de código será executada se o valor dado for verdadeiro. Nós vimos que {[8] } pode tomar qualquer um __main__ ou o nome do ficheiro de onde foi importado.

Isto significa que se __name__ for igual a __main__ Então o ficheiro deve ser o ficheiro principal e deve estar a correr (ou é o interpretador), não um módulo ou pacote importado para o programa.

Se realmente {[8] } tomar o valor de {[14] } Então o que está nesse bloco de código irá executar.

Isto diz-nos que se o ficheiro em execução é o ficheiro principal (ou se está a correr directamente do interpretador) então essa condição deve ser executada. Se for um pacote, então 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 com Alguns vou mostrar aqui:

Executar apenas se o ficheiro for um módulo ou pacote:

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

Executando uma condição se o arquivo é 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.

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

Há uma série de variáveis que o sistema (interpretador Python) fornece para arquivos de código (módulos). Você pode obter os seus valores sempre que quiser, por isso, vamos concentrar-nos na__Nome__ variável / atributo:

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

Antes do interpretador executar o ficheiro de código fonte, ele define algumas variáveis especiais para esse ficheiro; _ _ Nome_ _ é uma das variáveis especiais que o Python define automaticamente para cada ficheiro de código-fonte.

Se o Python estiver a carregar este ficheiro de código-fonte como o programa principal( ou seja, o ficheiro que executa), então ele define a variável especial __Nome__ para que este ficheiro tenha um valor "__main__"{5]}.

Se isto estiver a ser importado de outro Módulo, _ _ Nome_ _ será definido como o nome desse módulo.

Então, em o 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 apenas quando você executar o módulo diretamente; o bloco de código não será executado se outro módulo é chamado/a importação é devido o valor de __nome__ não será igual a "main" em que determinada instância.

Espero que isto ajude.

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

__name__: cada módulo em Python tem um atributo especial chamado __name__. É uma variável incorporada 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, principal. '__main__' é o nome do âmbito no qual o código de topo executa. Basicamente, você tem duas maneiras de usar um módulo Python: executá-lo diretamente como um script, ou importa-o. Quando um módulo é executado como um script, o seu __name__ é definido como __main__.

Assim, o valor do atributo __name__ é 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 ficheiro Python é chamado a partir da linha de comandos. Isto é tipicamente usado para chamar uma função "main ()" ou executar outro código de inicialização apropriado, como o tratamento de argumentos da linha de comandos, por exemplo.

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

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

Não estou a dizer que devas usar isto em código de produção, mas serve para ilustrar que não há nada de "mágico" em if __name__ == '__main__'. É uma boa convenção para invocar uma função principal em Python arquivo.

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

'__main__' é o nome do escopo no qual o código de alto nível executa. Um módulo __name__ é igual a '__main__' quando lido a partir de uma entrada padrão, de um programa ou de uma linha de comandos interactiva.

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

A razão para

if __name__ == "__main__":
    main()

É principalmente para evitar os problemas de bloqueio de importação que resultariam de ter o código directamente importado. Você quer que main() corra se o seu ficheiro foi invocado directamente (este é o caso __name__ == "__main__"), mas se o seu código foi importado, então o importador terá de introduzir o seu código no módulo principal verdadeiro para evitar problemas de bloqueio de importação.

Um efeito secundário é que você assina automaticamente para uma metodologia que suporta vários pontos de entrada. Você pode executar o seu programa usando main() como ponto de entrada, mas você não tem que. Enquanto setup.py espera main(), Outras ferramentas usam pontos de entrada alternativos. Por exemplo, para executar o seu ficheiro como um processo gunicorn, Você define uma função app() em vez de uma main(). Assim como com setup.py, gunicorn importa seu código para que você não queira que ele faça nada enquanto ele está sendo importado (por causa do problema de bloqueio de importação).

Você pode tornar o ficheiro utilizável como um programa assim 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

Considere:

print __name__

A saída para o acima é __main__.

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

A declaração acima é verdadeira e imprime "método directo" . Suponha que se eles importaram esta classe em outra classe ela não imprime "método direto" porque, ao importar, ele irá definir __name__ equal to "firstmodel name".

Tenho lido tanto nas respostas desta página. Eu diria, se você sabe a coisa, com certeza você vai entender essas respostas, caso contrário, você ainda está confuso.

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

1. import a a acçã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-lhe fazer uma verificação das condições

4. __name__ é uma variável implícita em todos .py módulos; quando uma.py é importado, o valor de __name__ de um.py módulo é definido para o arquivo de nome "a"; quando uma.py é executado diretamente usando "python um.py", o que significa que um.py é o ponto de entrada, o valor de __name__ de um.py módulo é definido como uma seqüência de caracteres __main__

5. Com base no mecanismo como o python define a variável __name__ para cada módulo, sabe como atingir o ponto 3? A resposta é justa. fácil, não é? Coloque uma condição if: if __name__ == "__main__": ...; pode mesmo colocar se __name__ == "a" dependendo da sua necessidade funcional

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

Criar um ficheiro, a.py:

print(__name__) # It will print out __main__

__name__ é sempre igual a __main__ sempre que esse ficheiro é executar directamente mostrando que este é o ficheiro principal.

Cria outro ficheiro, b.py , no mesmo directório:

import a  # Prints a

Investiga. Irá imprimir a , ou seja, o nome do ficheiro que é importado.

Então, para mostrar dois comportamentos diferentes do mesmo ficheiro , 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

Todas as respostas explicaram a funcionalidade. Mas vou dar um exemplo do seu uso que pode ajudar a limpar o conceito ainda mais.

Assume que tens dois ficheiros Python, a.py e b.py agora, a.py importações b.py nós gerimos o a.py ficheiro, onde a "importação b.py" o código é executado primeiro. Antes do resto do a.py o código corre, o código no ficheiro b.py deve funcionar completamente.

Na b.py código existe algum código que é exclusivo para esse arquivo b.py e nós não queremos nenhum outro arquivo (a não ser b.py ficheiro), que importou a b.py file, para executá-lo.

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

Se este ficheiro. py for importado por outros ficheiros. py, o código em "a instrução if" não será executado.

Se este. py for executado por python this_py.py sob a shell, ou clicado duas vezes nas janelas. o código sob "a instrução if" será executado.

É geralmente escrito para testes.

Se nome == 'principal':

Vemos se __name__ == '__main__': muitas vezes.

Verifica se um módulo está a ser importado ou não.

Por outras palavras, o código dentro do bloco if só será executado quando o código correr directamente. Aqui directly significa not imported.

Vamos ver o que 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 directamente por python test.py, o nome do módulo é __main__:

call test()
test module name=__main__

Esta resposta é para programadores Java que aprendem Python. Cada ficheiro Java contém normalmente uma classe pública. Você pode usar essa classe de duas maneiras:

(1) Ligue para a classe A partir de outros arquivos. Só tens de o Importar no programa de chamadas.

(2) Executar o stand da classe sozinho, para fins de teste.

Para o último caso, a classe deve conter um método principal() de vazio estático público. Em Python este propósito é servido pela etiqueta definida globalmente '__main__'.

Recentemente, deparei-me com isso ao criar uma classe em python (deep learning) e, tanto quanto sei e de acordo com as explicações acima listadas, vou elaborar {[[2]}

Nome=="principal"

Como às vezes nós construímos uma classe em um arquivo .py, e define um monte de funções dentro dessa classe. mas não queremos processar todas essas funções de classe para um único propósito. por exemplo, para criar uma classe e definir algumas funções para os dados criacao (.ficheiros npy) enquanto alguns para o carregamento de dados. então, se definirmos

Nome=="principal"

Xxx=class_name ()

Xxx.create_data ()

Significa que se chamarmos o ficheiro .py, então ele só irá criar dados e não irá processar outras funções de classe. outras funções de classe (carregamento de dados) também podem ser importadas por outras classes.

_ nome _ == _ principal _ vai certifique-se de que o código/instruções presentes no interior este bloco será executado apenas quando executamos este arquivo diretamente, em vez disso, se nós importar este como o módulo em outra python arquivo, em seguida, podemos chamar a função definida em e, também, o bloco que é presente no interior do _ nome == principal _ não será executada.

Qual é o nome do if == " do?

Resumo:

1, como um script executável, trabalhar para si próprio como trabalhador independente: Ele executa os códigos no módulo se for executado diretamente como "python foo.py"
2, como um módulo importado para trabalhar para outros:
Os seus códigos podem ser reutilizados com segurança se forem importados para outro módulo como"import foo"