mit Aussage

Die Python mit Erklärung ist eine sehr erweiterte Funktion, mit der das Kontext -Management -Protokoll implementiert werden kann. Wenn der Programmierer mit dem Codieren beginnt, verwenden sie im Grunde die Try/außer/schließlich, um die Ressourcen zu pflegen. Aber es gibt eine andere Möglichkeit, dies automatisch zu tun, die als "mit" Anweisung bezeichnet wird.

In diesem Artikel werden wir also diskutieren, wie wir das verwenden könnenmit' Stellungnahme.

Wir können dies mit einem sehr einfachen Beispiel verstehen.

Wann immer wir etwas zum Lesen oder Schreiben einer Datei codieren, müssen wir als Erstes die Datei öffnen und dann die Lesen oder Schreibvorgänge darauf ausführen, und schließlich schließen wir die Datei so, dass alle Ressourcen wird nicht beschäftigt sein. Es bedeutet also, dass wir die Ressource veröffentlichen müssen, nachdem wir unsere Arbeit abgeschlossen haben.

Dies können wir auch aus dem Kontextmanager verstehen. Ein Kontextmanager ist ein Objekt, das die Ressourcen zum Speichern, Wiederherstellen, Sperren oder Entsperren von Ressourcen, Öffnen und Schließen von Dateien usw. erledigt. Der Kontextmanager ist aktiv, wenn wir eine Datei zum Lesen oder Schreiben öffnen. Wenn wir die Datei nach dem Lesen oder Schreiben nicht schließen, wird die Ressource weiterhin für diese bestimmte Datei zugewiesen, und aus diesem Grund ist die Ressource beschäftigt, wenn ein bestimmter Prozess diese Ressource verwenden möchte.

Deshalb nennen wir die Methode close (), nachdem wir die Datei gelesen oder geschrieben haben.

f = offen ("Demo.txt")
Daten = f.lesen()
F.schließen()

Im obigen Code ist es also unkompliziert, und es gibt keinen Ausnahmebehandler, den wir verwendet haben. Wenn ein Fehler auftritt, hört das Programm bedingungslos auf. Und der zweite Fall ist, dass wir manchmal auch vergessen, die enge Datei wie wir hinzuzufügen.

Um einige der Probleme zu überwinden, können wir die folgende Methode verwenden, um den obigen Code zu schreiben.

versuchen:
f = offen ('Demo.txt ',' r ')
Druck (f.lesen())
außer Ausnahme als E:
print ("Fehler aufgetreten", e)
Endlich:
F.schließen()

Im obigen Code können Sie sehen, dass wir den Versuch verwendet haben, außer und schließlich blockieren. Auf diese Weise können wir also auch die Ausnahmebehandlung kontrollieren. Und wir schließen die Datei endlich im endgültigen Block. Wir haben auch den außer Block verwendet, der die Ausnahmen behandelt. Wenn wir das obige Szenario verwenden, wird unser Code nicht bedingungslos aufhören. Und unsere Datei wird sicherlich schließen, auch wenn wir beim Lesen der Datei einen Fehler erhalten.

Wir können den obigen Code aber auch durch eine andere Methode verfeinern, die wir die "mit" Anweisung genannt haben. Die Anweisung mit 'With' verwaltet automatisch die Schließung der Datei, und wir müssen uns nicht darum kümmern, die Datei nach dem Lesen oder Schreiben zu schließen.

Der Kontextmanager erstellt eine methode Enter () und exit () zur Laufzeit und ruft sie auf, wenn sie die Datei zerstören müssen. Während wir einfachen Code oder mit einem Versuch, außer Block. Aber die Anweisung 'mit' Anweisung kümmert sich automatisch um die Exit () -Methode. Das ist also die Schönheit der "mit" Aussage.

Wir können den obigen Code mit der Anweisung "With" wie unten neu schreiben:

mit offen ("Demo.txt ") als f:
Daten = f.lesen()

Der obige Code ist sehr einfach und wir müssen nicht jedes Mal darüber nachdenken.

Das sieht nach Magie aus, aber eigentlich ist das keine Magie. Die 'mit' Erklärung initiiert zwei Objekte, die wir __enter__ () und __exit__ () genannt haben. Die Anweisung, die den Anweisungen von 'With' folgt, heißt __enter__ () und gibt ein Objekt zurück, das als Variable zugewiesen wurde, und nach dem gesamten Blockvorgang ruft sie __Exit__ () auf.

Beispiel 1: ex1.py

#EX1.py
Klassendemo:
def __enter __ (selbst):
print ("auf __enter__ -Methode rufen")
zurück "wahr"
def __exit __ (self, exc_type, exc_val, exc_tb):
print ("auf __Exit__ -Methode anrufen")
Def Calling_demo ():
Return Demo () zurückgeben
mit Calling_demo () als f:
print ("Demo:", f)

Ausgang:

➜ ~ CD -Desktop
➜ Desktop python3 ex1.py
Anruf zur __enter__ -Methode
Demo: wahr
Anruf zur __exit__ -Methode
➜ Desktop

Erläuterung:

1. Wenn wir den obigen Code ex1 ausführen.Py, dann wird es zuerst die Methode __ENTER__ genannt.
2. Dann gibt es etwas aus dem Code (TRUE) zurück, das der Variablen f zugewiesen wurde.
3. Dann wurde der Block des Codes ausgeführt. In diesem Block drucken wir den Wert des F, was wahr ist.
4. Endlich, wenn der Prozess des Blocks vorbei ist, wird er als Methode __Exit__ bezeichnet.

Das Beste an der Aussage von 'With' ist, dass es auch automatisch die Ausnahme behandelt. Wie Sie im obigen Code -Beispiel EX1 sehen können.Py, die __Exit__ -Methode nimmt drei Parameter vor: exc_type, exc_val, exc_tb. Diese Parameter tragen dazu bei, die Ausnahmen zu bewältigen.

Syntax: __exit __ (self, exc_type, exc_value, exc_tb)

exc_type: Es zeigt den Namen der Klasse, in der eine Ausnahme auftritt.
exc_value: Es zeigt den Typ der Ausnahme wie Divide durch Nullfehler usw.
exc_traceback: Das Traceback ist ein umfassendes Detail zu der Ausnahme, genau wie ein Bericht, um den im Programm aufgetretenen Fehler zu lösen.

Jetzt werden wir den oben genannten Code ändern, um zu sehen, wie automatisch die Ausnahmen behandelt werden.

Beispiel_2: NulodivisionError.py

#ZerodivisionError.py
Klassendemo:
def __init __ (self, x, y):
print ("eingeben __init__")
selbst.x = x
selbst.y = y
def __enter __ (selbst):
print ("Finden Sie den __enter__")
Rückkehr selbst
def __exit __ (self, exc_type, exc_val, exc_tb):
print ("\ finde das __exit__")
print ("\ nType:", exc_type)
print ("\ nValue:", exc_val)
print ("\ ntraceBack:", exc_tb)
Def ExceptionDemo (Selbst):
# ZerodivisionError -Ausnahme
Druck (Selbst.x / selbst.y)
# mit Aussage keine Ausnahme anscheinen
mit Demo (4, 2) als F:
F.AUCECTEDEMO ()
print ("\ n \ n ========================================================= \ n \ n "))
# Mit Erklärung wird ein ZerodivisionError erhöht
mit Demo (1, 0) als f:
F.AUCECTEDEMO ()

Ausgang:

➜ Desktop Python3 ZerodiNeRror.py
Geben Sie __init__ ein
Finden Sie das __ENTER__
2.0
\ Finde das __exit__
Typ: Keine
Wert: Keine
Traceback: Keine
============================================
Geben Sie __init__ ein
Finden Sie das __ENTER__
\ Finde das __exit__
Typ:
Wert: Teilung um Null
Zurück verfolgen:
Traceback (letzte Anruflast):
Datei "ZeroDiVisonError.py ", Zeile 32, in
F.AUCECTEDEMO ()
Datei "ZeroDiVisonError.Py ", Zeile 21, in ExceptionDemo
Druck (Selbst.x / selbst.y)
NulodivisionError: Division von Null
➜ Desktop

Erläuterung:
Im obigen Code, Zeilennummer 25, Wir führen den Code mit der Anweisung "With" aus. Darin bestehen wir den Wert von x als 4 und y als 2. Im Ausgabeabschnitt können wir sehen, dass es zuerst den __init__method aufruft und x und y initialisiert. Dann ruft es die __enter__ -Methode auf und zugewiesen dieses Objekt der Variablen F.Anschließend ruft sie die Ausnahmedemo -Methode mit der F -Variablen auf und druckt dann den Abteilungswert, der 2 ist. Danach ruft es die __Exit__ -Methode auf und druckt dann alle drei wichtigen Parameterwerte keine, da wir bis jetzt keinen Fehler haben.

Bei Zeile Nr. 31 nennen wir dieselbe Methode mit dem Wert von x als 1 und y als 0. Wir können sehen, dass im Ausgangsabschnitt die Drei-Parameter-Werte unterschiedlich sind.

Der erste Parameter (exc_type) Type Drucken des Klassennamens, der einen Fehler verursachte.

Der zweite Parameter (exc_val) druckt die Art des Fehlers aus.

Der dritte Parameter (exc_tb) Drucken der Traceback -Details.

Abschluss:
Wir haben also gesehen. Die 'With' -Aussage hilft auch, den Kontextmanager ordnungsgemäß zu schließen, der während der Programmierung möglicherweise offen bleibt.

Dieser Artikelcode ist im GitHub -Link verfügbar:
https: // github.com/shekharpandey89/mit statement