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))
python
namespaces
main
python-module
idioms
Hingebungsvoll
quelle
quelle
if __name__ == "__main__":
die Blockbedingung bis Python 3 veraltet / veraltet? Ich habe einige Informationen darüber gefunden.Antworten:
Immer wenn der Python-Interpreter eine Quelldatei liest, führt er zwei Dinge aus:
es setzt ein paar spezielle Variablen wie
__name__
und dannEs 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
.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
Der Interpreter weist
"__main__"
der__name__
Variablen die fest codierte Zeichenfolge zu , d. hWenn 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:
Der Interpreter sucht nach Ihrer
foo.py
Datei (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.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
Es druckt die Zeichenfolge
"before import"
(ohne Anführungszeichen).Es lädt das
math
Modul und weist es einer Variablen mit dem Namen zumath
. Dies entspricht dem Ersetzenimport math
durch Folgendes (beachten Sie, dass dies__import__
eine einfache Funktion in Python ist, die eine Zeichenfolge verwendet und den eigentlichen Import auslöst):Es druckt die Zeichenfolge
"before functionA"
.Es führt den
def
Block aus, erstellt ein Funktionsobjekt und weist dieses Funktionsobjekt dann einer Variablen mit dem Namen zufunctionA
.Es druckt die Zeichenfolge
"before functionB"
.Es führt den zweiten
def
Block aus, erstellt ein anderes Funktionsobjekt und weist es dann einer aufgerufenen Variablen zufunctionB
.Es druckt die Zeichenfolge
"before __name__ guard"
.Nur wenn Ihr Modul das Hauptprogramm ist
__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
__name__
wird dies"foo"
nicht der Fall sein"__main__"
, und der Hauptteil derif
Anweisung wird übersprungen .Immer
"after __name__ guard"
In beiden Situationen wird die Zeichenfolge gedruckt .Zusammenfassung
Zusammenfassend ist hier, was in den beiden Fällen gedruckt werden würde:
Warum funktioniert es so?
Sie könnten sich natürlich fragen, warum jemand dies wollen würde. Manchmal möchten Sie eine
.py
Datei 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
.py
Dateien 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 Siepython foo2.py
in der Befehlszeile sagen ? Warum?__name__
Check-in entfernenfoo3.py
:quelle
subprocess.run('foo_bar.py')
in einem Python-Skript laufe ? Ich nehme an, dasfoo_bar
wird genauso gestartet,__name__ = '__main__'
wie wenn ich cmdfoo_bar.py
manuell eingebe . Ist das der Fall? Unter Berücksichtigung der Antwort von @MrFooz sollte es kein Problem geben, dies zu tun und so viele "Hauptmodule" gleichzeitig zu haben, wie ich möchte. Selbst__name__
wenn Sie den Wert ändern oder mehrere unabhängig voneinander erstellte Instanzen (oder Instanzen, die sich gegenseitig erstellt habensubprocess
) miteinander interagieren, sollte dies für Python wie gewohnt funktionieren. Vermisse ich etwassubprocess.run
. Eine allgemein bessere Möglichkeit, Code zwischen Skripten auszutauschen, besteht darin, Module zu erstellen und die Skripte die freigegebenen Module aufrufen zu lassen, anstatt sich gegenseitig als Skripte aufzurufen. Das Debuggen vonsubprocess.run
Aufrufen ist schwierig, da die meisten Debugger nicht über Prozessgrenzen hinweg springen. Dies kann zu einem nicht trivialen Systemaufwand führen, um zusätzliche Prozesse zu erstellen und zu zerstören usw.from foo2 import functionB
foo2 von functionB importiert werden? Das ist eine semantische Verzerrung.from module import method
importiert die Methode aus dem Modul.multiprocessing
insbesondere, dass dieser Test unter Windows erforderlich ist.Wenn Ihr Skript ausgeführt wird, indem Sie es als Befehl an den Python-Interpreter übergeben,
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 - diemain()
Funktion besteht implizit aus dem gesamten Code auf der obersten Ebene.In diesem Fall ist der Code der obersten Ebene ein
if
Block.__name__
ist eine integrierte Variable, die den Namen des aktuellen Moduls ergibt. Wenn jedoch ein Modul direkt ausgeführt wird (wiemyscript.py
oben), 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 wirdWenn 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:Nun, wenn Sie den Interpreter als aufrufen
Die Ausgabe wird sein
Wenn du läufst
two.py
stattdessen :Du erhältst
Wenn also ein Modul
one
geladen wird, ist es__name__
gleich"one"
statt"__main__"
.quelle
Die einfachste Erklärung für die
__name__
Variable (imho) lautet wie folgt:Erstellen Sie die folgenden Dateien.
und
Wenn Sie sie ausführen, erhalten Sie folgende Ausgabe:
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 dieif
Anweisung zuFalse
diesem Teil ausgewertet wird, wird nicht ausgeführt.Wie Sie sehen können, setzt Python
globals()['__name__']
bei der Ausführung einer Datei in dieser Datei auf"__main__"
. Dieses Mal wird dieif
Anweisung ausgewertetTrue
und ausgeführt.quelle
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
if
Block 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:
Sie können das Modul testen, indem Sie diesen Aufruf der Funktion unten hinzufügen:
und ausführen (an einer Eingabeaufforderung) mit etwas wie:
Das Problem
Wenn Sie das Modul jedoch in ein anderes Skript importieren möchten:
Beim Import wird die
do_important
Funktion aufgerufen, sodass Sie Ihren Funktionsaufruf wahrscheinlichdo_important()
unten auskommentieren würden.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:
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 :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
main
Funktion 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.Diese Redewendung finden Sie auch in der Python-Dokumentation in einer Erläuterung des
__main__
Moduls. In diesem Text heißt es:quelle
if __name__ == "__main__"
ist der Teil, der ausgeführt wird, wenn das Skript über die Befehlszeile mit einem Befehl wie ausgeführt wirdpython myscript.py
.quelle
helloworld.py
mit nurprint("hello world")
darin mit Befehl ausgeführt werden,python helloworld.py
auch wenn es keine gibtif __name__ == "__main__"
?__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:
der ansonsten anonyme globale Namensraum, um den Wert zugewiesen ,
'__main__'
um seine__name__
.Also einschließlich der letzten Zeilen
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:
quelle
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":
Und eine zweite Datei "xy.py":
Wenn Sie ausführen
xy.py
, Sieimport ab
. Die import-Anweisung führt das Modul sofort beim Import aus, sodassab
die Operationen vor dem Rest von ausgeführt werdenxy
. Sobald Sie fertig sindab
, 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
def
Blöcke erst dann selbstständig etwas tun, wenn sie aufgerufen werden. Was der Dolmetscher sagen könnte, wenn er vor sich hin murmelt:"__main__"
in der__name__
Variablen.__name__ == "ab.py"
.a()
; Das habe ich gerade gelernt. Drucken ' Eine Funktion in einer ab-Datei '."__main__"
!x()
; ok, ' Peripherie-Aufgabe drucken : könnte in anderen Projekten nützlich sein '.if
Aussage. Nun, die Bedingung wurde erfüllt (die Variable__name__
wurde auf gesetzt"__main__"
), also gebe ich diemain()
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 eindef main():
Block angezeigt, der den Hauptfluss der Skriptfunktionalität enthält.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 anrufenmain()
, 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: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.)
quelle
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 diesenif
Block 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.quelle
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;
und
Die Ausgabe von der Ausführung von script1 ist
Die Ausgabe von script2 lautet:
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.quelle
Schauen wir uns die Antwort abstrakter an:
Angenommen, wir haben diesen Code in
x.py
: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 dasx.py
importiert wird und der Code von dort ausgeführt wird (wie wenn eine Funktion in vonx.py
aufgerufen wirdy.py
).quelle
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:quelle
Erwägen:
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 diemain()
Funktion).Wenn Ihr Python-Skript jedoch von einem Modul verwendet wird, wird jeder Code außerhalb der
if
Anweisung ausgeführt, sodassif \__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.quelle
Bevor Sie etwas darüber erklären,
if __name__ == '__main__'
ist es wichtig zu verstehen, was__name__
ist und was es tut.__name__
ist ein DunderAlias - kann als globale Variable betrachtet werden (über Module zugänglich) und funktioniert ähnlich wieglobal
.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.Es kann nicht nur in Skripten verwendet werden, sondern ist auch sowohl im Interpreter als auch in Modulen / Paketen enthalten.
Dolmetscher:
Skript:
test_file.py :
Ergebend
__main__
Modul oder Paket:
somefile.py:
test_file.py:
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.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:
Es wird allgemein als bewährte Methode angesehen, die
if __name__ == '__main__'
Skripte einzubeziehen.Jetzt wissen wir, dass das Verhalten der
__name__
Dinge klarer wird:An
if
ist 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__
.__name__
kann auch in Modulen verwendet werden, um den Namen eines Moduls zu definierenEs 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:
Ausführen einer Bedingung, wenn die Datei die Hauptdatei ist, und einer anderen, wenn dies nicht der Fall ist:
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.
quelle
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.quelle
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:
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.quelle
and
.and
wird verwendet, um zu überprüfen, ob zwei boolesche Anweisungen wahr sind. Da Sie nicht am Ergebnis des interessiert sindand
, werdenif
Ihre Absichten durch eine Erklärung klarer kommuniziert.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:
bedeutet, dass der Codeblock:
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.
quelle
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.quelle
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:
import a
Aktion führt tatsächlich alles aus, was in "a" ausgeführt werden kann.Aufgrund von Punkt 1 möchten Sie möglicherweise nicht, dass beim Importieren alles in "a" ausgeführt wird
Um das Problem in Punkt 2 zu lösen, können Sie mit Python eine Bedingungsprüfung durchführen
__name__
ist eine implizite Variable in allen.py
Modulen; wenna.py
importiert wird, der Wert__name__
vona.py
wird Modul die Dateinamen "gesetzta
„; Wenna.py
direkt mit "python a.py
" ausgeführt wird, was bedeutet, dass diesa.py
der Einstiegspunkt ist, wird der Wert__name__
vona.py
module auf eine Zeichenfolge gesetzt__main__
__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 BedarfDas Wichtige an Python ist Punkt 4! Der Rest ist nur grundlegende Logik.
quelle
Erwägen:
Die Ausgabe für das Obige ist
__main__
.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"
.quelle
fibo.py (ein Modul namens
fibo
)Referenz: https://docs.python.org/3.5/tutorial/modules.html
quelle
Der Grund für
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ährendsetup.py
erwartetmain()
, verwenden andere Tools alternative Einstiegspunkte. Um Ihre Datei beispielsweise alsgunicorn
Prozess auszuführen , definieren Sie eineapp()
Funktion anstelle von amain()
. Importiert Ihren Code genau wie beisetup.py
,gunicorn
sodass Sie nicht möchten, dass er während des Imports etwas unternimmt (aufgrund des Problems mit der Importsperre).quelle
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:
Rufen Sie die Klasse aus anderen Dateien auf. Sie müssen es nur in das aufrufende Programm importieren.
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__'
.quelle
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
:1. Möglichkeit:
my_test_module.py
In ein anderes Modul importierenNun, wenn Sie aufrufen
main.py
:Beachten Sie, dass nur die
print()
Anweisung der obersten Ebene inmy_test_module
ausgeführt wird.2. Möglichkeit:
my_test_module.py
Als Skript aufrufenWenn Sie nun
my_test_module.py
als Python-Skript ausgeführt werden, werden beideprint()
Anweisungen ausgeführt:quelle
Jedes Modul in Python hat ein Attribut namens
__name__
. Der Wert von__name__
attribute ist,__main__
wenn das Modul direkt ausgeführt wird, wie zpython my_module.py
. Andernfalls (wie wenn Sie sagenimport my_module
) ist der Wert von__name__
der Name des Moduls.Kleines Beispiel, um es kurz zu erklären.
Wir können dies direkt als ausführen
Ausgabe
Nehmen wir nun an, wir rufen das obige Skript von einem anderen Skript auf
Wenn Sie dies ausführen
Ausgabe
Also, oben ist selbsterklärend , dass , wenn Sie anrufen Test von anderen Skript, wenn Schleife
__name__
intest.py
nicht ausführen.quelle
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.py
unter Shell ausgeführt wird oder in Windows doppelklickt. Der Code unter "if-Anweisung" wird ausgeführt.Es wird normalerweise zum Testen geschrieben.
quelle
Wenn der Python-Interpreter ein bestimmtes Modul ausführt, hat die
__name__
globale Variable einen Wert"__main__"
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 sehenb
quelle
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.
quelle
Erstellen Sie eine Datei, a.py :
__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:
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:
quelle
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
if
Blocks wird nur ausgeführt, wenn der Code direkt ausgeführt wird. Hierdirectly
heißtnot imported
.Mal sehen, was es mit einem einfachen Code macht, der den Namen des Moduls druckt:
Wenn wir den Code direkt über ausführen
python test.py
, lautet der Modulname__main__
:quelle
Es ist einfach der Einstiegspunkt, um die Datei auszuführen, wie die
main
Funktion in der Programmiersprache C.quelle
if __name__ == "__main__"
Block kein Code (außer Definitionen ohne Nebenwirkungen) stattfindet . Technisch gesehen ist der Anfang des ausgeführten Skripts der Einstiegspunkt des Programms.