Was macht der folgende Code 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))

Immer wenn der Python-Interpreter eine Quelldatei liest, führt er zwei Dinge aus:

• es setzt ein paar spezielle Variablen wie __name__und dann

• Es führt den gesamten in der Datei gefundenen Code aus.

Mal sehen, wie das funktioniert und wie es sich auf Ihre Frage zu den __name__Überprüfungen bezieht, die wir immer in Python-Skripten sehen.

Codebeispiel

Lassen Sie uns anhand eines etwas anderen Codebeispiels untersuchen, wie Importe und Skripte funktionieren. Angenommen, das Folgende befindet sich in einer Datei mit dem Namen foo.py.

# 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, definiert er zunächst einige spezielle Variablen. In diesem Fall kümmern wir uns um die __name__Variable.

Wenn Ihr Modul das Hauptprogramm ist

Wenn Sie Ihr Modul (die Quelldatei) als Hauptprogramm ausführen, z

python foo.py

Der Interpreter weist "__main__"der __name__Variablen die fest codierte Zeichenfolge zu , d. h

# 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 von einem anderen importiert wird

Angenommen, ein anderes Modul ist das Hauptprogramm und importiert Ihr Modul. Dies bedeutet, dass es eine solche Anweisung im Hauptprogramm oder in einem anderen Modul gibt, das das Hauptprogramm importiert:

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

Der Interpreter sucht nach Ihrer foo.pyDatei (zusammen mit der Suche nach einigen anderen Varianten) und weist vor der Ausführung dieses Moduls "foo"der __name__Variablen den Namen aus der Importanweisung zu , d. H.

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

Nachdem die speziellen Variablen eingerichtet wurden, führt der Interpreter den gesamten Code im Modul nacheinander aus. Möglicherweise möchten Sie ein weiteres Fenster neben dem Codebeispiel öffnen, damit Sie dieser Erklärung folgen können.

Immer

1. Es druckt die Zeichenfolge "before import"(ohne Anführungszeichen).

2. Es lädt das mathModul und weist es einer Variablen mit dem Namen zu math. Dies entspricht dem Ersetzen import mathdurch Folgendes (beachten Sie, dass dies __import__eine einfache Funktion in Python ist, die eine Zeichenfolge verwendet und den eigentlichen Import auslöst):

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

3. Es druckt die Zeichenfolge "before functionA".

4. Es führt den defBlock aus, erstellt ein Funktionsobjekt und weist dieses Funktionsobjekt dann einer Variablen mit dem Namen zu functionA.

5. Es druckt die Zeichenfolge "before functionB".

6. Es führt den zweiten defBlock aus, erstellt ein anderes Funktionsobjekt und weist es dann einer aufgerufenen Variablen zu functionB.

7. Es druckt die Zeichenfolge "before __name__ guard".

Nur wenn Ihr Modul das Hauptprogramm ist

8. Wenn Ihr Modul das Hauptprogramm ist, wird es sehen, dass __name__es tatsächlich auf eingestellt wurde, "__main__"und es ruft die beiden Funktionen auf, druckt die Zeichenfolgen "Function A"und "Function B 10.0".

Nur wenn Ihr Modul von einem anderen importiert wird

8. ( stattdessen ) Wenn Ihr Modul nicht das Hauptprogramm ist, sondern von einem anderen importiert wurde, __name__wird dies "foo"nicht der Fall sein "__main__", und der Hauptteil der ifAnweisung wird übersprungen .

Immer

9. "after __name__ guard"In beiden Situationen wird die Zeichenfolge gedruckt .

Zusammenfassung

Zusammenfassend ist hier, was in den beiden Fällen gedruckt werden würde:

# 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 funktioniert es so?

Sie könnten sich natürlich fragen, warum jemand dies wollen würde. Manchmal möchten Sie eine .pyDatei schreiben , die sowohl von anderen Programmen als auch von Modulen als Modul verwendet und auch als Hauptprogramm selbst ausgeführt werden kann. Beispiele:

• Ihr Modul ist eine Bibliothek, aber Sie möchten einen Skriptmodus, in dem einige Komponententests oder eine Demo ausgeführt werden.

• Ihr Modul wird nur als Hauptprogramm verwendet, verfügt jedoch über einige Komponententests. Das Testframework importiert .pyDateien wie Ihr Skript und führt spezielle Testfunktionen aus. Sie möchten nicht, dass das Skript ausgeführt wird, nur weil es das Modul importiert.

• Ihr Modul wird hauptsächlich als Hauptprogramm verwendet, bietet aber auch eine programmiererfreundliche API für fortgeschrittene Benutzer.

Abgesehen von diesen Beispielen ist es elegant, dass beim Ausführen eines Skripts in Python nur einige magische Variablen eingerichtet und das Skript importiert werden. Das "Ausführen" des Skripts ist ein Nebeneffekt beim Importieren des Skriptmoduls.

Denkanstöße

