Python中“assert”有什么用？

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

1. 它有助于在程序的早期发现问题，原因很清楚，而不是在其他操作失败时发现问题。例如，Python 中的类型错误可以经过几层代码，然后才能真正引发一个 if 早期发现。Exception

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

当你这样做时...

assert condition

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

在 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!"

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

至于禁用它们，当在优化模式下运行时，where is ，assert 语句将被忽略。只需传递旗帜：python__debug__False-O

python -O script.py

有关相关文档，请参阅此处。

来自文档：

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

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

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

您可以在交互式 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。

正如其他答案所指出的，类似于在给定条件不为真时抛出异常。一个重要的区别是，如果使用优化选项 -O 编译代码，则 assert 语句将被忽略。文档说，可以更好地描述为等同于assertassert expression

if __debug__:
   if not expression: raise AssertionError

如果您想彻底测试您的代码，然后在您满意没有一个断言案例失败时发布优化版本，这可能很有用 - 当优化打开时，变量变为 False，并且条件将停止计算。如果您依赖断言并且没有意识到它们已经消失，此功能也可以让您陷入困境。__debug__

assert 语句有两种形式。

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

if __​debug__:
    if not <expression>: raise AssertionError

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

if __​debug__:
    if not <expression1>: raise AssertionError(<expression2>)

这是一个简单的例子，把它保存在文件中（比方说 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

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

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

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

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

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!    

def getUser(self, id, Email):

    user_key = id and id or Email

    assert user_key

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

注意括号。正如在其他答案中指出的那样，在 Python 3 中，assert 仍然是一个语句，因此通过类比 ，可以推断出相同的 或 但你不应该。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)Falseassert(False,)True

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

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

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

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

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

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

以下是我写的关于 Python 断言的教程的摘要：

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

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

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

示例 1：

a = 5
b = 6

assert a == b

输出：

AssertionError

这是因为，显然，不等于 . 如果您想在代码中引发 ONE，这将特别有用。abException

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

上面的例子实际上毫无用处，但请记住，它主要用于调试目的，因此您可以跟踪您的错误。

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 会引发断言错误，这有助于开发人员识别发生了不可能的事情。

希望对:)有所帮助

我的简短解释是：

• assert如果表达式为 false，则引发，否则只是继续代码，如果有一个逗号，它将是 ，而 to 代码如下：AssertionErrorAssertionError: whatever after commaraise AssertionError(whatever after comma)

有关此内容的相关教程：

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

正如 C2 Wiki 上简明扼要地总结的那样：

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

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

如果你的断言失败了，这是对你（或你的继任者）的警告，你在编写程序时对程序的理解是错误的，并且它可能包含一个错误。

有关更多信息，John Regehr 有一篇关于断言使用的精彩博客文章，该文章也适用于 Python 语句。assert

该语句几乎存在于所有编程语言中。它有助于在程序的早期发现问题，其中原因很清楚，而不是稍后作为其他操作的副作用。他们总是期待一个条件。assertTrue

当您执行以下操作时：

assert condition

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

在 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

在使用它们之前，需要注意一些注意事项，主要是对于那些认为在 and 语句之间切换的人。使用的目的是在程序验证条件并返回一个值时，该值应立即停止程序，而不是采取某种替代方法来绕过错误：assertifassert

1. 括号

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

assert (condition, message)

例：

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

您将运行 with a which 表示元组作为第一个参数，发生这种情况是因为 Python 中的非空元组始终为 True。但是，您可以单独执行操作，而不会出现问题：assert(condition, message)

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. 数据处理或数据验证

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

值 1：

* 断言被禁用;

* 字节码文件是使用 .pyo 扩展名而不是.pyc;

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

* 并且，设置为__debug__False;

值 2：再禁用一项内容

* 文档字符串被禁用;

因此，使用该语句来验证某种预期数据是极其危险的，甚至意味着一些安全问题。然后，如果您需要验证某些权限，我建议您改用。作为前提有效，程序员通常在不让用户直接交互的库或模块上使用 an。assertraise AuthErrorassert

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

