con dichiarazione
Quindi, in questo articolo, discuteremo di come possiamo usare il 'con' dichiarazione.
Possiamo capirlo con un esempio molto semplice.
Ogni volta che codifichiamo qualcosa da leggere o scrivere un file, la prima cosa che dobbiamo fare è aprire il file, quindi eseguiamo le operazioni di lettura o scrittura su questo e, infine, chiudiamo il file in modo che tutte le risorse non sarà occupato. Quindi significa che dobbiamo rilasciare la risorsa dopo aver completato il nostro lavoro.
Questo possiamo anche capire dal contesto manager. Un gestore del contesto è un oggetto che si occupa delle risorse per salvare, ripristinare, bloccare o sbloccare le risorse, aprire e chiudere i file, ecc. Il contesto di contesto è attivo quando apriamo un file per la lettura o la scrittura. Se non chiudiamo il file dopo aver letto o scritto, la risorsa è comunque allocata a quel particolare file e, per questo motivo, la risorsa sarà occupata se un processo particolare desidera utilizzare quella risorsa.
Ecco perché chiamiamo il metodo Close () dopo aver letto o scritto il file.
f = aperto ("Demo.TXT")
dati = f.Leggere()
F.vicino()
Quindi, nel codice sopra, è semplice e non c'è un gestore di eccezioni che abbiamo usato. Quindi, se si verifica un errore, il programma si fermerà incondizionatamente. E il secondo caso è che a volte dimentichiamo anche di aggiungere il file di chiusura come abbiamo fatto.
Quindi, per superare alcuni dei problemi, possiamo usare il seguente metodo per scrivere il codice sopra.
Tentativo:
f = aperto ('demo.txt ',' r ')
Stampa (f.Leggere())
Tranne l'eccezione come E:
Stampa ("Errore si è verificato", E)
Finalmente:
F.vicino()
Nel codice sopra, puoi vedere che abbiamo usato il tentativo, tranne e infine bloccare. Quindi, in questo modo, possiamo anche controllare la gestione delle eccezioni. E chiudiamo finalmente il file nel blocco finalmente. Abbiamo anche usato il blocco tranne, che gestirà le eccezioni. Quindi, se usiamo lo scenario sopra, il nostro codice non si fermerà incondizionatamente. E il nostro file sicuramente chiuderà anche se ricevemo qualche errore durante la lettura del file.
Ma possiamo anche perfezionare il codice sopra attraverso un altro metodo che abbiamo chiamato l'istruzione "con". L'istruzione "con" gestirà automaticamente la chiusura del file e non dobbiamo preoccuparci di chiudere il file dopo aver letto o scritto.
Il contesto di contesto crea un metodo ENTER () e EXIT () in fase di esecuzione e lo chiama quando devono distruggere il file. Mentre esegui un codice semplice o con un tentativo, tranne Block, chiamiamo il metodo Exit () tramite il metodo Close (). Ma l'istruzione "con" si occupa automaticamente del metodo Exit (). Quindi questa è la bellezza dell'affermazione "con".
Possiamo riscrivere il codice sopra con l'istruzione "con" come di seguito:
con aperto ("Demo.txt ") come f:
dati = f.Leggere()
Il codice sopra è molto semplice e non dobbiamo pensarci ogni volta che chiudiamo il file, che viene fatto dall'istruzione "con" automaticamente.
Sembra magia, ma in realtà, questo non è magico. L'istruzione "con" avvia due oggetti che abbiamo chiamato __enter__ () e __exit__ (). L'affermazione che segue le dichiarazioni "con" è chiamata __enter__ () e restituisce un oggetto assegnato a come variabile, e dopo che tutto il processo di blocco è stato eseguito, chiama __exit__ ().
Esempio 1: ex1.Py
#ex1.Py
Demo di classe:
def __enter __ (self):
Print ("Calling to __enter__ Metodo")
restituire "vero"
def __exit __ (self, Exc_type, Exc_val, Exc_tb):
Print ("Calling to __exit__ metodo")
def calling_demo ():
restituire demo ()
con chiamate_demo () come f:
Print ("Demo:", F)
Produzione:
➜ ~ cd desktop
➜ desktop python3 ex1.Py
Chiamando al metodo __enter__
Demo: vero
Chiamando al metodo __exit__
➜ desktop
Spiegazione:
- Quando eseguiamo il codice sopra Ex1.Py, quindi viene prima chiamato il metodo __enter__.
- Quindi restituisce qualcosa dal codice (vero) assegnato alla variabile F.
- Quindi, il blocco del codice è stato eseguito. In quel blocco, stiamo stampando il valore della F, il che è vero.
- Finalmente, quando il processo del blocco è finito, viene chiamato il metodo __exit__.
La cosa migliore dell'affermazione "con" è che gestisce automaticamente anche l'eccezione. Come puoi vedere nell'esempio del codice sopra Ex1.Py, il metodo __exit__ prende tre parametri: Exc_type, Exc_val, Exc_tb. Questi parametri aiutano a gestire le eccezioni.
Sintassi: __exit __ (self, Exc_type, Exc_value, Exc_tb)
Exc_type: Racconta il nome della classe in cui si verifica un'eccezione.
Exc_value: Racconta il tipo di eccezione come Divide per Errore zero, ecc.
Exc_traceback: Il traceback è completo sull'eccezione, proprio come un rapporto per risolvere l'errore avvenuto nel programma.
Ora cambieremo il codice sopra per vedere come gestirà automaticamente le eccezioni.
Esempio_2: ZerodivisionError.Py
#ZerodivisionError.Py
Demo di classe:
def __init __ (self, x, y):
Stampa ("Enter __init__")
se stesso.x = x
se stesso.y = y
def __enter __ (self):
Stampa ("Trova il __enter__")
Restituisci se stessi
def __exit __ (self, Exc_type, Exc_val, Exc_tb):
print ("\ trova __exit__")
print ("\ ntype:", exc_type)
print ("\ nValue:", Exc_val)
print ("\ ntraceback:", exc_tb)
Def ExceptionDemo (self):
# Eccezione ZerodivisionError
Stampa (Self.x / self.y)
# con l'affermazione non sollevare un'eccezione
con demo (4, 2) come f:
F.ExceptionDemo ()
Stampa ("\ n \ n ======================================= \ n \ n ")
# con la dichiarazione aumenterà uno zerodivisionerror
con demo (1, 0) come f:
F.ExceptionDemo ()
Produzione:
➜ desktop python3 zerodivisonerror.Py
Immettere __init__
Trova il __enter__
2.0
\ Trova __exit__
Tipo: nessuno
Valore: nessuno
Traceback: nessuno
=========================================
Immettere __init__
Trova il __enter__
\ Trova __exit__
tipo:
Valore: divisione per zero
Rintracciare:
Traceback (chiamata più recente per ultima):
File "ZerodivisonError.py ", riga 32, in
F.ExceptionDemo ()
File "ZerodivisonError.Py ", riga 21, in ExceptionDemo
Stampa (Self.x / self.y)
ZerodivisionError: divisione di zero
➜ desktop
Spiegazione:
Nel codice sopra, Numero di riga 25, Eseguiamo il codice con l'istruzione "con". In questo, passiamo il valore di x come 4 e y come 2. Nella sezione output, possiamo vedere che prima chiama __init__method e inizializza xey. Quindi chiama il metodo __enter__ e assegnato tale oggetto alla variabile F.Quindi chiama il metodo ExceptionDemo utilizzando la variabile F e quindi stampa il valore di divisione, che è 2. Successivamente, chiama il metodo __exit__ e quindi stampa tutti e tre i parametri importanti nessuno dei valori perché non abbiamo alcun errore fino ad ora.
Alla riga numero 31, chiamiamo lo stesso metodo con il valore di x 1 e y come 0 perché vogliamo aumentare l'eccezione e vedere come l'istruzione "con" la gestisce senza il tentativo e tranne il blocco. Possiamo vedere che nella sezione di output, i valori a tre parametri sono diversi.
Il primo parametro (Exc_type) tipi che stampano il nome della classe, che ha causato un errore.
Il secondo parametro (Exc_val) stampa il tipo di errore.
Il terzo parametro (Exc_tb) Stampare i dettagli del traceback.
Conclusione:
Quindi, abbiamo visto come l'istruzione "con" si comporta effettivamente in modo intelligente per gestire automaticamente la gestione delle eccezioni. L'istruzione "con" aiuta anche a chiudere correttamente il contesto di contesto, che potrebbe lasciare aperta durante la programmazione.
Questo codice dell'articolo è disponibile sul collegamento GitHub:
https: // github.com/shekharpandey89/with-statement