• Frage: Kann ich mehrere __name__Prüfblöcke haben? Antwort: Es ist seltsam, dies zu tun, aber die Sprache wird Sie nicht aufhalten.

• Angenommen, das Folgende ist in foo2.py. Was passiert, wenn Sie python foo2.pyin der Befehlszeile 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")

• Stellen Sie nun fest, was passiert, wenn Sie den __name__Check-in entfernen foo3.py:

# 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 es als Skript verwendet wird? Beim Import als Modul?

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

def bar():
    print("bar")

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

Wenn Ihr Skript ausgeführt wird, indem Sie es als Befehl an den Python-Interpreter übergeben,

python myscript.py

Der gesamte Code auf Einrückungsstufe 0 wird ausgeführt. Definierte Funktionen und Klassen sind gut definiert, aber keiner ihrer Codes wird ausgeführt. Im Gegensatz zu anderen Sprachen gibt es keine main()Funktion, die automatisch ausgeführt wird - die main()Funktion besteht implizit aus dem gesamten Code auf der obersten Ebene.

In diesem Fall ist der Code der obersten Ebene ein ifBlock. __name__ist eine integrierte Variable, die den Namen des aktuellen Moduls ergibt. Wenn jedoch ein Modul direkt ausgeführt wird (wie myscript.pyoben), wird __name__stattdessen die Zeichenfolge festgelegt "__main__". Auf diese Weise können Sie testen, ob Ihr Skript direkt ausgeführt oder durch Testen von etwas anderem importiert wird

if __name__ == "__main__":
    ...

Wenn Ihr Skript in ein anderes Modul importiert wird, werden seine verschiedenen Funktions- und Klassendefinitionen importiert und sein Code der obersten Ebene ausgeführt, jedoch der Code im damaligen Text des if obigen Klausel wird nicht ausgeführt, wie es die Bedingung ist nicht angetroffen. Betrachten Sie als grundlegendes Beispiel die folgenden zwei Skripte:

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

Nun, wenn Sie den Interpreter als aufrufen

python one.py

Die Ausgabe wird sein

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

Wenn du läufst two.py stattdessen :

python two.py

Du erhältst

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 ein Modul onegeladen wird, ist es __name__gleich "one"statt "__main__".

Die einfachste Erklärung für die __name__Variable (imho) lautet wie folgt:

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__

Wenn Sie sie ausführen, erhalten Sie folgende Ausgabe:

$ python a.py
Hello World from b!

Wie Sie sehen können, setzt Python beim Importieren eines Moduls globals()['__name__']in diesem Modul den Namen des Moduls. Außerdem wird beim Import der gesamte Code im Modul ausgeführt. Da die ifAnweisung zu Falsediesem Teil ausgewertet wird, wird nicht ausgeführt.

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

Wie Sie sehen können, setzt Python globals()['__name__']bei der Ausführung einer Datei in dieser Datei auf "__main__". Dieses Mal wird die ifAnweisung ausgewertet Trueund ausgeführt.

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

Um die Grundlagen zu skizzieren:

• Die globale Variable __name__in dem Modul, das der Einstiegspunkt für Ihr Programm ist, lautet '__main__'. Andernfalls ist es der Name, unter dem Sie das Modul importieren.

• Code unter dem ifBlock wird also nur ausgeführt, wenn das Modul der Einstiegspunkt für Ihr Programm ist.

• Damit kann der Code im Modul von anderen Modulen importiert werden, ohne dass der darunter liegende Codeblock beim Import ausgeführt werden muss.

Warum brauchen wir das?

Entwickeln und Testen Ihres Codes

Angenommen, Sie schreiben ein Python-Skript, das als Modul verwendet werden soll:

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

Sie können das Modul testen, indem Sie diesen Aufruf der Funktion unten hinzufügen:

do_important()

und ausführen (an einer Eingabeaufforderung) mit etwas wie:

~$ python important.py

Das Problem

Wenn Sie das Modul jedoch in ein anderes Skript importieren möchten:

import important

Beim Import wird die do_importantFunktion aufgerufen, sodass Sie Ihren Funktionsaufruf wahrscheinlich do_important()unten auskommentieren würden.

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

Und dann müssen Sie sich daran erinnern, ob Sie Ihren Testfunktionsaufruf auskommentiert haben oder nicht. Und diese zusätzliche Komplexität würde bedeuten, dass Sie wahrscheinlich vergessen werden, was Ihren Entwicklungsprozess schwieriger macht.

Ein besserer Weg

Das __name__ Variable zeigt auf den Namespace, wo immer sich der Python-Interpreter gerade befindet.

In einem importierten Modul ist dies der Name dieses Moduls.

Innerhalb des primären Moduls (oder einer interaktiven Python-Sitzung, dh Read, Eval, Print Loop oder REPL des Interpreters) führen Sie jedoch alles aus "__main__".

Wenn Sie also vor der Ausführung überprüfen:

if __name__ == "__main__":
    do_important()

