Was bedeutet, wenn name == "main":tun?

https://stackoverflow.com/questions/419163

03-07-2019
|

Frage

Was bedeutet das if __name__ == "__main__": tun?

# 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))

Lösung

Jedes Mal, wenn der Python-Interpreter eine Quelldatei liest, es macht zwei Dinge:

es stellt einige spezielle Variablen wie __name__, und dann
führt sie den gesamten Code in der Datei gefunden.

Lassen Sie uns sehen, wie das funktioniert und wie sie sich auf Ihre Frage über die __name__ Kontrolle übernehmen wir immer in Python-Skripten sehen.

Code-Beispiel

Lassen Sie uns einen etwas anderen Codebeispiel verwenden, um herauszufinden, wie Import-Skripte funktionieren. Folgendes ist in einer Datei namens foo.py Angenommen.

# Suppose this is foo.py.

print("before import")
import math

print("before functionA")
def functionA():
    print("Function A")

print("before functionB")
def functionB():
    print("Function B {}".format(math.sqrt(100)))

print("before __name__ guard")
if __name__ == '__main__':
    functionA()
    functionB()
print("after __name__ guard")

Spezielle Variablen

Wenn der Python interpeter eine Quelldatei liest, es definiert zunächst einige speziellen Variablen. In diesem Fall kümmern wir uns um die __name__ Variable.

Wenn Ihr Modul ist das Hauptprogramm

Wenn Sie Ihr Modul ausgeführt werden (die Quelldatei) wie das Hauptprogramm, z.

python foo.py

der Interpreter wird ordnet den hart codierten Zeichenfolge "__main__" zum __name__ variable, d.

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__"

Wenn Ihr Modul wird durch eine andere importierte

Auf der anderen Seite an, dass ein anderes Modul das Hauptprogramm ist und es importiert Ihr Modul. Das heißt, es ist eine Aussage wie diese im Hauptprogramm oder in einem anderen Modul des Hauptprogramm Import:

# Suppose this is in some other main program.
import foo

In diesem Fall wird der Dolmetscher bei den Dateinamen des Moduls schauen, foo.py, die .py abzuzustreifen, und weisen Sie diese Zeichenfolge an Ihren Moduls __name__ Variable, d.

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Ausführen des Moduls-Code

Nachdem die speziellen Variablen eingerichtet sind, führt der Interpreter den gesamten Code in dem Modul, eine Anweisung zu einem Zeitpunkt. Sie können ein weiteres Fenster auf der Seite mit dem Codebeispiel öffnen möchten, so dass Sie mit dieser Erklärung folgen zusammen können.

immer

Es druckt die Zeichenfolge "before import" (ohne Anführungszeichen).
Es lädt das math Modul und ordnet sie einer Variablen namens math. Dies ist gleichbedeutend mit import math Folgendes ersetzt (beachte, dass __import__ ist eine Low-Level-Funktion in Python, die eine Zeichenfolge nimmt und löst den eigentlichen Import):

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

Es druckt die Zeichenfolge "before functionA".
Es führt den def Block, ein Funktionsobjekt erstellen, dann auf eine Variable mit dem Namen functionA dieses Funktionsobjekt zugeordnet wird.
Es druckt die Zeichenfolge "before functionB".
Es führt den zweiten def Block, eine andere Funktion Objekt zu erzeugen, dann ist es zu einer Variable namens functionB zuweisen.
Es druckt die Zeichenfolge "before __name__ guard".

Nur wenn Ihr Modul ist das Hauptprogramm

Wenn Ihr Modul das Hauptprogramm ist, dann wird es, dass __name__ zu sehen war in der Tat auf "__main__" und ruft die beiden Funktionen, das Drucken der Saiten "Function A" und "Function B 10.0".

Nur wenn Ihr Modul wird durch eine andere importierte

( statt ) Wenn Ihr Modul nicht das Hauptprogramm, sondern wurde durch eine andere importiert, dann wird __name__ "foo" werden, nicht "__main__", und es wird in den Körper des if Anweisung überspringen.

immer

Es wird die Zeichenfolge "after __name__ guard" in beiden Situationen drucken.

Zusammenfassung

Zusammenfassend hier ist was hat in den beiden Fällen gedruckt werden:

# What gets printed if foo is the main program
before import
before functionA
before functionB
before __name__ guard
Function A
Function B 10.0
after __name__ guard

# What gets printed if foo is imported as a regular module
before import
before functionA
before functionB
before __name__ guard
after __name__ guard

Warum kommt es auf diese Weise funktionieren?

Sie könnte natürlich fragen, warum jemand dies wünschen würde. Nun, manchmal will man ein schreiben.py-Datei, die von anderen Programmen und / oder Module als Modul sowohl verwendet werden kann, und kann auch als das Hauptprogramm selbst ausgeführt werden. Beispiele:

Ihr Modul ist eine Bibliothek, aber Sie wollen einen Skript-Modus haben, wo es einige Komponententests oder eine Demo läuft.
Ihr Modul ist nur als Hauptprogramm verwendet, aber es einige Unit-Tests hat, und der Test-Framework funktioniert durch .py Dateien wie Ihr Skript importieren und spezielle Testfunktionen ausgeführt werden. Sie wollen es nicht versuchen, das Skript ausgeführt wird, nur weil es das Modul ist zu importieren.
Ihr Modul meist als Hauptprogramm verwendet wird, aber es bietet auch einen Programmierer freundlichen API für fortgeschrittenen Anwender.

