invalid - python__name__ variable




Was passiert, wenn__name__== "__main__": (18)

Was macht das 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))

Was passiert, if __name__ == "__main__":

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

Als einziger Sonderfall jedoch, egal in welchem ​​Python-Prozess Sie ausführen, wie in mycode.py:

python mycode.py

Dem ansonsten anonymen globalen Namespace wird der Wert '__main__' seinem __name__ .

So auch die 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,

führt dazu, dass die eindeutig definierte main Ihres Skripts ausgeführt wird.

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

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

Was macht das if __name__ == "__main__":

Um die Grundlagen zu beschreiben:

  • Die globale Variable __name__ in dem Modul, das der Einstiegspunkt in Ihr Programm ist, lautet '__main__' . Ansonsten ist es der Name, unter dem Sie das Modul importieren.

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

  • Dadurch kann der Code im Modul von anderen Modulen importiert werden, ohne dass der 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"""

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 Importieren wird die do_important Funktion aufgerufen, sodass Sie Ihren Funktionsaufruf do_important() am Ende wahrscheinlich do_important() .

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

Und dann müssen Sie wissen, ob Sie den Aufruf der Testfunktion auskommentiert haben. Und diese zusätzliche Komplexität würde bedeuten, dass Sie wahrscheinlich vergessen werden, was Ihren Entwicklungsprozess schwieriger macht.

Ein besserer Weg

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

In einem importierten Modul ist dies der Name dieses Moduls.

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

Also, wenn Sie vor der Ausführung prüfen:

if __name__ == "__main__":
    do_important()

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

Ein noch besserer Weg

Es gibt jedoch einen pythonischen Weg, um dies zu verbessern.

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

Wenn wir den Code einsetzen, den wir beim Entwickeln und Testen in einer Funktion wie dieser ausüben möchten, prüfen '__main__' sofort nach '__main__' :

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ärmodul ausführen.

Dadurch können das Modul und seine Funktionen und Klassen in andere Skripts importiert werden, ohne dass die main wird. Außerdem können das Modul (und seine Funktionen und Klassen) aufgerufen werden, wenn es von einem anderen '__main__' Modul ausgeführt wird, dh

import important
important.main()

Diese Redewendung kann auch in der Python-Dokumentation in einer Erläuterung des __main__ Moduls gefunden werden. In diesem Text heißt es:

Dieses Modul stellt den (ansonsten anonymen) Umfang dar, in dem das Hauptprogramm des Interpreters ausgeführt wird - Befehle, die entweder aus der Standardeingabe, aus einer Skriptdatei oder aus einer interaktiven Eingabeaufforderung gelesen werden. In dieser Umgebung führt die idiomatic-Zeilengruppe "Bedingtes Skript" zur Ausführung eines Skripts:

if __name__ == '__main__':
    main()

wenn name == ' main ':

Wir sehen es __name__ == '__main__':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 directlybedeutet not imported.

Sehen wir uns an, was es mit einem einfachen Code tut, der den Namen des Moduls ausgibt:

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

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

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 werden, sondern sie definiert werden.)

Bevor der Interpreter die Quellcodedatei ausführt, definiert er jedoch 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 lädt (dh die von Ihnen ausgeführte Datei), wird die spezielle Variable __name__ für diese Datei mit dem Wert "__main__" festgelegt .

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

In deinem Beispiel also:

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 aus.


Die Mechanismen des fraglichen Codes, das "Wie", sind hier sehr unterschiedlich, aber für mich war alles sinnvoll, bis ich das "Warum" verstand. Dies sollte besonders für neue Programmierer hilfreich sein.

Nimm 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 xy.py ausführen, import ab Sie import ab . Die Importanweisung führt das Modul sofort beim Import aus, sodass die Operationen von ab vor den restlichen xy ausgeführt werden. Wenn Sie mit xy fertig sind, geht es weiter mit xy .

Der Interpreter verfolgt, welche Skripts mit __name__ . Wenn Sie ein Skript ausführen (egal wie Sie es benannt haben), wird es vom Interpreter als "__main__" , wodurch es zum Master- oder "Home "__main__" wird, das nach dem Ausführen eines externen Skripts zurückgegeben wird.

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

Gehen Sie den obigen Code durch, um zu verstehen, was passiert, und konzentrieren Sie sich zunächst auf die nicht eingerückten Zeilen und die Reihenfolge, in der sie in den Skripts erscheinen. Denken Sie daran, dass Funktions- oder def Blöcke nichts von sich aus tun, bis sie aufgerufen werden. Was könnte der Dolmetscher sagen, wenn er zu sich selbst murmelt:

  • Öffnen Sie xy.py als "Ausgangsdatei". nenne es "__main__" in der Variable __name__ .
  • Importieren und öffnen Sie die Datei mit dem __name__ == "ab.py" .
  • Oh, eine Funktion. Ich werde mich daran erinnern.
  • Ok, Funktion a() ; Ich habe das gerade gelernt. ' Eine Funktion in einer Datei ' drucken .
  • Ende der Datei; zurück zu "__main__" !
  • Oh, eine Funktion. Ich werde mich daran erinnern.
  • Noch einer.
  • Funktion x() ; ok, Drucken von ' peripherer Aufgabe: kann in anderen Projekten nützlich sein '.
  • Was ist das? Eine if Anweisung Nun, die Bedingung wurde erfüllt (die Variable __name__ wurde auf "__main__" ), also gebe ich die main() Funktion ein und "__main__" ' main function: Hier ist die Aktion '.

Die unteren beiden Zeilen bedeuten: "Wenn dies das "__main__" oder" home "ist, führen Sie die Funktion main() " Aus diesem Grund sehen Sie ein def main(): block up top, das den Hauptfluss der Funktionalität des Skripts enthält.

Warum das umsetzen?

Erinnern Sie sich an das, was ich zuvor zu Importaussagen gesagt habe? Wenn Sie ein Modul importieren, "erkennt" es es nicht nur und wartet auf weitere Anweisungen. Es führt tatsächlich alle ausführbaren Operationen aus, die im Skript enthalten sind. Wenn Sie also das Fleisch Ihres Skripts in die Funktion main() einfügen, wird es effektiv isoliert und isoliert, sodass es nicht sofort ausgeführt wird, wenn es von einem anderen Skript importiert wird.

Es wird wieder Ausnahmen geben, aber die übliche Praxis ist, dass main() normalerweise nicht extern aufgerufen wird. Sie fragen sich vielleicht noch etwas: Wenn wir nicht main() aufrufen, warum rufen wir das Skript überhaupt auf? Dies liegt daran, dass viele Benutzer ihre Skripts mit eigenständigen Funktionen strukturieren, die unabhängig vom restlichen Code in der Datei ausgeführt werden können. Sie werden später an anderer Stelle im Hauptteil des Skripts aufgerufen. Was bringt mich dazu:

Der Code funktioniert aber auch ohne

Ja, das ist richtig. Diese separaten Funktionen können von einem Inline-Skript aus aufgerufen werden, das nicht in einer main() Funktion enthalten ist. Wenn Sie daran gewöhnt sind (wie ich es in meinen frühen Lernstadien des Programmierens war), Inline-Skripts zu erstellen, die genau das tun, was Sie benötigen, und Sie versuchen, es erneut herauszufinden, wenn Sie diese Operation erneut benötigen. Nun, Sie sind an diese Art interner Struktur Ihres Codes nicht gewöhnt, weil sie komplizierter zu erstellen und nicht so intuitiv zu lesen ist.

Dies ist jedoch ein Skript, dessen Funktionen wahrscheinlich nicht extern aufgerufen werden können, da sonst sofort mit dem Berechnen und Zuweisen von Variablen begonnen werden würde. Wenn Sie versuchen, eine Funktion erneut zu verwenden, ist Ihr neues Skript so eng mit dem alten verwandt, dass es widersprüchliche Variablen gibt.

Durch die Aufteilung unabhängiger Funktionen erhalten Sie die Möglichkeit, Ihre vorherige Arbeit wiederzuverwenden, indem Sie sie in einem anderen Skript aufrufen. Beispielsweise kann "example.py" möglicherweise "xy.py" importieren und x() aufrufen, wobei die Funktion "x" von "xy.py" verwendet wird. (Vielleicht wird das dritte Wort einer gegebenen Zeichenfolge großgeschrieben; Erstellen eines NumPy-Arrays aus einer Liste von Zahlen und Quadrieren dieser Zahlen; oder Erstellen einer 3D-Oberfläche. Die Möglichkeiten sind unbegrenzt.)

(Nebenbei gesagt, diese Frage enthält eine Antwort von @kindall, die mir schließlich zum Verstehen verhalf - das Warum, nicht das Wie. Leider wurde es als Duplikat dieses hier gekennzeichnet , was ich für einen Fehler halte.)


Die einfachste Erklärung für die Variable __name__ (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__

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

$ python a.py
Hello World from b!

Wie Sie sehen, setzt Python beim Importieren eines Moduls globals()['__name__'] in diesem Modul auf den Namen des Moduls.

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

Wie Sie sehen, setzt Python bei der Ausführung einer Datei globals()['__name__'] in dieser Datei auf "__main__" .


Erwägen:

if __name__ == "__main__":
    main()

Es prüft, ob das __name__ Attribut des Python-Skripts "__main__" . Wenn also das Programm selbst ausgeführt wird, __main__ das Attribut __main__ . Das Programm wird also ausgeführt (in diesem Fall die Funktion main() ).

Wenn Ihr Python-Skript jedoch von einem Modul verwendet wird, wird jeglicher Code außerhalb der if Anweisung ausgeführt. if \__name__ == "\__main__" wird, wird nur if \__name__ == "\__main__" , ob das Programm als Modul verwendet wird oder nicht, und entscheidet daher, ob der Code ausgeführt wird.


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, diese Klasse wurde in eine andere Klasse importiert, es wird keine "direkte Methode" gedruckt, da sie beim Importieren gesetzt wird __name__ equal to "firstmodel name".


Lassen Sie uns die Antwort abstrakter betrachten:

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 "x.py" ausgeführt wird.

Es wird jedoch nur Block A (und nicht B) ausgeführt, wenn wir ein anderes Modul ausführen, beispielsweise "y.py", in das xy importiert und der Code von dort ausgeführt wird (wie wenn eine Funktion in "x.py" ist von y.py genannt).


Vereinfacht gesagt ist __name__ eine Variable, die für jedes Skript definiert ist und 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 Skript1 wird ausgeführt

Script 1's name: __main__

Die Ausgabe von script2 lautet:

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

Wie Sie sehen, teilt uns __name__ mit, welcher Code das Hauptmodul ist. Das ist großartig, da Sie nur Code schreiben können und sich nicht um strukturelle Probleme wie in C / C ++ kümmern müssen. Wenn eine Datei keine 'main'-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ßes bewirkt, und implementieren eine Bootload von Funktionen, die für andere Zwecke nützlich sind. Wenn ich sie verwenden möchte, kann ich Ihr Skript einfach importieren und verwenden, ohne Ihr Programm auszuführen ( if __name__ == "__main__": , Ihr Code wird nur innerhalb des if __name__ == "__main__": . In C / C ++ müssten Sie diese Teile in ein separates Modul aufteilen, 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 vorherigen Modulcode einzuschließen, gibt es sechs Dateien (neun, die Implementierungsdateien zählen) und fünf Verknüpfungen. Dies macht es schwierig, anderen Code in ein C-Projekt einzufügen, wenn er nicht speziell als Bibliothek kompiliert wird. Nun stell es dir für Python vor:

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


Wenn Sie Python interaktiv __name__ , wird der lokalen Variable __name__ der Wert __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 ihren eigenen __name__ Wert __name__ , um selbst zu bestimmen, wie sie verwendet werden, ob als Unterstützung für ein anderes Programm oder als Hauptanwendung, die über die Befehlszeile ausgeführt wird. Daher ist der folgende Ausdruck in Python-Modulen durchaus üblich:

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.

Wenn der Python-Interpreter eine Quelldatei liest, führt er den gesamten darin enthaltenen Code aus.

Vor der Ausführung des Codes werden einige spezielle Variablen definiert. Wenn der Python-Interpreter beispielsweise dieses Modul (die Quelldatei) als Hauptprogramm __name__ , setzt er die spezielle Variable __name__ auf den Wert "__main__" . Wenn diese Datei aus einem anderen Modul __name__ wird, wird __name__ auf den Namen des Moduls gesetzt.

Nehmen wir im Fall Ihres Skripts an, dass es als Hauptfunktion ausgeführt wird, z. B. haben Sie etwas gesagt

python threading_example.py

in der Kommandozeile. Nach dem Einrichten der Sondervariablen führt sie die import und lädt diese Module. Anschließend wird der def Block ausgewertet, ein Funktionsobjekt erstellt und eine Variable namens myfunction , die auf das Funktionsobjekt zeigt. Dann liest es die if __name__ stellt "__main__" , dass __name__ gleich "__main__" , und führt den dort gezeigten Block aus.

Ein Grund dafür ist, dass Sie manchmal ein Modul (eine .py Datei) schreiben, in dem es direkt ausgeführt werden kann. Alternativ kann es auch importiert und in einem anderen Modul verwendet werden. Durch die Hauptprüfung können Sie diesen Code nur ausführen, wenn Sie das Modul als Programm ausführen möchten und nicht, wenn jemand Ihr Modul importieren und Ihre Funktionen selbst aufrufen möchte.

Auf dieser Seite finden Sie weitere Details.

Hinweis (von Stainsor): Wenn Sie den Funktionsdefinitionen Code hinzufügen, wird dieser vor main ausgeführt.

print("This code executes before main.") 

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

def functionB():
    print("Function B")

if __name__ == '__main__':
    functionA()
    functionB()

Wenn dieses Modul tatsächlich main ist, führt dieser Code zu:

This code executes before main. 
Function A 
Function B

Wenn dieses Modul nicht Haupt ist, erhalten Sie:

This code executes before main. 

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

'__main__' ist der Name des Bereichs, in dem der Code der obersten Ebene ausgeführt wird. Der __name__ eines Moduls wird gleich '__main__' wenn er von der Standardeingabe, einem Skript oder einer interaktiven Eingabeaufforderung gelesen wird.

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

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


Vor kurzem bin ich darauf gestoßen, als ich eine Klasse in Python (Deep Learning) erstellt habe. Nach meinem Verständnis und in Übereinstimmung mit den oben aufgeführten Erklärungen werde ich darauf eingehen

__name__=="__main__"

Manchmal konstruieren wir eine Klasse in einer .py-Datei und definieren viele Funktionen innerhalb dieser Klasse. Wir möchten jedoch nicht alle diese Klassenfunktionen für einen einzigen Zweck verarbeiten. Zum Beispiel zum Erstellen einer Klasse und zum Definieren einiger Funktionen für die Datenerstellung (.npy-Dateien) und zum Laden von Daten. also wenn wir definieren

__name__=="__main__"

xxx = Klassenname ()

xxx.create_data ()

Bedeutet, wenn wir die .py-Datei aufrufen, werden nur Daten erstellt und keine anderen Klassenfunktionen verarbeitet. Andere Klassenfunktionen (Datenladen) können auch von anderen Klassen importiert werden.


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

Wenn diese .py-Datei von python this_py.pyShell ausgeführt wird oder in Windows doppelt geklickt wird. Der Code unter der "if-Anweisung" wird ausgeführt.

Es wird normalerweise zum Testen geschrieben.


Diese Antwort ist für 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 alleine aus.

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


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 , in demselben Verzeichnis:

import a  # Prints a

Starte es. Es wird ein Name ausgegeben , dh der Name der Datei, die importiert wird .

Um zwei unterschiedliche Verhaltensweisen derselben Datei zu zeigen , handelt es sich hierbei um einen häufig verwendeten Trick:

# Code to be run when imported into another python file

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




idioms