Python Context Manager

Ressourcen verwalten

Die Verwendung von Ressourcen wie Dateimanipulationen oder Datenbankzugriff ist in allen Computersprachen weit verbreitet. Es gibt jedoch eine begrenzte Anzahl dieser Ressourcen. Wir müssen sicherstellen, dass das Wiederherstellen solcher Ressourcen nach dem Gebrauch das wichtigste Hindernis wäre. Wenn sie nicht verabreicht werden, tritt eine Ressourcenleckage auf und verlangsamt den Computer oder schädigt es sogar. Die Fähigkeit für Benutzer, die neuverschmutzenden Ressourcen aufzubauen und aufzubauen, wird massiv wertvoll sein. Python -Kontextmanager, die es einfacher machen, effektiv mit Ressourcen umzugehen.

Kontextmanager für Ressourcenverwaltung

Es wird schwierig, eine Datei sofort zu schließen, wenn ein Code einen Fehler aufweist oder einen komplizierten Mechanismus aufweist, einschließlich vieler zurückgegebener Wege. Versuch wird in bestimmten Programmiersprachen typischerweise verwendet, um dies zu versichern, um dies zu versichern. In der Tat wird die Dateiressource nach der Verwendung beendet, obwohl ein Fehler vorliegt. Kontextverwalter, ein Modul von Python, aktivieren Ressourcenverwaltung einfach. Der Begriff „mit“ wird verwendet. Dies erstellt ein Objekt, das den Kontext bis zur Analyse verwaltet. Klassen oder Prozesse mit Modifikatoren werden verwendet, um Kontextmanager zu erstellen. Lassen Sie uns mehr Kontextmanager diskutieren.

Beispiel Nr. 1

Stellen Sie bei der Verwendung von Klassen zur Konstruktion von Kontextmanagern sicher, dass die Klasse die Funktionen wie Enter () und exit () enthält. Die Reinigungsaktivitäten werden über die Funktion exit () durchgeführt, die nur die Funktion Enter () zurückgibt. Um den Rahmen der Generierung von Kontextmanagern mit Klassen zu analysieren, entwickeln wir zunächst eine grundlegende Klasse namens ContextManager, wie hier zu sehen ist:

Klasse contextManager ():
def __init __ (self1):
Print ('Init -Funktion wird aufgerufen')
def __ENTER __ (self2):
Print ('Eingabefunktion wird aufgerufen')
Return Self2
def __exit __ (self2, exc_type, exc_value, exc_traceBack):
print ('Beendenfunktion wird aufgerufen')
mit contextManager () als Manager:
print ('Hier ist die mit Anweisung')

Zu Beginn des Code erstellen wir eine Klasse, die als ContextManager bezeichnet wird. Innerhalb dieser Klasse definieren wir eine Funktion init (). Anschließend verwenden wir die Print () -Methode, um die Anweisung „Init -Funktion aufgerufen wird“ anzuzeigen. In der nächsten Zeile wird eine weitere Funktion Enter () definiert. Diese Funktion enthält "self2" als Argument. Wir rufen die Print () -Methode auf, um die Anweisung „Eingabefunktion aufgerufen zu werden“ zu drucken. Dann heißt die Rückgabeerklärung aufgerufen.

Definieren wir eine neue Funktion namens exit (). Diese Funktion enthält vier verschiedene Argumente, die den Wert von Self2, exc_type, exc_value und exc_traceback enthalten. Für diese Funktion wird auch die Anweisung Print () angewendet, um die Zeile „Beendenfunktion aufgerufen wird“ anzuzeigen. Zuletzt erstellen wir einen Objektmanager der ContextManager -Klasse. Wir verwenden eine Print () -Antage, in der die Nachricht "Hier ist die mit der Anweisung" anzeigt,.

In diesem Beispiel wird eine ContextManager -Instanz generiert. Das Attribut nach dem Begriff "Manager" wird diese Zuweisung erhalten. Die folgenden Funktionen werden nacheinander ausgesetzt, wenn der oben genannte Code ausgeführt wird:

• drin()
• eingeben()
• Eine Deklarationsgremium, die Code innerhalb eines Abschnitts „mit“ enthält.
• Ausfahrt(). Die Argumente dieser Funktion werden verwendet, um Fehler zu kontrollieren.

Beispiel Nr. 2

Lassen Sie uns den vorhergehenden Ansatz verwenden, um eine Klasse zu erstellen, die bei der Verwaltung von Dateiressourcen unterstützt. Die FileManager -Klasse erleichtert den Zugriff, das Schreiben oder Lesen von Dateien und beendet sie.

