Ce ne si nom == " principal ": le faire?

Que fait le if __name__ == "__main__": ?

# Threading example
import time, thread

def myfunction(string, sleeptime, lock, *args):
    while True:
        lock.acquire()
        time.sleep(sleeptime)
        lock.release()
        time.sleep(sleeptime)

if __name__ == "__main__":
    lock = thread.allocate_lock()
    thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
    thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
4342
demandé sur RAM 2009-01-07 07:11:00
la source

29 ответов

Lorsque l'interpréteur Python lit un fichier source, il exécute tout le code qui s'y trouvent.

avant d'exécuter le code, il définira quelques variables spéciales. Par exemple, si L'interpréteur Python exécute ce module (le fichier source) comme programme principal, il définit la variable spéciale __name__ pour avoir une valeur "__main__" . Si ce fichier est importé d'un autre module, __name__ sera défini au nom du module.

dans le cas de votre script, supposons qu'il s'exécute comme fonction principale, par exemple vous avez dit quelque chose comme

python threading_example.py

sur la ligne de commande. Après avoir configuré les variables spéciales, il exécutera la déclaration import et chargera ces modules. Il évaluera ensuite le bloc def , créant un objet de fonction et créant une variable appelée myfunction qui pointe vers l'objet de fonction. Il lira alors la déclaration if et voir que __name__ fait égal à "__main__" , donc il exécutera le bloc montré là.

une des raisons pour faire cela est que parfois vous écrivez un module (un fichier .py ) où il peut être exécuté directement. Il peut également être importé et utilisé dans un autre module. En faisant la vérification principale, vous pouvez faire exécuter ce code uniquement lorsque vous voulez exécuter le module en tant que programme et ne pas le faire exécuter lorsque quelqu'un veut juste importer votre module et appeler vos fonctions elles-mêmes.

voir cette page pour plus de détails.

4642
répondu Mr Fooz 2018-05-24 00:55:37
la source

quand votre script est lancé en le passant comme commande à l'interpréteur Python,

python myscript.py

tout le code qui est au niveau d'indentation 0 est exécuté. Les fonctions et les classes qui sont définies sont, bien, définies, mais aucun de leur code n'est exécuté. Contrairement à d'autres langues, il n'y a pas de fonction main() qui s'exécute automatiquement - la fonction main() est implicitement tout le code au niveau supérieur.

dans ce cas, le code supérieur est un bloc if . __name__ est une variable intégrée qui s'évalue au nom du module courant. Cependant, si un module est exécuté directement (comme dans myscript.py ci-dessus), alors __name__ est défini à la place de la chaîne de caractères "__main__" . Ainsi, vous pouvez tester si votre script est exécuté directement ou s'il est importé par quelque chose d'autre en testant

if __name__ == "__main__":
    ...

Si votre script est importé dans un autre module, ses différents les définitions de fonctions et de classes seront importées et son code de niveau supérieur sera exécuté, mais le code dans le corps de la clause if ci-dessus ne sera pas exécuté car la condition n'est pas remplie. Comme exemple de base, considérons les deux scripts suivants:

# file one.py
def func():
    print("func() in one.py")

print("top-level in one.py")

if __name__ == "__main__":
    print("one.py is being run directly")
else:
    print("one.py is being imported into another module")
# file two.py
import one

print("top-level in two.py")
one.func()

if __name__ == "__main__":
    print("two.py is being run directly")
else:
    print("two.py is being imported into another module")

Maintenant, si vous invoquez l'interprète comme

python one.py

la sortie sera

top-level in one.py
one.py is being run directly

si vous utilisez two.py à la place:

python two.py

, Vous obtenez

top-level in one.py
one.py is being imported into another module
top-level in two.py
func() in one.py
two.py is being run directly

Ainsi, lorsque le module one est chargé, son __name__ est égal à "one" au lieu de "__main__" .

1498
répondu Adam Rosenfield 2018-01-31 16:28:16
la source

l'explication la plus simple de la variable __name__ (imho) est la suivante:

créez les fichiers suivants.

# a.py
import b

et

# b.py
print "Hello World from %s!" % __name__

if __name__ == '__main__':
    print "Hello World again from %s!" % __name__

les exécuter vous donnera cette sortie:

$ python a.py
Hello World from b!

comme vous pouvez le voir, lorsqu'un module est importé, Python place globals()['__name__'] dans ce module au nom du module.

$ python b.py
Hello World from __main__!
Hello World again from __main__!

