Python中的“断言”有啥用？

Posted 2023-02-18

技术标签:

【中文标题】Python中的“断言”有啥用？【英文标题】：What is the use of "assert" in Python?Python中的“断言”有什么用？ 【发布时间】：2011-07-05 18:32:20 【问题描述】：

我一直在阅读一些源代码，并在几个地方看到了assert 的用法。

具体是什么意思？它的用途是什么？

【问题讨论】：

***.com/questions/944592/… 【参考方案1】：

assert 语句几乎存在于所有编程语言中。它有两个主要用途：

它有助于在程序早期发现问题，原因很明确，而不是稍后在其他操作失败时检测。例如，Python 中的类型错误如果没有及早发现，在实际引发 Exception 之前可能会经过几层代码。

它作为其他开发人员阅读代码的文档，他们看到assert 并且可以自信地说它的条件从现在开始成立。

当你这样做时......

assert condition

...您告诉程序测试该条件，如果条件为假，则立即触发错误。

在Python中，大致等价于：

if not condition:
    raise AssertionError()

在 Python shell 中尝试：

>>> assert True # nothing happens
>>> assert False
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

断言可以包含可选消息，您可以在运行解释器时禁用它们。

在断言失败时打印一条消息：

assert False, "Oh no! This assertion failed!"

不要不要像函数一样使用括号来调用assert。这是一个声明。如果您执行assert(condition, message)，您将使用(condition, message) 元组作为第一个参数运行assert。

至于禁用它们，在优化模式下运行python 时，__debug__ 是False，断言语句将被忽略。只需传递-O 标志：

python -O script.py

有关相关文档，请参阅here。

【讨论】：

Nit：assert 是一个语句，而不是一个函数。 unlike print，在 Python 3 中是 still a statement。 @Chaine assert 的意思是“确保 *something” 为 True”。因此 assert a == 3 将确保 a 等于 3；如果 a 不等于 3（即 a= =3 是 False) 那么它会引发一个错误如果我只能使用if not condition: raise AssertError()，我为什么要使用断言？除了作为if not condition 语句的较短形式之外，还有什么条件可以使断言更好？完全无法理解这个答案是如何获得这么多赞成票的，实际上其他人也回答了。问题是“在Python中“断言”有什么用？”，所以它在问：什么时候使用，或者更准确地说：assert的使用场景是什么，但是在阅读了所有答案后，我完全一无所获我要！断言的目的经常被误解。它们不像建议的那样用于早期测试条件，也不是测试表达式的语法糖。它们的目的是“断言”某些条件在程序中的某些点是正确的，目的是帮助程序员了解这些点的系统状态。例如，如果在函数顶部看到“assert arg”语句，那么我将毫无疑问地知道 (arg is None) 对于该函数中的任何后续语句都是无效状态，从而减少了我拥有的状态集考虑。【参考方案2】：

来自文档：

断言语句是将调试断言插入程序的便捷方式

您可以在这里阅读更多内容：http://docs.python.org/release/2.5.2/ref/assert.html

【讨论】：

我喜欢这条评论，因为它只是非常清楚地解释了它是什么。我的问题是“如果我写了一个适当的单元测试，我为什么需要一个断言”？这些东西无论如何都不会在生产中运行。如果你想为每一个可能的极端情况编写单元测试，那么你不需要断言。但是断言可以更快地编写并且更简洁。它们还有助于代码的可读性，因为它们在代码中应该为真的地方断言某些东西是真的，而单元测试通常甚至不在同一个文件中。【参考方案3】：

其他人已经为您提供了文档链接。

您可以在交互式 shell 中尝试以下操作：

>>> assert 5 > 2
>>> assert 2 > 5
Traceback (most recent call last):
  File "<string>", line 1, in <fragment>
builtins.AssertionError:

第一条语句什么都不做，而第二条语句引发异常。这是第一个提示：断言对于检查代码给定位置（通常是函数的开头（前置条件）和函数的结尾（后置条件））中应该为真的条件很有用。

断言实际上与合约编程高度相关，这是一种非常有用的工程实践：

http://en.wikipedia.org/wiki/Design_by_contract.

【讨论】：

失去括号，断言不是函数。丢失括号比看起来更重要。见below。 Assert 实际上可以追溯到（早在“合同”之前）图灵，当时他写了一篇关于程序员如何处理创建正确程序这一相当艰巨的任务的最早论文。找到那篇论文留给读者作为练习，因为所有程序员都可以从熟悉他的工作中受益。 :-) turingarchive.org Exercise solution, with transcription errors corrected..【参考方案4】：

