我的代码中有try块：
try:
do_something_that_might_raise_an_exception()
except ValueError as err:
errmsg = 'My custom error message.'
raise ValueError(errmsg)
严格地说，我实际上是在提高另一个 ValueError，而不是ValueError引发的do_something...()，这被称为err in这个案例。如何将自定义消息附加到err？我尝试使用以下代码但由于err ValueError 实例而无法调用而失败：
try:
do_something_that_might_raise_an_exception()
except ValueError as err:
errmsg = 'My custom error message.'
raise err(errmsg)
答案 0 :(得分：114)
我意识到这个问题已经存在了一段时间，但是一旦你足够幸运只支持python 3.x，这真的变得美丽了：）
我们可以使用raise from链接例外。
try:
1 / 0
except ZeroDivisionError as e:
raise Exception('Smelly socks') from e
在这种情况下，调用者将捕获的异常具有我们引发异常的地方的行号。
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
注意底部异常只有我们引发异常的堆栈跟踪。您的调用者仍然可以通过访问他们捕获的异常的__cause__属性来获取原始异常。
或者您可以使用with_traceback。
try:
1 / 0
except ZeroDivisionError as e:
raise Exception('Smelly socks').with_traceback(e.__traceback__)
使用此表单，调用者将捕获的异常具有原始错误发生位置的回溯。
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
请注意，底部异常具有执行无效除法的行以及我们重新加载异常的行。
答案 1 :(得分：73)
更新：对于Python 3，请检查Ben's answer
将消息附加到当前异常并重新引发它： （外部的try / except只是为了显示效果）
对于python 2.x，其中x＆gt; = 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)
如果来自err的{{1}} 派生 ，这也会做正确的事情。例如ValueError。
请注意，您可以将任何内容添加到UnicodeDecodeError。例如err。
编辑： @Ducan在评论中指出上述内容与python 3不兼容，因为err.problematic_array=[1,2,3]不是.message的成员。相反，你可以使用它（有效的python 2.6或更高版本或3.x）：
ValueError<强> EDIT2：
根据目的，您还可以选择在自己的变量名称下添加额外信息。对于python2和python3：
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))
答案 2 :(得分：7)
try:
try:
int('a')
except ValueError as e:
raise ValueError('There is a problem: {0}'.format(e))
except ValueError as err:
print err
打印：
There is a problem: invalid literal for int() with base 10: 'a'
答案 3 :(得分：6)
似乎所有答案都是向e.args [0]添加信息，从而改变了现有的错误信息。相反，扩展args元组是否有缺点？我认为可能的好处是，您可以单独保留原始错误消息，以用于需要解析该字符串的情况;如果您的自定义错误处理产生了多个消息或错误代码，并且可以通过编程方式解析回溯（例如通过系统监视工具），则可以向元组添加多个元素。
## 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')
或
## 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')
你能看到这种方法的缺点吗？
答案 4 :(得分：2)
此代码模板应允许您使用自定义消息引发异常。
try:
raise ValueError
except ValueError as err:
raise type(err)("my message")
答案 5 :(得分：2)
这是我用来修改Python 2.7和3.x中的异常消息同时保留原始回溯的函数。它需要six
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)
答案 6 :(得分：2)
这仅适用于Python 3 。您可以修改异常的原始参数并添加自己的参数。
一个异常会记住创建它的参数。我想这是为了让您可以修改异常。
在函数reraise中，我们在异常的原始参数之前添加了所需的任何新参数（例如消息）。最后，我们在保留追溯历史的同时重新引发异常。
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()
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')
答案 7 :(得分：1)
Python 3内置异常具有except ValueError as err:
err.strerror = "New error message"
raise err
字段：
{{1}}
答案 8 :(得分：1)
使用
使用错误消息引发新异常raise Exception('your error message')
或
raise ValueError('your error message')
在您想要引发它的地方或使用'from'将错误消息附加（替换）到当前异常中：
except ValueError as e:
raise ValueError('your message') from e
答案 9 :(得分：1)
试试下面的：
try:
raise ValueError("Original message. ")
except Exception as err:
message = 'My custom error message. '
# Change the order below to "(message + str(err),)" if custom message is needed first.
err.args = (str(err) + message,)
raise
输出：
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
1 try:
----> 2 raise ValueError("Original message")
3 except Exception as err:
4 message = 'My custom error message.'
5 err.args = (str(err) + ". " + message,)
ValueError: Original message. My custom error message.
答案 10 :(得分：0)
当前的答案对我来说效果不好，如果没有重新捕获异常，则不会显示附加的消息。
但是，无论是否重新捕获异常，执行下面的操作都会保留跟踪并显示附加的消息。
try:
raise ValueError("Original message")
except ValueError as err:
t, v, tb = sys.exc_info()
raise t, ValueError(err.message + " Appended Info"), tb
（我使用的是Python 2.7，还没有在Python 3中尝试过它）
答案 11 :(得分：0)
以上解决方案均未达到我想要的目的，即向错误消息的第一部分添加了一些信息，即我希望用户首先看到我的自定义消息。
这对我有用：
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)
答案 12 :(得分：0)
上面提出的许多解决方案再次重新引发异常，这被认为是一种不好的做法。像这样简单的事情就可以了
try:
import settings
except ModuleNotFoundError:
print("Something meaningfull\n")
raise
因此，您将首先打印错误消息，然后引发堆栈跟踪，或者您可以简单地通过 sys.exit(1) 退出并且根本不显示错误消息。
答案 13 :(得分：-2)
如果你想自定义错误类型，你可以做的一件简单的事情是根据ValueError定义一个错误类。