Mit dem oben Gesagten wird Ihr Code nur ausgeführt, wenn Sie ihn als primäres Modul ausführen (oder ihn absichtlich von einem anderen Skript aus aufrufen).

Ein noch besserer Weg

Es gibt jedoch einen pythonischen Weg, dies zu verbessern.

Was ist, wenn wir diesen Geschäftsprozess von außerhalb des Moduls ausführen möchten?

Wenn wir den Code, den wir üben möchten, während wir uns entwickeln und testen, in eine Funktion wie diese einfügen und dann '__main__'unmittelbar danach prüfen :

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, die ausgeführt wird, wenn wir das Modul als primäres Modul ausführen.

Es ermöglicht das Importieren des Moduls und seiner Funktionen und Klassen in andere Skripte, ohne die mainFunktion auszuführen, und ermöglicht auch das Aufrufen des Moduls (und seiner Funktionen und Klassen), wenn es von einem anderen '__main__'Modul ausgeführt wird, d. H.

import important
important.main()

Diese Redewendung finden Sie auch in der Python-Dokumentation in einer Erläuterung des __main__Moduls. In diesem Text heißt es:

Dieses Modul stellt den (ansonsten anonymen) Bereich dar, in dem das Hauptprogramm des Interpreters ausgeführt wird - Befehle, die entweder von der Standardeingabe, von einer Skriptdatei oder von einer interaktiven Eingabeaufforderung gelesen werden. In dieser Umgebung wird in der Zeilengruppe "Bedingtes Skript" ein Skript ausgeführt:

if __name__ == '__main__':
    main()

if __name__ == "__main__"ist der Teil, der ausgeführt wird, wenn das Skript über die Befehlszeile mit einem Befehl wie ausgeführt wird python myscript.py.

Was macht if __name__ == "__main__":das

__name__ist eine globale Variable (in Python bedeutet global tatsächlich auf Modulebene ), die in allen Namespaces vorhanden ist. Dies ist normalerweise der Name des Moduls (alsstr Typ).

Als einziger Sonderfall jedoch in jedem Python-Prozess, den Sie ausführen, wie in mycode.py:

python mycode.py

der ansonsten anonyme globale Namensraum, um den Wert zugewiesen , '__main__'um seine __name__.

Also einschließlich der letzten Zeilen

if __name__ == '__main__':
    main()

• am Ende Ihres mycode.py-Skripts,
• Wenn es sich um das primäre Einstiegspunktmodul handelt, das von einem Python-Prozess ausgeführt wird,

bewirkt, dass Ihr Skript eindeutig definiert ist main Funktion ausgeführt wird.

Ein weiterer Vorteil der Verwendung dieses Konstrukts: Sie können Ihren Code auch als Modul in ein anderes Skript importieren und dann die Hauptfunktion ausführen, wenn Ihr Programm entscheidet:

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

Es gibt hier viele verschiedene Einstellungen zur Mechanik des fraglichen Codes, dem "Wie", aber für mich ergab nichts davon Sinn, bis ich das "Warum" verstand. Dies sollte insbesondere für neue Programmierer hilfreich sein.

Nehmen Sie die 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 macht dieser Code eigentlich?

Wenn Sie ausführen xy.py, Sie import ab. Die import-Anweisung führt das Modul sofort beim Import aus, sodass abdie Operationen vor dem Rest von ausgeführt werden xy. Sobald Sie fertig sind ab, geht es weiter mitxy .

Der Interpreter verfolgt, mit welchen Skripten ausgeführt wird __name__. Wenn Sie ein Skript ausführen - unabhängig davon, wie Sie es benannt haben -, ruft der Interpreter es auf "__main__"und macht es zum Master- oder Home-Skript, zu dem nach dem Ausführen eines externen Skripts zurückgekehrt wird.

Jedem anderen Skript, das von diesem "__main__"Skript aufgerufen wird, wird sein Dateiname als __name__(z __name__ == "ab.py". B. ) zugewiesen . Daher die Linieif __name__ == "__main__": der Test des Interpreters, um festzustellen, ob das ursprünglich ausgeführte 'Home'-Skript interpretiert / analysiert wird oder ob es vorübergehend in ein anderes (externes) Skript späht. Dies gibt dem Programmierer die Flexibilität, dass sich das Skript anders verhält, wenn es direkt ausgeführt wird oder extern aufgerufen wird.

Lassen Sie uns den obigen Code durchgehen, um zu verstehen, was passiert, und uns zunächst auf die nicht eingerückten Zeilen und die Reihenfolge konzentrieren, in der sie in den Skripten erscheinen. Denken Sie daran, dass Funktions- oder defBlöcke erst dann selbstständig etwas tun, wenn sie aufgerufen werden. Was der Dolmetscher sagen könnte, wenn er vor sich hin murmelt:

