格式: 断言表达式(参数) 当assert遇到语句时，Python对表达式求值。如果语句不为真，则引发异常(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!    

assert语句有两种形式。

简单形式assert <expression>相当于

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

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

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

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

我就不重复刚才说的相关内容了 message，括号，或-O选项和__debug__常量。同时查看 首先是医生 手的信息。我将集中讨论你的问题:assert有什么用? 更准确地说，什么时候(什么时候不)应该使用assert?

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

在我看来，assert最有趣的用法是受到 通过合同编程 由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函数(如 [Haskell中的头部功能]( http://www.zvon.org/other/haskell/Outputprelude/head_f.html))。的 给出的规范是:“如果列表不为空，则返回 清单的第一项”。看看下面的实现:

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

And

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

But:

>>> head2([]) is None
True

同样，这两种实现都是正确的，因为不应该传递空值 列出这些函数(我们不在规范范围内)。这是一个 不正确的判断，但如果你做了这样的判断，任何事情都有可能发生。 一个函数引发异常，另一个函数返回一个特殊值。 最重要的是:我们不能依赖这种行为。如果xs是空的， 这是可行的:

print(head2(xs))

但是这会使程序崩溃:

print(head1(xs))

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

想象一下，如果我有一种方法将规范插入到代码中以获得 以下效果:当我违反规范，例如通过传递一个空 清单上的人头，我会收到警告。写正确的答案会有很大的帮助 (即符合规范)程序。这就是assert的地方 进入现场:

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

And

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

And:

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

注意，head1抛出AssertionError，而不是IndexError。这是 因为AssertionError不是任何运行时错误:它标志着一个 违反规范。我想要一个警告，但是我得到了一个错误。 幸运的是，我可以禁用检查(使用-O选项)， 但风险由我自己承担。我将会做一个坠毁真的很贵，并希望 最好的想象一下，我的程序被嵌入到一艘宇宙飞船中，它穿越 黑洞。我将禁用断言，并希望程序足够健壮 尽量不要崩溃。

这个例子只是关于前提条件的，你可以使用assert来检查 后置条件(返回值和/或状态)和不变量(对象的状态) 类)。注意，使用assert检查后置条件和不变量可以 麻烦:

对于后置条件，您需要将返回值赋给一个变量，以及 也许是用来存储对象的初始状态如果你在处理一个方法; 对于不变量，必须在方法调用之前和之后检查状态。

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

---

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

assert语句几乎存在于每一种编程语言中。它有助于在程序的早期(原因很清楚的时候)检测问题，而不是在稍后作为其他操作的副作用检测问题。他们总是期待一个真实的条件。

当你这样做的时候:

assert condition

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

在Python中，assert表达式等价于:

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?

你将使用(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:

* assert被禁用;

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

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

*和，__debug__被设置为False;

值2:禁用一个东西

*文档字符串被禁用;

因此，使用assert语句来验证一种预期的数据是极其危险的，甚至意味着存在一些安全问题。然后，如果你需要验证一些权限，我建议你提出AuthError代替。作为有效的前置条件，assert通常由程序员在不与用户直接交互的库或模块上使用。

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

语法:assert <条件>或assert <条件>，<错误消息>

它有一个条件/表达式，它应该总是为真。如果条件为false, assert语句将停止程序并抛出AssertionError错误消息。你的断言表达式将是你不希望在程序中出现的东西。

e.g.

Assert <条件>——使用Assert而没有<错误消息> var = int(输入("输入值1-9包含:")) 断言var != 0 打印(var) 输出: 如果输入为0: AssertionError 如果输入为1: 1 断言<条件>，<错误消息>——使用带有<错误消息>的断言 var = int(输入("输入值1-9包含:")) 断言var !=0，"输入不能为零" 打印(var) 输出: 如果输入为0: AssertionError:输入不能为零 如果输入为1: 1

重点:

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

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

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