Comme vous pouvez le voir, lorsqu'un fichier est exécuté, Python place globals()['__name__'] dans ce fichier en "__main__" .

580
répondu pi. 2014-08-06 18:07:31
la source

Que fait le if __name__ == "__main__": ?

Pour décrire les notions de base:

  • La variable globale __name__ , dans le module qui est le point d'entrée de votre programme, est '__main__' . Sinon, c'est le nom par lequel vous importez le module.

  • ainsi, le code sous le bloc if ne sera activé que si le module est le point d'entrée à votre programme.

  • il permet d'importer le code dans le module par d'autres modules, sans exécuter le bloc de code ci-dessous lors de l'importation.


pourquoi on a besoin de ça?

développer et tester votre Code

dites que vous écrivez un script Python conçu pour être utilisé comme module:

def do_important():
    """This function does something very important"""

Vous pourrait tester le module en ajoutant Cet appel de la fonction au bas:

do_important()

et l'exécuter (sur une invite de commande) avec quelque chose comme:

~$ python important.py

Le Problème

cependant, si vous voulez importer le module dans un autre script:

import important

à l'importation, la fonction do_important s'appellerait, donc vous pourriez probablement commenter votre fonction appelez do_important() , en bas.

# do_important() # I must remember to uncomment to execute this!

et ensuite vous devrez vous rappeler si oui ou non vous avez commenté votre appel de fonction de test. Et cette complexité supplémentaire signifierait que vous êtes susceptible d'oublier, rendant votre processus de développement plus gênant.

"1519220920 Une" Meilleure Façon

la variable __name__ pointe vers l'espace de noms où se trouve l'interpréteur Python en ce moment.

dans un module importé, c'est le nom de ce module.

mais à l'intérieur du module primaire (ou d'une session Python interactive, i.e. la lecture, L'évaluation, la boucle D'impression, ou la REPL de l'interpréteur) vous exécutez tout de son "__main__" .

donc si vous cochez avant d'exécuter:

if __name__ == "__main__":
    do_important()

avec ce qui précède, votre code ne s'exécute que lorsque vous l'exécutez en tant que module primaire (ou l'appelez intentionnellement à partir d'un autre script).

Encore Mieux

il y a un moyen pythonique d'améliorer cela, cependant.

si nous voulons exécuter ce processus d'affaires provenant de l'extérieur du module?

si nous mettons le code que nous voulons exercer que nous développons et testons dans une fonction comme celle-ci, puis faire notre vérification pour '__main__' immédiatement après:

def main():
    """business logic for when running this module as the primary one!"""
    setup()
    foo = do_important()
    bar = do_even_more_important(foo)
    for baz in bar:
        do_super_important(baz)
    teardown()

# Here's our payoff idiom!
if __name__ == '__main__':
    main()

Nous avons maintenant une fonction finale pour la fin de notre module qui s'exécute que si on lance le module le module principal.

il permettra au module et à ses fonctions et classes d'être importés dans d'Autres scripts sans exécuter la fonction main , et permettra également au module (et à ses fonctions et classes) d'être appelé lors de l'exécution à partir d'un autre '__main__' module, i.e.

import important
important.main()

cet idiome se trouve aussi dans la documentation Python dans une explication du module __main__ . ce texte dit:

ce module représente la portée (autrement anonyme) dans laquelle le le programme principal de l'interpréteur exécute des commandes lues depuis entrée standard, à partir d'un fichier script, ou à partir d'une invite interactive. Il est - ce que cet environnement dans lequel l'idiomatique "script conditionnel" stanza provoque l'exécution d'un script:

if __name__ == '__main__':
    main()
424
répondu Aaron Hall 2018-03-27 05:27:47
la source

if __name__ == "__main__" est la partie qui s'exécute lorsque le script est exécuté depuis (disons) la ligne de commande en utilisant une commande comme python myscript.py .

94
répondu Harley Holcombe 2015-07-10 18:49:13
la source

Que fait if __name__ == "__main__": ?

__name__ est une variable globale (en Python, global signifie en fait au niveau du module ) qui existe dans tous les espaces de noms. Il s'agit généralement du nom du module (en tant que type str ).

comme le seul cas spécial, cependant, dans n'importe quel processus Python que vous exécutez, comme dans mycode.py:

python mycode.py

anonymes l'Espace-nom global se voit attribuer la valeur '__main__' à __name__ .

ainsi, y compris les lignes finales