• Öffnen Sie xy.py als "Home" -Datei. Nennen Sie es "__main__"in der __name__Variablen.
• Importieren und öffnen Sie die Datei mit dem __name__ == "ab.py".
• Oh, eine Funktion. Ich werde mich daran erinnern.
• Ok, Funktion a(); Das habe ich gerade gelernt. Drucken ' Eine Funktion in einer ab-Datei '.
• Ende der Datei; zurück zu "__main__"!
• Oh, eine Funktion. Ich werde mich daran erinnern.
• Noch einer.
• Funktion x(); ok, ' Peripherie-Aufgabe drucken : könnte in anderen Projekten nützlich sein '.
• Was ist das? Eine ifAussage. Nun, die Bedingung wurde erfüllt (die Variable __name__wurde auf gesetzt "__main__"), also gebe ich die main()Funktion ein und drucke ' Hauptfunktion: Hier ist die Aktion '.

Die beiden unteren Zeilen bedeuten: "Wenn dies das "__main__"oder 'Home'-Skript ist, führen Sie die aufgerufene Funktion aus. main()" Aus diesem Grund wird oben ein def main():Block angezeigt, der den Hauptfluss der Skriptfunktionalität enthält.

Warum dies implementieren?

Erinnerst du dich, was ich früher über Importanweisungen gesagt habe? Wenn Sie ein Modul importieren, erkennt es es nicht nur und wartet auf weitere Anweisungen. Es führt tatsächlich alle im Skript enthaltenen ausführbaren Vorgänge aus. Wenn Sie also das Fleisch Ihres Skripts in die main()Funktion einfügen, wird es effektiv unter Quarantäne gestellt und isoliert, sodass es beim Import durch ein anderes Skript nicht sofort ausgeführt wird.

Auch hier wird es Ausnahmen geben, aber es ist üblich, dass main()diese normalerweise nicht extern aufgerufen werden. Sie fragen sich vielleicht noch etwas: Wenn wir nicht anrufen main(), warum rufen wir das Skript überhaupt auf? Dies liegt daran, dass viele Benutzer ihre Skripte mit eigenständigen Funktionen strukturieren, die unabhängig vom Rest des Codes in der Datei ausgeführt werden können. Sie werden dann später an einer anderen Stelle im Hauptteil des Skripts aufgerufen. Was mich dazu bringt:

Aber der Code funktioniert ohne

Ja, das ist richtig. Diese separaten Funktionen können über ein Inline-Skript aufgerufen werden, das nicht in einer main()Funktion enthalten ist. Wenn Sie es gewohnt sind (wie ich es bin, in meinen frühen Lernphasen der Programmierung), Inline-Skripte zu erstellen, die genau das tun, was Sie brauchen, und Sie werden versuchen, es erneut herauszufinden, wenn Sie diese Operation jemals wieder benötigen. Nun, Sie sind nicht an diese Art der internen Struktur Ihres Codes gewöhnt, da die Erstellung komplizierter und das Lesen nicht so intuitiv ist.

Aber das ist ein Skript, dessen Funktionen wahrscheinlich nicht extern aufgerufen werden können, da es sonst sofort mit der Berechnung und Zuweisung von Variablen beginnen würde. Wenn Sie versuchen, eine Funktion wiederzuverwenden, ist Ihr neues Skript wahrscheinlich eng genug mit dem alten verwandt, sodass es zu widersprüchlichen Variablen kommt.

Durch das Aufteilen unabhängiger Funktionen erhalten Sie die Möglichkeit, Ihre vorherigen Arbeiten wiederzuverwenden, indem Sie sie in ein anderes Skript aufrufen. Zum Beispiel könnte "example.py" "xy.py" importieren und aufrufen x(), wobei die Funktion 'x' aus "xy.py" verwendet wird. (Vielleicht wird das dritte Wort einer bestimmten Textzeichenfolge großgeschrieben, ein NumPy-Array aus einer Liste von Zahlen erstellt und quadriert oder eine 3D-Oberfläche beeinträchtigt. Die Möglichkeiten sind unbegrenzt.)

(Abgesehen davon enthält diese Frage eine Antwort von @kindall, die mir endlich geholfen hat zu verstehen - das Warum, nicht das Wie. Leider wurde sie als Duplikat dieser markiert , was ich für einen Fehler halte.)

Wenn unser Modul ( M.py) bestimmte Anweisungen enthält , die ausgeführt werden sollen, wenn es als main (nicht importiert) ausgeführt wird, können wir diese Anweisungen (Testfälle, print-Anweisungen) unter diesen ifBlock stellen.

Standardmäßig (wenn das Modul als Hauptmodul ausgeführt wird, nicht importiert) ist die __name__Variable auf festgelegt "__main__", und wenn sie importiert __name__wird, erhält die Variable einen anderen Wert, höchstwahrscheinlich den Namen des Moduls ( 'M'). Dies ist hilfreich, um verschiedene Varianten eines Moduls zusammen auszuführen, ihre spezifischen Eingabe- und Ausgabeanweisungen zu trennen und auch wenn es Testfälle gibt.

Kurz gesagt , verwenden Sie diesen ' if __name__ == "main"' Block, um zu verhindern, dass (bestimmter) Code ausgeführt wird, wenn das Modul importiert wird.

