Python Context Manager

Gestione delle risorse

L'uso di risorse come manipolazioni di file o accesso al database è abbastanza diffuso in tutte le lingue di computer. Tuttavia, esiste un numero limitato di queste risorse. Dobbiamo garantire che il ripristino di tali risorse dopo l'uso sia l'ostacolo chiave. Quando non vengono dati, si verificheranno perdite di risorse e rallenta o addirittura danneggia il computer. La possibilità per gli utenti di accumulare e abbattere le risorse di riallocazione sarà enormemente preziosa. I manager di contesto di Python che rendono più facile gestire le risorse in modo efficace potrebbe essere utilizzato per raggiungere questo obiettivo.

Context Manager per la gestione delle risorse

Diventerà difficile chiudere un file immediatamente quando un pezzo di codice lancia un errore o ha un meccanismo complicato, inclusi molti percorsi restituiti. Try-Except-finalmente viene generalmente utilizzato in alcuni linguaggi di programmazione per assicurarlo. In effetti la risorsa di file viene terminata dopo averlo utilizzato, sebbene ci sia un errore. I gestori del contesto, un modulo di Python, abilitano semplicemente la gestione delle risorse. Verrà utilizzato il termine "con". Ciò creerà un oggetto che gestisce il contesto fino a quando non è stato analizzato. Le classi o i processi con modificatori verrebbero utilizzati per creare gestori di contesto. Discutiamo di più contesto manager.

Esempio n. 1

Utilizzando le classi per costruire manager di contesto, assicurarsi che la classe contenga le funzioni come Enter () e Exit (). Le attività di pulizia vengono eseguite tramite la funzione Exit (), che non restituirà altro che la funzione enter () fornisce la risorsa che richiede lo sviluppo. Per analizzare il quadro della generazione di gestori di contesto con le classi, sviluppiamo prima una classe di base denominata ContextManager, come visto qui:

Class contestyManager ():
def __init __ (self1):
print ('Init Function verrà chiamata')
def __enter __ (self2):
print ('INVIO la funzione verrà chiamata')
Restituisci Self2
def __exit __ (self2, Exc_type, Exc_value, Exc_traceback):
print ("La funzione di uscita verrà chiamata")
con contextManager () come manager:
stampa ("ecco la dichiarazione con la dichiarazione")

All'inizio del codice, creiamo una classe definita contesto. All'interno di questa classe, definiamo una funzione init (). Quindi utilizziamo il metodo Print () per visualizzare l'istruzione "La funzione init verrà chiamata". Nella riga successiva, un'altra funzione, enter (), verrà definita. Questa funzione contiene "self2" come argomento. Chiameremo il metodo Print () per stampare l'istruzione "Verrà chiamata funzione ENTER. Quindi la dichiarazione di restituzione viene chiamata.

Definiamo una nuova funzione denominata Exit (). Questa funzione ha quattro diversi argomenti, che contengono il valore di self2, Exc_type, Exc_value ed Exc_traceback. Per questa funzione, l'istruzione Print () viene anche applicata per mostrare la linea "La funzione di uscita verrà chiamata". Infine, creeremo un manager di oggetti della classe contestuale. Utilizziamo un'istruzione Print () che mostra il messaggio "ecco la dichiarazione".

Un'istanza di contesto viene generata in questo esempio. L'attributo dopo il termine "manager" viene data questa allocazione. Le seguenti funzioni vengono eseguite in sequenza dopo l'esecuzione del codice sopra menzionato:

• dentro()
• accedere()
• Un organo di dichiarazione che contiene codice all'interno di una sezione "con".
• Uscita(). Gli argomenti di questa funzione vengono utilizzati per controllare gli errori.

Esempio n. 2

Usiamo l'approccio precedente per creare una classe che aiuta a gestire le risorse dei file. La classe FileManager facilita l'accesso, la scrittura o la lettura da file.

Classe FileManager ():
def __init __ (self1, nome file, modalità):
Self1.FileName = nome file
Self1.modalità = modalità
Self1.file = nessuno
def __enter __ (self2):
Self2.File = Open (self2.nome file, self2.modalità)
Restituisci Self2.file
def __exit __ (self2, Exc_type, Exc_value, Exc_traceback):
Self2.file.vicino()
con FileManager ('Hello.txt ',' w ') come f:
F.Scrivi ("test")

Stampa (f.Chiuso)

Prima di tutto, creiamo una classe nota come "FileManager". Ora definiamo diverse funzioni relative a questa classe. Innanzitutto, definiamo la funzione di init (). All'interno di questa funzione, passiamo tre vari argomenti. Il primo parametro è "self1", il secondo parametro mostra il nome del file "nome file" e l'ultimo parametro mostra la "modalità" del file. Creiamo un oggetto definito un nome file e impostiamo il suo valore uguale al nome originale del file richiesto.

Quindi creiamo un altro oggetto chiamato "modalità", e qui specifichiamo il formato del file definito. Dichiariamo l'ultimo oggetto chiamato "file" e ora il valore di questo oggetto verrà impostato come "nessuno". Inizializzano un'altra funzione enter (). Forniamo il valore di "self2" come argomento per questa funzione. Qui chiamiamo il metodo Open () per aprire il file specificato. Questa funzione contiene due parametri che includono il nome del file che vogliamo aprire e la modalità di aprire il file. Il parametro della modalità mostra a quale scopo vogliamo aprire il file. La modalità del file sarà "scrittura" o "leggi".

Quindi utilizziamo la dichiarazione di restituzione. Nel passaggio successivo, vogliamo uscire da quel file. Quindi applichiamo il metodo Exit (). Passeremo quattro argomenti a questa funzione. Quindi utilizziamo il metodo FileManager (). Cariciamo un file utilizzando questa funzione. All'interno di questa funzione, specifichiamo il testo che vogliamo scrivere nel file. Inoltre, specifichiamo la modalità del file "W". Ora applichiamo il metodo Write (). Per terminare il codice, utilizziamo il metodo Print (). All'interno di questa funzione, utilizziamo un'istruzione vicina per chiudere il file.

Utilizzando contesto manager, gestiremo i file. Quando viene implementato il blocco "con", i passaggi appropriati avvengono uno dopo l'altro:

• Ogni volta che viene chiamata la funzione Init (), viene costruita un'istanza FileManager, con Hello.txt come titolo del file e "w" come formato del fi • il ciao.Il file TXT è accessibile in formato di scrittura mediante la funzione Enter (), che restituisce anche una classe di file all'attributo F.
• Il file contiene il contenuto "Test."
• Quando la sezione con la sezione è terminata, la funzione EXIT () si chiude a chiusura del file. Perché il FileManager ha effettivamente gestito efficacemente la risoluzione del file, che normalmente sarebbe stato richiesto per gestire esplicitamente, quando stampato (f.chiuso) viene eseguito, il risultato sarà vero.

Conclusione

In questo articolo, abbiamo parlato del Python Context Manager. Possiamo assegnare e utilizzare le risorse nei tempi specifici che scegliamo a causa dei gestori di contesto. L'espressione "con" è l'illustrazione più frequentemente utilizzata di un gestore del contesto. Ogni volta che vogliamo abbinare due eventi correlati e implementare un codice tra di loro, utilizziamo i gestori di contesto. Eseguiamo un esempio in cui dimostriamo la creazione di un gestore del contesto. Manipoliamo i file mediante l'uso di un gestore del contesto e con i comandi.