codestory

Die Anleitung zu Python Exception

  1. Was ist Exception?
  2. Das hierarchische Diagramm
  3. Die Ausnahme durch try-except fangen
  4. Der Block try-except-finally
  5. Die Ausnahme weiter werfen
  6. Eine Ausnahme (eine Exception) in einer anderen Exception einpacken

1. Was ist Exception?

Zuerst schauen wir ein Beispiel wie folgend:
Im Beispiel gibt es eine fehlerhafte Code wegen die Division durch 0. Die Division durch 0 verursacht eine Ausnahme: ZeroDivisionError
helloExceptionExample.py
print ("Three")

# Die Division hat kein Problem.
value = 10 / 2 
print ("Two")

# Die Division hat kein Problem.
value = 10 / 1 
print ("One")

d = 0

# Die Division hat ein Problem, das die Teilung durch 0 ist. Ein Fehler tritt hier auf.
value = 10 / d

# Die folgende Code wird nicht implementiert.
print ("Let's go!")
Das Ergebnis der Durchführung des Beispiel:
Sie können die Fehleranmeldung auf Console. Die Fehleranmeldung ist sehr klar, sie zeigt, auf welcher Zeile die Fehler auftritt
Schauen Sie das Thread des Programm in das folgende Beispiel.
  • Das Programm läuft ganz normal vom Schritt (1),(2) zum Schritt (6)
  • Der Schritt (7) tritt einen Fehler bei der Division durch 0 auf. Das Programm endet.
  • Die Code im Schritt (8) wird nicht durchgeführt.
Wir werden die Kode des oben Beispiel verändern
helloCatchException.py
print ("Three")

value = 10 / 2

print ("Two")

value = 10 / 1
 
print ("One")

d = 0 

try :
    # Die Division hat ein Problem, die Teilung durch 0.
    # Ein Fehler tritt hier auf (ZeroDivisionError).
    value = 10 / d 
    print ("value = ", value) 
except ZeroDivisionError as e : 
    print ("Error: ", str(e) )
    print ("Ignore to continue ...") 

print ("Let's go!")
Und das Ergebnis der Beispiel
Three
Two
One
Error division by zero
Ignore to coninue ...
Let's go!
Wir erklären das Thread des Programm durch das folgende Beispiel.
  • Die Schritte (1)-(6) läuft ganz normal.
  • Die Ausnahme passiert im Schritt (7), das Problem ist die Division durch 0.
  • Sofort implementiert es den Befehl im Block except, der Schritt (8) wird skipped.
  • Der Schritt (9) und (10) werden durchgeführt.
  • Der Schritt (11) wird durchgeführt

2. Das hierarchische Diagramm

This is the model of hierarchical map of Exception in Python.
  • Die Klasse in der höchsten Level ist BaseException
  • Die direkten Sub-Klasse sind Exception und KeyboardInterrupt, ..
DIe vorhandenen Exception vomPython werden normalerweise aus BaseException gestammt (derived) (aus BaseException verlängert). Inzwischen sollen die Ausnahme der Programmer aus der Klasse Exception oder aus seiner Sub-Klasse erben

3. Die Ausnahme durch try-except fangen

Wir schreiben eine Klasse Exception, die aus der Klasse Exception erbt.
See more:
Die Funktion checkAge ist die Alterprüfung. Wenn der Alter kleiner als 18 oder größer als 40 ist, wird eine Ausnahme geworfen
ageexception.py
# Python 3.x 
class AgeException(Exception): 
    def __init__(self, msg, age ):
        super().__init__(msg) 
        self.age = age 
        
class TooYoungException(AgeException): 
    def __init__(self, msg, age):
        super().__init__(msg, age)     

class TooOldException(AgeException): 
    def __init__(self, msg, age):
        super().__init__(msg, age)    
         
# Die Funktion prüft das Alter. Sie kann die Ausnahme werfen.
def checkAge(age): 
    if (age < 18) :
        # Wenn das Alter kleiner als 18 ist, wird eine Ausnahme geworfen. Die Funktion endet hier.
        raise TooYoungException("Age " + str(age) + " too young", age) 
    elif (age > 40) :
        # Wenn das Alter kleiner als 40 ist, wird eine Ausnahme geworfen
        # Die Funktion endet hier.        
        raise TooOldException("Age " +  str(age) + " too old", age); 
    # Wenn das Alter in dem Raum vom 18-40 liegt, wird die Code implementiert
    print ("Age " +  str(age) + " OK!");
Zum Beispiel
tryExceptDemo1.py
import ageexception
from ageexception import AgeException
from ageexception import TooYoungException
from ageexception import TooOldException

print ("Start Recruiting ...")
age = 11
print ("Check your Age ", age)
try : 
    ageexception.checkAge(age)
    print ("You pass!")  
except TooYoungException as e  : 
    print("You are too young, not pass!")    
    print("Cause message: ", str(e) )
    print("Invalid age: ", e.age) 
except  TooOldException as e : 
    print ("You are too old, not pass!")
    print ("Cause message: ", str(e) )
    print("Invalid age: ", e.age)
Das Beispiel durchführen
Start Recruiting ...
Check you Age 11
You are too young, not pass!
Cause message: Age 11 too young
Invalid age: 11
Das folgende Beispiel, wir fangen die Ausnahme durch die Ausnahme auf dem höheren Level. Auf dem höheren Level fangt es die Ausnahme und alle Sub-Ausnahmen.
tryExceptDemo2.py
import ageexception
from ageexception import AgeException
from ageexception import TooYoungException
from ageexception import TooOldException

print ("Start Recruiting ...")
age = 51 
print ("Check your Age ", age)
try : 
    ageexception.checkAge(age)
    print ("You pass!") 