Abgesehen von diesen Beispielen ist es elegant, dass ein Skript in Python läuft gerade ist ein paar magischen Variablen einrichten und das Skript importieren. „Ausführen“ das Skript ein Nebeneffekt ist die Skriptmodul importiert werden.

Food for Thought

Frage: Kann ich mehrere __name__ haben Überprüfung Blöcke? Antwort:. Es ist seltsam, dies zu tun, aber die Sprache wird nicht aufhören
Nehmen wir folgendes in foo2.py ist. Was passiert, wenn Sie auf der Kommandozeile python foo2.py sagen? Warum?

# Suppose this is foo2.py.

def functionA():
    print("a1")
    from foo2 import functionB
    print("a2")
    functionB()
    print("a3")

def functionB():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    functionA()
    print("m2")
print("t2")

Nun, herauszufinden, was passiert, wenn Sie die __name__ Check in foo3.py entfernen:

# Suppose this is foo3.py.

def functionA():
    print("a1")
    from foo3 import functionB
    print("a2")
    functionB()
    print("a3")

def functionB():
    print("b")

print("t1")
print("m1")
functionA()
print("m2")
print("t2")

Was wird dies tun, wenn sie als ein Skript verwendet? Wenn es als ein Modul importiert?

# Suppose this is in foo4.py
__name__ = "__main__"

def bar():
    print("bar")

print("before __name__ guard")
if __name__ == "__main__":
    bar()
print("after __name__ guard")

Andere Tipps

Wenn das Skript ausgeführt wird, indem es als Befehl an den Python-Interpreter vorbei,

python myscript.py

den gesamten Code, der auf Einrückungsebene 0 wird ausgeführt. Funktionen und Klassen, die definiert werden, sind gut definiert, aber keiner von ihrem Code wird ausgeführt. Im Gegensatz zu anderen Sprachen gibt es keine main() Funktion, die automatisch ausgeführt wird - die main() Funktion alle ist implizit der Code auf der obersten Ebene

In diesem Fall wird der Top-Level-Code ist ein if Block. __name__ ist eine interne Variable, die auf den Namen des aktuellen Moduls auswertet. Wenn jedoch ein Modul direkt (wie in myscript.py oben), dann führen wird __name__ anstatt auf den String "__main__" eingestellt. So können Sie testen, ob Ihr Skript direkt ausgeführt wird, oder durch etwas anderes durch Testen importiert

if __name__ == "__main__":
    ...

Wenn Ihr Skript in ein anderes Modul importiert wird, seine verschiedenen Funktionen und Klassendefinitionen werden importiert und sein Top-Level-Code wird ausgeführt, aber der Code in dem damaligen Körper der if Klausel oben nicht laufen bekommen als die Bedingung nicht erfüllt ist. Als einfaches Beispiel, die folgenden zwei Skripts:

# 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")

Wenn Sie nun den Interpreter als

aufrufen

python one.py

Der Ausgang wird

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

Wenn Sie laufen two.py statt:

python two.py

Sie erhalten

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

Wenn also Modul one geladen wird, seine __name__ gleich "one" statt "__main__".

Die einfachste Erklärung für die __name__ Variable (imho) ist die folgende:

Erstellen Sie die folgenden Dateien.

# a.py
import b

und

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

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

Ausführen von ihnen werden Sie diese Ausgabe erhalten:

$ python a.py
Hello World from b!

Wie Sie sehen können, wenn ein Modul importiert wird, setzt Python globals()['__name__'] in diesem Modul auf den Namen des Moduls. Auch beim Import der gesamten Code in dem Modul wird ausgeführt. Da die if Anweisung diesen Teil False wertet nicht ausgeführt wird.

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

Wie Sie sehen können, wenn eine Datei ausgeführt wird, setzt Python globals()['__name__'] in dieser Datei "__main__". Dieses Mal wertet die if Anweisung True und wird ausgeführt.

Was macht den if __name__ == "__main__":?

die Grundlagen skizzieren:

Die globale Variable, __name__, in dem Modul, das der Einstieg in das Programm ist, ist '__main__'. Ansonsten ist es der Name, den Sie das Modul importieren.
Also, Code unter dem if Block wird nur dann ausgeführt, wenn das Modul der Einstiegspunkt für Ihr Programm ist.
Es ermöglicht der Code in dem Modul von anderem Modulen importierbar zu sein, ohne den Codeblock unterhalb beim Import ausgeführt wird.

Warum brauchen wir das?

Entwickeln und Testen des Code

Sagen Sie bitte einen Python-Skript gerade schreiben entworfen, um als Modul verwendet werden:

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

Sie könnte , um das Modul testen, indem Sie diesen Aufruf der Funktion zum Boden Hinzufügen:

do_important()

und läuft es (auf einer Eingabeaufforderung) mit so etwas wie:

~$ python important.py

Das Problem

Wenn Sie jedoch wollen das Modul zu einem anderen Skript importieren:

import important

