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

网友回答：

不要这样做。抬起光秃秃的绝对不是正确的做法;请看亚伦霍尔的精彩答案。Exception

没有比这更 Python 的了：

raise Exception("I know Python!")

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

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

网友回答：

如何在 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_catch
Exception: 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') 

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

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

指纹

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

在 Python 2.5 中，为了鼓励用户对异常进行子类化并停止使用 ，增加了一个实际的属性，但是引入和最初弃用 args 已被撤回。messageBaseExceptionargsmessage

最佳实践：条款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 之间存在兼容性问题，更喜欢使用 bare 重新提出。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]

如果需要，您可以修改新加薪发生的情况 – 例如，为实例设置 new：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 中，你可以链接异常，保留回溯：

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

网友回答：

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

1. raise exception
2. raise exception (args)
3. raise
4. 从original_exception引发异常 （参数）

1. 引发异常与 2.引发异常 （参数）

如果您用于引发异常，则在打印异常对象时将打印 – 如下例所示。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 8, in <module>
                             # ZeroDivisionError: division by zero

4. 从original_exception引发异常 （参数）

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

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