¿Cómo provoco la misma excepción con un mensaje personalizado en Python?

Tengo este trybloque en mi código:

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

Hablando estrictamente, en realidad estoy planteando otro ValueError , no el ValueErrorarrojado do_something...(), que se conoce como erren este caso. ¿Cómo adjunto un mensaje personalizado err? Intento con el siguiente código pero falla debido a que err, por ValueError ejemplo , no se puede llamar:

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

Actualización: para Python 3, verifique la respuesta de Ben

Para adjuntar un mensaje a la excepción actual y volver a subirlo: (el intento externo / excepto es solo para mostrar el efecto)

Para python 2.x donde 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)

Esto también hará lo correcto si errse deriva de ValueError. Por ejemplo UnicodeDecodeError.

Tenga en cuenta que puede agregar lo que quiera err. Por ejemplo err.problematic_array=[1,2,3].

Editar: @Ducan señala en un comentario que lo anterior no funciona con python 3 ya .messageque no es miembro de ValueError. En cambio, podría usar esto (python válido 2.6 o posterior o 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:

Dependiendo de cuál sea el propósito, también puede optar por agregar la información adicional bajo su propio nombre de variable. Para python2 y 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

Si tienes la suerte de admitir solo Python 3.x, esto realmente se convierte en algo bello :)

elevar desde

Podemos encadenar las excepciones usando raise from .

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

En este caso, la excepción que detectaría su interlocutor tiene el número de línea del lugar donde planteamos nuestra excepción.

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

Observe que la excepción inferior solo tiene el stacktrace desde donde generamos nuestra excepción. La persona que llama aún puede obtener la excepción original accediendo al __cause__atributo de la excepción que detecta.

con_traceback

O puede usar with_traceback .

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

Al usar este formulario, la excepción que su interlocutor detectaría tiene el rastreo desde donde ocurrió el error original.

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

Observe que la excepción inferior tiene la línea donde realizamos la división no válida, así como la línea donde volvemos a plantear la excepción.

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

huellas dactilares:

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

Parece que todas las respuestas están agregando información a e.args [0], alterando así el mensaje de error existente. ¿Hay alguna desventaja en extender la tupla args en su lugar? Creo que la posible ventaja es que puede dejar solo el mensaje de error original para los casos en que se necesita analizar esa cadena; y podría agregar varios elementos a la tupla si su manejo de errores personalizado produjera varios mensajes o códigos de error, en los casos en que el rastreo se analizaría mediante programación (como a través de una herramienta de monitoreo del sistema).

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

o

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

¿Puedes ver una desventaja de este enfoque?

Esta plantilla de código debería permitirle generar una excepción con un mensaje personalizado.

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

Levante la nueva excepción con su mensaje de error usando

raise Exception('your error message')

o

raise ValueError('your error message')

dentro del lugar donde desea elevarlo O adjuntar (reemplazar) el mensaje de error a la excepción actual usando 'from' (solo se admite Python 3.x):

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

Esta es la función que uso para modificar el mensaje de excepción en Python 2.7 y 3.x mientras se conserva el rastreo original. Requieresix

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)

Las excepciones incorporadas en Python 3 tienen el strerrorcampo:

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

La respuesta actual no funcionó bien para mí, si la excepción no se vuelve a capturar, el mensaje adjunto no se muestra.

Pero al hacer lo siguiente, ambos mantienen la traza y muestran el mensaje adjunto, independientemente de si la excepción se vuelve a capturar o no.

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

(Usé Python 2.7, no lo he probado en Python 3)

Ninguna de las soluciones anteriores hizo exactamente lo que quería, que era agregar información a la primera parte del mensaje de error, es decir, quería que mis usuarios vieran primero mi mensaje personalizado.

Esto funcionó para mí:

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)

Esto solo funciona con Python 3 . Puede modificar los argumentos originales de la excepción y agregar sus propios argumentos.

Una excepción recuerda los argumentos con los que se creó. Supongo que esto es para que pueda modificar la excepción.

En la función reraise, anteponemos los argumentos originales de la excepción con cualquier argumento nuevo que queramos (como un mensaje). Finalmente, volvemos a plantear la excepción mientras conservamos el historial de rastreo.

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()

salida

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

Si desea personalizar el tipo de error, una cosa simple que puede hacer es definir una clase de error basada en ValueError.