Que fait "if __name__ =='__main__" en Python ?

Aujourd'hui, discutons de quelque chose qui est partout dans de nombreuses bases de code :qu'est-ce que if __name__ == '__main__' faire en Python ?

L'énoncé if __name__ == '__main__': vérifie si la variable __name__ est défini sur la valeur de chaîne '__main__' qui ne tient que dans le fichier source principal à partir duquel vous exécutez initialement votre code. Dans tous les autres contextes, comme dans les fichiers de code importés, la variable __name__ est réglé sur une valeur différente.

Ainsi, if __name__ == '__main__': évalue à True si vous l'utilisez dans votre fichier principal (celui que vous exécutez avec python main.py ). Si vous l'importez indirectement, il est évalué à False .

Ceci est utile car vous ne souhaitez généralement pas exécuter de code avec des effets secondaires lors de l'importation de modules.

Vous pouvez jouer avec le code dans cet exemple minimal :

Exercice :Exécutez le shell de code. Quelle est la sortie ? Maintenant, créez un nouveau fichier et import main . Quelle est la sortie maintenant ?

Si vous apprenez la programmation Python étape par étape, vous seriez tombé sur l'extrait de code ci-dessus quelque part. Même si ce n'est pas le cas, je suis sûr que vous le rencontrerez bientôt, et cela pourrait ressembler à une secousse dans votre parcours jusqu'ici fluide d'apprentissage de la programmation Python. J'ai été là-bas. J'étais en train de parcourir un livre sur la programmation Python quand j'ai vu ce morceau de code pour la première fois, et j'ai pensé - attendez une minute, ai-je raté quelque chose en venant ici ? Puis je suis revenu, révisant les dernières pages pour comprendre ce que j'avais raté, et cette boucle a duré un moment avant que je me sois finalement assis pour faire face au démon, et honnêtement, j'ai souri quand j'ai compris, c'est aussi simple que ça . Peut-être, nous apprenons de cette façon. On va et vient, on continue de sauter, et puis un jour, la magie opère. La seule chose qui marche, c'est de ne pas abandonner.

Aujourd'hui, je vais essayer de vous simplifier la compréhension d'une manière qui, espérons-le, vous fera sourire si vous avez été dans la boucle pour obtenir un indice de ce que c'est et que vous continuez à l'oublier.

Pour comprendre ce qui est if __name__ == __main__ utilisé pour nous plongerons d'abord dans quelques exemples de code pour comprendre ce que __name__ et __main__ sommes. Ensuite, nous cimenterons l'apprentissage à travers un autre exemple. Soyez donc patient et parcourez attentivement l'article. Les extraits de code peuvent sembler un peu déroutants, mais attendez que nous vous expliquions et voyons ce qui se passe exactement.

Que sont __name__ et __main__ ?

Commençons par __name__ . En termes simples, __name__ est une variable spéciale intégrée à Python.

