Duplicate possible:
Qu'est-ce queif __name__== "__main__"
fait?
J'ai vu des exemples de code et des tutoriels utilisant
def main():
# my code here
if __== "__main__":
main()
Mais pourquoi? Y at-il une raison pour ne pas définir vos fonctions en haut du fichier, alors il suffit d’écrire du code en dessous? c'est à dire
def my_function()
# my code here
def my_function_two()
# my code here
# some code
# call function
# print(something)
Je me demande juste s'il y a une rime à la main?
Sans la sentinelle principale, le code serait exécuté même si le script était importé en tant que module.
Tout le monde a déjà répondu, mais je pense avoir encore quelque chose à ajouter.
Raisons d'avoir cette instruction if
appelant main()
(sans ordre particulier):
D'autres langages (comme C et Java) ont une fonction main()
qui est appelée lors de l'exécution du programme. En utilisant cette if
, nous pouvons faire en sorte que Python se comporte comme eux, ce qui est plus familier pour beaucoup de gens.
Le code sera plus propre , plus facile à lire et mieux organisé. (ouais, je sais que c'est subjectif)
Il sera possible de import
que python coder en tant que module sans effets secondaires désagréables.
Cela signifie qu'il sera possible d'exécuter des tests avec ce code.
Cela signifie que nous pouvons importer ce code dans un shell interactif python et le tester/déboguer/l'exécuter.
Les variables à l'intérieur de def main
sont local, alors que celles à l'extérieur sont global. Cela peut introduire quelques bugs et comportements inattendus.
Mais vous êtes non requis pour écrire une fonction main()
et l'appeler dans une instruction if
.
Moi-même, je commence habituellement à écrire de petits scripts sans aucune fonction. Si le script devient suffisamment volumineux ou si je sens que l'insertion de tout ce code dans une fonction me sera bénéfique, je refactifie le code et le fais. Cela se produit également lorsque j'écris des scripts bash
.
Même si vous insérez du code dans la fonction principale, vous n'êtes pas obligé de l'écrire exactement comme cela. Une variante intéressante pourrait être:
import sys
def main(argv):
# My code here
pass
if __== "__main__":
main(sys.argv)
Cela signifie que vous pouvez appeler main()
à partir d'autres scripts (ou d'un shell interactif) en transmettant des paramètres personnalisés. Cela peut être utile dans les tests unitaires ou lors du traitement par lots. Mais rappelez-vous que le code ci-dessus nécessitera l’analyse d’argv, il serait donc peut-être préférable d’utiliser un autre appel qui transmet les paramètres déjà analysés.
Dans une application orientée objet que j'ai écrite, le code ressemblait à ceci:
class MyApplication(something):
# My code here
if __== "__main__":
app = MyApplication()
app.run()
Alors, n'hésitez pas à écrire le code qui vous convient le mieux. :)
si le contenu de foo.py
print __name__
if __== '__main__':
print 'XXXX'
n fichier foo.py peut être utilisé de deux manières.
- importé dans un autre fichier:
import foo
Dans ce cas, __name__
est foo
, la section de code n'est pas exécutée et n'imprime pas XXXX
.
- exécuté directement:
python foo.py
Lorsqu'il est exécuté directement, __name__
est identique à __main__
et le code de cette section est exécuté et affiche XXXX
L'une des utilisations de cette fonctionnalité est d'écrire différents types de tests unitaires dans le même module.
" Qu'est-ce que if __name__==“__main__”:
fait? " a déjà été répondu.
Avoir une fonction main()
vous permet d’appeler sa fonctionnalité si vous import
le module. Le principal avantage (sans jeu de mots) de cela (IMHO) est que vous pouvez le tester à l'unité.
Considérons le deuxième script. Si vous l'importez dans un autre, les instructions, au "niveau global", seront exécutées.