Einfach ausgedrückt __name__ist eine Variable für jedes Skript definiert, die definiert, ob das Skript als Hauptmodul oder als importiertes Modul ausgeführt wird.

Wenn wir also zwei Skripte haben;

#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 von script1 ist

Script 1's name: __main__

Die Ausgabe von script2 lautet:

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

Wie Sie sehen können, __name__erfahren Sie, welcher Code das Hauptmodul ist. Dies ist großartig, da Sie einfach Code schreiben können und sich nicht um strukturelle Probleme wie in C / C ++ kümmern müssen. Wenn eine Datei keine 'Haupt'-Funktion implementiert, kann sie nicht als ausführbare Datei kompiliert werden. Es kann dann nicht als Bibliothek verwendet werden.

Angenommen, Sie schreiben ein Python-Skript, das etwas Großartiges leistet, und Sie implementieren eine Vielzahl von Funktionen, die für andere Zwecke nützlich sind. Wenn ich sie verwenden möchte, kann ich einfach Ihr Skript importieren und verwenden, ohne Ihr Programm auszuführen (vorausgesetzt, Ihr Code wird nur im if __name__ == "__main__":Kontext ausgeführt). Während in C / C ++ diese Teile in ein separates Modul aufgeteilt werden müssten, das dann die Datei enthält. Stellen Sie sich die Situation unten vor.

Die Pfeile sind Importlinks. Für drei Module, die jeweils versuchen, den Code des vorherigen Moduls einzuschließen, gibt es sechs Dateien (neun, die Implementierungsdateien werden gezählt) und fünf Links. Dies macht es schwierig, anderen Code in ein C-Projekt aufzunehmen, es sei denn, er wurde speziell als Bibliothek kompiliert. Stellen Sie es sich jetzt für Python vor:

Sie schreiben ein Modul, und wenn jemand Ihren Code verwenden möchte, importiert er ihn einfach und die __name__Variable kann dazu beitragen, den ausführbaren Teil des Programms vom Bibliotheksteil zu trennen.

Schauen wir uns die Antwort abstrakter an:

Angenommen, wir haben diesen Code in x.py:

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

Die Blöcke A und B werden ausgeführt, wenn wir ausgeführt werden x.py.

Aber nur Block A (und nicht B) wird ausgeführt, wenn wir beispielsweise ein anderes Modul ausführen y.py, in das x.pyimportiert wird und der Code von dort ausgeführt wird (wie wenn eine Funktion in von x.pyaufgerufen wird y.py).

Wenn Sie Python interaktiv ausführen, wird der lokalen __name__Variablen der Wert "zugewiesen" __main__. Wenn Sie ein Python-Modul über die Befehlszeile ausführen, anstatt es in ein anderes Modul zu importieren, wird seinem __name__Attribut der Wert __main__und nicht der tatsächliche Name des Moduls zugewiesen . Auf diese Weise können Module anhand ihres eigenen __name__Werts selbst bestimmen, wie sie verwendet werden, sei es als Unterstützung für ein anderes Programm oder als Hauptanwendung, die über die Befehlszeile ausgeführt wird. Daher ist die folgende Redewendung in Python-Modulen weit verbreitet:

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.

Erwägen:

if __name__ == "__main__":
    main()

Es wird geprüft, ob das __name__Attribut des Python-Skripts lautet "__main__". Mit anderen Worten, wenn das Programm selbst ausgeführt wird, lautet das Attribut __main__, sodass das Programm ausgeführt wird (in diesem Fall die main()Funktion).

Wenn Ihr Python-Skript jedoch von einem Modul verwendet wird, wird jeder Code außerhalb der ifAnweisung ausgeführt, sodass if \__name__ == "\__main__"nur überprüft wird, ob das Programm als Modul verwendet wird oder nicht, und daher entschieden wird, ob der Code ausgeführt werden soll.

Bevor Sie etwas darüber erklären, if __name__ == '__main__'ist es wichtig zu verstehen, was __name__ist und was es tut.

Was ist __name__?

__name__ist ein DunderAlias - kann als globale Variable betrachtet werden (über Module zugänglich) und funktioniert ähnlich wie global.

Es ist eine Zeichenfolge (global wie oben erwähnt), wie durch type(__name__)(Nachgeben <class 'str'>) angegeben, und ein integrierter Standard für Python 3- und Python 2- Versionen.

Wo:

Es kann nicht nur in Skripten verwendet werden, sondern ist auch sowohl im Interpreter als auch in Modulen / Paketen enthalten.

Dolmetscher:

>>> print(__name__)
__main__
>>>

Skript:

test_file.py :

print(__name__)

Ergebend __main__

Modul oder Paket:

somefile.py:

def somefunction():
    print(__name__)

test_file.py:

import somefile
somefile.somefunction()

Ergebend somefile