正如其他答案所指出的，assert 类似于在给定条件不成立时引发异常。一个重要的区别是，如果您使用优化选项-O 编译代码，断言语句将被忽略。 documentation 表示 assert expression 可以更好地描述为等同于

if __debug__:
   if not expression: raise AssertionError

如果您想彻底测试您的代码，然后在您对所有断言案例都没有失败感到高兴时发布优化版本，这可能很有用 - 当优化开启时，__debug__ 变量变为 False 并且条件将停止评估。如果您依赖断言并且没有意识到它们已经消失，此功能也可以让您发现。

【讨论】：

这是否意味着，如果某个变量或正确的输入（根据编写程序的合同）可能导致程序崩溃，当它由用户运行时（假设 -O当用户运行程序时使用标志），您应该改用if Not Error: raise Exception(“ this is a error”)?这样，当用户运行程序时，程序仍然会显示错误的来源.. 另一方面，如果您预计程序可能由于不正确的逻辑/代码实现而出错（但不是由于根据合同对程序用户的输入)，您应该使用assert 语句吗？这里的假设是当程序发布给最终用户时，您正在使用 -O 标志，因此假设所有错误都已被删除。因此，任何错误或程序崩溃都是由于对程序的输入，根据合同有效，但不能由程序处理。所以它应该这样提醒用户。 @alpha_989 完全正确。我喜欢将断言视为健全性检查，它只是为了帮助您作为开发人员确保您认为正确的内容在您开发时实际上是正确的。【参考方案5】：

assert 语句有两种形式。

简单的形式assert <expression>等价于

if __debug__:
    if not <expression>: raise AssertionError

扩展形式assert <expression1>, <expression2>等价于

if __debug__:
    if not <expression1>: raise AssertionError(<expression2>)

【讨论】：

【参考方案6】：

这是一个简单的示例，将其保存在文件中（比如说 b.py）

def chkassert(num):
    assert type(num) == int


chkassert('a')

和$python b.py时的结果

Traceback (most recent call last):
  File "b.py", line 5, in <module>
    chkassert('a')
  File "b.py", line 2, in chkassert
    assert type(num) == int
AssertionError

【讨论】：

【参考方案7】：

断言是检查程序内部状态是否符合程序员预期的系统方法，目的是捕捉错误。请参阅下面的示例。

>>> number = input('Enter a positive number:')
Enter a positive number:-1
>>> assert (number > 0), 'Only positive numbers are allowed!'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: Only positive numbers are allowed!
>>>

【讨论】：

此外，断言通常可以用于单元测试程序。 ***.com/questions/1383/what-is-unit-testing 你的答案是正确的，但这个例子是一个非常糟糕的例子。不应使用断言来验证用户输入，因为根据编译标志，可以禁用断言。一个更好的例子是调用为正数定义的函数但传递一个负数。否！在您的示例中，如果有人输入负数，这不是代码中的错误，因此断言是完全不合适的。 assert math.pow(number, 2) >= 0 是一个更好（但仍然相当简单）的示例，因为您可以保证对于任何数字都是如此，除非 math.pow() 代码中出现错误。【参考方案8】：

如果 assert 之后的语句为 true 则程序继续，但如果 assert 之后的语句为 false 则程序出错。就这么简单。

例如：

assert 1>0   #normal execution
assert 0>1   #Traceback (most recent call last):
             #File "<pyshell#11>", line 1, in <module>
             #assert 0>1
             #AssertionError

【讨论】：

【参考方案9】：

格式：断言表达式[，参数] 当 assert 遇到语句时，Python 会计算表达式。如果语句不正确，则会引发异常（assertionError）。如果断言失败，Python 使用 ArgumentExpression 作为 AssertionError 的参数。 AssertionError 异常可以像使用 try-except 语句的任何其他异常一样被捕获和处理，但如果不处理，它们将终止程序并产生回溯。示例：

def KelvinToFahrenheit(Temperature):    
    assert (Temperature >= 0),"Colder than absolute zero!"    
    return ((Temperature-273)*1.8)+32    
print KelvinToFahrenheit(273)    
print int(KelvinToFahrenheit(505.78))    
print KelvinToFahrenheit(-5)

当执行上述代码时，会产生如下结果：

32.0
451
Traceback (most recent call last):    
  File "test.py", line 9, in <module>    
    print KelvinToFahrenheit(-5)    
  File "test.py", line 4, in KelvinToFahrenheit    
    assert (Temperature >= 0),"Colder than absolute zero!"    
AssertionError: Colder than absolute zero!

【讨论】：

【参考方案10】：

def getUser(self, id, Email):

    user_key = id and id or Email

    assert user_key

可用于确保在函数调用中传递参数。

【讨论】：

这会起作用，但据我了解，断言不应该用于检查用户输入，因为它们可以在运行时关闭。如果您真的想强制或验证用户输入，请使用 if not user_key: raise ValueError() 在此处检查最后 2 段：wiki.python.org/moin/UsingAssertionsEffectively assert 不应用于输入验证，因为如果 __debug__ 是 False，则验证将被删除。此外，将断言用于非调试目的可能会导致人们捕捉到生成的AssertionErrors，这会使调试变得更加困难而不是更少。【参考方案11】：

注意括号。正如其他答案中所指出的那样，in Python 3, assert is still a statement，因此与print(..) 类比，可以将相同的推断推断为assert(..) 或raise(..)，但您不应该这样做。

这是错误的：

assert(2 + 2 == 5, "Houston we've got a problem")

这是正确的：

assert 2 + 2 == 5, "Houston we've got a problem"

第一个不起作用的原因是 bool( (False, "Houston we've got a problem") ) 的计算结果为 True。

在语句assert(False) 中，这些只是False 周围的多余括号，它们的值是它们的内容。但是对于assert(False,)，括号现在是一个元组，一个非空元组在布尔上下文中计算为True。

【讨论】：

我来这里是为了寻找有关 parens 的确切信息和以下消息。谢谢。但是assert (2 + 2 = 5), "Houston we've got a problem" 应该没问题吧？不要忘记人们经常使用括号来表示符合 PEP 8 的隐式续行也不要忘记元组不是由括号定义而是由逗号定义的（元组与除了运算符优先级之外，使用括号）。 assert (2 + 2 = 5), "Houston we've got a problem" 不起作用......但它与断言语句无关，这很好。你的条件不起作用，因为它不是条件。错过了第二个=。 @SherylHohman, assert (2+2==5), “Houston we’ve got a problem 将评估为assert False, “Houston we’ve got a problem，因此会引发断言错误。这与assert 和(2+2==5) 之间是否有空格无关。其他评论者正在谈论的是，当您将 (2+2==5, “Houston we’ve got a problem”) 作为输入传递给 assert 函数时。所以输入实际上是一个元组，由两个术语 2+2==5 和“Houston we've got a problem”组成。【参考方案12】：

如果您想知道 Python 中保留函数的确切作用，请输入 help(enter_keyword)

如果您输入的是保留关键字，请确保将其作为字符串输入。

【讨论】：

【参考方案13】：

Python 中断言的目标是告知开发人员程序中的不可恢复错误。

断言并非旨在表明预期的错误情况，例如“找不到文件”，用户可以在其中采取纠正措施（或只是重试）。

另一种看待它的方式是，断言是代码中的内部自检。它们通过在您的代码中将某些条件声明为 不可能 来工作。如果这些条件不成立，则意味着程序中存在错误。

如果您的程序没有错误，这些情况将永远不会发生。但是，如果其中一个确实发生，程序将崩溃并出现断言错误，告诉您确切触发了哪个“不可能”条件。这使得跟踪和修复程序中的错误变得更加容易。

这是我写的a tutorial on Python’s assertions的摘要：

Python 的断言语句是一种调试辅助工具，而不是处理运行时错误的机制。 使用断言的目的是让开发人员更快地找到错误的可能根本原因。除非您的程序中存在错误，否则不应引发断言错误。

【讨论】：

感谢您的文章。非常有助于理解assert 语句以及何时使用它。我正在尝试理解您在文章中介绍的一些术语。我想我会在这里发布 cmets，这样更多的人可能会从澄清中受益。如果问题太天真，请见谅。如果你认为'user.is_admin()`是一个用户输入，因此不应该在assert statement中使用，那么price不能也被认为是一个用户输入吗？为什么你认为assert user.is_admin() 是数据验证而不是assert price？ @LaryxDecidua 不，你可以在我的网站上阅读它，该教程是公开的。如果您对时事通讯不感兴趣，只需点击退出或单击小“x”符号。希望这会有所帮助:-) +1 用于解释何时使用断言。我曾经向我解释过，如果调用者可以通过使用公共 API 触发断言，那么这始终是一个应该修复的错误。断言完成了它的工作并发现了一个真正的错误，或者它是执行公共合同的不正确的断言，应该用一个面临错误的适当调用者来替换。断言用于验证实现的内部私有逻辑，而不是针对调用者执行公共 API 合约。【参考方案14】：