Beim Import würde die do_important Funktion aufgerufen werden, so dass Sie wahrscheinlich Ihren Funktionsaufruf kommentieren Sie würden, do_important(), an der Unterseite.

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

Und dann werden Sie müssen bedenken, ob Sie Ihren Testfunktionsaufruf haben kommentiert werden. Und diese zusätzliche Komplexität würde bedeuten, Sie zu vergessen sind wahrscheinlich, so dass Ihr Entwicklungsprozess problematischer.

A Better Way

Die __name__ Variable auf den Namensraum, wo das Python-Interpreter zur Zeit geschieht, zu sein.

Innerhalb eines importierten Modul, dann ist es der Name des Moduls.

Aber im Innern des primären Moduls (oder eine interaktive Python-Session, das heißt den Interpreten lesen, Eval, Print-Schleife oder REPL) Sie laufen alles von seinem "__main__".

Wenn Sie also überprüfen, bevor ausführen:

if __name__ == "__main__":
    do_important()

Mit dem obigen wird der Code nur ausgeführt werden, wenn Sie es als primären Modul laufen lassen (oder es absichtlich von einem anderen Skript aufrufen).

Ein noch besserer Weg

Es gibt eine Pythonic Art und Weise, dies zu verbessern, though.

Was passiert, wenn wir diesen Geschäftsprozess ausgeführt werden soll von außerhalb des Moduls?

Wenn wir setzen Sie den Code, den wir ausüben wollen, wie wir in einer Funktion wie diese entwickeln und zu testen und dann unser Check für '__main__' tun sofort nach:

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()

Wir haben jetzt eine letzte Funktion für das Ende unseres Moduls, das, wenn wir das Modul als primäres Modul ausgeführt wird ausgeführt.

Es wird das Modul und seine Funktionen und Klassen können in andere Skripte importiert werden, ohne dass die main Funktion ausgeführt wird, und wird auch das Modul (und seine Funktionen und Klassen) erlauben aufgerufen werden, wenn von einem anderen '__main__' Modul ausgeführt wird, dh

import important
important.main()

dieses Idiom kann auch in der Python-Dokumentation in einer Erklärung des __main__ Moduls. dass der Text heißt es:

Dieses Modul stellt den (ansonsten anonym) Umfang, in dem die Dolmetscher Hauptprogramm ausführt - Lesebefehle entweder aus Standardeingabe aus einer Skriptdatei oder aus einer interaktiven Eingabeaufforderung. Es in denen diese Umgebung die idiomatische „bedingte Skript“ Strophe bewirkt, dass ein Skript ausgeführt werden:
if __name__ == '__main__':
    main()

if __name__ == "__main__" ist der Teil, der ausgeführt wird, wenn das Skript von (sagen wir) die Befehlszeile ausgeführt wird, einen Befehl wie python myscript.py verwendet wird.

Was bedeutet if __name__ == "__main__": tun?

__name__ eine Globale variable ist (in Python, global bedeutet eigentlich auf die Modul-Ebene), dass es in allen namespaces.Es ist in der Regel das Modul den Namen (als str Typ).

Als einzige speziellen Fall aber, in welcher Python-Prozess, den Sie ausführen, wie im mycode.py:

python mycode.py

den sonst anonymen globalen namespace zugeordnet ist, den Wert von '__main__' zu seinen __name__.

So, einschließlich die letzten Zeilen

if __name__ == '__main__':
    main()

am Ende Ihrer mycode.py Skript,
wenn es ist die primäre, entry-point-Modul, das von einem Python-Prozess,

dazu führen, dass Ihr Skript ist eindeutig definiert main Funktion ausführen.

Ein weiterer Vorteil dieser Konstruktion:Sie können auch importieren Sie Ihren code als Modul in einem anderen Skript, und führen Sie dann die main-Funktion, wenn-und, wenn Ihr Programm entscheidet:

import mycode
# ... any amount of other code
mycode.main()

Es gibt viele verschiedene Takes hier auf die Mechanik des Codes in Frage, die „Wie“, aber für mich nichts davon machte Sinn, bis ich das „Warum“ zu verstehen. Dies sollte für neue Programmierer besonders hilfreich sein.

Nehmen Sie Datei "ab.py":

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

Und eine zweite Datei "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()

Was ist dieser Code tatsächlich tun?

Wenn Sie ausführen xy.py, Sie import ab. Die Import-Anweisung läuft das Modul sofort auf Import, so ab Operationen, bevor der Rest der xy des ausgeführt werden soll. Einmal mit ab abgeschlossen, geht es weiter mit xy.

Der Interpreter verfolgt, welche Skripte mit __name__ ausgeführt werden. Wenn Sie einen Skript ausführen - ganz gleich, was Sie es genannt haben -. Die Dolmetscher Anrufe "__main__" es, es den Meister oder ‚Heimat‘ Skript zu machen, die zurückgegeben wird, nachdem ein externes Skript ausgeführt

