在Python中手动引发（抛出）异常

如何在Python中引发异常，以便以后可以通过except块捕获它？

2677724 次浏览
小开

别这样.提高一个裸露的Exception绝对是没有正确的做法；参见Aaron Hall的精彩回答。

没有比这更Pythonic的了：

raise Exception("I know Python!")

将Exception替换为您要抛出的特定类型的异常。

如果您想了解更多信息，请参阅加薪声明留档 for Python。

小开
最佳答案

如何在Python中手动抛出/引发异常？

使用语义上适合您的问题的最具体的异常构造函数

在你的信息中要具体，例如：

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

不要引发泛型异常

避免引发泛型Exception。要捕获它，您必须捕获所有其他更具体的子类异常。

问题1：隐藏错误

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

例如：

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

问题2：抓不到

更具体的捕获不会捕获一般异常：

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_catchException: general exceptions not caught by specific handling

最佳实践：raise声明

相反，使用语义上适合您的问题的最具体的异常构造函数

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

它还方便地允许将任意数量的参数传递给构造函数：

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

这些参数由Exception对象上的args属性访问。例如：

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

印刷品

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

在Python 2.5中，实际的message属性被添加到BaseException中，以鼓励用户子类Exceptions并停止使用args，但#0的引入和args的原始弃用已被收回。

最佳实践：except条款

例如，当您在异常子句中时，您可能希望记录发生了特定类型的错误，然后重新引发。在保留堆栈跟踪的同时做到这一点的最佳方法是使用裸引发语句。例如：

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!

不要修改你的错误，但如果你坚持。

您可以使用sys.exc_info()保留堆栈跟踪（和错误值），但这样更容易出错和Python 2和3之间存在兼容性问题更喜欢使用裸raise重新提升。

解释一下-sys.exc_info()返回类型、值和回溯。

type, value, traceback = sys.exc_info()

这是Python 2中的语法-注意这与Python 3不兼容：

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]

如果你愿意，你可以修改你的新提升会发生什么-例如为实例设置新的args：

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

我们在修改args时保留了整个回溯。请注意，这是不是最佳做法，在Python 3中是语法错误（这使得保持兼容性变得更加困难）。

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

在python3：

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

再次：避免手动操作回溯。它的效率较低和更容易出错。如果您使用线程和sys.exc_info，您甚至可能会得到错误的回溯（特别是如果您对控制流使用异常处理-我个人倾向于避免。）

Python 3，异常链接

在Python 3中，您可以链接Exceptions，以保留回溯：

raise RuntimeError('specific message') from error

注意点：

  • 此确实允许更改引发的错误类型，并且
  • 这与Python 2没有兼容。

废弃方法：

这些可以很容易地隐藏甚至进入生产代码。你想引发异常，这样做会引发异常，但不是你想要的！

在Python 2中有效，但在Python 3中无效如下：

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

只有在旧版本的Python中有效（2.4及更低），您可能仍然会看到有人提高字符串：

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

在所有现代版本中，这实际上会引发TypeError，因为您没有引发BaseException类型。如果您没有检查正确的异常并且没有知道该问题的审阅者，它可能会进入生产环境。

示例用法

我提出异常来警告我的API的消费者，如果他们不正确地使用它：

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

根据需要创建自己的错误类型

“我想故意犯一个错误，这样它就会进入除了。

您可以创建自己的错误类型，如果您想指示应用程序中特定的错误，只需子类化异常层次结构中的适当点：

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

和用法：

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

对于常见的情况，你需要抛出一个异常来响应一些意想不到的条件，并且你从来没有打算捕获，只是为了快速失败，以便在发生时能够从那里调试-最合乎逻辑的一个似乎是AssertionError：

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

在Python 3中，有四种不同的语法用于引发异常：

  1. 提出例外
  2. 引发异常
  3. 提高
  4. 从original_exception引发异常（args）

1.引发异常vs.2.引发异常（args）

如果您使用raise exception (args)引发异常，那么当您打印异常对象时将打印args-如下面的示例所示。

  # 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 exceptiontry:raise ValueErrorexcept ValueError as exp:print ("Error", exp)     # Output -> Error

3.声明提高

不带任何参数的raise语句重新引发了最后一个异常。

如果您在捕获异常后需要执行一些操作，然后想要重新引发异常，这很有用。但是如果之前没有任何异常，raise语句会引发TypeError异常。

def somefunction():print("some cleaning")
a=10b=0result=None
try:result=a/bprint(result)
except Exception:            # Output ->somefunction()           # Some cleaningraise                    # Traceback (most recent call last):# File "python", line 8, in <module># ZeroDivisionError: division by zero

4.从original_exception引发例外（args）

此语句用于创建异常链，其中响应另一个异常引发的异常可以包含原始异常的详细信息-如下面的示例所示。

class MyCustomException(Exception):pass
a=10b=0reuslt=Nonetry: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__)

输出：

ZeroDivisionError --  division by zeroMyException Zero Divisiondivision by zero
小开

先阅读现有的答案，这只是一个附录。

请注意，您可以使用或不使用参数引发异常。

示例：

raise SystemExit

退出程序，但您可能想知道发生了什么。所以您可以使用这个。

raise SystemExit("program exited")

这将在关闭程序之前将“程序退出”打印为标准错误。

小开

只是要注意：有时您做想要处理通用异常。如果您正在处理一堆文件并记录您的错误，您可能希望捕获文件发生的任何错误，记录它，并继续处理其余文件。在这种情况下，一个

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

块是一个很好的方法。不过，您仍然需要raise特定异常，以便您知道它们的含义。

小开

抛出异常的另一种方法是使用#0。您可以使用断言来验证条件是否得到满足。如果没有，那么它将引发AssertionError。有关更多详细信息，请查看这里。

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))
小开

为此，您应该学习Python的提高语句。

它应该保存在try块中。

示例-

try:raise TypeError            # Replace TypeError by any other error if you wantexcept TypeError:print('TypeError raised')
小开

您可能还想提高自定义异常。例如，如果您正在编写一个库，为您的模块创建一个基本异常类是一个非常好的做法，然后有更具体的自定义子异常。

你可以像这样实现它：

class MyModuleBaseClass(Exception):pass
class MoreSpecificException(MyModuleBaseClass):pass

# To raise custom exceptions, you can just# use the raise keywordraise MoreSpecificExceptionraise MoreSpecificException('message')

如果您对自定义基类不感兴趣，您可以从普通异常类（如Exception、TypeError、ValueError等）继承自定义异常类。

小开

如果你不关心要引发的其中错误，你可以使用assert来引发AssertionError：

>>> assert False, "Manually raised error"Traceback (most recent call last):File "<pyshell#24>", line 1, in <module>assert False, "Manually raised error"AssertionError: Manually raised error>>>

如果条件为False，则assert关键字会引发AssertionError。在这种情况下，我们直接指定False，因此它会引发错误，但为了让它具有我们希望它引发的文本，我们添加逗号并指定我们想要的错误文本。在这种情况下，我写了Manually raised error，这会引发该文本。

小开

如果您不关心引发的异常，请执行：

def crash(): return 0/0

好老除以0。


提交答案