Resources beheren: in elke programmeertaal is het gebruik van resources zoals bestandsbewerkingen of databaseverbindingen heel gebruikelijk. Maar deze middelen zijn beperkt in aanbod. Daarom, het grootste probleem ligt in het ervoor te zorgen om deze middelen vrij te geven na gebruik. Als ze niet worden vrijgegeven, zal dit leiden tot bronlekkage en kan het systeem vertragen of crashen. Het zou zeer nuttig zijn als de gebruiker een mechanisme voor de automatische installatie en teardown van de middelen.In Python, kan het worden bereikt door het gebruik van context managers die de juiste behandeling van middelen te vergemakkelijken. De meest voorkomende manier van het uitvoeren van bestandsbewerkingen is met behulp van de met trefwoord zoals hieronder getoond:

Let’s take the example of file management. Wanneer een bestand wordt geopend, wordt een bestandsdescriptor gebruikt die een beperkte bron is. Slechts een bepaald aantal bestanden kan worden geopend door een proces op een moment. Het volgende programma demonstreert het.

Output:

Traceback (most recent call last): File "context.py", line 3, in OSError: Too many open files: 'test.txt'

Een foutmelding dat er te veel bestanden geopend. Het bovenstaande voorbeeld is een geval van file descriptor lekkage. Het gebeurt omdat er te veel geopende bestanden en ze zijn niet gesloten. Er kunnen kansen zijn waar een programmeur kan vergeten om een geopend bestand te sluiten.

Resources beheren met contextbeheer :

stel dat een blok code een uitzondering oproept of als het een complex algoritme heeft met meerdere returnpaden, wordt het omslachtig om een bestand op alle plaatsen te sluiten.
over het algemeen in andere talen bij het werken met bestanden wordt try-except-finally gebruikt om ervoor te zorgen dat de bestandsbron wordt gesloten na gebruik, zelfs als er een uitzondering is.Python biedt een eenvoudige manier om resources te beheren: Context Managers. Het trefwoord met wordt gebruikt. Wanneer het wordt geëvalueerd moet het resulteren in een object dat context management uitvoert. Context managers kunnen worden geschreven met behulp van klassen of functies(met decorateurs).

een Context Manager maken:

wanneer context managers worden gemaakt met behulp van klassen, moet de gebruiker ervoor zorgen dat de klasse de methoden heeft: __enter__() en __exit__(). De _ _ enter__ () geeft de bron terug die moet worden beheerd en de __exit__ () geeft niets terug, maar voert de opschoonbewerkingen uit.
laten we eerst een eenvoudige klasse maken genaamd ContextManager om de basisstructuur te begrijpen van het creëren van context managers met behulp van klassen, zoals hieronder getoond:

Output:

init method calledenter method calledwith statement blockexit method called

In dit geval wordt een ContextManager-object aangemaakt. Dit wordt toegewezen aan de variabele na het sleutelwoord as dat wil zeggen manager. Bij het uitvoeren van het bovenstaande programma wordt het volgende in volgorde uitgevoerd:

• __init__()

• __enter__()

• statement body (code in het with block)
• __exit__ ()

Bestandsbeheer met contextbeheer:

laten we het bovenstaande concept toepassen om een klasse te maken die helpt bij bestandsbronbeheer.De FileManager-klasse helpt bij het openen van een bestand, het schrijven/lezen van inhoud en vervolgens sluiten.

classFileManager():

def__init__(self, filename, mode):

self.filename =filename

self.mode =mode

self.file=None

def__enter__(self):

self.file=open(self.filename, self.mode)

returnself.file

def__exit__(self, exc_type, exc_value, exc_traceback):

self.file.close()

with FileManager('test.txt', 'w') as f:

f.write('Test')

print(f.closed)

uitvoer:

True

Bestandsbeheer met contextbeheer en met statement:

bij het uitvoeren van het met-blok gebeuren de volgende bewerkingen in volgorde:

• een bestandsbeheer-object wordt gemaakt met test.txt als de bestandsnaam en w (write) als de modus wanneer __init__ methode wordt uitgevoerd.

• De _ _ enter _ _ methode opent de test.txt-bestand in schrijfmodus (setup-operatie) en geeft het FileManager-object terug naar variabele f.

• De tekst ‘Test’ wordt in het bestand geschreven.

• de _ _ exit_ _ methode zorgt voor het sluiten van het bestand bij het afsluiten van het met-blok(teardown operatie).
  Wanneer print (F.closed) wordt uitgevoerd, is de uitvoer True omdat de FileManager al heeft gezorgd voor het sluiten van het bestand, wat anders expliciet moest worden gedaan.

Databaseverbindingsbeheer met contextbeheer:

laten we een eenvoudig databaseverbindingsbeheersysteem maken. Het aantal databaseverbindingen dat tegelijkertijd geopend kan worden is ook beperkt(net als bestandsdescriptoren). Daarom zijn contextmanagers behulpzaam bij het beheren van verbindingen met de database, omdat er kans bestaat dat de programmeur vergeet om de verbinding te sluiten.

frompymongo importMongoClient

classMongoDBConnectionManager():

def__init__(self, hostname, port):

self.hostname =hostname

self.port =port

self.connection =None

def__enter__(self):

self.connection =MongoClient(self.hostname, self.port)

returnself

def__exit__(self, exc_type, exc_value, exc_traceback):

self.connection.close()

with MongoDBConnectionManager('localhost', '27017') as mongo:

collection =mongo.connection.SampleDb.test

data =collection.find({'_id': 1})

print(data.get('name'))

Database connection management met behulp van context manager en met instructie :

Op het uitvoeren van het blok, de volgende verrichtingen gebeuren in volgorde:

• Een MongoDBConnectionManager object is gemaakt met localhost als de hostnamename en 27017 als de poort __init__ methode is uitgevoerd.

• De__ enter _ _ methode opent de mongodb verbinding en retourneert het mongodbconnectionmanager object naar variabele mongo.

• toegang tot de testcollectie in de sampledb-database en het document met _id = 1 wordt opgehaald. Het veld Naam van het document wordt afgedrukt.

• de _ _ exit _ _ methode zorgt voor het sluiten van de verbinding bij het verlaten van het met blok(teardown operatie).

artikel Tags: