Que fait la construction if __name__ == "__main__" en Python ?

Dans certains langages de programmation, la méthode main sert de seul point d'entrée pour l'exécution d'un programme. Lors de la transition d'autres langages vers Python, l'idiome si __nom__ == "__main__" pourrait sembler accomplir la même tâche. En Python, ce n'est pas le cas.

Le si __nom__ == "__main__" idiom permet à un code spécifique de s'exécuter lorsque le fichier s'exécute en tant que script. Il s'assure également que le même code ne s'exécute pas lorsque vous importez le fichier en tant que module.

Comprendre le comportement de la variable __name__

Le __nom__ variable est intégrée à Python. Il représente le nom du module ou du script dans lequel il est utilisé. Lorsqu'un script s'exécute en tant que programme principal, sa valeur est définie sur __principal__. Si vous importez le script en tant que module, la valeur de la variable est définie sur le nom réel du module.

Cela peut être déroutant au début, mais jetez un œil à l'exemple suivant :

Créez un script et nommez-le salutations.py. Ce script contiendra une fonction qui salue un utilisateur et imprime la valeur du __nom__ variable. Il demandera également à l'utilisateur d'entrer son nom.

définitivementsaluer(nom):
 imprimer(f "Bonjour, {nom}!")
imprimer("Valeur de __nom__ :", __nom__)
si __nom__ == "__principal__":
 nom_utilisateur = entrée("S'il vous plaît entrez votre nom: ")
 saluer (nom_utilisateur)
autre:
 imprimer("Le module 'salutations' a été importé.")

Exécution de la salutations.py le script affichera la sortie suivante :

La valeur de la __nom__ rendements variables comme __principal__ car le script s'exécute directement.

Créez maintenant un autre script et nommez-le script2.py. Ensuite, importez le salutations script en tant que module.

importer salutations
imprimer("Exécution du script de salutations...")
salutations.saluer("Alice")

Appelant le saluer fonction de la salutation module donne la sortie suivante.

La valeur de la __nom__ la variable change pour le nom réel du module importé. Dans ce cas, salutations.

Cette valeur est ce que l'idiome si __nom__ == "__main__" recherche pour déterminer si un fichier s'exécute en tant que script ou est importé en tant que module.

Quand utiliser la construction if __name__ == "__main__"?

Vous pouvez ajouter le si __nom__ == "__main__" construire dans n'importe quel script. Mais il existe certains scénarios où son utilisation peut être la plus bénéfique. Vous découvrirez ces scénarios à l'aide du programme de calcul simple ci-dessous.

# calculateur.py
définitivementajouter(un B):
retour un + b
définitivementsoustraire(un B):
retour un B
définitivementmultiplier(un B):
retour un B
définitivementdiviser(un B):
si b != 0:
retour un B
autre:
retour"Erreur: Division par zéro !"
si __nom__ == "__principal__":
 imprimer(« Bienvenue dans la calculatrice! »)
 imprimer("Sélectionnez une opération :")
 imprimer("1. Ajouter")
 imprimer("2. Soustraire")
 imprimer("3. Multiplier")
 imprimer("4. Diviser")
 choix = int (entrée("Entrez votre choix (1-4):"))
 num1 = float (entrée("Entrez le premier numéro: "))
 num2 = float (entrée("Entrez le deuxième numéro: "))
si choix == 1:
 résultat = ajouter (num1, num2)
 imprimer(f"La somme de {num1} et {num2} est: {résultat}")
elif choix == 2:
 résultat = soustraire (num1, num2)
 imprimer(f"La différence entre {num1} et {num2} est: {résultat}")
elif choix == 3:
 résultat = multiplier (num1, num2)
 imprimer(f"Le produit de {num1} et {num2} est: {résultat}")
elif choix == 4:
 résultat = diviser (num1, num2)
 imprimer(f"La division de {num1} par {num2} est: {résultat}")
autre:
 imprimer("Choix invalide !")

