这是一个悬而未决的问题，我有两个方面想涉及:何时添加断言以及如何编写错误消息。

目的

向初学者解释一下，断言是一种可能引发错误的语句，但您不会捕获它们。他们通常不应该被抚养，但在现实生活中，他们有时还是会被抚养。这是一个严重的情况，代码无法恢复，我们称之为“致命错误”。

其次，它是为了“调试目的”，虽然正确，但听起来非常轻蔑。我更喜欢“声明不变量，它永远不应该被违反”的提法，尽管它对不同的初学者有不同的作用……有些人“只是得到它”，而另一些人要么没有找到它的任何用途，要么取代正常的异常，甚至用它来控制流。

风格

在Python中，assert是语句，而不是函数!(记住assert(False， 'is true')不会引发。但是，先说一下:

何时以及如何编写可选的“错误消息”?

这实际上适用于单元测试框架，它通常有许多专用的方法来执行断言(assertTrue(条件)，assertFalse(条件)，assertEqual(实际的，预期的)等)。它们通常还提供了一种对断言进行评论的方法。

在一次性代码中，您可以不使用错误消息。

在某些情况下，没有什么可以添加到断言:

def垃圾场(东西): 屁 # ...

但除此之外，消息对于与其他程序员(有时是你代码的交互式用户，例如在Ipython/Jupyter等)的交流是有用的。

给他们信息，而不仅仅是泄露内部实现细节。

而不是:

assert meaningless_identifier <= MAGIC_NUMBER_XXX, 'meaningless_identifier is greater than MAGIC_NUMBER_XXX!!!'

写:

assert meaningless_identifier > MAGIC_NUMBER_XXX, 'reactor temperature above critical threshold'

或者甚至:

assert meaningless_identifier > MAGIC_NUMBER_XXX, f'reactor temperature({meaningless_identifier }) above critical threshold ({MAGIC_NUMBER_XXX})'

我知道，我知道——这不是静态断言的情况，但我想指出消息的信息值。

消极还是积极的信息?

这可能是有争议的，但读到这样的东西让我很受伤:

assert a == b, 'a is not equal to b'

这是两个相互矛盾的东西。因此，每当我对代码库产生影响时，我就会通过使用“必须”和“应该”等额外的动词来明确我们想要什么，而不是说我们不想要什么。 断言a == b， 'a必须等于b'

然后，获取AssertionError: a must equal to b也是可读的，并且语句在代码中看起来是合乎逻辑的。此外，您可以在不读取回溯(有时甚至不可用)的情况下从中获得一些信息。

Assert是检查- 1. 有效条件， 2. 有效的表述， 3.真正的逻辑; 源代码。它不会让整个项目失败，而是会发出警报，提示源文件中有些地方不合适。

在例1中，因为变量'str'不是空的。因此不会引发任何断言或异常。

示例1:

#!/usr/bin/python

str = 'hello Python!'
strNull = 'string is Null'

if __debug__:
    if not str: raise AssertionError(strNull)
print str

if __debug__:
    print 'FileName '.ljust(30,'.'),(__name__)
    print 'FilePath '.ljust(30,'.'),(__file__)


------------------------------------------------------

Output:
hello Python!
FileName ..................... hello
FilePath ..................... C:/Python\hello.py

在例2中，var 'str'为空。因此，我们可以通过assert语句来避免用户走在错误程序前面。

示例2:

#!/usr/bin/python

str = ''
strNull = 'NULL String'

if __debug__:
    if not str: raise AssertionError(strNull)
print str

if __debug__:
    print 'FileName '.ljust(30,'.'),(__name__)
    print 'FilePath '.ljust(30,'.'),(__file__)


------------------------------------------------------

Output:
AssertionError: NULL String

当我们不想调试并意识到源代码中的断言问题时。禁用优化标志

python -O assertStatement.py 没有东西会被打印出来

assert的四个目的

假设您与四位同事Alice、Bernd、Carl和Daphne一起处理20万行代码。 他们喊你的代码，你喊他们的代码。

那么assert有四个角色:

Inform Alice, Bernd, Carl, and Daphne what your code expects. Assume you have a method that processes a list of tuples and the program logic can break if those tuples are not immutable: def mymethod(listOfTuples): assert(all(type(tp)==tuple for tp in listOfTuples)) This is more trustworthy than equivalent information in the documentation and much easier to maintain. Inform the computer what your code expects. assert enforces proper behavior from the callers of your code. If your code calls Alices's and Bernd's code calls yours, then without the assert, if the program crashes in Alices code, Bernd might assume it was Alice's fault, Alice investigates and might assume it was your fault, you investigate and tell Bernd it was in fact his. Lots of work lost. With asserts, whoever gets a call wrong, they will quickly be able to see it was their fault, not yours. Alice, Bernd, and you all benefit. Saves immense amounts of time. Inform the readers of your code (including yourself) what your code has achieved at some point. Assume you have a list of entries and each of them can be clean (which is good) or it can be smorsh, trale, gullup, or twinkled (which are all not acceptable). If it's smorsh it must be unsmorshed; if it's trale it must be baludoed; if it's gullup it must be trotted (and then possibly paced, too); if it's twinkled it must be twinkled again except on Thursdays. You get the idea: It's complicated stuff. But the end result is (or ought to be) that all entries are clean. The Right Thing(TM) to do is to summarize the effect of your cleaning loop as assert(all(entry.isClean() for entry in mylist)) This statements saves a headache for everybody trying to understand what exactly it is that the wonderful loop is achieving. And the most frequent of these people will likely be yourself. Inform the computer what your code has achieved at some point. Should you ever forget to pace an entry needing it after trotting, the assert will save your day and avoid that your code breaks dear Daphne's much later.

在我看来，assert的两个文档目的(1和3)和 保障措施(2和4)同样有价值。 告知人民甚至可能比告知计算机更有价值 因为它可以防止assert要捕捉的错误(在情况1中) 无论如何，接下来还有很多错误。

断言应该用于测试不应该发生的情况。目的是在程序状态损坏的情况下尽早崩溃。

异常应该用于可能发生的错误，并且几乎总是应该创建自己的Exception类。

例如，如果您正在编写一个从配置文件读取到dict的函数，那么文件中的不当格式将引发ConfigurationSyntaxError，而您可以断言您不会返回None。

在您的示例中，如果x是通过用户界面或外部源设置的值，则最好使用异常。

如果x只是在同一个程序中由您自己的代码设置的，则使用断言。

assert的使用和异常的引发都与通信有关。

Assertions are statements about the correctness of code addressed at developers: An assertion in the code informs readers of the code about conditions that have to be fulfilled for the code being correct. An assertion that fails at run-time informs developers that there is a defect in the code that needs fixing. Exceptions are indications about non-typical situations that can occur at run-time but can not be resolved by the code at hand, addressed at the calling code to be handled there. The occurence of an exception does not indicate that there is a bug in the code.

最佳实践

因此，如果您将运行时发生的特定情况视为您想要通知开发人员的错误(“嗨，开发人员，这种情况表明某处存在错误，请修复代码。”)，那么请使用断言。如果断言检查代码的输入参数，当输入参数违反条件时，您通常应该在文档中添加代码具有“未定义行为”。

相反，如果这种情况的出现并不是您眼中的错误，而是您认为应该由客户端代码处理的(可能很少，但可能)情况，则引发异常。引发哪种异常的情况应该是相应代码文档的一部分。

有没有演出[…]使用assert时的问题

断言的计算需要一些时间。但是，它们可以在编译时被删除。然而，这有一些后果，见下文。

有[…]使用assert的代码维护问题

Normally assertions improve the maintainability of the code, since they improve readability by making assumptions explicit and during run-time regularly verifying these assumptions. This will also help catching regressions. There is one issue, however, that needs to be kept in mind: Expressions used in assertions should have no side-effects. As mentioned above, assertions can be eliminated at compile time - which means that also the potential side-effects would disappear. This can - unintendedly - change the behaviour of the code.

除了其他答案之外，断言本身也会抛出异常，但仅抛出AssertionErrors。从实用主义的角度来看，当您需要对捕获的异常进行精细控制时，断言并不适合。