errori python3 ed eccezioni
Come un principiante Python, solo l'apprendimento della programmazione Python spesso di vedere qualche messaggio di errore, non abbiamo già detto di fronte a questo capitolo sarà dedicato.
Python ha due errori facilmente riconoscibili: gli errori di sintassi e le eccezioni.
Errore di sintassi
Python errori di sintassi o analitica chiamata sbagliata, i principianti spesso incontrano, come esempi
>>> while True print('Hello world') File "<stdin>", line 1, in ? while True print('Hello world') ^ SyntaxError: invalid syntax
In questo esempio, la funzione di stampa () viene controllato per errori prima manca due punti (:).
Parser ha sottolineato l'errore del suo partito, e nel posto sbagliato per trovare il primo marcatore di una piccola freccia.
anormale
Anche la grammatica programma Python è corretta, è il momento di correre, ci possono essere degli errori. Gli errori di runtime rilevati sono chiamati eccezioni.
La maggior parte non sarà un gestore di eccezioni sotto forma di messaggi di errore mostra qui:
>>> 10 * (1/0) Traceback (most recent call last): File "<stdin>", line 1, in ? ZeroDivisionError: division by zero >>> 4 + spam*3 Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name 'spam' is not defined >>> '2' + 2 Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: Can't convert 'int' object to str implicitly
Appaiono anomali in diverse tipologie, questi tipi sono stampati come parte delle informazioni: Esempi di tipi ZeroDivisionError, NameError e TypeError.
La parte anteriore del messaggio di errore mostra il contesto di verifica un'eccezione, lo stack di chiamate e visualizzati sotto forma di informazioni specifiche.
Gestione delle eccezioni
Il seguente esempio, permette agli utenti di inserire un intero valido, ma permette all'utente di interrompere il programma (con le modalità del sistema operativo fornite Control-C o). interruzioni utente causerà un'eccezione KeyboardInterrupt.
>>> while True: try: x = int(input("Please enter a number: ")) break except ValueError: print("Oops! That was no valid number. Try again ")
provare opere economico come segue;
- In primo luogo, la clausola try (tra le parole chiave e parola chiave tranne istruzioni try)
- Se non si verifica alcuna eccezione, la clausola except viene ignorata, provare clausola è estremità eseguiti.
- Se si verifica un'eccezione nella procedura clausola try, quindi provare la clausola, il resto verrà ignorato. Se il nome e il tipo di eccezione se non dopo la partita, poi il corrispondente clausola except viene eseguito. Codice provare dichiarazione dopo l'ultima esecuzione.
- Se un'eccezione non corrisponde con qualsiasi eccezione, questa eccezione verrà passato alla prova superiore.
Un'istruzione try può contenere più di una clausola except, a che fare con diverse specifiche eccezioni. Al massimo un ramo verrà eseguito.
Handler solo per la relativa elaborazione delle eccezioni clausola try, piuttosto che l'altro gestore di eccezioni try.
Una clausola except in grado di gestire più eccezioni che verranno messi in una parentesi come una tupla, per esempio:
except (RuntimeError, TypeError, NameError): pass
L'ultima clausola except può ignorare il nome dell'eccezione, esso sarà trattato come un jolly. È possibile utilizzare questo metodo per stampare un messaggio di errore, e poi di nuovo gettato.
import sys try: f = open('myfile.txt') s = f.readline() i = int(s.strip()) except OSError as err: print("OS error: {0}".format(err)) except ValueError: print("Could not convert data to an integer.") except: print("Unexpected error:", sys.exc_info()[0]) raise
provare except ha una clausola opzionale altro, se si utilizza questo punto, deve essere posto dopo tutto, tranne le clausole. Questa clausola non avrà alcun problema si verifica nella clausola try viene eseguito. Ad esempio:
for arg in sys.argv[1:]: try: f = open(arg, 'r') except IOError: print('cannot open', arg) else: print(arg, 'has', len(f.readlines()), 'lines') f.close()
Utilizzare la clausola altro che tutte le istruzioni nella clausola try, che è meglio evitare alcuni imprevisti, ma tranne che non prendere l'eccezione.
La gestione delle eccezioni non solo trattare con queste eccezioni si verificano provare direttamente la clausola, ma anche di chiamare la clausola gestore (anche chiamate di funzione indiretta) dove gettato. Ad esempio:
>>> def this_fails(): x = 1/0 >>> try: this_fails() except ZeroDivisionError as err: print('Handling run-time error:', err) Handling run-time error: int division or modulo by zero
Un'eccezione
Python usa istruzione throw di sollevare una eccezione specificata. Ad esempio:
>>> raise NameError('HiThere') Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: HiThere
sollevare un solo parametro specifica l'eccezione di essere gettato. Deve essere un caso insolito di una classe o anormale (cioè sottoclasse Exception).
Se vuoi sapere se genera un'eccezione, non vuole trattare con esso, poi una semplice dichiarazione può alzare di nuovo gettato.
>>> try: raise NameError('HiThere') except NameError: print('An exception flew by!') raise An exception flew by! Traceback (most recent call last): File "<stdin>", line 2, in ? NameError: HiThere
eccezioni definite dall'utente
Si possono avere le proprie eccezioni creando una nuova classe di eccezioni. Le eccezioni dovrebbero ereditare dalla classe Exception, sia direttamente eredità, successione o indirettamente, ad esempio:
>>> class MyError(Exception): def __init__(self, value): self.value = value def __str__(self): return repr(self.value) >>> try: raise MyError(2*2) except MyError as e: print('My exception occurred, value:', e.value) My exception occurred, value: 4 >>> raise MyError('oops!') Traceback (most recent call last): File "<stdin>", line 1, in ? __main__.MyError: 'oops!'
In questo esempio, la classe Exception predefinito __init __ () viene sovrascritto.
Quando si crea un modulo può gettare una varietà di anormale Una pratica comune è quella di creare una classe di eccezione di base per questo pacchetto, e quindi sulla base di questa classe di base per creare diverse sottoclassi per le diverse condizioni di errore:
class Error(Exception): """Base class for exceptions in this module.""" pass class InputError(Error): """Exception raised for errors in the input. Attributes: expression -- input expression in which the error occurred message -- explanation of the error """ def __init__(self, expression, message): self.expression = expression self.message = message class TransitionError(Error): """Raised when an operation attempts a state transition that's not allowed. Attributes: previous -- state at beginning of transition next -- attempted new state message -- explanation of why the specific transition is not allowed """ def __init__(self, previous, next, message): self.previous = previous self.next = next self.message = message
La maggior parte dei nomi sono l'eccezione alla "Errore", alla fine, proprio come una denominazione standard come anormale.
comportamento pulizia Definito
istruzione try ha un'altra clausola facoltativa, che definisce eseguirà il comportamento di pulizia in qualsiasi circostanza. Ad esempio:
>>> try: raise KeyboardInterrupt finally: print('Goodbye, world!') Goodbye, world! KeyboardInterrupt
Indipendentemente esempi precedenti provare clausola, non c'è verifica alcuna eccezione, infine viene eseguita clausola.
Se un'eccezione nella clausola try (o eccezione e altro clausola) è stato buttato fuori, ma non hanno alcuna eccezione si è fermato, allora questo sarà sollevata di nuovo dopo la clausola finally viene eseguita.
Ecco un esempio più complesso (contenuta nella stessa istruzione in una prova ad eccezione di e clausola finally):
>>> def divide(x, y): try: result = x / y except ZeroDivisionError: print("division by zero!") else: print("result is", result) finally: print("executing finally clause") >>> divide(2, 1) result is 2.0 executing finally clause >>> divide(2, 0) division by zero! executing finally clause >>> divide("2", "1") executing finally clause Traceback (most recent call last): File "<stdin>", line 1, in ? File "<stdin>", line 3, in divide TypeError: unsupported operand type(s) for /: 'str' and 'str'
comportamento di pulitura predefinite
Alcuni oggetti definiscono il comportamento clean-up standard, indipendentemente dal fatto che il sistema viene utilizzato con successo una volta non ne ha bisogno, poi ripulire questo comportamento standard viene eseguito.
Questo esempio mostra questo lato tenta di aprire un file e quindi stampare il contenuto sullo schermo:
for line in open("myfile.txt"): print(line, end="")
Il problema di cui sopra con questo codice è che una volta terminato, il file rimane aperto, non chiuso.
Parole chiave con oggetti dichiarazione può essere garantita ad esempio i file saranno finiti utilizzando la corretta esecuzione dei suoi metodi di pulizia:
with open("myfile.txt") as f: for line in f: print(line, end="")
Dopo il codice precedente è terminata, anche se i problemi nel processo, il file f è sempre chiusa.