Klasse filemanager ():
def __init __ (self1, Dateiname, Modus):
self1.Dateiname = Dateiname
self1.Modus = Modus
self1.Datei = keine
def __ENTER __ (self2):
self2.Datei = open (self2.Dateiname, self2.Modus)
Return Self2.Datei
def __exit __ (self2, exc_type, exc_value, exc_traceBack):
self2.Datei.schließen()
mit filemanager ('Hallo.txt ',' w ') als f:
F.Schreiben ('Test')

Druck (f.geschlossen)

Erstens erstellen wir eine Klasse, die als "Filemanager" bekannt ist. Jetzt definieren wir verschiedene Funktionen im Zusammenhang mit dieser Klasse. Erstens definieren wir die Funktion von init (). Innerhalb dieser Funktion vergeben wir drei verschiedene Argumente. Der erste Parameter ist "self1", der zweite Parameter zeigt den Namen der Datei „Dateiname“ und der letzte Parameter den „Modus“ der Datei zeigt. Wir erstellen ein Objekt, das als Dateinamen bezeichnet wird, und setzen seinen Wert gleich dem ursprünglichen Namen der erforderlichen Datei.

Anschließend erstellen wir ein anderes Objekt namens "Modus", und hier geben wir das Format der definierten Datei an. Wir deklarieren das letzte als "Datei" bezeichnete Objekt und jetzt wird der Wert dieses Objekts als "None" festgelegt. Lassen Sie uns eine andere Funktion initialisieren Enter () initialisieren. Wir liefern den Wert von „self2“ als Argument für diese Funktion. Hier rufen wir die Open () -Methode an, um die angegebene Datei zu öffnen. Diese Funktion enthält zwei Parameter, die den Namen der Datei enthalten, die wir öffnen möchten, und die Art des Öffnens der Datei. Der Modusparameter zeigt an, zu welchem ​​Zweck wir die Datei öffnen möchten. Der Modus der Datei lautet "schreiben" oder "lesen".

Dann verwenden wir die Rückgabeerklärung. Im nächsten Schritt möchten wir diese Datei beenden. Also wenden wir die METHODE EXIT () an. Wir werden vier Argumente an diese Funktion verabschieden. Dann verwenden wir die filemanager () -Methode. Wir laden eine Datei mit dieser Funktion. In dieser Funktion geben wir den Text an, den wir in die Datei schreiben möchten. Außerdem geben wir den Modus der Datei „W“ an. Jetzt wenden wir die Write () -Methode an. Um den Code zu beenden, verwenden wir die Print () -Methode. Innerhalb dieser Funktion verwenden wir eine enge Anweisung, um die Datei einfach zu schließen.

Durch die Verwendung von Context Manager werden wir Dateien verwalten. Wenn der Block „mit“ implementiert ist, finden die entsprechenden Schritte nacheinander statt:

• Wann immer die init () -Funktion aufgerufen wird, wird eine FileManager -Instanz konstruiert, die Hallo hat.Txt als Titel der Datei und "W" als Format des FI • Das Hallo.Die TXT -Datei wird von der Funktion Entert () im Schreibformat zugegriffen, wodurch auch eine Dateiklasse an das Attribut F zurückgegeben wird.
• Die Datei enthält den Inhalt “Test.”
• Wenn der Abschnitt mit dem Abschnitt beendet wird, wird die Funktion exit () übernommen, die die Datei schließen. Weil der Filemanager tatsächlich die Beendigung der Datei effektiv verwaltet hat, die normalerweise beim Druck explizit behandelt worden wäre (F.geschlossen) wird ausgeführt, das Ergebnis wird wahr sein.

Abschluss

In diesem Artikel haben wir über den Python Context Manager gesprochen. Wir können die Ressourcen zu den bestimmten Zeiten zuweisen und nutzen, die wir aufgrund von Kontextmanagern auswählen,. Der „mit“ Ausdruck ist die am häufigsten verwendete Illustration eines Kontextmanagers. Wann immer wir zwei verwandte Ereignisse kombinieren und einen Code zwischen ihnen implementieren möchten, verwenden wir Kontextmanager. Wir führen ein Beispiel aus, in dem wir die Erstellung eines Kontextmanagers demonstrieren. Wir manipulieren Dateien mithilfe eines Kontextmanagers und mit Befehlen.