我不会重复关于相关的说法 message、括号或 option 和 constants。还要检查 首先，Doc 手部信息。我将重点关注你的问题：有什么用？ 更准确地说，什么时候（什么时候不）应该使用？-O__debug__assertassert

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

在我看来，最有趣的是，使用灵感来自合同编程 由 B. Meyer 在 [Object-Oriented Software Construction]（ https://www.eiffel.org/doc/eiffel/Object-Oriented_Software_Construction%2C_2nd_Edition ） 中描述，并在 [Eiffel 编程语言]（ https://en.wikipedia.org/wiki/Eiffel_（programming_language）） 中实现。你不能完全 使用语句通过合约模拟编程，但它是 有趣的是保持意图。assertassert

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

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

和

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

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

如果列表不为空，则两个函数具有相同的结果和此结果 是正确的：

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

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

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

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

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

这个例子只是关于前提条件，你可以用它来检查 后置条件（返回值和/或状态）和不变量（状态 类）。请注意，检查后置条件和不变量可以是 笨重：assertassert

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

你不会有像埃菲尔铁塔那样复杂的东西，但你可以 提高程序的整体质量。

---

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

在 Pycharm 中，如果您使用 along 来声明对象的类型，它将允许您在编码时访问父对象的方法和属性，它将自动完成。assertisinstance

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

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

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

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

它有一个条件/表达式，它应该始终为真。如果条件为 false，则该语句将停止程序并抛出一条错误消息，指出 。因此，您的断言表达式将是您在程序中不想要的东西。assertAssertionError

例如：

1. assert <condition>-- 使用不带 assert<error message>

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

   输出：

   如果输入为 0 ：

   AssertionError
   

   如果输入为 1 ：

   1
   

2. assert <condition>,<error message>-- 将 assert 与<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 ：

   1
   

要点：

1. 它用作调试工具。
2. 它需要一个表达式和一个可选消息。
3. 它几乎存在于所有编程语言中

assert 是什么意思？它是如何使用的？

这里有很好的答案，但不是问题的第二部分。尽管有多年的实践经验，但我直到最近才明白断言的目的。

其他人已经解释了如何使用，所以我非常简短。这是你如何使用它：assert

assert condition, "error message"

并且不要使用括号，assert 是一个关键字，而不是一个函数。

assert (condition, "error message")  # wrong: this never fails!

这里给出了如何使用断言的一个很好的解释： http://wiki.c2.com/?WhatAreAssertions 的重点是在代码中声明不变量。不变性是除非代码中存在错误，否则不应违反的条件。将它们视为可执行文档。这与面向对象编程封装外部世界的代码的方式密切相关。assert

用简单的英语来说：你应该在代码中使用断言，就像其他开发人员的注释一样。但总比评论好，“评论”其实是在调试模式下检查的！如果删除断言后无法期望程序正常工作，则说明您用错了。事实上，如果你打开优化 （），Python 将忽略所有 s。所以不要依赖他们在那里。特别是，不要使用断言来验证用户输入。请改为引发异常。assertpython -O

这里有一个很好的例子，可以把它们联系在一起。假设您希望在代码中有一个特殊的数字类，它表示称为 的正整数。你为什么要这样？有许多函数使用正整数作为参数。通过在代码中使用，您不必在每个函数中一次又一次地检查输入是否有效。它由 保证。粗略的实现如下所示PositiveIntPositiveIntPositiveInt

class PositiveInt(int):
    # int is immutable, so we have to override new and not init
    def __new__(cls, value):
        if value <= 0:
            raise ValueError(f"{value} is not positive")
        assert value > 0, "value must be positive"
        return super(PositiveInt, cls).__new__(cls, value)   

正如你所看到的，我同时使用一个进行输入验证，并在函数的末尾使用一个。这似乎是多余的，但仅限于这个微不足道的例子！想象一下，该函数更长、更复杂，因此您是否正确验证了输入并不明显。末尾的断言可确保检测到验证代码中的错误。它还使验证代码的意图对其他程序员来说很清楚，而不是简单的注释。if ...: raise ...assert

总而言之：像评论一样使用。随处使用！它很便宜，如果它成为用户的性能问题，您可以在版本中将其关闭。assertpython -O