Lorsque vous écrivez des scripts Python, assurez-vous d'ajouter ceci !

Les personnes qui utilisent Python écrivent souvent des scripts Que ce soit pour améliorer l'efficacité du travail ou pour répondre à certains besoins spécifiques, les scripts Python sont une chose courante et utile.

Cependant, j'ai récemment découvert un problème que je n'avais jamais remarqué auparavant, à savoir s'il faut ajouter if __name__ == "__main__":
Cette déclaration a en fait un grand impact sur l'utilisation du script, et il y a bien d'autres choses dedans. Grande connaissance.

Malentendus courants

De nombreux amis sont plus décontractés lorsqu'ils écrivent des scripts simples. Les scripts simples sont écrits directement sans fonctions et exécutés séquentiellement. Pour les scripts plus complexes, des fonctions peuvent être ajoutées. Cette façon d'écrire est moins lisible et les utilisateurs ne peuvent souvent pas trouver d'un seul coup d'œil l'entrée et la séquence d'exécution du programme.

La méthode d'écriture recommandée par la communauté Python consiste à ajouter la déclaration suivante lors de l'écriture d'un script :

def main():
# do something
print("do something.")

if __name__ == "__main__":
main()

La plupart des gens diront quand ils verront cela, qu'est-ce que cela signifie ? Ce n'est pas si important de l'ajouter ou non !

Ne soyez pas trop occupé et dédaigneux, regardons de plus près !

À quoi ça sert ?

Avant d'expliquer la fonction de if __name__ == '__main__' en détail, ressentons-la intuitivement à partir d'un exemple simple.

# const.py
 
PI = 3.14
 
def train():
print("PI:", PI)
 
train()

# area.py
 
from const import PI
 
def calc_round_area(radius):
return PI * (radius ** 2)
 
def calculate():
print("round area: ", calc_round_area(2))
 
calculate()

Jetons un coup d'œil aux résultats d'exécution de Area.py : La variable PI de

PI: 3.14
round area:12.56

, lors de l'exécution, l'impression dans la fonction train()
dans const.py est également importée, mais nous ne référençons que le variable et non une fonction de référence, c'est donc quelque chose que nous ne voulons pas voir.

La solution à ce problème est également très simple. Il suffit d'ajouter une phrase à const.py :

PI = 3.14

def train():
 print("PI:", PI)

if __name__ == "__main__":
 train()

Exécutez à nouveau area.py, le résultat de sortie est le suivant :

round area:12.56

C'est le résultat que nous attendions. .

Entrée en cours d'exécution du programme

À partir des exemples ci-dessus, nous pouvons constater que s'il n'y a pas de if __name__=="__main__":, lors de l'importation du fichier sous Area.py, tous les codes de const.py
seront exécutés, et après l'avoir ajouté, exécutez uniquement la partie importée du code.

C'est l'effet évident de if __name__=="__main__":. En fait, if __name__=="__main__": est équivalent à l'entrée du programme de
Simulation Python. Puisque les modules se réfèrent les uns aux autres, différents modules peuvent avoir de telles définitions, mais il ne peut y avoir qu'un seul programme d'entrée. Le programme d'entrée sélectionné dépend de la valeur de __name__.

Regardons à nouveau un petit programme :

print("look here")
print(__name__)
 
if __name__ == '__main__':
print("I'm test.py")

Les résultats d'exécution du programme sont les suivants :

look here
__main__
I'm test.py

On peut constater que la valeur de la variable __name__ est __main__ à ce moment, donc "Je suis
test .py" est imprimé. Si vous exécutez d'autres fichiers et appelez ce fichier via le fichier en cours d'exécution, l'instruction ne sera pas imprimée car l'entrée du programme est incorrecte et l'instruction ne sera pas exécutée.

Spécification du code

Avec if __name__=="__main__": équivalent à Python
Le programme a également une fonction d'entrée Nous pouvons clairement savoir où commence la logique du programme. Bien sûr, nous devons également changer consciemment le. logique du programme. La logique de départ est toute placée ici. En fait, c'est aussi l'approche recommandée par PyCharm
.

Pourquoi de nombreux excellents langages de programmation, tels que C, Java, Golang et C++, ont-ils une fonction d'entrée principale. Je pense qu'une raison très importante est que l'entrée du programme est unifiée et facile à lire ?

Les scénarios multi-processus sont très utiles

Si vous utilisez plusieurs processus pour le calcul parallèle, codez comme ceci :

import multiprocessing as mp

def useful_function(x):
return x * x

print("processing in parallel")
with mp.Pool() as p:
results = p.map(useful_function, [1, 2, 3, 4])
print(results)

Exécutez ce code, la console continuera à imprimer :

processing in parallel
processing in parallel
processing in parallel
processing in parallel
processing in parallel
processing in parallel
processing in parallel
processing in parallel
processing in parallel

Et le programme continuera à signaler RuntimeError .

Si vous ajoutez if __name__=="__main__": , le programme se déroulera comme prévu :

import multiprocessing as mp

def useful_function(x):
return x * x

if __name__ == '__main__':
print("processing in parallel")
with mp.Pool() as p:
results = p.map(useful_function, [1, 2, 3, 4])
print(results)

Le multi-programme de Python consiste à démarrer plusieurs interpréteurs Python, et chaque interpréteur Python importera votre script, copiera une copie du fichier global variables et fonctions pour le processus enfant. S'il y a if

__name__=="__main__":, alors le code derrière celui-ci ne sera pas importé et ne sera pas exécuté à plusieurs reprises. Sinon, le code qui crée plusieurs processus sera
importé et exécuté, créant ainsi des processus enfants de manière infiniment récursive

Résumé

if __name__=="__main__": Bien que ce ne soit pas obligatoire, j'insiste là-dessus Il est recommandé suivez cette spécification lors de l’écriture de scripts.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!