GeeksforGeeks
håndtering af ressourcer : på ethvert programmeringssprog er brugen af ressourcer som filoperationer eller databaseforbindelser meget almindelig. Men disse ressourcer er begrænsede i udbuddet. Derfor ligger hovedproblemet i at sørge for at frigive disse ressourcer efter brug. Hvis de ikke frigives, vil det føre til ressourcelækage og kan få systemet til enten at bremse eller gå ned. Det ville være meget nyttigt, hvis brugeren har en mekanisme til automatisk opsætning og nedbrydning af ressourcer.I Python kan det opnås ved brug af kontekstledere, der letter korrekt håndtering af ressourcer. Den mest almindelige måde at udføre filoperationer på er ved at bruge med-nøgleordet som vist nedenfor:
with open("test.txt") as f: data =f.read() Let’s take the example of file forvaltning. Når en fil åbnes, forbruges en filbeskrivelse, som er en begrænset ressource. Kun et bestemt antal filer kan åbnes af en proces ad gangen. Følgende program demonstrerer det.
file_descriptors = forx inrange(100000): file_descriptors.append(open('test.txt', 'w')) output:
Traceback (most recent call last): File "context.py", line 3, in OSError: Too many open files: 'test.txt'
en fejlmeddelelse, der siger, at for mange filer er åbne. Ovenstående eksempel er et tilfælde af filbeskrivelses lækage. Det sker, fordi der er for mange åbne filer, og de er ikke lukket. Der kan være chancer, hvor en programmør kan glemme at lukke en åbnet fil.
håndtering af ressourcer ved hjælp af kontekststyring :
Antag, at en blok kode rejser en undtagelse, eller hvis den har en kompleks algoritme med flere returstier, bliver det besværligt at lukke en fil alle steder.generelt på andre sprog, når du arbejder med filer prøv-undtagen-endelig bruges til at sikre, at filressourcerne lukkes efter brug, selvom der er en undtagelse.Python giver en nem måde at styre ressourcer på: Kontekstforvaltere. Med nøgleordet bruges. Når det bliver evalueret, skal det resultere i et objekt, der udfører kontekststyring. Kontekstledere kan skrives ved hjælp af klasser eller funktioner(med dekoratører).
oprettelse af en Kontekststyring:
Når du opretter kontekstledere ved hjælp af klasser, skal brugeren sikre, at klassen har metoderne: __enter__() og __afslut__(). _ _ Enter__ () returnerer den ressource, der skal styres, og __afslut__() returnerer ikke noget, men udfører oprydningsoperationerne.
Lad os først oprette en simpel klasse kaldet Kontekstmanager for at forstå den grundlæggende struktur for at skabe kontekstledere ved hjælp af klasser, som vist nedenfor:
classContextManager(): def__init__(self): print('init method called') def__enter__(self): print('enter method called') returnself def__exit__(self, exc_type, exc_value, exc_traceback): print('exit method called') with ContextManager() as manager: print('with statement block') Output:
init method calledenter method calledwith statement blockexit method called
i dette tilfælde oprettes et Kontekstmanagerobjekt. Dette tildeles variablen efter as-nøgleordet, dvs.manager. Når du kører ovenstående program, udføres følgende i rækkefølge:
- __init__()
- sætningsorgan (kode inde i med blok)
- _Afslut __ ()
Filhåndtering ved hjælp af konteksthåndtering:
lad os anvende ovenstående koncept til at oprette en klasse, der hjælper med filressourcestyring.FileManager-klassen hjælper med at åbne en fil, skrive/læse indhold og derefter lukke den.
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) Output:
True
Filhåndtering ved hjælp af konteksthåndtering og med erklæring :
Ved udførelse af med-blokken sker følgende operationer i rækkefølge:
- et FileManager-objekt oprettes med test.som tilstanden, når__ init _ _ – metoden udføres.
- __enter__ – metoden åbner testen.filmanager-objektet til variabel f.
- teksten ‘Test’ skrives ind i filen.
- __Afslut__ – metoden tager sig af at lukke filen ved afslutning af med-blokken(nedrivningsoperation).
når print(f.lukket) køres, er outputtet sandt, da filmanager allerede har sørget for at lukke filen, som ellers skulle udføres eksplicit.
Databaseforbindelsesstyring ved hjælp af kontekststyring:
lad os oprette et simpelt databaseforbindelsesstyringssystem. Antallet af databaseforbindelser, der kan åbnes ad gangen, er også begrænset(ligesom filbeskrivere). Derfor er kontekstforvaltere nyttige til at styre forbindelser til databasen, da der kan være chancer for, at programmøren kan glemme at lukke forbindelsen.
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')) databaseforbindelsesstyring ved hjælp af konteksthåndtering og med erklæring:
Ved udførelse af med-blokken sker følgende operationer i rækkefølge:
- et mongodbconnectionmanager-objekt oprettes med localhost som hostnamename og 27017 som porten, når __init__ – metoden udføres.
- metoden __enter__ åbner mongodb-forbindelsen og returnerer objektet MongoDBConnectionManager til variabel mongo.
- testsamlingen i SampleDb-databasen åbnes, og dokumentet med _id=1 hentes. Dokumentets navnefelt udskrives.
- __Afslut__ – metoden tager sig af at lukke forbindelsen ved afslutning af med-blokken(nedrivningsoperation).