Python Context Manager

Administrere ressurser

Bruk av ressurser som filmanipulasjoner eller databasetilgang er ganske utbredt på alle dataspråk. Imidlertid er det et begrenset antall av disse ressursene. Vi må sørge for at å gjenopprette slike ressurser etter bruk vil være den viktigste hindringen. Når de ikke blir gitt, vil ressurslekkasje oppstå, og det bremser eller skader datamaskinen. Muligheten for brukere til å bygge opp og bryte ned omfordeling av ressurser vil være massivt verdifull. Python kontekstledere som gjør det lettere å håndtere ressurser effektivt kan brukes til å oppnå dette.

Kontekstleder for ressursstyring

Det vil bli vanskelig å lukke en fil umiddelbart når et stykke kode kaster en feil eller har en komplisert mekanisme, inkludert mange returnerte stier. Prøve-unntak-finalt brukes vanligvis på visse programmeringsspråk for å sikre det. Faktisk filressurs avsluttes etter å ha brukt den, selv om det er en feil. Kontekstledere, en modul av Python, muliggjør ressursstyring ganske enkelt. Begrepet "med" vil bli brukt. Dette vil skape et objekt som administrerer kontekst til det er blitt analysert. Klasser eller prosesser med modifikatorer vil bli brukt til å opprette kontekstledere. La oss diskutere flere kontekstbehandler.

Eksempel nr. 1

Mens du bruker klasser for å konstruere kontekstledere, må du sørge for at klassen inneholder funksjonene som enter () og exit (). Opprydningsaktivitetene utføres via Exit () -funksjonen, som ikke vil returnere annet enn funksjonen Enter () gir ressursen som krever utvikling. For å analysere rammen for å generere kontekstledere med klasser, la oss først utvikle en grunnleggende klasse som heter ContextManager, som sett her:

Class ContextManager ():
def __init __ (self1):
trykk ('initfunksjon vil bli kalt')
def __enter __ (self2):
trykk ('Enter -funksjonen vil bli kalt')
Returner Self2
def __exit __ (self2, exc_type, exc_value, exc_traceback):
trykk ('Avsluttfunksjon vil bli kalt')
med ContextManager () som manager:
trykk ('Her er med uttalelsen')

I begynnelsen av koden oppretter vi en klasse som er betegnet som kontekstmanager. Innenfor denne klassen definerer vi en funksjon init (). Deretter bruker vi Print () -metoden for å vise uttalelsen “Init -funksjonen vil bli kalt”. I neste linje vil en annen funksjon, enter (), bli definert. Denne funksjonen inneholder “Self2” som et argument. Vi kaller metoden Print () for å skrive ut uttalelsen “Enter -funksjonen vil bli kalt”. Da kalles returerklæringen.

La oss definere en ny funksjon som heter Exit (). Denne funksjonen har fire forskjellige argumenter, som inneholder verdien av selv2, exc_type, exc_value og exc_traceback. For denne funksjonen blir også PRINT () -klæringen brukt for å vise at linjen "Utgangsfunksjon vil bli kalt". Til slutt vil vi opprette en objektleder i ContextManager -klassen. Vi bruker en utskrift () uttalelse som viser meldingen “Her er med uttalelsen”.

En kontekstManager -forekomst genereres i dette eksemplet. Attributtet etter begrepet "manager" får denne tildelingen. Følgende funksjoner utføres sekvensielt ved utførelse av den nevnte koden:

• i det()
• Tast inn()
• Et erklæring organ som inneholder kode i en "med" seksjon.
• exit(). Argumentene for denne funksjonen blir brukt til å kontrollere feil.

Eksempel nr. 2

La oss bruke den foregående tilnærmingen for å bygge en klasse som hjelper til med å håndtere filressurser. Filemanager -klassen letter tilgang, skriving til eller leser fra og avslutter filer.

klasse Filemanager ():
def __init __ (self1, filnavn, modus):
selv1.filnavn = filnavn
selv1.modus = modus
selv1.fil = ingen
def __enter __ (self2):
selv2.fil = åpen (self2.Filnavn, Self2.modus)
Returner Self2.fil
def __exit __ (self2, exc_type, exc_value, exc_traceback):
selv2.fil.Lukk()
med Filemanager ('Hei.txt ',' w ') som f:
f.Skriv ('Test')

trykk (f.lukket)

Først av alt lager vi en klasse kjent som "filemanager". Nå definerer vi forskjellige funksjoner relatert til denne klassen. Først definerer vi funksjonen til init (). Innenfor denne funksjonen passerer vi tre forskjellige argumenter. Den første parameteren er “Self1”, den andre parameteren viser navnet på filen “Filnavn”, og den siste parameteren viser “modus” på filen. Vi oppretter et objekt kalt et filnavn og setter verdien lik det opprinnelige navnet på den nødvendige filen.

Så oppretter vi et annet objekt som heter "Mode", og her spesifiserer vi formatet til den definerte filen. Vi erklærer det siste objektet som er navngitt som "fil", og nå vil verdien av dette objektet bli satt som "ingen". La oss initialisere en annen funksjon Enter (). Vi gir verdien av "selv2" som et argument for denne funksjonen. Her kaller vi Open () -metoden for å åpne den spesifiserte filen. Denne funksjonen inneholder to parametere som inkluderer navnet på filen som vi ønsker å åpne og å åpne filen. Modusparameteren viser for hvilket formål vi ønsker å åpne filen. Filens modus vil være "skriv", eller "lese".

Så bruker vi returerklæringen. I neste trinn vil vi avslutte filen. Så vi bruker Exit () -metoden. Vi vil gi fire argumenter til denne funksjonen. Så bruker vi filemanager () -metoden. Vi laster inn en fil ved å bruke denne funksjonen. Innenfor denne funksjonen spesifiserer vi teksten som vi ønsker å skrive i filen. Og også, vi spesifiserer modus for filen "w". Nå bruker vi skrive () -metoden. For å avslutte koden, bruker vi metoden Print (). Innenfor denne funksjonen bruker vi en nær uttalelse for å bare lukke filen.

Ved å bruke Context Manager, vil vi administrere filer. Når "med" -blokken blir implementert, finner de aktuelle trinnene sted etter hverandre:

• Hver gang init () -funksjonen kalles, konstrueres en filemanager -forekomst, med hei.txt som tittelen på filen og "w" som formatet til fi • hei.TXT -fil får tilgang til i skriveformat etter enter () -funksjonen, som også returnerer en filklasse til attributtet F.
• Filen inneholder innholdet “Test.”
• Når med -seksjonen avsluttes, håndtaker Funksjonen for utkjørselen og lukker filen. Fordi filemanageren faktisk effektivt har administrert avslutningen av filen, som normalt ville vært pålagt å håndtere eksplisitt, når du skriver ut (f.lukket) utføres, utfallet vil være sant.

Konklusjon

I denne artikkelen har vi snakket om Python Context Manager. Vi kan tilordne og bruke ressursene til de bestemte tidspunktene vi velger på grunn av kontekstledere. "Med" -uttrykket er den mest brukte illustrasjonen av en kontekst manager. Hver gang vi ønsker å koble sammen to relaterte hendelser og implementere et stykke kode mellom dem, bruker vi kontekstledere. Vi utfører et eksempel der vi demonstrerer opprettelsen av en kontekstsjef. Vi manipulerer filer ved bruk av en kontekstbehandler og med kommandoer.