>>>this_is_very_complex_function_result = 9
>>>c = this_is_very_complex_function_result
>>>test_us = (c < 4)

>>> #first we try without assert
>>>if test_us == True:
    print("YES! I am right!")
else:
    print("I am Wrong, but the program still RUNS!")

I am Wrong, but the program still RUNS!


>>> #now we try with assert
>>> assert test_us
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    assert test_us
AssertionError
>>>

【讨论】：

【参考方案15】：

如果assert 关键字后面的代码是False，Python 中的assert 关键字会引发AssertionError。如果没有，它会继续，因为什么都没发生。

示例 1：

a = 5
b = 6

assert a == b

输出：

AssertionError

这是因为，很明显，a 不等于 b。如果您想在代码中引发 Exception，这将特别有用。

def get_dict_key(d, k):
    try:
        assert k in d
        return d[k]
    except Exception:
        print("Key must be in dict.")

上面的例子实际上没什么用，但请记住，它主要用于调试目的，所以你可以追踪你的错误。

【讨论】：

请正确格式化您的代码。另外，这对以前的答案有何改进？我的解释有问题吗？您的解释并没有为现有答案添加任何内容，而且糟糕的语法使其难以阅读。如果您正在寻找要回答的问题，请考虑浏览新的问题提要。提供的答案确实回答了如何使用assert，但没有回答何时使用（或不使用）@987654332 @.【参考方案16】：

Python assert 基本上是一种调试辅助工具，用于测试代码内部自检的条件。当您的代码遇到不可能的边缘情况时，Assert 使调试变得非常容易。断言检查那些不可能的情况。

假设有一个计算折扣后商品价格的功能：

def calculate_discount(price, discount):
    discounted_price = price - [discount*price]
    assert 0 <= discounted_price <= price
    return discounted_price

在这里，discounted_price 永远不能小于 0 并且大于实际价格。因此，如果违反上述条件，assert 会引发 Assertion Error，这有助于开发人员识别不可能发生的事情。

希望对你有帮助:)

【讨论】：

assert 在调试上下文中很有用，但不应依赖于调试上下文之外。【参考方案17】：

我的简短解释是：

assert 如果表达式为假，则引发AssertionError，否则继续代码，如果有逗号，则为AssertionError: whatever after comma，代码如下：raise AssertionError(whatever after comma)

有关此的相关教程：

https://www.tutorialspoint.com/python/assertions_in_python.htm

【讨论】：

答案提供了如何使用assert，而不是何时使用（或不使用）assert；还要注意，如果__debug__ 是False，则可以禁用assert。【参考方案18】：

正如C2 Wiki 上的简明总结：

断言是程序中特定点的布尔表达式，它为真除非程序中存在错误。

您可以使用assert 语句来记录您对特定程序点的代码的理解。例如，您可以记录有关输入（前置条件）、程序状态（不变量）或输出（后置条件）的假设或保证。

如果您的断言失败，这会提醒您（或您的继任者）您在编写程序时对程序的理解是错误的，并且它可能包含错误。

如需更多信息，John Regehr 在Use of Assertions 上有一篇精彩的博文，它也适用于 Python assert 语句。

【讨论】：

+1 指出使用assert 语句有助于记录程序员对代码的理解。【参考方案19】：

assert 语句几乎存在于所有编程语言中。它有助于在您的程序早期发现问题，原因是明确的，而不是稍后作为某些其他操作的副作用。他们总是期待True 条件。

当您执行以下操作时：

assert condition

您是在告诉程序测试该条件，如果为假则立即触发错误。

在 Python 中，assert expression 等价于：

if __debug__:
    if not <expression>: raise AssertionError

您可以使用扩展表达式传递可选消息：

if __debug__:
    if not (expression_1): raise AssertionError(expression_2)

在 Python 解释器中尝试一下：

>>> assert True # Nothing happens because the condition returns a True value.
>>> assert False # A traceback is triggered because this evaluation did not yield an expected value.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

在使用它们之前有一些注意事项，主要针对那些认为在assert 和if 语句之间切换的人。使用assert 的目的是在程序验证一个条件并返回一个应该立即停止程序而不是采取其他方法绕过错误的情况下：

1。括号

您可能已经注意到，assert 语句使用两个条件。因此，不要使用括号将它们作为一个明确的建议。如果你这样做：