except AgeException as e  : 
    print("You are not pass!")  
    print("type(e): ", type(e) )
    print("Cause message: ", str(e) )
    print("Invalid age: ", e.age)
Output:
Start Recruiting ...
Check you Age 51
You are not pass!
type(e): <class 'ageexceptioon.TooOldException'>
Cause message: Age 51 too old
Invalid age: 51

4. Der Block try-except-finally

Oben kennen wir das Ausnahmenfangen durch try-except lernen. Die volle Behandlung der Ausnahme ist try-except-finally. der Block finally wird immer implementiert trotzdem die Ausnahme bei Block try passiert oder nicht.
try - except - finally
try : 
    # Etwas hier machen
except Exception1 as e : 
    # Etwas hier machen.
except Exception2 as e : 
    # Etwas hier machen.
finally : 
    # Das Block finally wird immer implementiert.
    # Etwas hier machen
Zum Beispiel
tryExceptFinallyDemo.py
def toInteger(text) : 
    try :  
        print ("-- Begin parse text: ", text) 
        # Eine Ausnahme kann hier geworfen werden (ValueError).
        value = int(text) 
        return value 
    except ValueError as e : 
        # Falls 'text' kein Zahl ist, wird das Block 'except' implementiert          
        print ("ValueError message: ", str(e))
        print ("type(e): ", type(e)) 
        # 0 zurückgeben wenn ein Fehler ValueError auftritt.
        return 0  
    finally :  
        print ("-- End parse text: " + text)  
 
text = "001234A2" 
value = toInteger(text) 
print ("Value= ", value)
Zum Beispiel
-- Begin parse text: 001234A2
ValueError message: invalid literal for int() with base 10: '001234A2'
type(e): <class 'ValueError'>
-- End parse text: 001234A2
Value= 0
Das ist der Thread des Programms. Der Block finally wird immer implementiert
Der Befehl pass
Wenn Sie in den Block 'except' oder 'finally' nicht behandeln möchten, können Sie den Befehl 'pass' (pass statement). Der Befehl pass macht nichts, es ist wie ein Befehl null.
passStatementExample.py
print ("Three")
try :
    value = 10 / 0;
except Exception as e:
    pass

print ("Two")  
print ("One")
print ("Let's go")
Output:
Three
Two
One
Let's go

5. Die Ausnahme weiter werfen

Bei der Behandlung der Ausnahme können Sie diese Ausnahme fangen und behandeln oder sie weiter werfen (rethrow)
reRaiseExceptionDemo1.py
def checkScore(score) :
    if score < 0 or score > 100:
        raise Exception("Invalid Score " + str(score) )

def checkPlayer(name, score):
    try :
        checkScore(score)
    except Exception as e :
        print ("Something invalid with player: ",name, ' >> ', str(e) )
        # re throw exception.
        raise   
# ------------------------------------------ 
checkPlayer("Tran", 101)
Zum Beispiel: die Ausnahme durch eine andere Ausnahme fangen und weiter werfen (rethrow)
reRaiseExceptionDemo2.py
def checkScore(score) :  
    if score < 0 or score > 100:
        raise Exception("Invalid Score " + str(score) )

def checkPlayer(name, score):
    try :
        checkScore(score)
    except Exception as e :
        print ("Something invalid with player: ",name, ' >> ', str(e) )
        # throw new exception.
        raise Exception("Something invalid with player: "+ name + " >> "+ str(e)) 

# ------------------------------------------ 
checkPlayer("Tran", 101)

6. Eine Ausnahme (eine Exception) in einer anderen Exception einpacken

Python erlaubt eine Ausnahme zu fangen und eine neue Ausnahme zu werfen. Die neue kann die Information der ersten Ausnahmen speichern, die Sie durch das Attribut __cause__ zugreifen
Syntax
try :
    # Etwas hier machen
except Exception as e :
    raise OtherException("Message...") from e
Das Beispiel voll anschauen
wrapExceptionDemo.py
# Python 3.x:
# Die Ausnahme von dem Geschlecht
class GenderException(Exception): 
    def __init__(self, msg):
        super().__init__(msg)     

# Die Ausnahme von der Sprache.
class LanguageException(Exception): 
    def __init__(self, msg):
        super().__init__(msg)     


class PersonException(Exception): 
    def __init__(self, msg):
        super().__init__(msg)

# Die Funktion kann GenderException werfen.
def checkGender(gender): 
    if gender != 'Female' :
        raise GenderException("Accept female only")

# Die Funktion kann LanguageException werfen.
def checkLanguage(language):   
    if language != 'English' :
        raise LanguageException("Accept english language only") 

def checkPerson(name, gender, language): 
    try : 
        # GenderException werfen können
        checkGender(gender)
        # LanguageException werfen können.
        checkLanguage(language)
    except Exception as e:
        # Die Exception fangen und die anderen Exception werfen.
        # Die neue Ausnahme hat die Information  __cause__ = e.
        raise PersonException(name + " does not pass") from e
    
# -------------------------------------------------------- 
try  : 
    checkPerson("Nguyen", "Female", "Vietnamese") 
except PersonException as e: 
    print ("Error message: ", str(e) )    
    # GenderException oder LanguageException
    cause = e.__cause__   
    print ('e.__cause__: ', repr(cause)) 
    print ("type(cause): " , type(cause) ) 
    print (" ------------------ ")
    
    if type(cause) is GenderException : 
        print ("Gender exception: ", cause) 
    elif type(cause) is LanguageException: 
        print ("Language exception: ", cause)
Output:
Error message: Nguyen does not pass
e.__cause__: LanguageException('Accept english language only',)
type(cause): <class '__main__.LanguageException'>
 ------------------
Language exception: Accept english language only

Neueste Artikel

Show More