Beachten Sie, dass bei Verwendung in einem Paket oder Modul __name__der Name der Datei verwendet wird. Der Pfad des eigentlichen Modul- oder Paketpfads wird nicht angegeben, verfügt jedoch über eigene DunderAlias __file__, die dies ermöglichen.

Sie sollten sehen, dass, wo __name__, wo es sich um die Hauptdatei (oder das Hauptprogramm) handelt, immer zurückgegeben __main__wird und wenn es sich um ein Modul / Paket oder etwas handelt, das von einem anderen Python-Skript ausgeführt wird, der Name der Datei zurückgegeben wird, in der es sich befindet stammt aus.

Trainieren:

Eine Variable sein bedeutet, dass es den Wert kann überschrieben werden ( „kann“ bedeutet nicht „sollte“), um den Wert des Überschreiben __name__in einem Mangel an Lesbarkeit führt. Also tu es aus irgendeinem Grund nicht. Wenn Sie eine Variable benötigen, definieren Sie eine neue Variable.

Es wird immer davon ausgegangen , dass der Wert __name__sein , __main__oder den Namen der Datei. Das erneute Ändern dieses Standardwerts führt zu mehr Verwirrung darüber, dass er gut tut, und führt später zu Problemen.

Beispiel:

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

Es wird allgemein als bewährte Methode angesehen, die if __name__ == '__main__'Skripte einzubeziehen.

Nun zur Antwort if __name__ == '__main__':

Jetzt wissen wir, dass das Verhalten der __name__Dinge klarer wird:

An ifist eine Flusssteuerungsanweisung, die den Codeblock enthält, der ausgeführt wird, wenn der angegebene Wert wahr ist. Wir haben gesehen, dass __name__entweder __main__oder der Dateiname, aus dem es importiert wurde, verwendet werden kann.

Dies bedeutet, dass wenn __name__gleich, __main__dann muss die Datei die Hauptdatei sein und tatsächlich ausgeführt werden (oder es ist der Interpreter), nicht ein Modul oder Paket, das in das Skript importiert wird.

Wenn tatsächlich __name__der Wert von angenommen wird, __main__wird alles ausgeführt, was sich in diesem Codeblock befindet.

Dies sagt uns, dass diese Bedingung ausgeführt werden muss, wenn die ausgeführte Datei die Hauptdatei ist (oder wenn Sie direkt vom Interpreter ausgeführt werden). Wenn es sich um ein Paket handelt, sollte dies nicht der Fall sein, und der Wert wird nicht angegeben __main__.

Module:

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

Varianten:

Es ist auch möglich, andere, weniger verbreitete, aber nützliche Dinge zu tun __name__, von denen ich einige hier zeigen werde:

Wird nur ausgeführt, wenn die Datei ein Modul oder Paket ist:

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

Ausführen einer Bedingung, wenn die Datei die Hauptdatei ist, und einer anderen, wenn dies nicht der Fall ist:

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

Sie können es auch verwenden, um ausführbare Hilfefunktionen / Dienstprogramme für Pakete und Module bereitzustellen, ohne dass Bibliotheken aufwändig verwendet werden müssen.

Außerdem können Module über die Befehlszeile als Hauptskripte ausgeführt werden, was ebenfalls sehr nützlich sein kann.

Ich denke, es ist am besten, die Antwort 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ückgibt.

__main__: Wie andere Programmiersprachen hat auch Python einen Ausführungseinstiegspunkt, dh main. '__main__' ist der Name des Bereichs, in dem Code der obersten Ebene ausgeführt wird . Grundsätzlich haben Sie zwei Möglichkeiten, ein Python-Modul zu verwenden: Führen Sie es direkt als Skript aus oder importieren Sie es. Wenn ein Modul als Skript ausgeführt wird, __name__wird es auf gesetzt __main__.

Daher wird der Wert des __name__Attributs festgelegt, __main__wenn das Modul als Hauptprogramm ausgeführt wird. Andernfalls wird der Wert von __name__ so festgelegt, dass er den Namen des Moduls enthält.

Dies ist eine Besonderheit, wenn eine Python-Datei über die Befehlszeile aufgerufen wird. Dies wird normalerweise verwendet, um eine "main ()" - Funktion aufzurufen oder einen anderen geeigneten Startcode auszuführen, z. B. die Behandlung von Befehlszeilenargumenten.

Es könnte auf verschiedene Arten geschrieben werden. Ein anderer ist:

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

Ich sage nicht, dass Sie dies im Produktionscode verwenden sollten, aber es dient dazu zu veranschaulichen, dass es nichts "Magisches" gibt if __name__ == '__main__'. Dies ist eine gute Konvention zum Aufrufen einer Hauptfunktion in Python-Dateien.

Es gibt eine Reihe von Variablen, die das System (Python-Interpreter) für Quelldateien (Module) bereitstellt. Sie können ihre Werte jederzeit abrufen. Konzentrieren wir uns also auf den __name__ Variable / das Attribut :

Wenn Python eine Quellcodedatei lädt, führt es den gesamten darin enthaltenen Code aus. (Beachten Sie, dass nicht alle in der Datei definierten Methoden und Funktionen aufgerufen, sondern definiert werden.)

