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

曾经终败给现在 2024-03-30 12:11 102阅读 0赞

## 问： ##

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

## 答1: ##

> huntsbot.com汇聚了国内外优秀的初创产品创意，可按收入、分类等筛选，希望这些产品与实践经验能给您带来灵感。

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

Use the most specific Exception constructor that semantically fits your issue。

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

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 "", line 1, in 
      File "", line 3, in demo_no_catch
    Exception: general exceptions not caught by specific handling

最佳实践：raise 声明

Instead, use the most specific Exception constructor that semantically fits your issue。

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 中，向 BaseException 添加了一个实际的 message 属性，以鼓励用户将异常子类化并停止使用 args，但使用 the introduction of message and the original deprecation of args has been retracted。

最佳实践：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!

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

您可以使用 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] + ' ',)
            raise error_type, error_instance, traceback

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

>>> catch_error_modify_message()
    Traceback (most recent call last):
      File "", line 1, in 
      File "", line 3, in catch_error_modify_message
      File "", line 2, in error
    ValueError: oops!

在 Python 3 中：

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

再次：避免手动操作回溯。它是 less efficient 并且更容易出错。如果您使用线程和 sys.exc\_info，您甚至可能会得到错误的回溯（特别是如果您使用异常处理进行控制流 - 我个人倾向于避免这种情况。）

Python 3，异常链接

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

raise RuntimeError('specific message') from error

意识到：

这确实允许更改引发的错误类型，并且

这与 Python 2 不兼容。

不推荐使用的方法：

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

Valid in Python 2, but not in Python 3 如下：

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

只有 valid in much older versions of 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.')

`try: raise ValueError('error') except ValueError as e: print('we will catch exception: Exception',str(e)) #是最好的解决方案`

`@SharathBJ 您提出了一个 ValueError 并将其报告为类型 Exception，这是不必要的精度损失。 repr(e) 至少会为您报告类型。`

`在哪里显示您可以在引发异常时传递消息的官方文档？例如：raise TypeError("my message")`

`@GabrielStaples 这是关于实例化参数的文档：docs.python.org/3/library/exceptions.html#BaseException.args`

`@AaronHall，啊，我明白了。我没有意识到异常类型，例如 TypeError，是对类构造函数的调用！现在有道理了。因此，该消息是错误类型类的通用构造函数 arg。`

## 答2: ##

> 一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

不要这样做。提出一个简单的异常绝对不是正确的做法；请参阅 Aaron Hall 的出色答案。

没有比这更 Pythonic 的了：

raise Exception("I know Python!")

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

如果您想了解更多信息，请参阅 Python 的 the raise statement documentation。

`不谢谢！这消除了对您捕获的内容进行具体说明的可能性。这完全是错误的做法。看看 Aaron Hall 的出色答案，而不是这个。像这样的时候，我希望每个答案都可以投反对票。`

`@PeterR同样糟糕的是，它的反对票如此之少。对于任何阅读此答案的人，永远不要这样做！正确答案是 Aaron Hall 的答案。`

`@CharlieParker 有。这是 Aaron Hall's answer 的第一部分。`

`@codeforester 也许是因为它正在回答这个问题。`

`这个答案仍然存在，因为许多有经验的开发人员不同意使用专门的异常类。我希望我可以对评论投反对票。`

## 答3: ##

> 打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

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

引发异常引发异常 (args) 从 original\_exception 引发引发异常 (args)

1.  引发异常与 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

1.  声明提升

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

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

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 
                                 # ZeroDivisionError: division by zero

1.  从 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

`请注意，PEP8 更喜欢 exception(args) 而不是 exception (args)`

`还有 raise exception(args) from None 表示当前活动的异常已处理并且不再感兴趣。否则，如果您在 except 块内引发异常并且未处理，则两个异常的回溯将由消息“在处理上述异常期间，发生另一个异常”分开显示`

## 答4: ##

> 保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

对于您需要抛出异常以响应某些意外情况的常见情况，并且您从不打算捕获，而只是快速失败以使您能够从那里进行调试，如果它发生了 - 最合乎逻辑的一个似乎是AssertionError：

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

