Wie kann ich dieselbe Ausnahme mit einer benutzerdefinierten Nachricht in Python auslösen?

Ich habe diesen tryBlock in meinem Code:

try:
    do_something_that_might_raise_an_exception()
except ValueError as err:
    errmsg = 'My custom error message.'
    raise ValueError(errmsg)

Genau genommen ziehe ich tatsächlich einen anderen auf ValueError , nicht den ValueErrorvon do_something...(), der errin diesem Fall als geworfen bezeichnet wird. Wie hänge ich eine benutzerdefinierte Nachricht an err? Ich versuche den folgenden Code, aber er schlägt fehl, weil erreine ValueError Instanz nicht aufrufbar ist:

try:
    do_something_that_might_raise_an_exception()
except ValueError as err:
    errmsg = 'My custom error message.'
    raise err(errmsg)

Update: Überprüfen Sie für Python 3 Bens Antwort

So hängen Sie eine Nachricht an die aktuelle Ausnahme an und lösen sie erneut aus: (Der äußere Versuch / die Ausnahme dient nur dazu, den Effekt anzuzeigen.)

Für Python 2.x mit x> = 6:

try:
    try:
      raise ValueError  # something bad...
    except ValueError as err:
      err.message=err.message+" hello"
      raise              # re-raise current exception
except ValueError as e:
    print(" got error of type "+ str(type(e))+" with message " +e.message)

Dies wird auch das Richtige tun , wenn errsich ableiten aus ValueError. Zum Beispiel UnicodeDecodeError.

Beachten Sie, dass Sie hinzufügen können, was Sie möchten err. Zum Beispiel err.problematic_array=[1,2,3].

Bearbeiten: @Ducan zeigt in einem Kommentar, dass das oben Gesagte nicht mit Python 3 funktioniert, da .messagees kein Mitglied von ist ValueError. Stattdessen können Sie dies verwenden (gültiges Python 2.6 oder höher oder 3.x):

try:
    try:
      raise ValueError
    except ValueError as err:
       if not err.args: 
           err.args=('',)
       err.args = err.args + ("hello",)
       raise 
except ValueError as e:
    print(" error was "+ str(type(e))+str(e.args))

Edit2:

Je nach Zweck können Sie die zusätzlichen Informationen auch unter Ihrem eigenen Variablennamen hinzufügen. Für Python2 und Python3:

try:
    try:
      raise ValueError
    except ValueError as err:
       err.extra_info = "hello"
       raise 
except ValueError as e:
    print(" error was "+ str(type(e))+str(e))
    if 'extra_info' in dir(e):
       print e.extra_info

Wenn Sie das Glück haben, nur Python 3.x zu unterstützen, wird dies wirklich zu einer Sache der Schönheit :)

erhöhen von

Wir können die Ausnahmen mit Raise from verketten .

try:
    1 / 0
except ZeroDivisionError as e:
    raise Exception('Smelly socks') from e

In diesem Fall hat die Ausnahme, die Ihr Anrufer abfangen würde, die Zeilennummer des Ortes, an dem wir unsere Ausnahme auslösen.

Traceback (most recent call last):
  File "test.py", line 2, in <module>
    1 / 0
ZeroDivisionError: division by zero

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "test.py", line 4, in <module>
    raise Exception('Smelly socks') from e
Exception: Smelly socks

Beachten Sie, dass die unterste Ausnahme nur den Stacktrace enthält, von dem aus wir unsere Ausnahme ausgelöst haben. Ihr Anrufer kann weiterhin die ursprüngliche Ausnahme erhalten, indem er auf das __cause__Attribut der Ausnahme zugreift, die er abfängt.

with_traceback

Oder Sie können with_traceback verwenden .

try:
    1 / 0
except ZeroDivisionError as e:
    raise Exception('Smelly socks').with_traceback(e.__traceback__)

Bei Verwendung dieses Formulars hat die Ausnahme, die Ihr Anrufer abfangen würde, den Traceback, von dem der ursprüngliche Fehler aufgetreten ist.

Traceback (most recent call last):
  File "test.py", line 2, in <module>
    1 / 0
ZeroDivisionError: division by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "test.py", line 4, in <module>
    raise Exception('Smelly socks').with_traceback(e.__traceback__)
  File "test.py", line 2, in <module>
    1 / 0
Exception: Smelly socks

Beachten Sie, dass die unterste Ausnahme die Zeile enthält, in der wir die ungültige Division durchgeführt haben, sowie die Zeile, in der wir die Ausnahme erneut auslösen.

try:
    try:
        int('a')
    except ValueError as e:
        raise ValueError('There is a problem: {0}'.format(e))
except ValueError as err:
    print err

Drucke:

There is a problem: invalid literal for int() with base 10: 'a'

Es scheint, dass alle Antworten e.args [0] Informationen hinzufügen und dadurch die vorhandene Fehlermeldung ändern. Gibt es einen Nachteil beim Erweitern des Args-Tupels? Ich denke, der mögliche Vorteil ist, dass Sie die ursprüngliche Fehlermeldung für Fälle, in denen das Parsen dieser Zeichenfolge erforderlich ist, in Ruhe lassen können. Sie können dem Tupel mehrere Elemente hinzufügen, wenn Ihre benutzerdefinierte Fehlerbehandlung mehrere Meldungen oder Fehlercodes erzeugt, wenn der Traceback programmgesteuert analysiert wird (z. B. über ein Systemüberwachungstool).

## Approach #1, if the exception may not be derived from Exception and well-behaved:

def to_int(x):
    try:
        return int(x)
    except Exception as e:
        e.args = (e.args if e.args else tuple()) + ('Custom message',)
        raise

>>> to_int('12')
12

>>> to_int('12 monkeys')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in to_int
ValueError: ("invalid literal for int() with base 10: '12 monkeys'", 'Custom message')

oder

## Approach #2, if the exception is always derived from Exception and well-behaved:

def to_int(x):
    try:
        return int(x)
    except Exception as e:
        e.args += ('Custom message',)
        raise

>>> to_int('12')
12

>>> to_int('12 monkeys')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in to_int
ValueError: ("invalid literal for int() with base 10: '12 monkeys'", 'Custom message')

Können Sie einen Nachteil dieses Ansatzes erkennen?

Mit dieser Codevorlage sollten Sie eine Ausnahme mit einer benutzerdefinierten Nachricht auslösen können.

try:
     raise ValueError
except ValueError as err:
    raise type(err)("my message")

Lösen Sie entweder die neue Ausnahme mit Ihrer Fehlermeldung mit aus

raise Exception('your error message')

oder

raise ValueError('your error message')

an der Stelle, an der Sie es auslösen möchten ODER die Fehlermeldung mit 'from' an die aktuelle Ausnahme anhängen (ersetzen) (nur Python 3.x wird unterstützt):

except ValueError as e:
  raise ValueError('your message') from e

Dies ist die Funktion, mit der ich die Ausnahmemeldung in Python 2.7 und 3.x unter Beibehaltung des ursprünglichen Tracebacks ändere. Es benötigtsix

def reraise_modify(caught_exc, append_msg, prepend=False):
    """Append message to exception while preserving attributes.

    Preserves exception class, and exception traceback.

    Note:
        This function needs to be called inside an except because
        `sys.exc_info()` requires the exception context.

    Args:
        caught_exc(Exception): The caught exception object
        append_msg(str): The message to append to the caught exception
        prepend(bool): If True prepend the message to args instead of appending

    Returns:
        None

    Side Effects:
        Re-raises the exception with the preserved data / trace but
        modified message
    """
    ExceptClass = type(caught_exc)
    # Keep old traceback
    traceback = sys.exc_info()[2]
    if not caught_exc.args:
        # If no args, create our own tuple
        arg_list = [append_msg]
    else:
        # Take the last arg
        # If it is a string
        # append your message.
        # Otherwise append it to the
        # arg list(Not as pretty)
        arg_list = list(caught_exc.args[:-1])
        last_arg = caught_exc.args[-1]
        if isinstance(last_arg, str):
            if prepend:
                arg_list.append(append_msg + last_arg)
            else:
                arg_list.append(last_arg + append_msg)
        else:
            arg_list += [last_arg, append_msg]
    caught_exc.args = tuple(arg_list)
    six.reraise(ExceptClass,
                caught_exc,
                traceback)

In Python 3 integrierte Ausnahmen haben das strerrorFeld:

except ValueError as err:
  err.strerror = "New error message"
  raise err

Die aktuelle Antwort hat bei mir nicht gut funktioniert. Wenn die Ausnahme nicht erneut abgefangen wird, wird die angehängte Nachricht nicht angezeigt.

Wenn Sie jedoch wie unten beschrieben vorgehen, wird die Ablaufverfolgung beibehalten und die angehängte Nachricht angezeigt, unabhängig davon, ob die Ausnahme erneut abgefangen wird oder nicht.

try:
  raise ValueError("Original message")
except ValueError as err:
  t, v, tb = sys.exc_info()
  raise t, ValueError(err.message + " Appended Info"), tb

(Ich habe Python 2.7 verwendet, habe es in Python 3 nicht ausprobiert.)

Keine der oben genannten Lösungen hat genau das getan, was ich wollte, nämlich dem ersten Teil der Fehlermeldung einige Informationen hinzuzufügen, dh ich wollte, dass meine Benutzer zuerst meine benutzerdefinierte Nachricht sehen.

Das hat bei mir funktioniert:

exception_raised = False
try:
    do_something_that_might_raise_an_exception()
except ValueError as e:
    message = str(e)
    exception_raised = True

if exception_raised:
    message_to_prepend = "Custom text"
    raise ValueError(message_to_prepend + message)

Dies funktioniert nur mit Python 3 . Sie können die ursprünglichen Argumente der Ausnahme ändern und Ihre eigenen Argumente hinzufügen.

Eine Ausnahme merkt sich die Argumente, mit denen sie erstellt wurde. Ich gehe davon aus, dass dies so ist, dass Sie die Ausnahme ändern können.

In der Funktion stellen reraisewir den ursprünglichen Argumenten der Ausnahme alle neuen Argumente voran, die wir möchten (wie eine Nachricht). Schließlich lösen wir die Ausnahme erneut aus, während der Rückverfolgungsverlauf beibehalten wird.

def reraise(e, *args):
  '''re-raise an exception with extra arguments
  :param e: The exception to reraise
  :param args: Extra args to add to the exception
  '''

  # e.args is a tuple of arguments that the exception with instantiated with.
  #
  e.args = args + e.args

  # Recreate the expection and preserve the traceback info so thta we can see 
  # where this exception originated.
  #
  raise e.with_traceback(e.__traceback__)   


def bad():
  raise ValueError('bad')

def very():
  try:
    bad()
  except Exception as e:
    reraise(e, 'very')

def very_very():
  try:
    very()
  except Exception as e:
    reraise(e, 'very')

very_very()

Ausgabe

Traceback (most recent call last):
  File "main.py", line 35, in <module>
    very_very()
  File "main.py", line 30, in very_very
    reraise(e, 'very')
  File "main.py", line 15, in reraise
    raise e.with_traceback(e.__traceback__)
  File "main.py", line 28, in very_very
    very()
  File "main.py", line 24, in very
    reraise(e, 'very')
  File "main.py", line 15, in reraise
    raise e.with_traceback(e.__traceback__)
  File "main.py", line 22, in very
    bad()
  File "main.py", line 18, in bad
    raise ValueError('bad')
ValueError: ('very', 'very', 'bad')

Wenn Sie den Fehlertyp anpassen möchten, können Sie einfach eine Fehlerklasse definieren, die auf ValueError basiert.