Bevor der Interpreter die Quellcodedatei ausführt, definiert er einige spezielle Variablen für diese Datei. __Name__ ist eine dieser speziellen Variablen, die Python automatisch für jede Quellcodedatei definiert.

Wenn Python diese Quellcodedatei als Hauptprogramm (dh die von Ihnen ausgeführte Datei) lädt, setzt es die spezielle Variable __name__ für diese Datei auf den Wert "__main__" .

Wenn dies aus einem anderen Modul importiert wird , wird __name__ auf den Namen dieses Moduls gesetzt.

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 ausgeführt, wenn Sie das Modul direkt ausführen; Der Codeblock wird nicht ausgeführt, wenn ein anderes Modul ihn aufruft / importiert, da der Wert von __name__ in dieser bestimmten Instanz nicht gleich " main " ist.

Hoffe das hilft.

if __name__ == "__main__": ist im Grunde die Skriptumgebung der obersten Ebene und gibt den Interpreter an, der ('Ich habe die höchste Priorität, die zuerst ausgeführt werden soll').

'__main__'ist der Name des Bereichs, in dem Code der obersten Ebene ausgeführt wird. Ein Modul __name__wird gleichgesetzt, '__main__'wenn es von einer Standardeingabe, einem Skript oder einer interaktiven Eingabeaufforderung gelesen wird.

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

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

Um kurz zu sein, müssen Sie mehrere Punkte kennen:

1. import a Aktion führt tatsächlich alles aus, was in "a" ausgeführt werden kann.

2. Aufgrund von Punkt 1 möchten Sie möglicherweise nicht, dass beim Importieren alles in "a" ausgeführt wird

3. Um das Problem in Punkt 2 zu lösen, können Sie mit Python eine Bedingungsprüfung durchführen

4. __name__ist eine implizite Variable in allen .pyModulen; wenn a.pyimportiert wird, der Wert __name__von a.pywird Modul die Dateinamen "gesetzt a„; Wenn a.pydirekt mit " python a.py" ausgeführt wird, was bedeutet, dass dies a.pyder Einstiegspunkt ist, wird der Wert __name__von a.pymodule auf eine Zeichenfolge gesetzt__main__

5. __name__Wissen Sie, wie Sie Punkt 3 erreichen, basierend auf dem Mechanismus, wie Python die Variable für jedes Modul festlegt ? Die Antwort ist ziemlich einfach, oder? Setzen Sie eine if-Bedingung : if __name__ == "__main__": ...; Sie können sogar setzen, wenn __name__ == "a"je nach Ihrem funktionalen Bedarf

Das Wichtige an Python ist Punkt 4! Der Rest ist nur grundlegende Logik.

Erwägen:

print __name__

Die Ausgabe für das Obige ist __main__.

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

Die obige Aussage ist wahr und gibt "direkte Methode" aus . Angenommen, wenn sie diese Klasse in eine andere Klasse importiert haben, wird keine "direkte Methode" ausgegeben, da sie beim Importieren festgelegt wird __name__ equal to "first model name".

Sie können die Datei sowohl als Skript als auch als importierbares Modul verwenden .