`这对于 ValueError 比 AssertionError 更好，因为断言没有问题（因为这里没有进行断言）——问题在于值。在这种情况下，如果您真的需要 AssertionError，请编写 assert distance > 0, 'Distance must be positive'。但是您不应该以这种方式进行错误检查，因为可以关闭断言 (python -O)。`

`@Two-BitAlchemist 好点。当我编写上面的简单示例时，这个想法在简化中丢失了。在许多类似的情况下，它是与特定值无关的条件。相反，意思是“控制流永远不应该到达这里”。`

`@Two-BitAlchemist 断言可以关闭，是的，但是您根本不应该使用它们进行错误检查吗？`

`这得看情况。我不会让它成为我打算分发的程序中唯一的错误检查。另一方面，我可以为我的同事制作一个程序，并告诉他们如果使用 -O 运行该程序，他们将自行承担使用该程序的风险。`

`@Two-BitAlchemist 对我来说，断言的作用不是错误检查本身（这是测试的目的），但它们在代码中设置了某些错误无法通过的栅栏。因此，追踪和隔离错误变得更加容易，这将不可避免地发生。这只是需要一点努力的好习惯，而测试需要大量的努力和大量的时间。`

## 答5: ##

> 与HuntsBot一起，探索全球自由职业机会–huntsbot.com

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

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

例子：

raise SystemExit

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

raise SystemExit("program exited")

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

`这不是违反 OOP 范式吗？我假设，第一种情况抛出类引用，第二种情况抛出 SystemExit 的实例。 raise SystemExit() 不是更好的选择吗？为什么第一个甚至可以工作？`

`python.org/dev/peps/pep-3109 讨论了这个`

## 答6: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

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

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

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

## 答7: ##

> huntsbot.com – 程序员副业首选，一站式外包任务、远程工作、创意产品分享订阅平台。

要捕获所有异常，请使用 BaseException。它位于异常层次结构的顶部。

1.捕捉异常

try:
        # Do something
    except BaseException as error:
        print('An exception occurred: {
        }'.format(error))

2.引发异常

try:
        # Do something
    except BaseException as error:
        raise 'An exception occurred: {
        }'.format(error)

以上代码支持 Python 2.7 到最新版本。

参考：Exception Hierarchy

`第二个引发异常的例子，应该修改。字符串 An exception occurred 应以通用类实例为前缀，即在这种情况下为 BaseException，或更具体的派生对象异常。`

## 答8: ##

> 打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

引发异常的另一种方法是使用 assert。您可以使用 assert 来验证是否满足条件。如果不是，那么它将引发 AssertionError。有关更多详细信息，请查看 here。

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

`并非万无一失，因为当使用优化 (-O) 标志对解释器进行调用时，会忽略 CPython 中的断言；如果你想真正控制程序流程“嘿，这种情况不应该发生，但如果它是真的异常结束”，手动raise AssertionError()`

## 答9: ##

> 保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

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

它应该保存在 try 块内。

例子 -

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

`你能说明为什么你的例子很好吗？我已经阅读了这个问题的所有答案，我真的很好奇。`

## 答10: ##

> HuntsBot周刊–不定时分享成功产品案例，学习他们如何成功建立自己的副业–huntsbot.com

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

你可以这样实现：

class MyModuleBaseClass(Exception):
        pass
    
    class MoreSpecificException(MyModuleBaseClass):
        pass
    
    
    # To raise custom exceptions, you can just
    # use the raise keyword
    raise MoreSpecificException
    raise MoreSpecificException('message')

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

## 答11: ##

> HuntsBot周刊–不定时分享成功产品案例，学习他们如何成功建立自己的副业–huntsbot.com

如果您不关心要引发 哪个 错误，可以使用 assert 引发 AssertionError：

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

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

原文链接：[https://www.huntsbot.com/qa/Zv3B/manually-raising-throwing-an-exception-in-python?lang=zh\_CN&from=csdn][https_www.huntsbot.com_qa_Zv3B_manually-raising-throwing-an-exception-in-python_lang_zh_CN_from_csdn]

> huntsbot.com全球7大洲远程工作机会，探索不一样的工作方式

[https_www.huntsbot.com_qa_Zv3B_manually-raising-throwing-an-exception-in-python_lang_zh_CN_from_csdn]: https://www.huntsbot.com/qa/Zv3B/manually-raising-throwing-an-exception-in-python?lang=zh_CN&from=csdn