Come gestire le eccezioni in Python

La gestione delle eccezioni è la tua capacità di personalizzare e visualizzare i messaggi di errore per le parti del tuo programma che non funzionano.

Sia che tu stia costruendo un sito web, creando un'API, un modulo o qualsiasi altro prodotto utilizzando Python, la tua capacità di gestire efficacemente le eccezioni ti consente di indicare esplicitamente la causa di un errore.

Qui daremo un'occhiata a come puoi gestire le eccezioni in Python.

Come funziona la gestione delle eccezioni in Python

Quando sollevi eccezioni, stai dicendo a Python di far apparire un messaggio ogni volta che un blocco di codice fallisce. La gestione delle eccezioni è come dire a qualcuno di provare a sollevare un peso. E se non possono, dovrebbero avvisarti.

Per sollevare un'eccezione in Python, tuttavia, dirai a Python di provare ad eseguire un particolare blocco di codice. Se quel blocco fallisce, puoi chiedere a Python di sollevare un'eccezione definita al codice fallito.

Quando dovresti usare le eccezioni nella programmazione Python?

Nella maggior parte delle occasioni, puoi mascherare gli errori standard di Python usando le eccezioni. Ma è necessario rimanere vigili, poiché ciò potrebbe causare problemi di debug. Di conseguenza, potresti trovare difficile capire la causa principale di un eventuale bug.

Pertanto, dovresti usare le eccezioni quando hai sufficientemente testato il tuo codice e sei sicuro che funzioni. In definitiva, è buona norma usarli per gestire potenziali errori che possono derivare dall'estremità dell'utente piuttosto che dal codice stesso.

In altre parole, puoi utilizzare le eccezioni come strumento di avviso per guidare gli utenti su come utilizzare il tuo programma.

Gestire le eccezioni Python Python

Per gestire le eccezioni in Python, devi prima avvolgere il tuo codice in a prova...tranne bloccare. Occasionalmente, potrebbe essere necessario includere a finalmente dichiarazione per gestire ulteriori azioni, a seconda delle vostre esigenze.

Il concetto di codifica delle eccezioni Python generalmente assomiglia a questo:

provare:
"codice da eseguire"
tranne:
"messaggio di errore"

Come accennato in precedenza, puoi anche usare finalmente in un blocco di eccezione. Ma il codice che scrivi dentro a finalmente La clausola è indipendente e viene eseguita indipendentemente dall'eccezione.

In sostanza, è utile se si dispone di un altro blocco di codice che si desidera eseguire continuamente indipendentemente da ciò che accade all'interno del prova...tranne bloccare.

Ecco un esempio:

provare:
stampa (9+6)
tranne:
print("messaggio di errore")
finalmente:
print("riavvia")
Produzione:
15
per favore riavvia 

Nel codice sopra, per favore riavvia viene eseguito continuamente, indipendentemente dal fatto che ci sia o meno un'eccezione.

Un altro la condizione può anche seguire an tranne dichiarazione:

provare:
C = 2 + SI
tranne:
print("B deve essere definito")
altro:
print (u"Aggiunto con successo! Il risultato è %s"%(C))
Produzione: B deve essere definito

Ora riprova con "B" definito:

provare:
B = 5
C = 2 + SI
tranne:
print("B deve essere definito")
altro:
print (u"Aggiunto con successo! Il risultato è %s"%(C))
Produzione: Aggiunto con successo! Il risultato è 7

Gli esempi precedenti sono eccezioni non standardizzate. Ma puoi avere un'eccezione più esplicita quando combini eccezioni integrate (definite) con quelle non standardizzate:

provare:
C = 2 + SI
tranne NameError come err:
print (err, ":", "B deve essere definito, per favore")
altro:
print (u"Aggiunto con successo! Il risultato è %s"%(C))
Produzione: il nome 'B' non è definito: B deve essere definito, per favore

L'eccezione di cui sopra controlla prima se c'è un NomeErrore nel provare bloccare. Quindi stampa lo standard NomeErrore prima eccezione ("il nome 'B' non è definito"). E lo supporta con la tua eccezione scritta ("B deve essere definito, per favore").

Relazionato: Principi di programmazione di base che ogni programmatore deve conoscere

E se vuoi gestire una catena di eccezioni, puoi anche accompagnare a provare blocco con molti tranne dichiarazioni. Questo è abbastanza utile se il tuo provare block ha il potenziale per avere molte eccezioni:

provare:
B = 5
C = 2 + SI
D = galleggiante (6)
F = 7/0
tranne NameError come err:
print (err,":", "B deve essere definito, per favore")
tranne ValueError come val:
print (val,":", "Non puoi convertire quei dati")
tranne ZeroDivisionError come zeroerr:
print (zeroerr,":", "Non puoi dividere un numero per zero")
altro:
print (u"Operazione riuscita! I risultati sono: %s, %se %s"%(C, D, F))
Produzione: divisione per zero: non puoi dividere un numero per zero

E se la divisione è valida? Ad esempio, sostituendo F = 7/0 nel codice sopra con F = 7/5 dà:

Produzione: Operazione riuscita! I risultati sono: 7, 6.0 e 1.4

Eccezioni definite dall'utente in Python

Puoi anche trovare la tua eccezione e chiamarla più avanti nel tuo programma. Ciò ti consente di fornire una descrizione specifica della tua eccezione e di nominarla come preferisci.

Tuttavia, ogni eccezione definita dall'utente (direttamente o indirettamente) proviene ancora dal built-in Eccezione classe di Python.

Il codice di esempio sotto fa riferimento alla base Eccezione direttamente chiamando Errore di runtime da:

class connectionError (RuntimeError):
def __init__(self, valore):
self.value = valore
provare:
sollevare connectionError ("Nome host errato")
tranne connectionError come err:
stampa (valore.err.)
Produzione: Nome host errato

Notare che errore di connessione, in questo caso, è una classe definita dall'utente, che puoi aumentare ogni volta che ne hai bisogno nel tuo programma.

Relazionato: La guida per principianti alle espressioni regolari con Python

È possibile creare un'eccezione definita dall'utente derivandola direttamente da Eccezione classe base. L'eccezione seguente, tuttavia, impedisce la sottrazione di 5 da 6 e chiama direttamente l'eccezione dalla classe base:

errori di classe (eccezione):
passaggio
class sixFiveError (errori):
def __init__(self, valore, messaggio):
self.value = valore
self.message = messaggio
provare:
raise sixFiveError (6-5,"Questa sottrazione non è consentita")
tranne sixFiveError come e:
print("Si è verificato un errore:", e.message)
Produzione: Si è verificato un errore: questa sottrazione non è consentita

In pratica, puoi utilizzare un'eccezione definita in precedenza chiamandola in un'altra funzione. Ad esempio, puoi creare un floatError che consente solo l'aggiunta di due float:

# Prima chiama le classi di eccezione di base:
errori di classe (eccezione):
passaggio
# Successivamente, deriva la tua eccezione dalla classe base:
class FloatError (errori):
def __init__(self, valore, messaggio):
self.value = valore
self.message = messaggio
# Crea una funzione per aggiungere due float:
def addTwoFloat (a, b):
if (tipo (a) e tipo (b)) != float:
raise FloatError (a+b,"I numeri devono essere float da aggiungere")
altro:
stampa (a + b)
addTwoFloat (4, 7)
Produzione: __main__.FloatError: (11, 'I numeri devono essere float da aggiungere')

Perché ora hai definito a FloatError classe, Python lo solleva se provi ad aggiungere due letterali non float usando il addtwoFloat funzione.

Puoi stampare il FloatError class nello stesso file Python in cui l'hai creato per vedere cosa succede:

stampa (Errore mobile)
Produzione:

FloatError, tuttavia, non è un'eccezione Python incorporata. Puoi verificarlo chiamando FloatError in un altro nuovo file Python in cui non hai creato questa classe:

stampa (Errore mobile)
Produzione: NameError: il nome 'FloatError' non è definito

ottieni un NomeErrore perché Python non lo riconosce come eccezione standard.

Puoi provare ad autodefinire anche altre classi di errore per vedere come si comportano.

Rendi i tuoi programmi Python più intuitivi con le eccezioni

Ci sono molte eccezioni standard in Python. Ma puoi anche definire il tuo. Tuttavia, la facilità di utilizzo del programma dipende in una certa misura da come gestisce le varie eccezioni (definite dall'utente, non specifiche o standard).

Le eccezioni, tuttavia, ti consentono di stabilire come dovrebbe funzionare il tuo programma quando gli utenti interagiscono con loro. L'indicazione chiara e concisa della causa di un errore consente inoltre agli utenti di sapere cosa stanno facendo di sbagliato e, a volte, li indirizza nella giusta direzione.

Come eseguire il debug del codice Python

Equipaggiati con il know-how per schiacciare ogni bug Python sul tuo cammino.

Leggi Avanti

Circa l'autore