Manuelles Auslösen (Auslösen) einer Ausnahme in Python

Wie kann ich eine Ausnahme in Python auslösen, damit sie später über einen exceptBlock abgefangen werden kann ?

Wie kann ich eine Ausnahme in Python manuell auslösen / auslösen?

Verwenden Sie den spezifischsten Ausnahmekonstruktor, der semantisch zu Ihrem Problem passt .

Seien Sie in Ihrer Nachricht genau, z. B.:

raise ValueError('A very specific bad thing happened.')

Erhöhen Sie keine generischen Ausnahmen

Vermeiden Sie es, ein Generikum zu erheben Exception. Um es abzufangen, müssen Sie alle anderen spezifischeren Ausnahmen abfangen, die es unterordnen.

Problem 1: Fehler verstecken

raise Exception('I know Python!') # Don't! If you catch, likely to hide bugs.

Zum Beispiel:

def demo_bad_catch():
    try:
        raise ValueError('Represents a hidden bug, do not catch this')
        raise Exception('This is the exception you expect to handle')
    except Exception as error:
        print('Caught this error: ' + repr(error))

>>> demo_bad_catch()
Caught this error: ValueError('Represents a hidden bug, do not catch this',)

Problem 2: Wird nicht fangen

Und spezifischere Fänge werden die allgemeine Ausnahme nicht erfassen:

def demo_no_catch():
    try:
        raise Exception('general exceptions not caught by specific handling')
    except ValueError as e:
        print('we will not catch exception: Exception')


>>> demo_no_catch()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in demo_no_catch
Exception: general exceptions not caught by specific handling

Best Practices: raiseAussage

Verwenden Sie stattdessen den spezifischsten Ausnahmekonstruktor, der semantisch zu Ihrem Problem passt .

raise ValueError('A very specific bad thing happened')

Dies ermöglicht auch die Übergabe einer beliebigen Anzahl von Argumenten an den Konstruktor:

raise ValueError('A very specific bad thing happened', 'foo', 'bar', 'baz') 

Auf diese Argumente wird über das argsAttribut des ExceptionObjekts zugegriffen . Zum Beispiel:

try:
    some_code_that_may_raise_our_value_error()
except ValueError as err:
    print(err.args)

druckt

('message', 'foo', 'bar', 'baz')    

In Python 2.5, ein tatsächliches messagewurde Attribut hinzugefügt , um BaseExceptionfür den Einsatz von Benutzern Unterklasse Ausnahmen und Stop ermutigend args, aber die Einführung messageund die ursprüngliche deprecation von args zurückgezogen worden ist .

Best Practices: exceptKlausel

Wenn Sie sich in einer Ausnahmeklausel befinden, möchten Sie beispielsweise protokollieren, dass ein bestimmter Fehlertyp aufgetreten ist, und ihn dann erneut auslösen. Der beste Weg, dies unter Beibehaltung des Stack-Trace zu tun, ist die Verwendung einer Bare-Raise-Anweisung. Zum Beispiel:

logger = logging.getLogger(__name__)

try:
    do_something_in_app_that_breaks_easily()
except AppError as error:
    logger.error(error)
    raise                 # just this!
    # raise AppError      # Don't do this, you'll lose the stack trace!

Ändern Sie Ihre Fehler nicht ... aber wenn Sie darauf bestehen.

Sie können den Stacktrace (und den Fehlerwert) mit beibehalten sys.exc_info(), dies ist jedoch weitaus fehleranfälliger und weist Kompatibilitätsprobleme zwischen Python 2 und 3 auf. Verwenden Sie raisezum erneuten Erhöhen lieber ein Bare .

Zur Erklärung: sys.exc_info()Gibt den Typ, den Wert und den Traceback zurück.

type, value, traceback = sys.exc_info()

Dies ist die Syntax in Python 2 - beachten Sie, dass dies nicht mit Python 3 kompatibel ist:

    raise AppError, error, sys.exc_info()[2] # avoid this.
    # Equivalently, as error *is* the second object:
    raise sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]

Wenn Sie möchten, können Sie ändern, was mit Ihrer neuen Erhöhung geschieht - z. B. neue Einstellungen argsfür die Instanz:

def error():
    raise ValueError('oops!')

