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

不要这样做。养一个光秃秃的绝对不是正确的做法;请看亚伦·霍尔（Aaron Hall）的精彩回答。Exception

没有比这更 Pythonic 的了：

raise Exception("I know Python!")

替换为要引发的特定类型的异常。Exception

如果您想了解更多信息，请参阅 Python 的 raise 语句文档。

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

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

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

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

不要引发一般异常

避免提出通用 .要捕获它，您必须捕获所有其他更具体的异常，这些异常是它的子类。Exception

问题 1：隐藏 bug

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

最佳实践：声明raise

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

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

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

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

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

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

指纹

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

在 Python 2.5 中，添加了一个实际属性，以支持鼓励用户对 Exceptions 进行子类化并停止使用 ，但 message 的引入和最初弃用 args 已被撤回。messageBaseExceptionargs

最佳实践：条款except

例如，在 except 子句中，您可能希望记录发生了特定类型的错误，然后重新引发。在保留堆栈跟踪的同时执行此操作的最佳方法是使用裸 raise 语句。例如：

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!

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

您可以使用 保留堆栈跟踪（和错误值），但这更容易出错，并且在 Python 2 和 3 之间存在兼容性问题，更喜欢使用裸来重新提升。sys.exc_info()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

我们在修改参数时保留了整个回溯。请注意，这不是最佳实践，它是 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_message
  File "<stdin>", line 2, in error
ValueError: oops! <modification>

在 Python 3 中：

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.

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

用法示例

我提出异常，以警告我的 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. 引发异常 （args）
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 exception
try:
    raise ValueError
except ValueError as exp:
    print("Error", exp)     # Output -> Error

3. 声明提升

没有任何参数的语句将重新引发最后一个异常。raise

如果需要在捕获异常后执行某些操作，然后想要重新引发异常，这将非常有用。但是，如果之前没有任何异常，则该语句会引发异常。raiseTypeError

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 9, in <module>
                             # ZeroDivisionError: division by zero

4. 从original_exception引发异常 （args）

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

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

输出：

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

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

请注意，可以引发带或不带参数的异常。

例：

raise SystemExit

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

raise SystemExit("program exited")

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

请注意：有时您确实希望处理一般异常。如果要处理一堆文件并记录错误，则可能需要捕获文件发生的任何错误，将其记录下来，然后继续处理其余文件。在这种情况下，一个

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

阻止是一个很好的方法。不过，您仍然需要特定的例外情况，以便了解它们的含义。raise

引发异常的另一种方法是使用 assert。您可以使用 assert 来验证是否满足条件。如果没有，那么它会提高.有关更多详细信息，请查看此处。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 的 raise 语句。

它应该保存在 try 块内。

例-

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

您可能还希望引发自定义异常。例如，如果你正在编写一个库，那么为模块创建一个基异常类，然后更具体地自定义子异常是一个非常好的做法。

你可以像这样实现：

class MyModuleBaseClass(Exception):
    pass

class MoreSpecificException(MyModuleBaseClass):
    pass


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

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

如果你不关心要引发哪个错误，你可以用它来引发一个：assertAssertionError

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

关键字会引发 if 条件为 。在本例中，我们直接指定，因此它引发了错误，但要让它具有我们希望它引发的文本，我们添加一个逗号并指定我们想要的错误文本。在这种情况下，我写了，这用该文本提出了它。assertAssertionErrorFalseFalseManually raised error

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

def crash(): return 0/0

它不允许您向用户抛出特定消息，但会使 python interpriter 崩溃。

对于更高级的 python，使用 python 的用户可能会认为表达式将在编译时计算（python 被编译），但 python 编译器不会在运行时计算表达式。 如果我们看一下 python 的 dissasembely 模块显示的内容，我们可以看到字节码。dis

              2 LOAD_CONST               1 (0)
              4 LOAD_CONST               1 (0)
              6 BINARY_OP               11 (/)

因此，本质上的 python 会将常量 0 推到堆栈上，然后将另一个 0 推送到堆栈上，然后运行二进制运算符进行除法。

虽然这个函数很没用，不应该在生产代码中使用，但它仍然会让 python interpriter 崩溃。