Pourquoi utiliser def main()?

Question

J'ai vu certains exemples de code et tutoriels qui utilisent

def main():
    # mon code ici

if __name__ == "__main__":
    main()

Mais pourquoi? Y a-t-il une raison de ne pas définir vos fonctions en haut du fichier, puis simplement écrire du code en dessous? c'est-à-dire

def my_function()
    # mon code ici

def my_function_two()
    # mon code ici

# un peu de code
# appeler la fonction
# imprimer(quelque chose)

Je me demande juste s'il y a une raison à tout cela?

Answer 1

Sans le principal point de repère, le code serait exécuté même si le script était importé en tant que module.

Answer 2

Tout le monde a déjà répondu, mais je pense quand même avoir quelque chose à ajouter.

Raisons d'avoir cette instruction if appelant main() (sans ordre particulier) :

• D'autres langages (comme le C et le Java) ont une fonction main() qui est appelée lorsque le programme est exécuté. En utilisant cet 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é. (oui, je sais que c'est subjectif)

• Il sera possible d'importer ce code Python en tant que module sans effets secondaires désagréables.

• Cela signifie qu'il sera possible de faire des tests sur ce code.

• Cela signifie que nous pouvons importer ce code dans une console interactive Python et le tester/déboguer/exécuter.

• Les variables à l'intérieur de def main sont locales, tandis que celles à l'extérieur sont globales. Cela peut introduire quelques bugs et comportements inattendus.

Mais, vous n'êtes pas obligé d'écrire une fonction main() et de l'appeler à l'intérieur d'une instruction if.

Personnellement, je commence généralement par écrire de petits scripts temporaires sans aucune fonction. Si le script devient assez gros, ou si je sens que mettre tout ce code dans une fonction me sera profitable, alors je le refactorise et je le fais. Cela arrive aussi lorsque j'écris des scripts bash.

Même si vous mettez du code à l'intérieur de la fonction main, vous n'êtes pas obligé de l'écrire exactement comme ça. Une variation intéressante pourrait être :

import sys

def main(argv):
    # Mon code ici
    pass

if __name__ == "__main__":
    main(sys.argv)

Cela signifie que vous pouvez appeler main() depuis d'autres scripts (ou une console interactive) en passant des paramètres personnalisés. Cela peut être utile dans des tests unitaires, ou lors du traitement par lot. Mais rappelez-vous que le code ci-dessus nécessitera l'analyse de argv, donc il serait peut-être préférable d'utiliser un autre appel qui passe déjà des paramètres analysés.

Dans une application orientée objet que j'ai écrite, le code ressemblait à ceci :

class MaClasseQuelconque(quelquechose):
    # Mon code ici

if __name__ == "__main__":
    app = MaClasseQuelconque()
    app.run()

Alors, n'hésitez pas à écrire le code qui vous convient le mieux. :)

Answer 3

Si le contenu de foo.py

imprimer __name__
if __name__ == '__main__':
    imprimer 'XXXX'

Un fichier foo.py peut être utilisé de deux façons.

• importé dans un autre fichier : import foo

Dans ce cas, __name__ est foo, la section de code n'est pas exécutée et ne imprime pas XXXX.

• exécuté directement : python foo.py

Lorsqu'il est exécuté directement, __name__ est le même que __main__ et le code dans cette section est exécuté et imprime XXXX

Une des utilisations de cette fonctionnalité est d'écrire différents types de tests unitaires dans le même module.

Answer 4

"Que fait if __name__==“__main__”: ?" a déjà été répondu.

Avoir une main() fonction vous permet d'appeler sa fonctionnalité si vous importez le module. Le principal (sans jeu de mots) avantage de cela (à mon avis) est que vous pouvez le tester unitairement.

Answer 5

Considérez le deuxième script. Si vous l'importez dans un autre, les instructions, comme au "niveau global", seront exécutées.