Jede andere Skript, das von diesem "__main__" Skript genannt wird dessen Dateinamen als __name__ (zum Beispiel __name__ == "ab.py") zugeordnet. Daher ist die Linie if __name__ == "__main__": den Test des Dolmetschers zu bestimmen, ob es zu interpretieren / Parsen die ‚Heimat‘ Skript, das zunächst ausgeführt wurde, oder wenn er vorübergehend in einer anderen (extern) Skript spähen ist. Dies gibt dem Programmierer Flexibilität das Skript sich anders verhalten zu haben, wenn sie extern aufgerufen direkt ausgeführt hat gegenüber.

Lassen Sie sich durch den obigen Code Schritt zu verstehen, was passiert, zunächst auf den nicht vertieften Linien konzentriert und die Reihenfolge, wie sie in den Skripten erscheinen. Denken Sie daran, dass die Funktion - oder def - Blöcke tun nichts für sich, bis sie genannt werden. Was der Dolmetscher könnte sagen, wenn sich murmelte:

Öffnen xy.py als ‚Heimat‘ Datei; nennt es in der "__main__" Variable __name__.
Import und offene Datei mit dem __name__ == "ab.py".
Oh, eine Funktion. Ich werde daran denken.
Ok, Funktion a(); Ich habe gelernt, dass. Druck ' Eine Funktion in ab-Datei '.
Ende der Datei; zurück zu "__main__"!
Oh, eine Funktion. Ich werde daran denken.
Ein anderes.
Funktion x(); ok, Druck. ' Peripherie Aufgabe: vielleicht in anderen Projekten nützlich sein
Was ist das? Eine if Aussage. Nun hat die Bedingung erfüllt worden ist (der Variable __name__ auf "__main__" gesetzt wurde), so dass ich die main() Funktion und Druck eingeben ' Hauptfunktion: das ist, wo die Aktion

Die beiden unteren Zeilen bedeuten: „Wenn dies der "__main__" oder‚Heimat‘Skript ist, führen Sie die Funktion aufgerufen main()“. Deshalb sollten Sie ein def main(): oben versperren sehen werden, die den Hauptfluss des Skripts Funktionalität enthält.

Warum implementieren das?

Denken Sie daran, was ich vorhin gesagt, über Import-Anweisungen? Wenn Sie ein Modul importieren es nicht nur ‚erkennen‘ es und auf weitere Anweisungen warten - es läuft tatsächlich alle ausführbaren Operationen im Skript enthalten. So setzen Sie das Fleisch des Skripts in die main() Funktion effektiv unter Quarantäne es, sie in Isolation setzen, so dass es nicht sofort ausgeführt werden, wenn sie von einem anderen Skript importiert werden.

Auch hier wird es Ausnahmen geben, aber gängige Praxis ist, dass main() in der Regel nicht von außen aufgerufen. So können Sie noch etwas fragen werden: Wenn wir nicht main() nennen, warum wir überhaupt das Skript aufrufen? Es ist, weil viele Menschen ihre Skripte mit Standalone-Funktionen strukturieren, die in der Datei des Restes des Codes unabhängig werden gebaut zu laufen. Sie sind dann später an anderer Stelle im Körper des Skript aufgerufen. Was mich dazu bringt:

Aber der Code funktioniertohne es

Ja, das ist richtig. Diese separaten Funktionen können von einem Inline-Skript aufgerufen werden, wird nicht in einer main() Funktion enthalten. Wenn Sie sich daran gewöhnt, (wie ich bin, in meiner frühen Lernstufe Programmierung) in-line-Skripte zu erstellen, die genau das tun, was Sie brauchen, und Sie werden versuchen, es wieder, um herauszufinden, ob Sie jemals wieder, dass der Betrieb benötigen .. . gut, ich bin nicht auf diese Art der inneren Struktur, um Ihren Code verwendet, weil es komplizierter ist, zu bauen und es ist nicht so intuitiv zu lesen.

Aber das ist ein Skript, das wahrscheinlich nicht haben seine Funktionen extern genannt, denn wenn sie es sofort beginnen würde, tat Berechnung und Variablen zugewiesen wird. Und die Chancen sind, wenn Sie eine Funktion, Ihr neues Skript wiederverwenden möchten, ist eng genug, um den alten Zusammenhang, dass es widersprüchliche Variablen sein.

In unabhängige Funktionen aufteilen aus, erhalten Sie die Möglichkeit, Ihre bisherige Arbeit neu zu nutzen, indem sie in ein anderes Skript aufgerufen wird. Zum Beispiel: „example.py“ könnte „xy.py“ importieren und x() nennen, die Verwendung der ‚x‘ Funktion macht aus „xy.py“. (Vielleicht ist es das dritte Wort einer bestimmten Textzeichenfolge Kapitalisierung, eine NumPy Array aus einer Liste von Zahlen zu schaffen und quadrierte sie,.. Oder Detrending eine 3D-Oberfläche Die Möglichkeiten sind grenzenlos)

(Nebenbei bemerkt, diese Frage enthält eine Antwort von @kindall dass endlich zu verstehen, hat mir geholfen - das warum, nicht, wie leider ist es als Duplikat von markiert. dieses , was ich denke, ist ein Fehler.)

Wenn es bestimmte Aussagen in unserem Modul (M.py) wir wollen ausgeführt werden, wenn es als Haupt ausgeführt werde (nicht importiert), können wir diese Aussagen (Testfälle, print-Anweisungen) stellen unter diesem if Block.