def catch_error_modify_message():
    try:
        error()
    except ValueError:
        error_type, error_instance, traceback = sys.exc_info()
        error_instance.args = (error_instance.args[0] + ' <modification>',)
        raise error_type, error_instance, traceback

Und wir haben den gesamten Traceback beibehalten, während wir die Argumente geändert haben. Beachten Sie, dass dies keine bewährte Methode ist und die Syntax in Python 3 ungültig ist (was die Beibehaltung der Kompatibilität erheblich erschwert).

>>> catch_error_modify_message()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in catch_error_modify_message
  File "<stdin>", line 2, in error
ValueError: oops! <modification>

In Python 3 :

    raise error.with_traceback(sys.exc_info()[2])

Nochmals: Vermeiden Sie die manuelle Bearbeitung von Tracebacks. Es ist weniger effizient und fehleranfälliger. Und wenn Sie Threading verwenden und sys.exc_infomöglicherweise sogar das falsche Traceback erhalten (insbesondere, wenn Sie die Ausnahmebehandlung für den Kontrollfluss verwenden - was ich persönlich eher vermeiden würde).

Python 3, Ausnahmeverkettung

In Python 3 können Sie Ausnahmen verketten, die Tracebacks beibehalten:

    raise RuntimeError('specific message') from error

Sei vorsichtig:

• dies nicht erlauben , der Fehlertyp ändert erhöht und
• Dies ist nicht kompatibel mit Python 2.

Veraltete Methoden:

Diese können sich leicht verstecken und sogar in den Produktionscode gelangen. Sie möchten eine Ausnahme auslösen, und wenn Sie dies tun, wird eine Ausnahme ausgelöst, aber nicht die beabsichtigte!

In Python 2, jedoch nicht in Python 3, gilt Folgendes:

raise ValueError, 'message' # Don't do this, it's deprecated!

Nur in viel älteren Versionen von Python (2.4 und niedriger) gültig , sehen Sie möglicherweise immer noch Leute, die Zeichenfolgen erhöhen:

raise 'message' # really really wrong. don't do this.

In allen modernen Versionen wird dadurch tatsächlich a ausgelöst TypeError, da Sie keinen BaseExceptionTyp erhöhen . Wenn Sie nicht nach der richtigen Ausnahme suchen und keinen Prüfer haben, der sich des Problems bewusst ist, kann es in die Produktion gehen.

Beispiel Verwendung

Ich löse Ausnahmen aus, um Verbraucher vor meiner API zu warnen, wenn sie diese falsch verwenden:

def api_func(foo):
    '''foo should be either 'baz' or 'bar'. returns something very useful.'''
    if foo not in _ALLOWED_ARGS:
        raise ValueError('{foo} wrong, use "baz" or "bar"'.format(foo=repr(foo)))

Erstellen Sie Ihre eigenen Fehlertypen, wenn Sie vorschlagen

"Ich möchte absichtlich einen Fehler machen, damit er in die Ausnahme geht."

Sie können Ihre eigenen Fehlertypen erstellen. Wenn Sie angeben möchten, dass etwas Bestimmtes mit Ihrer Anwendung nicht stimmt, klassifizieren Sie einfach den entsprechenden Punkt in der Ausnahmehierarchie:

class MyAppLookupError(LookupError):
    '''raise this when there's a lookup error for my app'''

und Verwendung:

if important_key not in resource_dict and not ok_to_be_missing:
    raise MyAppLookupError('resource is missing, and that is not ok.')

TUN SIE DAS NICHT . Ein nacktes Kind aufzuziehen Exceptionist absolut nicht das Richtige. siehe stattdessen Aaron Halls ausgezeichnete Antwort .

Viel pythonischer geht es nicht:

raise Exception("I know python!")

Siehe die raise - Anweisung docs für Python , wenn Sie weitere Informationen möchten.

In Python3 gibt es 4 verschiedene Syntaxen für das Auslösen von Ausnahmen:

1. raise exception 
2. raise exception (args) 
3. raise
4. raise exception (args) from original_exception

1. Ausnahme auslösen vs. 2. Ausnahme auslösen (Argumente)

