Was macht if __name__ == “__main__”: in Python?

Was bedeutet dies und warum sollte man das einbeziehen? if Aussage?

if __name__ == "__main__":
    print("Hello, World!")

_{Wenn Sie versuchen, eine Frage zu schließen, bei der jemand diese Redewendung verwenden sollte und nicht, sollten Sie das Schließen als Duplikat von Warum führt Python mein Modul aus, wenn ich es importiere, und wie stoppe ich es? stattdessen. Für Fragen, bei denen jemand einfach keine Funktionen aufgerufen hat oder fälschlicherweise eine benannte Funktion erwartet main automatisch als Einstiegspunkt verwendet werden soll, verwenden Sie Warum wird die Funktion main() nicht ausgeführt, wenn ich ein Python-Skript starte? Wo beginnt das Skript zu laufen?.}

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

python myscript.py

Der gesamte Code, der sich auf Einrückungsebene 0 befindet, wird ausgeführt. Definierte Funktionen und Klassen sind, nun ja, 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() function ist implizit der gesamte Code auf der obersten Ebene.

In diesem Fall ist der Top-Level-Code ein if Block. __name__ ist eine eingebaute Variable, die den Namen des aktuellen Moduls ergibt. Wenn jedoch ein Modul direkt ausgeführt wird (wie in myscript.py oben), dann __name__ wird stattdessen auf die Zeichenfolge gesetzt "__main__". So können Sie durch Testen testen, ob Ihr Skript direkt ausgeführt oder 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 Top-Level-Code wird ausgeführt, aber der Code im Then-Body der if Die obige Klausel wird nicht ausgeführt, da die Bedingung nicht erfüllt ist. Betrachten Sie als grundlegendes Beispiel die folgenden beiden 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

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

Also, wenn Modul one wird geladen, es ist __name__ gleich "one" Anstatt von "__main__".

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

Um die Grundlagen zu skizzieren:

• Die globale Variable, __name__in dem Modul, das der Einstiegspunkt zu Ihrem Programm ist, ist '__main__'. Andernfalls ist es der Name, unter dem Sie das Modul importieren.

• Code also unter der if Block wird nur ausgeführt, wenn das Modul der Einstiegspunkt zu Ihrem Programm ist.

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

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

Du könnte Testen Sie das Modul, indem Sie diesen Aufruf der Funktion unten hinzufügen:

do_important()

und es (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_important Funktion aufgerufen würde, also würden Sie Ihren Funktionsaufruf wahrscheinlich auskommentieren, do_important()ganz unten.

# 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 dazu führen, dass Sie wahrscheinlich vergessen, was Ihren Entwicklungsprozess mühsamer macht.

Ein besserer Weg

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

Innerhalb eines importierten Moduls ist es der Name dieses Moduls.

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

Also, wenn Sie 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 aufrufen).

Ein noch besserer Weg

Es gibt jedoch eine pythonische Möglichkeit, 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 beim Entwickeln und Testen ausführen möchten, in eine Funktion wie diese einfügen und dann unsere Überprüfung durchführen '__main__' gleich 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 abschließende Funktion für das Ende unseres Moduls, die ausgeführt wird, wenn wir das Modul als primäres Modul ausführen.

Dadurch können das Modul und seine Funktionen und Klassen in andere Skripte importiert werden, ohne dass das ausgeführt wird main -Funktion und ermöglicht auch, dass das Modul (und seine Funktionen und Klassen) aufgerufen werden, wenn es von einer anderen ausgeführt wird '__main__' Modul, dh

import important
important.main()

Dieses Idiom findet sich auch in der Python-Dokumentation in einer Erläuterung der __main__ Modul. Dieser Text besagt:

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. Es ist diese Umgebung, in der die idiomatische Strophe „Bedingtes Skript“ die Ausführung eines Skripts bewirkt:

if __name__ == '__main__':
    main()

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

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

__name__ ist eine globale Variable (in Python bedeutet global eigentlich auf der Modulebene), die in allen Namespaces vorhanden ist. Dies ist normalerweise der Name des Moduls (als str Typ).

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

python mycode.py

dem ansonsten anonymen globalen Namensraum wird der Wert von zugewiesen '__main__' zu seinem __name__.

Also inkl die Schlusszeilen

if __name__ == '__main__':
    main()

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

wird dazu führen, dass Ihr Skript eindeutig definiert ist main Funktion zu laufen.

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 und wann Ihr Programm entscheidet:

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