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.

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

>>> try:
        raise KeyboardInterrupt
	finally:
        print('Goodbye, world!')
   
Goodbye, world!
KeyboardInterrupt

>>> 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'

for line in open("myfile.txt"):
    print(line, end="")

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")