In diesem Leitfaden werden Sie die Funktionalität und Bedeutung von if __name__ == ‚__main__‘ in Python verstehen.
Haben Sie jemals eine Python-Codebasis mit verschiedenen Modulen überflogen?
Wenn ja, sind Sie wahrscheinlich auf die Bedingung if __name__ == ‚__main__‘ in einem oder mehreren Modulen gestoßen. In den nächsten Minuten entmystifizieren wir die Bedeutung der obigen Bedingung und sehen uns ein Beispiel an, wo sie hilfreich sein kann.
Lass uns anfangen!
Inhaltsverzeichnis
Was ist die Bedeutung von __name__ in Python?
In Python ist ein Modul eine .py-Datei, die Funktionsdefinitionen, einen Satz auszuwertender Ausdrücke und mehr enthält. Wenn wir beispielsweise eine Datei mit dem Namen hello_world.py haben, bezeichnen wir diese als die Datei hello_world.py oder das Modul hello_world.
Wenn Sie ein Python-Modul ausführen, legt der Python-Interpreter die Werte für einige spezielle Variablen vor der Ausführung fest: __name__ ist eine davon. Der Schlüssel zum Verständnis der Bedeutung von __name__ besteht darin, zu verstehen, wie Importe in Python funktionieren.
📁 Laden Sie den Code für diesen Abschnitt hier herunter.
Gehen Sie zum Ordner example-1. Wir haben die Datei module1.py. Die Variable __name__ befindet sich im Namespace des aktuellen Moduls.
Dieses Modul gibt eine Zeile aus, gefolgt vom Wert der Variablen __name__.
# example-1/module1.py
print("This is module1.")
print(f"The __name__ variable of module 1 is: {__name__}.")
Lassen Sie uns jetzt module1 über die Befehlszeile ausführen.
$ python module1.py
In der Ausgabe sehen wir, dass die Variable __name__ auf __main__ gesetzt ist.
This is module1. The __name__ variable of module 1 is: __main__.
Importieren von Modulen in Python
Zusätzlich zum Ausführen eines Python-Moduls möchten Sie möglicherweise manchmal Funktionen aus einem anderen Python-Modul innerhalb des aktuellen Moduls verwenden. Python erleichtert dies durch Importe.
Durch Importe können Sie die Funktionalität eines anderen Moduls wiederverwenden – indem Sie es in den Gültigkeitsbereich des aktuellen Moduls importieren – ohne den Code neu schreiben zu müssen.
Die Datei module2.py enthält Folgendes. Wir haben module1 nach innen importiert. Modul2.
# example-1/module2.py
import module1 # module1 is imported
print(f"This is module2")
print(f"The __name__ variable of module2 is: {__name__}.")
Wir führen module2.py aus und beobachten die Ausgabe.
$ python module2.py
In der Ausgabe unten:
- Wir sehen, dass Modul1 unter der Haube ausgeführt wird, wenn wir es in Modul2 importieren, und die entsprechende Ausgabe wird ausgedruckt.
- Aber diesmal ist die Variable __name__ nicht __main__, sondern module1.
- Da wir module2 direkt ausgeführt haben, ist die dem Modul entsprechende __name__-Variable jetzt __main__.
Output This is module1. The __name__ variable of module 1 is: module1. This is module2 The __name__ variable of module2 is: __main__.
💡 Schlüsselidee:
– Wenn ein Modul direkt ausgeführt wird, wird seine Variable __name__ auf ist gleich __main__ gesetzt.
– Wenn ein Modul in ein anderes Modul importiert wird, wird sein __name__ auf den Namen des Moduls gesetzt.
Beispiel für if __name__==’__main__‘ in Python
In diesem Abschnitt sehen wir einen praktischen Anwendungsfall der Bedingung if __name__ == ‚__main__‘. Wir definieren eine einfache Funktion und schreiben dann Komponententests, um zu überprüfen, ob die Funktion wie erwartet funktioniert.
📁 Laden Sie den Code herunter und folgen Sie ihm.
Den Code für diesen Abschnitt finden Sie im Ordner example-2.
Hier ist add.py eine Python-Datei, die die Definition der Funktion add_ab() enthält. Die Funktion add_ab() nimmt zwei beliebige Zahlen auf und gibt ihre Summe zurück.
# example-2/add.py
def add_ab(a,b):
return a + b
Wir verwenden das Unittest-Modul von Python, um die Funktion add_ab() zu testen.
Schreiben von Testfällen für eine Python-Funktion
Sehen Sie sich das folgende Code-Snippet an, das den Inhalt des Moduls test_add enthält.
# example-2/test_add.py
import unittest
from add import add_ab
class TestAdd(unittest.TestCase):
def test_add_23(self):
self.assertEqual(add_ab(2,3), 5)
def test_add_19(self):
self.assertEqual(add_ab(1,9), 10)
def test_add_1_minus7(self):
self.assertEqual(add_ab(1,-7), -6)
Der obige Code macht folgendes:
- Importiert das integrierte unittest-Modul von Python
- Importiert die Funktion add_ab() aus dem Add-Modul
- Definiert die Testklasse TestAdd und eine Reihe von Testfällen als Methoden innerhalb der Testklasse
Um Komponententests für Ihren Code einzurichten, sollten Sie zunächst eine Testklasse definieren, die von unittest.TestCase erbt. Alle Testfälle sollten als Methoden innerhalb der Klasse angegeben werden und mit test_ beginnen.
Hinweis: Wenn Sie die Methoden nicht als test_
Lassen Sie uns nun versuchen, das Modul test_add vom Terminal aus auszuführen.
$ python test_add.py
Sie werden sehen, dass keine Ausgabe erfolgt und keiner der Tests ausgeführt wurde.
Warum ist das so?🤔
Dies liegt daran, dass Sie zum Ausführen der Komponententests unittest als Hauptmodul ausführen sollten, während Sie test_add.py mit dem folgenden Befehl ausführen.
$ python -m unittest test_add.py
Beim Ausführen des obigen ausführlichen Befehls sehen wir, dass alle drei Tests erfolgreich ausgeführt wurden.
Output ... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK
Es ist jedoch praktisch, die Tests auszuführen, wenn dieses Modul test_add ausgeführt wird, ja? Lassen Sie uns im nächsten Abschnitt lernen, wie das geht.
Verwenden von if __name__ == ‚__main__‘ zum Ausführen von unittest als Hauptmodul
Wenn Sie alle Komponententests ausführen möchten, wenn das Modul direkt ausgeführt wird, können Sie die Bedingung hinzufügen.
# example-2/test_add.py
import unittest
from add import add_ab
class TestAdd(unittest.TestCase):
def test_add_23(self):
self.assertEqual(add_ab(2,3), 5)
def test_add_19(self):
self.assertEqual(add_ab(1,9), 10)
def test_add_1_minus7(self):
self.assertEqual(add_ab(1,-7), -6)
# Run unittest as the main module
if __name__ == '__main__':
unittest.main()
Die Bedingung im obigen Code-Snippet sagt dem Python-Interpreter: Wenn dieses Modul direkt ausgeführt wird, dann führe den darin enthaltenen Code aus. unittest.main().
Sie können das Modul test_add ausführen, nachdem Sie die beiden obigen Codezeilen hinzugefügt haben.
$ python test_add.py
▶️ Das direkte Ausführen des Test-Hinzufügen-Moduls führt jetzt alle drei Tests aus, die wir definiert haben.
Output ... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK
Die obige Ausgabe OK zeigt an, dass alle Tests erfolgreich ausgeführt wurden. Die drei Punkte … zeigen an, dass drei Tests durchgeführt und alle bestanden wurden.
Lassen Sie uns nun den erwarteten Rückgabewert test_add_1_minus7 auf 8 ändern. Da die Funktion in diesem Fall – 6 zurückgibt, sollte es einen fehlgeschlagenen Test geben.
def test_add_1_minus7(self):
self.assertEqual(add_ab(1,-7), 8)
Wie in der Ausgabe unten zu sehen ist, erhalten wir von den drei Tests .F., Muster, einer davon ist fehlgeschlagen (der zweite Test), und im Traceback erhalten wir einen AssertionError mit der Angabe – 6 != 8.
Output
.F.
======================================================================
FAIL: test_add_1_minus7 (__main__.TestAdd)
----------------------------------------------------------------------
Traceback (most recent call last):
File "test_add.py", line 12, in test_add_1_minus7
self.assertEqual(add_ab(1,-7), 8)
AssertionError: -6 != 8
----------------------------------------------------------------------
Ran 3 tests in 0.021s
FAILED (failures=1)
Es ist wichtig zu beachten, dass die Tests nicht unbedingt in derselben Reihenfolge ausgeführt werden, in der sie in der Testklasse angegeben sind. Im obigen Beispiel ist test_add_1_minus7 als dritte Methode in der Testklasse definiert, aber der entsprechende Test wurde als zweites ausgeführt.
Zusammenfassen
Ich hoffe, dieses Tutorial hat Ihnen geholfen zu verstehen, wie die Bedingung if __name__ == ‚__main__‘ in Python funktioniert.
Hier ist eine kurze Zusammenfassung der wichtigsten Takeaways:
- Der Python-Interpreter legt die Variable __name__ fest, bevor er das Python-Skript ausführt.
- Wenn Sie ein Modul direkt ausführen, ist der Wert von __name__ __main__.
- Wenn Sie ein Modul in ein anderes Python-Skript importieren, ist der Wert von __name__ der Modulname.
- Sie können if __name__ == ‚__main__‘ verwenden, um die Ausführung zu steuern und welche Teile des Moduls während direkter bzw. importierter Ausführungen ausgeführt werden.
Sehen Sie sich als Nächstes diese ausführliche Anleitung zu Python-Sets an. Viel Spaß beim Lernen!🎉