if __name__ == '__main__':
    main()
  • à la fin de votre mycode.py script,
  • lorsque c'est le module primaire, point d'entrée qui est exécuté par un processus Python,

fera tourner la fonction main de votre script.

un autre avantage de l'utilisation de cette construction: vous pouvez également importer votre code comme un module dans un autre script et ensuite exécuter la fonction principale si et quand votre programme décide:

import mycode
# ... any amount of other code
mycode.main()
60
répondu Aaron Hall 2017-01-10 20:35:04
la source

il y a beaucoup de prises de position différentes ici sur la mécanique du code en question, Le" Comment", mais pour moi rien de cela n'avait de sens jusqu'à ce que je comprenne le"pourquoi". Cela devrait être particulièrement utile pour les nouveaux programmeurs.

Prendre le fichier "ab.py":

def a():
    print('A function in ab file');
a()

et un second fichier "xy.py":

import ab
def main():
    print('main function: this is where the action is')
def x():
    print ('peripheral task: might be useful in other projects')
x()
if __name__ == "__main__":
    main()

Que fait ce code?

quand vous exécutez xy.py , vous import ab . L'instruction d'importation exécute le module immédiatement sur l'importation, de sorte que les opérations de ab 's soient exécutées avant le reste de xy 's. Une fois terminé avec ab , il continue avec xy .

l'interpréteur garde la trace des scripts qui tournent avec __name__ . Lorsque vous exécutez un script-quel que soit le nom que vous lui donnez - l'interprète l'appelle "__main__" , ce qui en fait le script maître ou "Home" qui retourne après avoir exécuté un script externe.

tout autre script appelé à partir de ce script "__main__" reçoit son nom de fichier comme __name__ (par exemple, __name__ == "ab.py" ). Par conséquent, la ligne if __name__ == "__main__": est le test de l'interprète pour déterminer s'il interprète/analyse le script 'home' qui a été initialement exécuté, ou s'il regarde temporairement dans un autre script (externe). Cela donne au programmeur la flexibilité nécessaire pour que le script se comporte différemment. si elle est exécutée directement vs. appelée extérieurement.

passons à travers le code ci-dessus pour comprendre ce qui se passe, en se concentrant d'abord sur les lignes non marquées et l'ordre dans lequel elles apparaissent dans les scripts. Rappelez - vous que les blocs de fonction - ou def - ne font rien par eux-mêmes jusqu'à ce qu'ils soient appelés. Ce que l'interprète peut dire si marmonna pour lui-même:

  • ouvert xy.py comme le fichier' home'; l'appeler "__main__" dans le __name__ à la variable.
  • Importer et ouvrir un fichier avec l' __name__ == "ab.py" .
  • Oh, une fonction. Je vais le rappeler.
  • Ok, fonction a() ; je viens d'apprendre cela. Impression " " une fonction dans le fichier ab ".
  • fin du fichier; retour à "__main__" !
  • Oh, une fonction. Je vais le rappeler.
  • un autre.
  • Fonction x() ; OK, impression" tâche périphérique: pourrait être utile dans d'autres projets ".
  • Qu'est-ce que c'est? Une déclaration if . Eh bien, la condition a été remplie (la variable __name__ a été définie à "__main__" ), donc je vais entrer la fonction main() et imprimer fonction principale: c'est où l'action est ".

les deux dernières lignes signifient: "__main__" ou" home "script, exécuter la fonction appelée main() ". C'est pourquoi vous verrez un def main(): bloc haut, qui contient le flux principal de la fonctionnalité du script.

Pourquoi mettre en œuvre cela?

vous vous souvenez de ce que j'ai dit plus tôt à propos des déclarations d'importation? Lorsque vous importez un module, il n'est pas juste "reconnaître" et attendre de nouvelles instructions - il exécute toutes les opérations exécutables contenu dans le script. Donc, mettre la viande de votre script dans la fonction main() le met effectivement en quarantaine, le mettant en isolation pour qu'il ne s'exécute pas immédiatement lorsqu'il est importé par un autre script.

encore une fois, il y aura des exceptions, mais la pratique courante est que main() n'est généralement pas appelé à l'extérieur. Vous vous demandez peut-être encore une chose: si nous n'appelons pas main() , pourquoi appelons-nous le script? C'est parce que beaucoup de les gens structurent leurs scripts avec des fonctions autonomes qui sont construites pour être exécutées indépendamment du reste du code dans le fichier. Ils sont ensuite appelés ailleurs dans le corps du script. Ce qui m'amène à ceci:

mais le code fonctionne sans lui

Oui, c'est ça. Ces fonctions séparées peuvent être appelées à partir d'un script en ligne qui n'est pas contenu dans un main() fonction. Si vous êtes habitué (comme je le suis, dans mes premières étapes d'apprentissage de la programmation) À construire des scripts en ligne qui font exactement ce dont vous avez besoin, et vous essayerez de le comprendre à nouveau si vous avez besoin de cette opération à nouveau ... Eh bien, vous n'êtes pas habitué à ce genre de structure interne à votre code, parce que c'est plus compliqué à construire et ce n'est pas aussi intuitif à lire.

mais c'est un script qui ne peut probablement pas avoir ses fonctions appelées extérieurement, parce que s'il l'a fait commencerait immédiatement à calculer et à assigner des variables. Et les chances sont que si vous essayez de réutiliser une fonction, votre nouveau script est assez proche de l'ancien pour qu'il y ait des variables contradictoires.

en séparant les fonctions indépendantes, vous gagnez la capacité de réutiliser votre travail précédent en les appelant dans un autre script. Par exemple, "example.py" pourrait importer "xy.py" et appeler x() , en utilisant la fonction " x " de "xy.py". (Peut-être il s'agit de mettre en majuscule le troisième mot d'une chaîne de texte donnée, de créer un NumPy array à partir d'une liste de nombres et de les quadriller, ou de détourner une surface 3D. Les possibilités sont illimitées.)

(en passant, cette question contient une réponse de @kindall qui m'a finalement aidé à comprendre - le pourquoi, pas le comment. Malheureusement il a été marqué comme une copie de celui-ci , qui je pense est une erreur.)

51
répondu joechoj 2018-05-24 01:29:32
la source

quand il y a certaines instructions dans notre module ( M.py ) nous voulons être exécutés quand il sera exécuté en tant que main (non importé), nous pouvons placer ces instructions (cas de test, instructions d'impression) sous ce bloc if .

comme par défaut (lorsque le module tourne comme main, non importé) la variable __name__ est définie à "__main__" , et quand elle sera importée la variable __name__ obtiendra une valeur différente, très probablement le nom du module ( 'M' ). Ceci est utile pour exécuter différentes variantes d'un module ensemble, et séparer leurs entrées et sorties spécifiques et aussi s'il y a des cas de test.

en bref , utilisez ce bloc if __name__ == "main" ' pour empêcher (certains) code d'être exécuté lorsque le module est importé.

42
répondu Nabeel Ahmed 2018-05-24 01:07:29
la source

regardons la réponse d'une manière plus abstraite:

supposons que nous ayons ce code dans X. PY:

...
<Block A>
if __name__ == '__main__':
    <Block B>
...

les Blocs A et B sont exécutées lorsque nous sommes en cours d'exécution "x.py".

mais juste le bloc A (et non B) est lancé quand nous exécutons un autre module," Y. py " par exemple, dans lequel x.y est importé et le code est exécuté à partir de là (comme lorsqu'une fonction dans "X. py" est appelé de Y. py).

33
répondu Alisa 2015-03-04 23:31:20
la source

lorsque vous exécutez Python de manière interactive, la variable locale __name__ reçoit une valeur de __main__ . De même, lorsque vous exécutez un module Python à partir de la ligne de commande, plutôt que de l'importer dans un autre module , son attribut __name__ se voit attribuer une valeur de __main__ , plutôt que le nom réel du module. De cette façon, les modules peuvent regarder leurs propres __name__ valeur de déterminer eux-mêmes comment ils sont utilisés, que ce soit comme support pour un autre programme ou comme l'application principale exécutée à partir de la ligne de commande. Ainsi, l'idiome suivant est assez courant dans les modules Python:

if __name__ == '__main__':
    # Do something appropriate here, like calling a
    # main() function defined elsewhere in this module.
    main()
else:
    # Do nothing. This module has been imported by another
    # module that wants to make use of the functions,
    # classes and other useful bits it has defined.
31
répondu Zain 2013-12-11 15:23:53
la source

dit simplement, __name__ est une variable définie pour chaque script qui définit si le script est lancé comme le module principal ou s'il est lancé comme un module importé.

donc si nous avons deux scripts;

#script1.py
print "Script 1's name: {}".format(__name__)

et

#script2.py
import script1
print "Script 2's name: {}".format(__name__)

la sortie de l'exécution script1 est

Script 1's name: __main__

et la sortie de l'exécution de script2 est:

Script1's name is script1
Script 2's name: __main__

comme vous peut voir, __name__ nous dit quel code est le module 'principal'. C'est génial, parce que vous pouvez simplement écrire du code et ne pas avoir à vous soucier des problèmes de structure comme dans C/C++, où, si un fichier n'implémente pas une fonction "principale" alors il ne peut pas être compilé comme un exécutable et s'il le fait, il ne peut pas être utilisé comme une bibliothèque.

dites que vous écrivez un script Python qui fait quelque chose de génial et que vous implémentez un boatload de fonctions qui sont utiles à d'autres fins. Si je veux je peux simplement importer votre script et l'utiliser sans exécuter votre programme (étant donné que votre code n'exécute que dans le contexte if __name__ == "__main__": ). Alors qu'en C / C++, vous devrez découper ces pièces dans un module séparé qui inclut alors le fichier. Imaginez la situation ci-dessous;

Complicated importing in C

les flèches sont des liens d'importation. Pour les trois modules, chacun essayant d'inclure les modules précédents code il y a six fichiers (neuf, en comptant les fichiers de mise en œuvre) et cinq liens. Il est donc difficile d'inclure d'autres codes dans un projet C à moins qu'ils ne soient compilés spécifiquement comme une bibliothèque. Maintenant, visualisez-le pour Python:

Elegant importing in Python

vous écrivez un module, et si quelqu'un veut utiliser votre code, il suffit de l'importer et la variable __name__ peut aider à séparer la partie exécutable de la programme de la partie bibliothèque.

31
répondu redbandit 2018-05-24 01:28:19
la source

prendre en considération:

if __name__ == "__main__":
    main()

il vérifie si l'attribut __name__ du script Python est "__main__" . En d'autres termes, si le programme lui-même est exécuté, l'attribut sera __main__ , donc le programme sera exécuté (dans ce cas, la fonction main() ).

cependant, si votre script Python est utilisé par un module, n'importe quel code en dehors de l'instruction if sera exécuté, donc if \__name__ == "\__main__" est utilisé juste pour vérifier si le programme est utilisé comme un module ou non, et décide donc d'exécuter le code.

26
répondu Larry 2018-05-24 01:31:42
la source

avant d'expliquer quoi que ce soit au sujet de if __name__ == '__main__' il est important de comprendre ce qu'est __name__ et ce qu'il fait.

Qu'est-ce que __name__ ?

__name__ est un DunderAlias - peut être considéré comme une variable globale (accessible à partir de modules) et fonctionne d'une manière similaire à global .

il s'agit d'une chaîne (globale comme mentionné ci-dessus) comme indiqué par type(__name__) (donnant <class 'str'> ), et est un standard intégré pour les deux versions Python 3 et Python 2 .

où:

il peut non seulement être utilisé dans les scripts, mais peut aussi être trouvé dans l'interpréteur et les modules/paquets.

interprète:

>>> print(__name__)
__main__
>>>

Script:

test_file.py :

print(__name__)

résultant en __main__

Module ou colis:

somefile.py:

def somefunction():
    print(__name__)

test_file.py:

import somefile
somefile.somefunction()

résultant en somefile

notez que lorsqu'il est utilisé dans un paquet ou un module, __name__ prend le nom du fichier. Le chemin du module ou du paquet actuel n'est pas indiqué, mais a sa propre DunderAlias __file__ , qui permet cela.

vous devriez voir que, où __name__ , où il est le fichier principal (ou le programme) sera toujours retour __main__ , et si c'est un module/paquet, ou quelque chose qui s'exécute avec un autre script Python, retournera le nom du fichier d'où il vient.

pratique:

étant une variable signifie que sa valeur peut être écrasée ("peut "ne signifie pas" devrait"), l'écrasement de la valeur de __name__ se traduira par un manque de lisibilité. Donc, ne ne pas le faire, pour une raison quelconque. Si vous avez besoin d'une variable de définir une nouvelle variable.

Il est toujours supposé que la valeur de __name__ être __main__ ou le nom du fichier. Une fois de plus, changer cette valeur par défaut causera plus de confusion qu'elle fera du bien, ce qui causera des problèmes plus loin dans la ligne.

exemple:

>>> __name__ = 'Horrify' # Change default from __main__
>>> if __name__ == 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>

il est considéré comme une bonne pratique en général d'inclure if __name__ == '__main__' en scripts.

maintenant répondre if __name__ == '__main__' :

maintenant nous connaissons le comportement de __name__ les choses deviennent plus claires:

An if est une instruction de contrôle de flux qui contient le bloc de code s'exécute si la valeur donnée est vraie. Nous avons vu que __name__ peut prendre soit __main__ ou le nom du fichier d'où elle a été importée.

cela signifie que si __name__ est égal à __main__ alors le fichier doit être le fichier principal et doit réellement être exécuté (ou c'est l'interpréteur), pas un module ou un paquet importé dans le script.

si en effet __name__ prend la valeur de __main__ alors ce qui est dans ce bloc de code s'exécutera.

cela nous dit que si le fichier exécuter est le fichier principal (ou vous exécutez directement depuis l'interpréteur) alors cette condition doit être exécutée. Si c'est un paquet alors il ne doit pas, et la valeur ne sera pas __main__ .

"1519420920 de Modules":

__name__ peut également être utilisé dans les modules pour définir le nom d'un module

variantes:

il est également possible de faire d'autres choses, moins communes mais utiles avec __name__ , certains que je vais montrer ici:

N'exécutant que si le fichier est un module ou un paquet:

if __name__ != '__main__':
    # Do some useful things 

exécuter une condition si le fichier est le principal et un autre si ce n'est pas:

if __name__ == '__main__':
    # Execute something
else:
    # Do some useful things

vous pouvez également l'utiliser pour fournir de l'aide runnable fonctions / utilitaires sur les paquets et les modules sans l'utilisation élaborée des bibliothèques.

il permet également aux modules d'être exécutés à partir de la ligne de commande en tant que scripts principaux, ce qui peut également être très utile.

19
répondu Simon 2018-05-24 01:39:09
la source

il y a un certain nombre de variables que le système (l'interpréteur Python) fournit pour les fichiers source (modules). Vous pouvez obtenir leurs valeurs quand vous voulez, alors, laissez-nous nous concentrer sur le __nom__ _ variable / attribut:

lorsque Python charge un fichier de code source, il exécute tout le code qu'il contient. (Notez qu'il n'appelle pas toutes les méthodes et fonctions définies dans le fichier, mais il les définit.)

avant le _ _ _ name _ _ est l'une de ces variables spéciales que Python définit automatiquement pour chaque fichier de code source.

si Python charge ce fichier de code source comme programme principal (i.e. le fichier que vous exécutez), alors il définit la variable spéciale ___ nom_ _ pour que ce fichier ait une valeur " ___ main _ _ " .

si cela est importé d'un autre module, ___ nom_ _ sera défini au nom de ce module.

ainsi, dans votre exemple en partie:

if __name__ == "__main__":
   lock = thread.allocate_lock()
   thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
   thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))

signifie que le bloc de code:

lock = thread.allocate_lock()
thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))

ne sera exécuté que lorsque vous exécutez le module directement; le bloc de code ne sera pas exécuté si un autre module l'appelle / l'importe parce que la valeur de _ _ nom _ _ _ ne sera pas égale " principal " dans ce cas particulier.

J'espère que ça va aider.

18
répondu codewizard 2016-07-20 12:30:24
la source

je pense que c'est mieux pour briser la réponse en profondeur et en mots simples:

__name__ : chaque module en Python a un attribut spécial appelé __name__ . C'est une variable intégrée qui renvoie le nom du module.

__main__ : comme les autres langages de programmation, Python dispose également d'un point d'entrée d'exécution, c'est-à-dire main. '__main__' est le nom de la portée dans laquelle le code de haut niveau exécute . Fondamentalement vous avez deux façons d'utiliser un module Python: le lancer directement comme un script, ou l'importer. Lorsqu'un module est exécuté sous forme de script, son __name__ est défini à __main__ .

ainsi, la valeur de l'attribut __name__ est définie à __main__ lorsque le module est exécuté comme programme principal. Sinon, la valeur de __name__ contient le nom du module.

17
répondu Inconnu 2018-05-24 01:30:36
la source

c'est un spécial pour quand un fichier Python est appelé à partir de la ligne de commande. Ceci est typiquement utilisé pour appeler une fonction "main()" ou exécuter d'autres codes de démarrage appropriés, comme la gestion des arguments en ligne de commande par exemple.

il peut être écrit de plusieurs façons. Une autre est:

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

Je ne dis pas que vous devez utiliser ceci dans le code de production, mais cela sert à illustrer qu'il n'y a rien de" magique "dans if __name__ == '__main__' . C'est une bonne convention pour invoquer une fonction principale dans les fichiers Python.

17
répondu Prof. Falken 2018-09-03 10:05:11
la source

if __name__ == "__main__": est fondamentalement l'environnement de script de haut niveau, et il spécifie l'interpréteur que ('j'ai la plus haute priorité à exécuter en premier').

'__main__' est le nom de la portée dans laquelle le code de haut niveau exécute. Le __name__ d'un module est défini comme '__main__' lorsqu'il est lu à partir d'une entrée standard, d'un script ou d'une invite interactive.

if __name__ == "__main__":
    # Execute only if run as a script
    main()
16
répondu The Gr8 Adakron 2018-05-24 01:14:07
la source

La raison pour laquelle

if __name__ == "__main__":
    main()

est principalement pour éviter le serrure d'importation problèmes qui résulteraient de ayant le code directement importé . Vous voulez que main() s'exécute si votre fichier a été directement invoqué (c'est le cas __name__ == "__main__" ), mais si votre code a été importé alors l'importateur doit entrer votre code à partir du module principal vrai pour éviter des problèmes de serrure d'importation.

un effet secondaire est-ce que vous vous connectez automatiquement à une méthodologie qui prend en charge plusieurs points d'entrée. Vous pouvez exécuter votre programme en utilisant main() comme point d'entrée, mais vous n'avez pas à . Alors que setup.py s'attend à main() , d'autres outils utilisent d'autres points d'entrée. Par exemple, pour exécuter votre fichier comme un processus gunicorn , vous définissez une fonction app() au lieu d'une fonction main() . Tout comme avec setup.py , gunicorn importe votre code donc vous ne voulez pas qu'il do tout ce qui est importé (en raison de la question de l'import lock).

12
répondu personal_cloud 2018-04-19 00:05:59
la source

Vous pouvez rendre le fichier utilisable comme un script ainsi qu'un importables module .

fibo.py (un module nommé fibo )

# Other modules can IMPORT this MODULE to use the function fib
def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

# This allows the file to be used as a SCRIPT
if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

référence: https://docs.python.org/3.5/tutorial/modules.html

8
répondu sam 2017-03-14 00:44:26
la source

prendre en considération:

print __name__

la sortie pour ce qui précède est __main__ .

if __name == "__main__":
  print "direct method"

la déclaration ci-dessus est vraie et imprime " méthode directe . Supposons que s'ils importent cette classe dans une autre classe, elle n'imprime pas "méthode directe" parce que, lors de l'importation, elle définira __name__ equal to "firstmodel name" .

8
répondu Janarthanan Ramu 2018-05-24 01:16:37
la source

j'ai beaucoup lu dans les réponses de cette page. Je dirais, si vous savez la chose, pour sûr que vous comprendrez ces réponses, sinon, vous êtes encore confus.

pour être bref, vous devez savoir plusieurs points:

  1. import a action fonctionne en fait tout ce qui peut être exécuté dans "a "

  2. en raison du point 1, vous ne voulez peut-être pas que tout soit exécuté dans "a "lors de son importation

  3. pour résoudre le problème au point 2, python vous permet de mettre un contrôle d'état

  4. __name__ est une variable implicite en tout .modules py; quand A. py est importé, la valeur de __name__ d'A. le module py est défini à son nom de fichier "a"; quand A. py est exécuté directement en utilisant " python A. py", ce qui signifie A. py est le point d'entrée, puis la valeur de __name__ de A. le module py est réglé sur une chaîne de caractères __main__

  5. basé sur le mécanisme comment python définit la variable __name__ pour chaque module, savez-vous comment atteindre le point 3? La réponse est assez facile, droit? Mettez un si condition: if __name__ == "__main__": ... ; vous pouvez même mettre si __name__ == "a" en fonction de votre besoin fonctionnel

la chose importante à laquelle python est spécial est le point 4! Le reste est juste de la logique de base.

6
répondu jack 2018-06-24 18:48:36
la source

créer un fichier, A. py :

print(__name__) # It will print out __main__

__name__ est toujours égal à __main__ chaque fois que ce fichier est exécuter directement montrant qu'il s'agit du fichier principal.

créer un autre fichier, B. py , dans le même répertoire:

import a  # Prints a

lancez-le. Il imprimera a , c'est-à-dire le nom du fichier qui est importé .

donc, pour montrer deux comportements différents du même fichier , c'est un truc couramment utilisé:

# Code to be run when imported into another python file

if __name__ == '__main__':
    # Code to be run only when run directly
2
répondu TheVishal 2018-05-24 01:34:14
la source

toutes les réponses ont à peu près expliqué la fonctionnalité. Mais je vais donner un exemple de son utilisation qui pourrait aider à clarifier davantage le concept.

supposons que vous avez deux fichiers Python, A. py et B. py. Maintenant, un.PY imports B. py. On gère le A. PY file, où le " B. le code py" est exécuté en premier. Avant le reste du A. le code py s'exécute, le code dans le fichier B. py doit courir complètement.

dans le B. code py il y a du code qui est exclusif à ce fichier.b.py et nous ne voulons pas que n'importe quel autre fichier (autres que b.py fichier), qui a importé le b.py fichier pour l'exécuter.

donc c'est ce que cette ligne de code vérifie. Si c'est le fichier principal (c, b.py) l'exécution du code, qui, dans ce cas, il n'est pas (un.py est le fichier principal en cours d'exécution), alors que le code est exécuté.

2
répondu preetika mondal 2018-05-24 01:38:56
la source

si c'est le cas .les fichiers py sont importés par d'autres .PY files, le code sous "l'instruction if" ne sera pas exécuté.

si c'est le cas .py sont exécutés par python this_py.py sous shell, ou double cliqué dans Windows. le code sous "l'instruction if" sera exécuté.

Il est généralement écrit pour les tests.

2
répondu pah8J 2018-06-19 14:44:29
la source

si nom == ' principal ':

nous voyons si __name__ == '__main__': assez souvent.

, Il vérifie si un module est importé ou pas.

en d'autres termes, le code dans le bloc if ne sera exécuté que si le code est exécuté directement. Ici directly signifie not imported .

voyons ce qu'il fait en utilisant un code simple qui imprime le nom du module:

# test.py
def test():
   print('test module name=%s' %(__name__))

if __name__ == '__main__':
   print('call test()')
   test()

si nous exécutons le code directement via python test.py , le nom du module est __main__ :

call test()
test module name=__main__
1
répondu Ali Hallaji 2018-05-24 01:36:51
la source

cette réponse est pour les programmeurs Java apprenant Python. Chaque fichier Java contient typiquement une classe publique. Vous pouvez utiliser cette classe de deux façons:

(1) Appel de la classe à partir d'autres fichiers. Il suffit de l'importer dans le programme d'appel.

(2) Lancer la classe stand alone, à des fins d'essai.

dans ce dernier cas, la classe doit contenir une méthode publique statique void main (). En Python ce but est servi par l'étiquette définie à l'échelle mondiale '__main__' .

1
répondu Raja 2018-10-07 07:52:46
la source

récemment, je suis tombé sur ce tout en créant un cours en python (Deep learning) et à ma compréhension et en accord avec les explications haut énumérées ci-dessus, je vais élaborer""

nom ==" principal "

Que, parfois, nous construisons une classe dans un .py fichier, et définit beaucoup de fonctions à l'intérieur de cette classe. mais nous ne voulons pas traiter toutes ces fonctions de classe pour un seul but. par exemple, pour créer une classe et de définir des fonctions pour la création de données (.npy) tandis que certains pour le chargement de données. donc, si nous définissons

nom ==" principal "

xxx=class_name ()

xxx.create_data ()

signifie Si nous appelons le .fichier py, alors il ne créera des données et ne traitera pas d'autres classes fonction. d'autres fonctions de classe (chargement de données) peuvent également être importés par d'autres classes.

0
répondu Khan 2018-10-12 15:06:52
la source

_ nom _ == _ main _ s'assurera que le code / les instructions présents dans ce bloc ne s'exécuteront que lorsque nous exécuterons ce fichier directement, à la place si nous importons ce module dans un autre fichier python, nous pouvons appeler la fonction définie dans ce bloc et aussi le bloc quel que soit le nom présent à l'intérieur du _ == main _ ne sera pas exécuté.

-1
répondu Ravichandran K 2018-06-28 13:19:06
la source

Ce qui fait la si nom == " principal ":?

Outline:

1, comme un script exécutable, travailler pour soi-même en tant que travailleur indépendant: Il exécute les codes dans le module Si est exécuté directement comme "python foo.py "

2, comme un module importé pour travailler pour d'autres:

Ses codes pourraient être réutilisés en toute sécurité s'ils étaient importés à un autre module "importer foo "

-1
répondu JawSaw 2018-08-20 03:57:07
la source

Autres questions sur python namespaces idioms main python-module