En Python, nous pouvons exécuter du code en tant que fichier source ou, en d'autres termes, un code python qui s'exécute seul (lu - non importé à partir d'un fichier source Python séparé). Cette phrase peut prêter à confusion pour le moment, mais explorons cela plus avant.

Regardez l'extrait de code ci-dessous. C'est un simple fichier python avec une seule ligne :

print(f" First Module's Name : {__name__}")

En termes simples, nous demandons à Python d'imprimer la valeur que __name__ variable a à ce moment. Notez qu'il n'y a pas d'instruction d'importation ni même aucune autre ligne de code au-dessus.

Figure 1

Vérifiez la sortie dans la figure 2 ci-dessous. Nous exécutons les lignes de code ci-dessus et trouvons la sortie

Nom du premier module :__main__

Figure 2

Nous importons module1.py en module2.py et demandez à Python de renvoyer le nom du deuxième module (deuxième parce que c'est le deuxième code python que nous exécutons) stocké dans  __name__ variable à nouveau.

Figure 3

# File: module2.py
import module1

print(f"Second Module's Name : {__name__}")

Fait intéressant, dans la figure 5 ci-dessous, nous avons la sortie

Nom du premier module :module1

Nom du deuxième module :__main__

Figure 4

Les informations ci-dessus résumées simplement peuvent être expliquées comme suit. Python commence à exécuter la première ligne de code trouvée dans un fichier Python, mais avant d'exécuter quoi que ce soit pour afficher la sortie, Python définit certaines variables spéciales. __nom__ est une de ces variables. Lorsque le fichier source est exécuté seul, c'est-à-dire qu'il n'est pas importé d'un autre code source, le __name__ la variable est définie sur la valeur __main__ , et donc la sortie que nous avons obtenue dans la figure 3 était Nom du premier module :__main__ . Si vous importez le fichier à partir d'un autre module (comme dans l'extrait de code de la figure 4), la valeur de __name__ La variable est définie sur le nom du module à partir duquel elle est importée. D'où la sortie de la figure 5.

Regardons maintenant la séquence d'exécution.

1. module1.py dans la figure 1 est exécuté,
2. Variable __nom__ est défini sur la valeur __main__
3. __main__ module est exécuté et la sortie est Nom du premier module :__main__
4. Module2.py dans la figure 4 est exécuté,
5. Variable __nom__ est défini sur la valeur module1
6. module1 est le bloc de code dans module1.py qui est exécuté, et la sortie est Nom du premier module :module1
7. Ensuite, nous passons à la ligne 3 dans module2.py, la valeur du nom est réinitialisée à __main__ , car il s'agit d'un nouveau morceau de code dans module2.py, et la sortie est Nom du deuxième module :__main__

Utiliser si __name__ =='__main__'

Mais ne pensons qu'au code dans module2.py. Dans le monde réel, avec module2.py, je ne voudrais pas imprimer la sortie de module1.py, mais seulement importer certaines fonctionnalités et obtenir une sortie pour les lignes de code écrites dans module2.py, c'est-à-dire Nom du deuxième module :__main__

Mais comment pouvons-nous le faire? Il doit y avoir un moyen parce que cela semble plus logique de cette façon. Reportez-vous à l'extrait de code ci-dessous dans la figure 6.

Figure 5

# File: module1.py
'''print(f"First Module's Name : {__name__}")'''


def main():
	print(f"First Module's Name : {__name__}")

if __name__ == '__main__':
	main()

Nous allons donc définir une fonction main() , et mettez l'instruction d'impression de module1.py à l'intérieur de la fonction principale. Maintenant, nous utilisons cette petite astuce consistant à utiliser l'instruction if __name__ == '__main__' et placez la fonction principale à l'intérieur de cette instruction if. Regardons maintenant la séquence d'exécution de notre programme.

1. Nous avons un main() fonction où l'on demande d'imprimer le nom du premier module stocké dans le __name__ variable. De l'exemple ci-dessus, nous connaissons la valeur stockée dans le __name__ la variable est __main__ .
2. À la ligne 7, nous disons si la valeur de __name__ la variable est égale à __main__ , alors seulement continuez et exécutez le main() fonction.
3. En exécutant maintenant le module1.py modifié, nous pouvons voir la sortie sous la forme Nom du premier module :__main__ comme prévu. Reportez-vous à la première sortie de la figure 7
4. Maintenant, lorsque nous exécutons module2.py, nous obtenons la sortie sous la forme Nom du deuxième module :__main__

Remarquez comment la sortie de module2.py a changé maintenant. Bien que nous ayons importé module1 dans notre programme module2.py, le programme dans module1.py ne s'exécute pas. Pourquoi? Parce que la valeur stockée dans le __name__ la variable en ce moment est module1 et non __main__ . Donc, en utilisant une fonction main() et if __name__ ==‘__main__’ a mis des restrictions sur l'exécution des lignes de code dans module1.py car il n'exécuterait module1.py que si __name__ =='__main__'

Figure 6

Tout mettre dans un exemple concret

Prenons maintenant un exemple plus générique, qui donnerait plus de sens à tout ce que nous avons discuté ci-dessus.

• Regardez l'extrait de code ci-dessous de cubes.py dans la Figure 8. Aux lignes 1 et 2, nous avons une fonction cube() , qui prend num comme argument. La fonction cubes(num) renvoie le cube d'un nombre donné.
• Sur la ligne 4, nous utilisons une boucle for qui itère sur une liste de nombres de 0 à 9.
• Sur la ligne 5, nous utilisons le cubes(num) fonction avec i comme entrée pour afficher le cube, comme illustré à la figure 9. Assez simple.

Figure 7

Figure 8

def cube(num):
	return num ** 3

for i in range(10):
	print(f"{i} cubed is {cube(i)}")

Dans l'extrait de code de modules.py ci-dessous dans la figure 10, nous importons cube(num) fonction de cubes.py et essayez d'imprimer cube de 10 en ligne 3. Logiquement, nous essayons d'utiliser la fonction cube(num) , qui renvoie un cube de n'importe quel nombre d'entrée donné.

Figure 9

# File modules.py
from cubes import cube

print(cube(10))

Cependant, regardez la sortie ci-dessous. Nous avons la sortie des deux programmes cubes.py et modules.py . Ce n'est pas ce que nous avions l'intention ou voulu faire.

Figure 10

Rappelez-vous l'explication ci-dessus où nous avons utilisé if __name__ =='__main__' pour limiter l'exécution de code à partir de modules1.py . Essayons de mettre en œuvre la même idée et voyons si cela fonctionne ici.

Dans l'extrait de code de cubesModified.py dans la figure 11, nous plaçons la boucle for et l'instruction print de cubes.py dans la fonction main(). Et encore une fois, nous utilisons la déclaration if __name__ ==‘__main__’ pour exécuter le code de cubesModified.py uniquement lorsque la valeur de la variable __name__ est égale à __main__.

Figure 11

# File: cubesModified.py
def cube(num):
	return num ** 3

def main():
	for i in range(10):
		print(f"{i} cubed is {cube(i)}")

''' effectively what this line of code is trying to say 
here is if name equals main or in other words, "if I am 
currently running this particular file (cubesModified.py)"
then run the main function.'''

if __name__ == "__main__":
	main()

Nous exécutons cubesModified.py et obtenez la sortie comme ci-dessous et selon nos attentes.

Figure 12

Cependant, maintenant, lorsque nous exécutons modulesModified.py où nous importons cube(num) fonction à partir de cubesModified.py , il n'exécute que le code de notre modulesModified.py comme le montre la figure 15, et la sortie est 1000 car la valeur stockée dans __name__ variable dans cubesModified et non __main__.

Figure 13

# File: cubesModified
from cubesModified import cube

print(cube(10))

Figure 14

J'espère que cette explication vous aidera à mieux comprendre ce que fait if __name__ =='__main__' . Allez-y et jouez avec le code dans l'éditeur de code et cimentez votre compréhension. Bonne chance !!

Auteur

Cet article est une contribution de Finxter Abhigyan Ojha . Vous pouvez trouver son profil Upwork ici.