fibo.py (ein Modul namens 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

Der Grund für

if __name__ == "__main__":
    main()

dient in erster Linie dazu, die Probleme mit der Importsperre zu vermeiden , die durch den direkten Import von Code entstehen würden . Sie möchten main()ausgeführt werden, wenn Ihre Datei direkt aufgerufen wurde (dies ist der __name__ == "__main__"Fall). Wenn Ihr Code jedoch importiert wurde, muss der Importeur Ihren Code vom eigentlichen Hauptmodul eingeben, um Probleme mit der Importsperre zu vermeiden.

Ein Nebeneffekt ist, dass Sie sich automatisch bei einer Methode anmelden, die mehrere Einstiegspunkte unterstützt. Sie können Ihr Programm main()als Einstiegspunkt ausführen , müssen dies aber nicht . Während setup.pyerwartet main(), verwenden andere Tools alternative Einstiegspunkte. Um Ihre Datei beispielsweise als gunicornProzess auszuführen , definieren Sie eine app()Funktion anstelle von a main(). Importiert Ihren Code genau wie bei setup.py, gunicornsodass Sie nicht möchten, dass er während des Imports etwas unternimmt (aufgrund des Problems mit der Importsperre).

Diese Antwort richtet sich an Java-Programmierer, die Python lernen. Jede Java-Datei enthält normalerweise eine öffentliche Klasse. Sie können diese Klasse auf zwei Arten verwenden:

1. Rufen Sie die Klasse aus anderen Dateien auf. Sie müssen es nur in das aufrufende Programm importieren.

2. Führen Sie die Klasse zu Testzwecken eigenständig aus.

Im letzteren Fall sollte die Klasse eine öffentliche statische void main () -Methode enthalten. In Python wird dieser Zweck durch das global definierte Label erfüllt '__main__'.

Der Code unter if __name__ == '__main__': wird nur ausgeführt, wenn das Modul als Skript aufgerufen wird .

Betrachten Sie als Beispiel das folgende Modul my_test_module.py:

# my_test_module.py

print('This is going to be printed out, no matter what')

if __name__ == '__main__':
    print('This is going to be printed out, only if user invokes the module as a script')

1. Möglichkeit: my_test_module.pyIn ein anderes Modul importieren

# main.py

import my_test_module

if __name__ == '__main__':
    print('Hello from main.py')

Nun, wenn Sie aufrufen main.py:

python main.py 

>> 'This is going to be printed out, no matter what'
>> 'Hello from main.py'

Beachten Sie, dass nur die print()Anweisung der obersten Ebene in my_test_moduleausgeführt wird.

2. Möglichkeit: my_test_module.pyAls Skript aufrufen

Wenn Sie nun my_test_module.pyals Python-Skript ausgeführt werden, werden beide print()Anweisungen ausgeführt:

python my_test_module.py

>>> 'This is going to be printed out, no matter what'
>>> 'This is going to be printed out, only if user invokes the module as a script'

Jedes Modul in Python hat ein Attribut namens __name__. Der Wert von __name__ attribute ist, __main__ wenn das Modul direkt ausgeführt wird, wie z python my_module.py. Andernfalls (wie wenn Sie sagen import my_module) ist der Wert von __name__ der Name des Moduls.

Kleines Beispiel, um es 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 als ausführen

python test.py  

Ausgabe

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

Nehmen wir nun an, wir rufen das obige Skript von einem anderen Skript auf

#script external_calling.py

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

print(test.__name__)

Wenn Sie dies ausführen

python external_calling.py

Ausgabe

42
I am inside hello_world
test

Also, oben ist selbsterklärend , dass , wenn Sie anrufen Test von anderen Skript, wenn Schleife __name__in test.pynicht ausführen.

Wenn diese .py-Datei von anderen .py-Dateien importiert wird, wird der Code unter "if-Anweisung" nicht ausgeführt.

Wenn diese .py von python this_py.pyunter Shell ausgeführt wird oder in Windows doppelklickt. Der Code unter "if-Anweisung" wird ausgeführt.

Es wird normalerweise zum Testen geschrieben.

Wenn der Python-Interpreter ein bestimmtes Modul ausführt, hat die __name__globale Variable einen Wert"__main__"

  def a():
      print("a")
  def b():
      print("b")

  if __name__ == "__main__": 

          print ("you can see me" )
          a()
  else: 

          print ("You can't see me")
          b()

Wenn Sie dieses Skript drucken , können Sie mich sehen

ein

Wenn Sie diese Datei importieren, sagen Sie A zu Datei B und führen Sie die Datei B aus, dann wird if __name__ == "__main__"in Datei A falsch, sodass sie gedruckt wird. Sie können mich nicht sehen

b

Alle Antworten haben die Funktionalität ziemlich genau erklärt. Ich werde jedoch ein Beispiel für seine Verwendung nennen, das dazu beitragen könnte, das Konzept weiter zu klären.

Angenommen, Sie haben zwei Python-Dateien, a.py und b.py. Jetzt importiert a.py b.py. Wir führen die a.py-Datei aus, in der zuerst der Code "import b.py" ausgeführt wird. Bevor der Rest des a.py-Codes ausgeführt wird, muss der Code in der Datei b.py vollständig ausgeführt werden.

Im b.py-Code gibt es einen Code, der exklusiv für diese Datei b.py ist, und wir möchten nicht, dass eine andere Datei (außer der b.py-Datei), die die b.py-Datei importiert hat, ausgeführt wird.

Das ist es, was diese Codezeile überprüft. Wenn es sich um die Hauptdatei (dh b.py) handelt, in der der Code ausgeführt wird, was in diesem Fall nicht der Fall ist (a.py ist die laufende Hauptdatei), wird nur der Code ausgeführt.

Erstellen Sie eine Datei, a.py :

print(__name__) # It will print out __main__

__name__ist immer gleich, __main__wenn diese Datei direkt ausgeführt wird , was zeigt, dass dies die Hauptdatei ist.

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

import a  # Prints a

Starte es. Es druckt ein , das heißt, den Namen der Datei , die importiert wird .

Um zwei unterschiedliche Verhaltensweisen derselben Datei zu zeigen , ist dies 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

if name == ' main ':

Wir sehen wenn __name__ == '__main__':ziemlich oft.

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

Mit anderen Worten, der Code innerhalb des ifBlocks wird nur ausgeführt, wenn der Code direkt ausgeführt wird. Hier directlyheißtnot imported .

Mal sehen, was es mit einem einfachen Code macht, der 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 ausführen python test.py, lautet der Modulname __main__:

call test()
test module name=__main__

Es ist einfach der Einstiegspunkt, um die Datei auszuführen, wie die mainFunktion in der Programmiersprache C.