assert (condition, message)

例子：

>>> assert (1==2, 1==1)
<stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?

您将运行assert 并使用(condition, message) 作为第一个参数，它表示一个元组，这会导致Python 中的非空元组总是True。但是，您可以毫无问题地单独进行：

assert (condition), "message"

例子：

>>> assert (1==2), ("This condition returns a %s value.") % "False"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: This condition returns a False value.

2。调试目的

如果您想知道何时使用assert 语句。举个现实生活中的例子：

* 当您的程序倾向于控制用户输入的每个参数或其他任何参数时：

def loremipsum(**kwargs):
    kwargs.pop('bar') # return 0 if "bar" isn't in parameter
    kwargs.setdefault('foo', type(self)) # returns `type(self)` value by default
    assert (len(kwargs) == 0), "unrecognized parameter passed in %s" % ', '.join(kwargs.keys())

* 另一种情况是在数学上，当 0 或非正数作为某个方程的系数或常数时：

def discount(item, percent):
    price = int(item['price'] * (1.0 - percent))
    print(price)
    assert (0 <= price <= item['price']),\
            "Discounted prices cannot be lower than 0 "\
            "and they cannot be higher than the original price."

    return price

* 甚至是一个简单的布尔实现示例：

def true(a, b):
    assert (a == b), "False"
    return 1

def false(a, b):
    assert (a != b), "True"
    return 0

3。数据处理或数据验证

最重要的是不要依赖 assert 语句来执行数据处理或数据验证，因为可以在 Python 初始化时使用 -O 或 -OO 标志关闭该语句 - 表示值 1、2、和 0（默认），分别为 - 或 PYTHONOPTIMIZE 环境变量。

值 1：

* 断言被禁用；

* 字节码文件是使用.pyo 扩展名而不是.pyc 生成的；

* sys.flags.optimize 设置为 1 (True);

* 并且，__debug__ 设置为 False；

值 2： 再禁用一个东西

* 文档字符串被禁用；

因此，使用assert 语句来验证某种预期数据是极其危险的，甚至暗示了一些安全问题。然后，如果您需要验证某些权限，我建议您改为 raise AuthError。作为一个前置条件，assert 常被程序员用于没有用户直接交互的库或模块。

【讨论】：

【参考方案20】：

正如在其他答案中所写，assert 语句用于检查状态给定点的程序。

我不会重复有关关联的内容消息、括号或-O 选项和__debug__ 常量。先检查the doc 手信息。我将专注于您的问题：assert 有什么用？更准确地说，何时（何时不）应该使用assert？

assert 语句对于调试程序很有用，但不鼓励检查用户输入。我使用以下经验法则：保持断言以检测 this 不应该发生的情况。一个用户输入可能不正确，例如密码太短，但这不是 this 不应该发生 的情况。如果一个圆的直径不是它的两倍半径，您处于这不应该发生的情况。

在我看来，最有趣的 assert 的使用灵感来自 programming by contract 为 B. Meyer 在 [面向对象的软件构建] 中描述的（ https://www.eiffel.org/doc/eiffel/Object-Oriented_Software_Construction%2C_2nd_Edition ) 并以 [Eiffel 编程语言]( https://en.wikipedia.org/wiki/Eiffel_(programming_language))。你不能完全使用assert 语句模拟合约编程，但它是保持意图很有趣。