Wenn Sie raise exception (args) eine Ausnahme auslösen, argswird diese beim Drucken des Ausnahmeobjekts gedruckt - wie im folgenden Beispiel gezeigt.

  #raise exception (args)
    try:
        raise ValueError("I have raised an Exception")
    except ValueError as exp:
        print ("Error", exp)     # Output -> Error I have raised an Exception 



  #raise execption 
    try:
        raise ValueError
    except ValueError as exp:
        print ("Error", exp)     # Output -> Error 

3. steigen

raiseAnweisung ohne Argumente löst die letzte Ausnahme erneut aus. Dies ist nützlich, wenn Sie nach dem Abfangen der Ausnahme einige Aktionen ausführen und sie dann erneut auslösen möchten. Wenn es zuvor keine Ausnahme gab, raiselöst die Anweisung eine TypeErrorAusnahme aus.

def somefunction():
    print("some cleaning")

a=10
b=0 
result=None

try:
    result=a/b
    print(result)

except Exception:            #Output ->
    somefunction()           #some cleaning
    raise                    #Traceback (most recent call last):
                             #File "python", line 8, in <module>
                             #ZeroDivisionError: division by zero

4. Ausnahme (args) von original_exception auslösen

Diese Anweisung wird verwendet, um eine Ausnahmeverkettung zu erstellen, bei der eine Ausnahme, die als Antwort auf eine andere Ausnahme ausgelöst wird, die Details der ursprünglichen Ausnahme enthalten kann - wie im folgenden Beispiel gezeigt.

class MyCustomException(Exception):
pass

a=10
b=0 
reuslt=None
try:
    try:
        result=a/b

    except ZeroDivisionError as exp:
        print("ZeroDivisionError -- ",exp)
        raise MyCustomException("Zero Division ") from exp

except MyCustomException as exp:
        print("MyException",exp)
        print(exp.__cause__)

Ausgabe:

ZeroDivisionError --  division by zero
MyException Zero Division 
division by zero

Für den allgemeinen Fall, dass Sie als Reaktion auf einige unerwartete Bedingungen eine Ausnahme auslösen müssen und diese niemals abfangen möchten, sondern einfach schnell versagen müssen, damit Sie von dort aus debuggen können, falls dies jemals passieren sollte - die logischste scheint zu sein AssertionError::

if 0 < distance <= RADIUS:
    #Do something.
elif RADIUS < distance:
    #Do something.
else:
    raise AssertionError("Unexpected value of 'distance'!", distance)

Lesen Sie zuerst die vorhandenen Antworten, dies ist nur ein Nachtrag.

Beachten Sie, dass Sie Ausnahmen mit oder ohne Argumente auslösen können.

Beispiel:

raise SystemExit

Beendet das Programm, aber Sie möchten vielleicht wissen, was passiert ist. Sie können dies also verwenden.

raise SystemExit("program exited")

Dadurch wird "Programm beendet" an stderr ausgegeben, bevor das Programm geschlossen wird.

Eine andere Möglichkeit, Ausnahmen auszulösen, ist assert. Sie können assert verwenden, um zu überprüfen, ob eine Bedingung erfüllt ist. Andernfalls wird sie ausgelöst AssertionError. Weitere Details finden Sie hier .

def avg(marks):
    assert len(marks) != 0,"List is empty."
    return sum(marks)/len(marks)

mark2 = [55,88,78,90,79]
print("Average of mark2:",avg(mark2))

mark1 = []
print("Average of mark1:",avg(mark1))

Nur zur Anmerkung: Es gibt Zeiten, in denen Sie generische Ausnahmen behandeln möchten. Wenn Sie eine Reihe von Dateien verarbeiten und Ihre Fehler protokollieren, möchten Sie möglicherweise alle für eine Datei auftretenden Fehler abfangen, protokollieren und den Rest der Dateien weiter verarbeiten. In diesem Fall a

try:
    foo() 
except Exception as e:
    print(str(e)) # Print out handled error

Blockieren Sie einen guten Weg, um es zu tun. Sie möchten dennoch raisebestimmte Ausnahmen festlegen, damit Sie wissen, was sie bedeuten.

Sie sollten dafür die Raise-Anweisung von Python lernen. Es sollte im Try-Block aufbewahrt werden. Beispiel -

try:
    raise TypeError            #remove TypeError by any other error if you want
except TypeError:
    print('TypeError raised')