Compreender o método principal do python [duplicado]
- O que faz se ___ nome_ _ = "__ main__": fazer? 27 Respostas
def main():
# display some lines
if __name__ == "__main__": main()
Como é executado o main e por que preciso deste estranho {[[2]} para executar main. O meu código é terminado sem saída quando eu remover o if.
o código mínimo -
class AnimalActions:
def quack(self): return self.strings['quack']
def bark(self): return self.strings['bark']
class Duck(AnimalActions):
strings = dict(
quack = "Quaaaaak!",
bark = "The duck cannot bark.",
)
class Dog(AnimalActions):
strings = dict(
quack = "The dog cannot quack.",
bark = "Arf!",
)
def in_the_doghouse(dog):
print(dog.bark())
def in_the_forest(duck):
print(duck.quack())
def main():
donald = Duck()
fido = Dog()
print("- In the forest:")
for o in ( donald, fido ):
in_the_forest(o)
print("- In the doghouse:")
for o in ( donald, fido ):
in_the_doghouse(o)
if __name__ == "__main__": main()
4 answers
A abordagem Python de "main" é quase única para a linguagem(*).
A semântica é um pouco subtil. O identificador__name__ Está ligado ao nome de qualquer módulo à medida que é importado. No entanto, quando um ficheiro está a ser executado então __name__ está definido em "__main__" (a cadeia literal: __main__).
Isto é quase sempre usado para separar a parte do código que deve ser executada das partes do código que definem a funcionalidade. Então o código Python muitas vezes contém uma linha tipo:
#!/usr/bin/env python
from __future__ import print_function
import this, that, other, stuff
class SomeObject(object):
pass
def some_function(*args,**kwargs):
pass
if __name__ == '__main__':
print("This only executes when %s is executed rather than imported" % __file__)
Usando esta convenção pode-se ter um arquivo definir classes e funções para uso em outros programas, e também incluir código para avaliar apenas quando o arquivo é chamado como um script autônomo.
É importante compreender que todo o código acima da linha if __name__ está a ser executado, avaliado, em ambos os casos. É avaliado pelo interpretador quando o arquivo é importado ou quando é executado. Se colocar uma declaração print antes da linha if __name__, então ela irá imprimir saída cada vez que qualquer outro código tenta importar isso como um módulo. (É claro que isso seria anti-social [[27]]. Não faça isso).
Idealmente, quase todos os módulos Python podem fazer algo útil se forem chamados a partir da linha de comandos. Em muitos casos, isto é utilizado para a gestão de testes de unidade. Se um determinado ficheiro definir funcionalidade que só é útil no contexto de outros componentes de um sistema, então ainda se pode usar __name__ == "__main__" para isolar um bloco de código que chama um conjunto de testes de unidade que se aplicam a este módulo.
(Se você não vai ter nenhuma funcionalidade nem testes de unidade do que é melhor garantir que o modo de arquivo não é executável).
Resumo: if __name__ == '__main__': tem dois casos de uso primário:
- permitir que um módulo forneça funcionalidade para importação para outro código, mas também fornecendo semântica útil como um script autônomo (um invólucro de linha de comando em torno da funcionalidade)
- permitir que um módulo defina um conjunto de testes de unidade que são armazenados com (no mesmo ficheiro que) o código a ser testado e que podem ser executados independentemente do resto da base de código.
É bastante comum a def main(*args) e ter if __name__ == '__main__': basta chamar main(*sys.argv[1:]) Se você quiser definir main de uma maneira que é semelhante a algumas outras linguagens de programação. Se o seu ficheiro. py for primariamente destinado a ser usado como um módulo em outro código, então você pode def test_module() E chamando test_module() na sua suite if __name__ == '__main__:'.
- (A Ruby também implementa uma funcionalidade semelhante
if __file__ == $0).
Em Python, a execução não tem de começar no principal. A primeira linha de "código executável" é executado primeiro.
def main():
print("main code")
def meth1():
print("meth1")
meth1()
if __name__ == "__main__":main() ## with if
Resultado -
meth1
main code
Mais sobre o main() - http://ibiblio.org/g2swap/byteofpython/read/module-name.html
Um módulo__name__
Todos os módulos têm um nome e instruções num módulo podem descobrir o nome do seu módulo. Isto é especialmente útil em uma situação particular-como mencionado anteriormente, quando um o módulo é importado pela primeira vez, o bloco principal desse módulo é executado. E se quisermos executar o bloco somente se o programa foi usado por si mesmo e não quando foi importado de outro módulo? Isto pode ser conseguido usando o atributo name do módulo.
Usar o __nome de um módulo__
#!/usr/bin/python
# Filename: using_name.py
if __name__ == '__main__':
print 'This program is being run by itself'
else:
print 'I am being imported from another module'
Resultado -
$ python using_name.py
This program is being run by itself
$ python
>>> import using_name
I am being imported from another module
>>>
Como Funciona -
Cada módulo Python tem a sua definição __name__ e se for __main__, implica que o módulo está sendo executado autônomo pelo Usuário e podemos fazer as ações apropriadas correspondentes.
O Python não tem um ponto de entrada definido como Java, C, C++, etc. Em vez disso, ele simplesmente executa um arquivo de código Linha-A-linha. A instrução if permite-lhe criar uma função main que será executada se o seu ficheiro for carregado como o módulo "Main" em vez de como uma biblioteca noutro módulo.
Se importar o ficheiro module (.py) que está a criar agora a partir de outro programa python, ele irá NÃO executar o código dentro de
if __name__ == '__main__':
...
Se executar o script directamente a partir da consola, será executado.
O Python não usa nem necessita de uma função principal (). Qualquer código que não esteja protegido por essa guarda será executado após a execução ou importação do módulo.
Isto é expandido um pouco mais em python.berkely.edu