这是一个例子。想象一下，您必须编写一个 head 函数（如 [head Haskell 中的函数]( http://www.zvon.org/other/haskell/Outputprelude/head_f.html))。这您给出的规范是：“如果列表不为空，则返回列表的第一项”。查看以下实现：

>>> def head1(xs): return xs[0]

和

>>> def head2(xs):
...     if len(xs) > 0:
...         return xs[0]
...     else:
...         return None

_{（是的，这可以写成return xs[0] if xs else None，但这不是重点）}。

如果列表不为空，两个函数的结果相同，这个结果是正确的：

>>> head1([1, 2, 3]) == head2([1, 2, 3]) == 1
True

因此，两种实现（我希望）都是正确的。当您尝试时，它们会有所不同取一个空列表的头项：

>>> head1([])
Traceback (most recent call last):
...
IndexError: list index out of range

但是：

>>> head2([]) is None
True

同样，两种实现都是正确的，因为没有人应该传递一个空的列出这些函数（我们超出规范）。那是一个不正确的呼叫，但如果你这样做，任何事情都可能发生。一个函数引发异常，另一个函数返回一个特殊值。最重要的是：我们不能依赖这种行为。如果xs 为空，这将起作用：

print(head2(xs))

但这会使程序崩溃：

print(head1(xs))

为了避免一些意外，我想知道我什么时候经过一些意外函数的参数。换句话说：我想知道什么时候观察到行为是不可靠的，因为它取决于实现，而不是规范。当然，我可以阅读规范，但程序员并不总是仔细阅读文档。

想象一下，如果我有办法将规范插入代码中以获取以下效果：当我违反规范时，例如传递一个空列出head，我收到警告。这将是一个很大的帮助写一个正确的（即符合规范）程序。这就是assert 进入现场：

>>> def head1(xs):
...     assert len(xs) > 0, "The list must not be empty"
...     return xs[0]

和

>>> def head2(xs):
...     assert len(xs) > 0, "The list must not be empty"
...     if len(xs) > 0:
...         return xs[0]
...     else:
...         return None

现在，我们有：

>>> head1([])
Traceback (most recent call last):
...
AssertionError: The list must not be empty

还有：

>>> head2([])
Traceback (most recent call last):
...
AssertionError: The list must not be empty

请注意，head1 会抛出 AssertionError，而不是 IndexError。那是很重要，因为 AssertionError 不是 any 运行时错误：它表示违反规范。我想要一个警告，但我得到一个错误。幸运的是，我可以禁用检查（使用-O 选项），但风险自负。我会做崩溃真的很贵，希望最好的。想象一下，我的程序嵌入在一艘宇宙飞船中，该飞船穿过一个黑洞。我将禁用断言并希望程序足够强大尽量不要崩溃。

这个例子只是关于前置条件，你可以使用assert来检查后置条件（返回值和/或状态）和不变量（a 的状态）班级）。请注意，使用assert 检查后置条件和不变量可以是繁琐：

对于后置条件，您需要将返回值分配给一个变量，并且如果您正在处理一个方法，可能会存储对象的初始状态；对于不变量，您必须检查方法调用前后的状态。

您不会拥有像 Eiffel 那样复杂的东西，但您可以提高程序的整体质量。

总而言之，assert 语句是检测 this 的便捷方式不应该发生的情况。违反规范（例如通过 head) 的空列表是头等不应该发生的情况。因此，虽然assert 语句可用于检测任何意外情况，这是确保满足规范的一种特权方式。一旦您将assert 语句插入到代码中以表示规范，我们希望您提高了程序的质量，因为不正确的参数，不正确的返回值，不正确的类状态......，会被举报。

【讨论】：

【参考方案21】：

在 Pycharm 中，如果你使用 assert 和 isinstance 来声明一个对象的类型，它会让你在编码时访问父对象的方法和属性，它会自动完成。

例如，假设self.object1.object2 是一个MyClass 对象。

import MyClasss

def code_it(self):
    testObject = self.object1.object2 # at this point, program doesn't know that testObject  is a MyClass object yet
    assert isinstance(testObject , MyClasss) # now the program knows testObject is a MyClass object
    testObject.do_it() # from this point on, PyCharm will be able to auto-complete when you are working on testObject

【讨论】：

【参考方案22】：

断言是在我们的程序中自信地陈述事实的陈述。

语法：assert <condition> 或 assert <condition>,<error message>

它有一个条件/表达式应该始终为真。如果条件为假，assert 语句将停止程序并抛出一条错误消息说AssertionError。所以你的断言表达式将是你的程序中不想要的东西。

例如

assert <condition> -- 使用不带<error message>的断言

var = int(input("Enter value 1-9 inclusive:"))                                 
assert var!=0 
print(var)

输出：

如果输入为 0：

AssertionError

如果输入为 1：

assert <condition>,<error message> -- 使用带有<error message>的断言

var = int(input("Enter value 1-9 inclusive:"))                                 
assert var!=0,"Input cannot be zero"
print(var)

输出：

如果输入为 0：

AssertionError: Input cannot be zero

如果输入为 1：

要点：

用作调试工具。它接受一个表达式和一个可选消息。它几乎存在于所有编程语言中

【讨论】：

以上是关于Python中的“断言”有啥用？的主要内容，如果未能解决你的问题，请参考以下文章

python中的迭代器有啥用

在 Chai 断言库中，当我们已经有“assert.deepEqual()”和“assert.strictEqual()”时，“assert.equal()”有啥用？

python中的sys.argv有啥用？print sys.argv啥意思？

python中print（）有啥用？

spring中的依赖注入有啥用？