Le premier scénario est lorsque vous souhaitez exécuter un script indépendamment et effectuer des actions spécifiques. Cela permet au script de fonctionner comme un programme autonome. Le si __nom__ == "__main__" construct permet aux utilisateurs d'interagir avec la calculatrice à l'aide de l'interface de ligne de commande. Cela donne aux utilisateurs la possibilité d'utiliser les fonctionnalités du programme sans avoir à comprendre ou à modifier le code sous-jacent.

Il est toujours possible d'exécuter le programme sans le si __nom__ == "__main__" construire et obtenir le même résultat, mais votre code perdrait l'organisation du code modulaire.

Le deuxième scénario est lorsque vous voulez que votre code pour avoir une conception modulaire. Cela permet à d'autres programmes d'importer votre script en tant que module et d'utiliser ses fonctions sans déclencher de fonctionnalités inutiles.

Dans le cas du programme de calculatrice, d'autres programmes peuvent importer les calculatrice module sans déclencher l'interface CLI et les invites d'entrée utilisateur. Cela garantit la réutilisation du code et la conception modulaire. Par conséquent, la calculatrice peut être intégrée de manière transparente dans des applications plus importantes.

importer calculatrice
# Utiliser les fonctions du module calculatrice
result_add = calculatrice.add(5, 3)
imprimer("Résultat de l'addition :", result_add)
result_subtract = calculatrice.subtract(10, 4)
imprimer("Résultat de la soustraction :", result_subtract)

Le troisième scénario est lorsque vous voulez tester et déboguer votre script Python indépendamment de tout autre module ou script qui pourrait l'importer. Dans l'exemple de la calculatrice, il est plus facile de se concentrer sur le test des fonctionnalités de la calculatrice sans interférence du code externe.

importer calculatrice
# Tester les fonctions de la calculatrice
si __nom__ == "__principal__":
# Tester l'addition
 result = calculatrice.add(5, 3)
 imprimer("Résultat supplémentaire :", résultat)
# Tester la soustraction
 result = calculatrice.soustraire(8, 4)
 imprimer("Résultat de la soustraction :", résultat)
# Tester la multiplication
 résultat = calculatrice.multiplier(2, 6)
 imprimer("Résultat de la multiplication :", résultat)

Le code ci-dessus montre comment déboguer le script de la calculatrice indépendamment.

Quand est-il inutile d'utiliser la construction if __name__ == "__main__"?

Comme vous l'avez vu dans les scénarios ci-dessus, l'utilisation du si __nom__ == "__main__" construct consiste à différencier le script que vous exécutez en tant que programme principal et celui que vous importez en tant que module. Il existe cependant des cas où son utilisation n'est pas nécessaire.

Le premier cas est lorsque votre script est simple et n'a pas de fonctions ou de modules réutilisables et que vous ne le destinez pas à l'importation. Dans ce cas, vous devez omettre cette construction car le script entier s'exécute lors de son exécution. Ceci est courant pour les scripts à usage unique qui remplissent un objectif spécifique et ne sont pas destinés à être réutilisés ou importés.

L'autre cas est lorsque vous travaillez dans une session Python interactive, par ex. lors de l'utilisation du bloc-notes Jupyter. Dans une session interactive, vous saisissez et exécutez du code directement dans l'invite de commande ou dans un shell Python interactif. Tels que Python REPL (Read-Eval-Print Loop). Cela vous permet d'expérimenter le code et de tester de petits extraits, vous donnant des résultats immédiats.

Dans ces environnements interactifs, le concept d'un script s'exécutant en tant que programme principal ou importé en tant que module ne s'applique pas. Vous exécutez directement des extraits de code sans avoir besoin d'un point d'entrée de script traditionnel.

Comment devenir un maître en Python?

Pour devenir un maître dans n'importe quel langage de programmation, vous devez comprendre comment fonctionnent les concepts sous-jacents des fonctions ou des outils. Tout comme vous avez appris la construction if __name__ == "__main__" dans cet article.

Comprendre les concepts sous-jacents vous aidera à savoir exactement comment votre programme se comportera lorsque vous les utiliserez. Il n'y a pas d'urgence, apprendre les concepts un par un vous aidera à approfondir chacun d'eux.