Wie standardmäßig (wenn das Modul als Haupt ausgeführt wird, nicht importiert) die __name__ Variable auf "__main__", und wenn es die __name__ Variable importiert werde einen anderen Wert bekommen, wahrscheinlich der Name des Moduls ('M') . Dies ist hilfreich, in verschiedenen Varianten eines Modulen zusammen laufen, und Trennung ihrer spezifischen Input & Output-Anweisungen und auch, wenn es irgendwelche Testfälle.

Kurz gesagt: , verwenden Sie diesen 'if __name__ == "main"' Block zu verhindern (bestimmte) Code von Lauf zu sein, wenn das Modul importiert wird.

Lassen Sie uns in einer abstrakteren Art und Weise auf die Antwort aussehen:

Angenommen, wir diesen Code in x.py haben:

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

Die Blöcke A und B laufen, wenn wir laufen "x.py".

Aber nur einen Block (und nicht B) ausgeführt wird, wenn wir ein anderes Modul ausgeführt wird, „y.py“ zum Beispiel, in dem xy importiert wird und der Code wird von dort aus laufen (wie wenn eine Funktion in „x. py“wird von y.py genannt).

Einfach gesagt, __name__ ist eine Variable für jedes Skript definiert, die das Skript legt fest, ob als Hauptmodul ausgeführt wird oder es als importierte Modul wird ausgeführt werden.

Wenn wir also zwei Skripte;

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

und

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

Die Ausgabe von der Ausführung script1 ist

Script 1's name: __main__

Und die Ausgabe von script2 Ausführung ist:

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

Wie Sie sehen können, sagt __name__ uns, welcher Code das ‚Haupt‘ Modul ist. Das ist großartig, weil Sie nur Code schreiben können und nicht über strukturelle Probleme wie in C / C ++ kümmern, wo, wenn eine Datei nicht eine ‚main‘ Funktion dann nicht implementiert es nicht als ausführbares kompiliert werden kann und wenn ja, es kann dann nicht als Bibliothek genutzt werden.

Sagen Sie bitte ein Python-Skript schreiben, die etwas Großes tut und Sie eine Schiffsladung von Funktionen implementieren, die für andere Zwecke nützlich sind. Wenn ich sie verwenden möchten, kann ich nur das Skript importieren und verwenden, ohne Ihr Programm ausgeführt wird (vorausgesetzt, dass der Code nur innerhalb des if __name__ == "__main__": Kontext ausführt). Während in C / C ++ würden Sie diese Stücke in ein separates Modul zum Teil aus, die dann die Datei enthält. Bild, um die Situation unter;

Die Pfeile sind Import-Links. Für drei Module jeweils versucht, den vorherigen Module Code gibt es sechs Dateien (neun, Zählen der Implementierungsdateien) und fünf Links zu umfassen. Dies macht es schwierig, einen anderen Code in ein C-Projekt, sofern diese nicht ausdrücklich als Bibliothek kompiliert wird. Jetzt Bild es für Python:

Sie schreiben ein Modul, und wenn jemand will, Ihren Code verwenden sie es einfach importieren und die __name__ Variable kann helfen, den ausführbaren Teil des Programms aus der Bibliothek Teil zu trennen.

Wenn Sie Python interaktiv die lokale __name__ Variable ausgeführt wird einen Wert von __main__ zugeordnet. Ebenso, wenn Sie einen Python-Modul über die Befehlszeile ausführen, anstatt es in ein anderes Modul zu importieren, wird sein __name__ Attribut einen Wert von __main__ zugewiesen, anstatt die tatsächlichen Namen des Moduls. Auf diese Weise kann die Module auf eigenem __name__ Wert suchen, selbst zu bestimmen, wie sie verwendet wird, wäre es als Unterstützung für ein anderes Programm oder als die Hauptanwendung von der Kommandozeile ausgeführt. Somit ist das folgende Idiom durchaus üblich, in Python-Modulen:

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.

Bedenken Sie:

if __name__ == "__main__":
    main()

Es wird überprüft, ob das __name__ Attribut des Python-Skript "__main__" ist. Mit anderen Worten, wenn das Programm selbst ausgeführt wird, wird das Attribut __main__, so wird das Programm (in diesem Fall der main() Funktion) ausgeführt werden.

Allerdings, wenn Ihr Python-Skript von einem Modul verwendet wird, wird jeder Code außerhalb der if Anweisung ausgeführt werden, so if \__name__ == "\__main__" nur verwendet wird, um zu überprüfen, ob das Programm als ein Modul verwendet wird oder nicht, und deshalb entscheidet, ob zu laufen der Code.

Bevor wir etwas über if __name__ == '__main__' es ist wichtig zu verstehen, was __name__ ist und was es tut.

Was ist __name__?

__name__ ist ein DunderAlias - gedacht werden kann, als eine Globale variable (erreichbar von Modulen) und arbeitet in einer ähnlichen Art und Weise zu global.

Es ist eine Zeichenfolge (global wie oben erwähnt), wie angegeben durch type(__name__) (nachgeben <class 'str'>), und ist eine eingebaute standard für beide Python 3 und Python 2 Versionen.

Wo:

Es kann nicht nur verwendet werden in-Skripte, sondern kann auch gefunden werden in beiden der Dolmetscher und Module/Pakete.

Interpreter:

>>> print(__name__)
__main__
>>>

Script:

test_file.py:

print(__name__)

Was in __main__

Modul oder Paket:

somefile.py:

def somefunction():
    print(__name__)

test_file.py:

import somefile
somefile.somefunction()

Was in somefile

Beachten Sie, dass, wenn verwendet, die in einem Paket oder Modul, __name__ nimmt den Namen der Datei.Der Pfad der eigentliche Modul oder package-Pfad ist nicht angegeben, sondern hat seine eigenen DunderAlias __file__,, die für diese ermöglicht.

Sie sollten sehen, dass, wo __name__,, wo ist die main-Datei (oder ein Programm) wird immer zurück __main__, und wenn es ein Modul/Paket, oder alles, was ausgeführt wird off einige andere Python-Skript, wird wieder der name der Datei, wo es entstanden ist.

Praxis:

Wird eine variable bedeutet, dass es Wert ist, können überschrieben werden sollen ("können" bedeutet nicht "sollte"), und überschreiben Sie den Wert von __name__ führt eine mangelnde Lesbarkeit.So tun es nicht, aus irgendeinem Grund.Wenn Sie benötigen eine variable eine neue variable definieren.

Es wird immer davon ausgegangen, dass der Wert von __name__ zu __main__ oder der name der Datei.Wieder einmal verändert das default-Wert zu noch mehr Verwirrung, es wird gut tun, die Probleme verursacht, weiter unten die Linie.

Beispiel:

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

Es wird als gute Praxis im Allgemeinen enthalten die if __name__ == '__main__' in scripts.

Nun zur Antwort if __name__ == '__main__':

Jetzt wissen wir, das Verhalten von __name__ die Dinge klarer werden:

Ein if ist eine flow control-Anweisung mit der code-block, der ausgeführt wird, wenn der Wert wahr ist.Wir haben gesehen, dass __name__ kann entweder __main__ oder der name der Datei wurde importiert aus.

Dies bedeutet, dass, wenn __name__ ist gleich __main__ dann muss die Datei sein, die main-Datei und muss tatsächlich ausgeführt werden (oder es ist der interpreter), nicht auf ein Modul oder ein Paket importiert, in das Skript ein.

Wenn ja, __name__ nimmt der Wert von __main__ dann was ist in diesem code-block ausgeführt wird.

Dies sagt uns, dass, wenn die Datei ausgeführt wird, ist der Haupt-Datei (oder Sie werden vom interpreter direkt) dann, dass die Bedingung ausgeführt werden müssen.Wenn es ist ein Paket, dann sollte es nicht, und der Wert wird nicht __main__.

Module:

__name__ kann auch verwendet werden in Modulen zu definieren, die den Namen eines Moduls

Varianten:

Es ist auch möglich, andere, weniger Häufig, aber nützliche Dinge mit __name__, einige zeige ich hier:

Ausführung nur, wenn die Datei ist ein Modul oder Paket:

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

Läuft eine Bedingung, wenn sich die Datei ist das Haupt-und ein anderer, wenn es nicht ist:

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

Sie können auch es verwenden, um runnable-Hilfe-Funktionen/Dienstprogramme auf Pakete und Module ohne den aufwendigen Einsatz von Bibliotheken.

Es ermöglicht auch Module, die aus der Befehlszeile ausgeführt als Haupt-Skripte, die auch sein kann sehr nützlich.

Ich denke, es am besten ist, die Antwort in der Tiefe und in einfachen Worten zu brechen:

__name__: Jedes Modul in Python hat ein spezielles Attribut namens __name__. Es ist eine integrierte Variable, die den Namen des Moduls zurück.

__main__: Wie andere Programmiersprachen auch Python hat einen Ausführungseinstiegspunkt, das heißt main. '__main__' ist der Name des Bereichs, in dem Top-Level-Code ausführt . Grundsätzlich haben Sie zwei Möglichkeiten, ein Python-Modul: Führen Sie es direkt als Skript oder importieren. Wenn ein Modul als Skript ausgeführt wird, seine __name__ wird auf __main__.

Somit wird der Wert des __name__ Attributs auf __main__, wenn das Modul wie das Hauptprogramm ausgeführt wird. Andernfalls wird der Wert von __name__ gesetzt, um den Namen des Moduls enthalten.

Es ist ein besondere für, wenn eine Python-Datei von der Kommandozeile aufgerufen wird. Dies wird normalerweise verwendet, um einen Anruf „main ()“ Funktion oder führen anderen geeigneten Startcode, wie Kommandozeilenargumente Handhabung zum Beispiel.

Es könnte auf verschiedene Weise geschrieben werden. Ein weiterer Grund ist:

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

Ich sage nicht, Sie in Produktionscode verwenden sollen, aber es soll zeigen, dass es nichts „magische“ über if __name__ == '__main__' ist. Es ist eine gute Konvention eine Hauptfunktion in Python-Dateien für den Aufruf.

Es gibt eine Reihe von Variablen, dass das System (Python-Interpreter) sieht Quelldateien (Module). Sie können ihre Werte jederzeit wollen erhalten Sie, also lassen Sie uns konzentrieren sich auf die __ __ Name Variable / Attribut:

Wenn Python eine Quellcodedatei lädt, es den gesamten Code darin gefunden ausführt. (Beachten Sie, dass es nicht alle Methoden und Funktionen in der Datei definiert ist nennen, aber es ihnen nicht definiert.)

Vor der Interpreter die Datei Quellcode ausführt obwohl, definiert es einige spezielle Variablen für diese Datei; __ __ Name ist einer dieser besonderen Variablen, die Python automatisch für jede Quellcodedatei definiert.

Wenn Python wird diese Quellcodedatei als das Hauptprogramm zu laden (dh die Datei, die Sie ausgeführt werden), dann setzt er den besonderen __ Namen __ Variable für diese Datei einen Wert hat „__ main__“ .

Wenn diese von einem anderen Modul importiert wird, __ __ Name wird dieses Moduls Name eingestellt werden.

Also, in Ihrem Beispiel teilweise:

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))

bedeutet, dass der Codeblock:

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

wird nur dann ausgeführt, wenn Sie das Modul direkt ausführen; der Codeblock wird nicht ausgeführt, wenn ein anderes Modul ruft / importieren, weil der Wert von __ Namen __ wird nicht gleich „ Haupt “ in diesem speziellen Fall.

Hope, das hilft aus.

if __name__ == "__main__": ist im Grunde die Top-Level-Skriptumgebung, und es gibt den Interpreter, dass ( "Ich habe die höchste Priorität zuerst ausgeführt werden müssen).

'__main__' ist der Name des Bereichs, in dem Top-Level-Code ausführt. Ein Moduls __name__ gleich gesetzt, wenn von der Standardeingabe, ein Skript oder aus einer interaktiven Eingabeaufforderung zu lesen '__main__'.

if __name__ == "__main__":
    # Execute only if run as a script
    main()

Der Grund für

if __name__ == "__main__":
    main()

ist in erster Linie die Importsperre Probleme, die von mit Code direkt importiert entstehen würden. Sie wollen main() wenn die Datei ausgeführt werden direkt aufgerufen wurde (das ist der __name__ == "__main__" Fall), aber wenn Ihr Code importiert wurde dann der Importeur hat den Code aus dem wahren Hauptmodul einzugeben, um Importsperre Probleme zu vermeiden.

Ein Nebeneffekt ist, dass Sie automatisch zu einer Methodik anmelden, die mehrere Einstiegspunkte unterstützt. Sie können Ihr Programm mit main() als Einstiegspunkt, laufen, aber Sie haben nicht zu . Während setup.py main() erwartet, verwenden andere Werkzeuge alternative Einstiegspunkte. Zum Beispiel Ihre Datei als gunicorn Prozess auszuführen, definieren Sie eine app() Funktion anstelle eines main(). Genau wie bei setup.py, gunicorn Importe Code, so dass Sie nicht wollen, dass es nichts tun tun, während es (wegen der Importsperre Ausgabe) importiert werden wird.

Ich habe in den Antworten auf dieser Seite so viel gelesen. Ich würde sagen, wenn Sie die Sache wissen, für sicher, dass Sie die Antworten verstehen, sonst, Sie sind immer noch verwirrt.

Um kurz zu sein, müssen Sie einige Punkte wissen:

import a Aktion läuft eigentlich alles, was in "a" ran werden kann
Aufgrund der Nummer 1, können Sie nicht wollen, dass alles in "a" ausgeführt werden beim Import es
das Problem in Punkt 2 zu lösen, Python können Sie eine Bedingungsprüfung setzen
__name__ ist eine implizite Variable in allen Py-Modulen; wenn a.py importiert wird, wird der Wert von __name__ von a.py Modul zu den Dateinamen „a“ gesetzt; wenn a.py wird direkt unter Verwendung von „Python a.py“ laufen, was bedeutet, a.py der Eintrittspunkt ist, dann wird der Wert des __name__ a.py Modul in einen String __main__ gesetzt
Basierend auf dem Mechanismus, wie Python die Variable __name__ für jedes Modul setzt, wissen Sie, wie Punkt 3 zu erreichen? Die Antwort ist ziemlich einfach, nicht wahr? Setzen Sie ein, wenn die Bedingung: if __name__ == "__main__": ...; Sie können auch wenn __name__ == "a" je nach Funktionsbedarf setzen

Das Wichtigste ist, dass Python ist das Besondere an ist Punkt 4! Der Rest ist nur grundlegende Logik.

Bedenken Sie:

print __name__

Der Ausgang für die oben ist __main__.

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

Die obige Aussage wahr ist und druckt "direkte Methode" . Nehmen wir an, wenn sie diese Klasse in eine andere Klasse importiert es nicht drucken „direkte Methode“ , weil während des Imports, wird es eingestellt __name__ equal to "first model name".

Sie können machen die Datei verwendbar als Skript sowie ein importierbaren Modul .

fibo.py (ein Modul mit dem Namen 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]))

Referenz: https://docs.python.org/3.5/tutorial/modules. html

Diese Antwort ist für Java-Programmierer lernen Python. Jede Java-Datei enthält in der Regel eine öffentliche Klasse. Sie können diese Klasse auf zwei Arten verwendet werden:

Rufen Sie die Klasse aus anderen Dateien. Sie müssen es nur im rufenden Programm importieren.
Führen Sie die Klasse stehen für Testzwecke allein.

Für den letzteren Fall sollte die Klasse eine public static void main () Methode enthält. In Python wird diese Aufgabe durch die global definierte Label '__main__' serviert.

Wenn diese Py-Datei von anderen Py-Dateien importiert wird, wird der Code unter „die if-Anweisung“ nicht ausgeführt werden.

Wenn diese Py von python this_py.py unter Shell ausgeführt werden, oder doppelt angeklickt in Windows. der Code unter „die if-Anweisung“ ausgeführt wird.

Es ist in der Regel für die Prüfung geschrieben.

Erstellen

eine Datei a.py :

print(__name__) # It will print out __main__

__name__ ist immer gleich __main__, wenn die Datei ist laufen direkt zeigt, dass dies die Hauptdatei ist.

Erstellen Sie eine andere Datei, b.py , im selben Verzeichnis:

import a  # Prints a

Starten Sie es. Es druckt a , das heißt, der Name der Datei, die wird importiert .

So zeigt zwei unterschiedliche Verhalten der gleichen Datei , das ist ein häufig verwendeter Trick:

# Code to be run when imported into another python file

if __name__ == '__main__':
    # Code to be run only when run directly

, wenn Namen == ' Haupt ':

Wir sehen, wenn sehr oft __name__ == '__main__':.

Es wird überprüft, ob ein Modul importiert wird oder nicht.

Mit anderen Worten, wird der Code innerhalb des if Block nur ausgeführt werden, wenn der Code direkt ausgeführt wird. Hier directly bedeutet not imported.

Lassen Sie uns sehen, was es einen einfachen Code nicht verwenden, das den Namen des Moduls druckt:

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

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

Wenn wir den Code direkt über python test.py laufen, der Modulname ist __main__:

call test()
test module name=__main__

Alle Antworten haben erklärt, so ziemlich die Funktionalität. Aber ich werde ein Beispiel für die Verwendung zur Verfügung stellen, die das Konzept Ausräumen könnte helfen weiter.

Angenommen, Sie zwei Python-Dateien haben, a.py und b.py. Nun a.py Importe b.py. Wir betreiben die a.py Datei, wo der „Import b.py“ Code zuerst ausgeführt wird. Bevor der Rest des a.py Code ausgeführt wird, muss der Code in der Datei b.py vollständig ausgeführt werden.

Im b.py Code gibt es einige Codes, der auf diese Datei b.py exklusiv ist, und wir wollen keine andere Datei (außer b.py-Datei), die die b.py Datei importiert hat, um führen sie es.

Das ist also, was diese Zeile Code überprüft. Wenn es die Hauptdatei (das heißt, b.py) ist der Code ausgeführt wird, die in diesem Fall ist es nicht (a.py ist die Hauptdatei läuft), dann wird nur der Code ausgeführt wird.

Einfach ist es der Einstiegspunkt die Datei wie die main Funktion in der C Programmiersprache.

laufen

Jedes Modul in Python hat ein Attribut, das als Namen bezeichnet wird. Der Wert von Namen Attribute ' Haupt ', wenn das Modul läuft direkt. Andernfalls wird der Wert von Namen ist der Name des Moduls.

Kleines Beispiel kurz zu erklären.

#Script test.py

apple = 42

def hello_world():
    print("I am inside hello_world")

if __name__ == "__main__":
    print("Value of __name__ is: ", __name__)
    print("Going to call hello_world")
    hello_world()

Wir können dies direkt ausführen als

python test.py

Output

Value of __name__ is: __main__
Going to call hello_world
I am inside hello_world

Nehmen wir nun an wir oben Skript aufrufen aus anderen Skript

#script external_calling.py

import test
print(test.apple)
test.hello_world()

print(test.__name__)

Wenn Sie ausführen dieses

python external_calling.py

Output

42
I am inside hello_world
test

So, oben ist selbsterklärend, dass, wenn Sie anrufen Test von anderen Skript, wenn Schleife Namen in test.py werden nicht ausgeführt.

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow

Was bedeutet, wenn name == "main":tun?

Code-Beispiel

Spezielle Variablen

Ausführen des Moduls-Code

Warum kommt es auf diese Weise funktionieren?

Food for Thought

Was macht den `if name == "main":`?

Entwickeln und Testen des Code

Das Problem

A Better Way

Ein noch besserer Weg

Was bedeutet `if name == "main":` tun?

, wenn Namen == ' Haupt ':

Was bedeutet, wenn __name__ == "__main__":tun?

Code-Beispiel

Spezielle Variablen

Ausführen des Moduls-Code

Warum kommt es auf diese Weise funktionieren?

Food for Thought

Was macht den if __name__ == "__main__":?

Entwickeln und Testen des Code

Das Problem

A Better Way

Ein noch besserer Weg

Was bedeutet if __name__ == "__main__": tun?

, wenn Namen == ' Haupt ':

Was bedeutet, wenn name == "main":tun?

Was macht den `if name == "main":`?

Was bedeutet `if name == "main":` tun?