python断言assert实例

❶ python 如何用 assert() 终止程序

python assert断言是声明布尔值必须为真的判定，如果发生异常就说明表达式为假。
可以理解assert断言语句为raise-if-not，用来测试表示式，其返回值为假，就会触发异常。

参考：网页链接

❷ python 关于assert的用法，以下是完整代码。 求助大家请问一下为什么会报错webDriver 的对象没有 assert

是不是单词写错了？
assertIsNone

❸ 如何解决的Python类型错误

1.Python异常类

Python是面向对象语言，所以程序抛出的异常也是类。常见的Python异常有以下几个，大家只要大致扫一眼，有个映像，等到编程的时候，相信大家肯定会不只一次跟他们照面（除非你不用Python了）。

异常 描述
NameError 尝试访问一个没有申明的变量
ZeroDivisionError 除数为0
SyntaxError 语法错误
IndexError 索引超出序列范围
KeyError 请求一个不存在的字典关键字
IOError 输入输出错误（比如你要读的文件不存在）
AttributeError 尝试访问未知的对象属性
ValueError 传给函数的参数类型不正确，比如给int()函数传入字符串形
2.捕获异常
Python完整的捕获异常的语句有点像：
复制代码 代码如下:

try:
try_suite
except Exception1,Exception2,...,Argument:
exception_suite
...... #other exception block
else:
no_exceptions_detected_suite
finally:
always_execute_suite

额...是不是很复杂？当然，当我们要捕获异常的时候，并不是必须要按照上面那种格式完全写下来，我们可以丢掉else语句，或者finally语句；甚至不要exception语句，而保留finally语句。额，晕了？好吧，下面，我们就来一一说明啦。
2.1.try...except...语句
try_suite不消我说大家也知道，是我们需要进行捕获异常的代码。而except语句是关键，我们try捕获了代码段try_suite里的异常后，将交给except来处理。
try...except语句最简单的形式如下：
复制代码 代码如下:

try:
try_suite
except:
exception block

上面except子句不跟任何异常和异常参数，所以无论try捕获了任何异常，都将交给except子句的exception block来处理。如果我们要处理特定的异常，比如说，我们只想处理除零异常，如果其他异常出现，就让其抛出不做处理，该怎么办呢？这个时候，我们就要给except子句传入异常参数啦！那个ExceptionN就是我们要给except子句的异常类（请参考异常类那个表格），表示如果捕获到这类异常，就交给这个except子句来处理。比如：
复制代码 代码如下:

try:
try_suite
except Exception:
exception block

举个例子：
复制代码 代码如下:

>>> try:
... res = 2/0
... except ZeroDivisionError:
... print "Error:Divisor must not be zero!"
...
Error:Divisor must not be zero!

看，我们真的捕获到了ZeroDivisionError异常！那如果我想捕获并处理多个异常怎么办呢？有两种办法，一种是给一个except子句传入多个异常类参数，另外一种是写多个except子句，每个子句都传入你想要处理的异常类参数。甚至，这两种用法可以混搭呢！下面我就来举个例子。
复制代码 代码如下:

try:
floatnum = float(raw_input("Please input a float:"))
intnum = int(floatnum)
print 100/intnum
except ZeroDivisionError:
print "Error:you must input a float num which is large or equal then 1!"
except ValueError:
print "Error:you must input a float num!"
[root@Cherish tmp]# python test.py
Please input a float:fjia
Error:you must input a float num!
[root@Cherish tmp]# python test.py
Please input a float:0.9999
Error:you must input a float num which is large or equal then 1!
[root@Cherish tmp]# python test.py
Please input a float:25.091
4

上面的例子大家一看都懂，就不再解释了。只要大家明白，我们的except可以处理一种异常，多种异常，甚至所有异常就可以了。
大家可能注意到了，我们还没解释except子句后面那个Argument是什么东西？别着急，听我一一道来。这个Argument其实是一个异常类的实例（别告诉我你不知到什么是实例），包含了来自异常代码的诊断信息。也就是说，如果你捕获了一个异常，你就可以通过这个异常类的实例来获取更多的关于这个异常的信息。例如：
复制代码 代码如下:

>>> try:
... 1/0
... except ZeroDivisionError,reason:
... pass
...
>>> type(reason)
<type 'exceptions.ZeroDivisionError'>
>>> print reason
integer division or molo by zero
>>> reason
ZeroDivisionError('integer division or molo by zero',)
>>> reason.__class__
<type 'exceptions.ZeroDivisionError'>
>>> reason.__class__.__doc__
'Second argument to a division or molo operation was zero.'
>>> reason.__class__.__name__
'ZeroDivisionError'

上面这个例子，我们捕获了除零异常，但是什么都没做。那个reason就是异常类ZeroDivisionError的实例，通过type就可以看出。
2.2try ... except...else语句
现在我们来说说这个else语句。Python中有很多特殊的else用法，比如用于条件和循环。放到try语句中，其作用其实也差不多：就是当没有检测到异常的时候，则执行else语句。举个例子大家可能更明白些：
复制代码 代码如下:

>>> import syslog
>>> try:
... f = open("/root/test.py")
... except IOError,e:
... syslog.syslog(syslog.LOG_ERR,"%s"%e)
... else:
... syslog.syslog(syslog.LOG_INFO,"no exception caught\n")
...
>>> f.close()

2.3 finally子句
finally子句是无论是否检测到异常，都会执行的一段代码。我们可以丢掉except子句和else子句，单独使用try...finally，也可以配合except等使用。
例如2.2的例子，如果出现其他异常，无法捕获，程序异常退出，那么文件 f 就没有被正常关闭。这不是我们所希望看到的结果，但是如果我们把f.close语句放到finally语句中，无论是否有异常，都会正常关闭这个文件，岂不是很 妙
复制代码 代码如下:

>>> import syslog
>>> try:
... f = open("/root/test.py")
... except IOError,e:
... syslog.syslog(syslog.LOG_ERR,"%s"%e)
... else:
... syslog.syslog(syslog.LOG_INFO,"no exception caught\n")
... finally:
>>> f.close()

大家看到了没，我们上面那个例子竟然用到了try,except,else,finally这四个子句！:-)，是不是很有趣？到现在，你就基本上已经学会了如何在Python中捕获常规异常并处理之。
3.两个特殊的处理异常的简便方法
3.1断言（assert）
什么是断言，先看语法：
复制代码 代码如下:

assert expression[,reason]

其中assert是断言的关键字。执行该语句的时候，先判断表达式expression，如果表达式为真，则什么都不做；如果表达式不为真，则抛出异常。reason跟我们之前谈到的异常类的实例一样。不懂？没关系，举例子！最实在！
复制代码 代码如下:

>>> assert len('love') == len('like')
>>> assert 1==1
>>> assert 1==2,"1 is not equal 2!"
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
AssertionError: 1 is not equal 2!

我们可以看到，如果assert后面的表达式为真，则什么都不做，如果不为真，就会抛出AssertionErro异常，而且我们传进去的字符串会作为异常类的实例的具体信息存在。其实，assert异常也可以被try块捕获：
复制代码 代码如下:

>>> try:
... assert 1 == 2 , "1 is not equal 2!"
... except AssertionError,reason:
... print "%s:%s"%(reason.__class__.__name__,reason)
...
AssertionError:1 is not equal 2!
>>> type(reason)
<type 'exceptions.AssertionError'>

3.2.上下文管理（with语句）
如果你使用try,except,finally代码仅仅是为了保证共享资源（如文件，数据）的唯一分配，并在任务结束后释放它，那么你就有福了！这个with语句可以让你从try,except,finally中解放出来！语法如下：
复制代码 代码如下:

with context_expr [as var]:
with_suite

是不是不明白？很正常，举个例子来！
复制代码 代码如下:

>>> with open('/root/test.py') as f:
... for line in f:
... print line

上面这几行代码干了什么？
（1）打开文件/root/test.py
（2）将文件对象赋值给 f
（3）将文件所有行输出
（4）无论代码中是否出现异常，Python都会为我们关闭这个文件，我们不需要关心这些细节。
这下，是不是明白了，使用with语句来使用这些共享资源，我们不用担心会因为某种原因而没有释放他。但并不是所有的对象都可以使用with语句，只有支持上下文管理协议（context management protocol）的对象才可以，那哪些对象支持该协议呢？如下表：
file
decimal.Context
thread.LockType
threading.Lock
threading.RLock
threading.Condition
threading.Semaphore
threading.BoundedSemaphore
至于什么是上下文管理协议，如果你不只关心怎么用with,以及哪些对象可以使用with，那么我们就不比太关心这个问题：）
4.抛出异常(raise)
如果我们想要在自己编写的程序中主动抛出异常，该怎么办呢？raise语句可以帮助我们达到目的。其基本语法如下：
复制代码 代码如下:

raise [SomeException [, args [,traceback]]

第一个参数，SomeException必须是一个异常类，或异常类的实例
第二个参数是传递给SomeException的参数，必须是一个元组。这个参数用来传递关于这个异常的有用信息。
第三个参数traceback很少用，主要是用来提供一个跟中记录对象（traceback）
下面我们就来举几个例子。
复制代码 代码如下:

>>> raise NameError
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError
>>> raise NameError() #异常类的实例
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError
>>> raise NameError,("There is a name error","in test.py")
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
>>> raise NameError("There is a name error","in test.py") #注意跟上面一个例子的区别
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError: ('There is a name error', 'in test.py')
>>> raise NameError,NameError("There is a name error","in test.py") #注意跟上面一个例子的区别
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError: ('There is a name error', 'in test.py')

其实，我们最常用的还是，只传入第一个参数用来指出异常类型，最多再传入一个元组，用来给出说明信息。如上面第三个例子。
5.异常和sys模块
另一种获取异常信息的途径是通过sys模块中的exc_info()函数。该函数回返回一个三元组:(异常类，异常类的实例，跟中记录对象)
复制代码 代码如下:

>>> try:
... 1/0
... except:
... import sys
... tuple = sys.exc_info()
...
>>> print tuple
(<type 'exceptions.ZeroDivisionError'>, ZeroDivisionError('integer division or molo by zero',), <traceback object at 0x7f538a318b48>)
>>> for i in tuple:
... print i
...
<type 'exceptions.ZeroDivisionError'> #异常类
integer division or molo by zero #异常类的实例
<traceback object at 0x7f538a318b48> #跟踪记录对象

❹ python常用的断言方式有哪些

（一）assertEqual 和 assertNotEqual
assertEqual：如两个值相等，则pass
assertNotEqual：如两个值不相等，则pass
下面看下具体使用方法
self.driver.find_element_by_xpath("//android.widget.LinearLayout[1]/android.support.v7.app.ActionBar.e[2]").click()#切到超模25tab
sleep(3)
self.assertEqual(self.driver.find_element_by_id('com.boohee.secret:id/tv_title').text,u'超模25','切到超模25tab失败')
（1）这边是通过id（com.boohee.secret:id/tv_title）获取它的text值，与预期“超模25”对比，如相等则pass；不相等则fail。
（2）后面的“切到超模25tab失败”是fail时需要打印的信息，可写可不写。
断言assertNotEqual反着用就可以了。
（二）assertTrue和assertFalse
assertTrue：判断bool值为True，则pass
assertFalse：判断bool值为False，则Pass
下面看下具体使用方法
self.driver.find_element_by_xpath("//android.widget.LinearLayout[1]/android.widget.TextView[1]").click()#点击登录入口
sleep(2)
self.driver.find_element_by_xpath("//android.widget.LinearLayout[1]/android.widget.EditText[1]").send_keys("testq1")#输入用户名
sleep(2)
self.assertTrue(self.find_element_by_id('com.boohee.secret:id/btn_login').is_enabled(),'未输密码登录按钮为不可点状态,Fail')
（1）这边是通过id（com.boohee.secret:id/btn_login）获取它的激活状态，如为True则pass；反之则fail。
（2）后面的“未输密码登录按钮为不可点状态”是fail时需要打印的信息，可写可不写。
断言assertFalse反着用就可以了。
（三）assertIsNone和assertIsNotNone
assertIsNone：不存在，则pass
assertIsNotNone：存在，则pass
下面看下具体使用方法
self.driver.find_element_by_xpath("//android.widget.LinearLayout[1]/android.widget.TextView[1]").click()#点击登录入口
sleep(2)
self.driver.find_element_by_xpath("//android.widget.LinearLayout[1]/android.widget.EditText[1]").send_keys("testq1")#输入用户名
sleep(2)
self.driver.find_element_by_xpath("//android.widget.LinearLayout[2]/android.widget.EditText[1]").send_keys("boohee")#输入密码
sleep(2)
self.driver.find_element_by_xpath("//android.widget.LinearLayout[1]/android.widget.Button[1]").click()#点击登录按钮
sleep(10)
self.assertIsNotNone(self.driver.find_element_by_id('com.boohee.secret:id/tv_edit_profile'),'无编辑资料按钮,登录失败,Fail')
（1）这边是通过寻找id（com.boohee.secret:id/tv_edit_profile）的元素是否存在，如存在则pass；不存在则fail。
（2）后面的“无编辑资料按钮,登录失败,Fail”是fail时需要打印的信息，可写可不写。
断言assertIsNone反着用就可以了。

❺ pthon 中获取数据库中的值用于断言中时报错，该怎么解决,具体信息如下：

这个问题是如何在一些场景下使用断言表达式，通常会有人误用它，所以我决定写一篇文章来说明何时使用断言，什么时候不用。

为那些还不清楚它的人，Python的assert是用来检查一个条件，如果它为真，就不做任何事。如果它为假，则会抛出AssertError并且包含错误信息。例如：

py> x = 23
py> assert x > 0, "x is not zero or negative"
py> assert x%2 == 0, "x is not an even number"
Traceback (most recent call last):
File "", line 1, in
AssertionError: x is not an even number

很多人用assert作为一个很快和容易的方法来在参数错误的时候抛出异常。但这样做是错的，非常错误，有两个原因。首先AssertError不是在测试参数时应该抛出的错误。你不应该像这样写代码：

if not isinstance(x, int):
raise AssertionError("not an int")

你应该抛出TypeError的错误，assert会抛出错误的异常。

但是，更危险的是，有一个关于assert的困扰：它可以被编译好然后从来不执行，如果你用 –O 或 –oo
选项运行Python，结果不保证assert表达式会运行到。当适当的使用assert时，这是未来，但是当assert不恰当的使用时，它会让代码用
-O执行时出错。

那什么时候应该使用assert？没有特定的规则，断言应该用于：

防御型的编程
运行时检查程序逻辑
检查约定
程序常量
检查文档

（在测试代码的时候使用断言也是可接受的，是一种很方便的单元测试方法，你接受这些测试在用-O标志运行时不会做任何事。我有时在代码里使用
assert False来标记没有写完的代码分支，我希望这些代码运行失败。尽管抛出NotImplementedError可能会更好。）

关于断言的意见有很多，因为它能确保代码的正确性。如果你确定代码是正确的，那么就没有用断言的必要了，因为他们从来不会运行失败，你可以直接移除这些断言。如果你确定检查会失败，那么如果你不用断言，代码就会通过编译并忽略你的检查。

在以上两种情况下会很有意思，当你比较肯定代码但是不是绝对肯定时。可能你会错过一些非常古怪的情况。在这个情况下，额外的运行时检查能帮你确保任何错误都会尽早地被捕捉到。

另一个好的使用断言的方式是检查程序的不变量。一个不变量是一些你需要依赖它为真的情况，除非一个bug导致它为假。如果有bug，最好能够尽早发现，所以我们为它进行一个测试，但是又不想减慢代码运行速度。所以就用断言，因为它能在开发时打开，在产品阶段关闭。

一个非变量的例子可能是，如果你的函数希望在它开始时有数据库的连接，并且承诺在它返回的时候仍然保持连接，这就是函数的不变量：

Python

def some_function(arg):
assert not DB.closed()
... # code goes here
assert not DB.closed()
return result

断言本身就是很好的注释，胜过你直接写注释：

# when we reach here, we know that n > 2

你可以通过添加断言来确保它：

assert n > 2

断言也是一种防御型编程。你不是让你的代码防御现在的错误，而是防止在代码修改后引发的错误。理想情况下，单元测试可以完成这样的工作，可是需要面
对的现实是，它们通常是没有完成的。人们可能在提交代码前会忘了运行测试代码。有一个内部检查是另一个阻挡错误的防线，尤其是那些不明显的错误，却导致了
代码出问题并且返回错误的结果。

加入你有一些if…elif 的语句块，你知道在这之前一些需要有一些值：

# target is expected to be one of x, y, or z, and nothing else.
if target == x:
run_x_code()
elif target == y:
run_y_code()
else:
run_z_code()

假设代码现在是完全正确的。但它会一直是正确的吗？依赖的修改，代码的修改。如果依赖修改成 target = w
会发生什么，会关系到run_w_code函数吗？如果我们改变了代码，但没有修改这里的代码，可能会导致错误的调用 run_z_code
函数并引发错误。用防御型的方法来写代码会很好，它能让代码运行正确，或者立马执行错误，即使你在未来对它进行了修改。

在代码开头的注释很好的一步，但是人们经常懒得读或者更新注释。一旦发生这种情况，注释会变得没用。但有了断言，我可以同时对代码块的假设书写文档，并且在它们违反的时候触发一个干净的错误

assert target in (x, y, z)
if target == x:
run_x_code()
elif target == y:
run_y_code()
else:
assert target == z
run_z_code()

这样，断言是一种防御型编程，同时也是一种文档。我想到一个更好的方案：

if target == x:
run_x_code()
elif target == y:
run_y_code()
elif target == z:
run_z_code()
else:
# This can never happen. But just in case it does...
raise RuntimeError("an unexpected error occurred")

按约定进行设计是断言的另一个好的用途。我们想象函数与调用者之间有个约定，比如下面的：

“如果你传给我一个非空字符串，我保证传会字符串的第一个字母并将其大写。”

如果约定被函数或调用这破坏，代码就会出问题。我们说函数有一些前置条件和后置条件，所以函数就会这么写：

def first_upper(astring):
assert isinstance(astring, str) and len(astring) > 0
result = astring[0].upper()
assert isinstance(result, str) and len(result) == 1
assert result == result.upper()
return result

按约定设计的目标是为了正确的编程，前置条件和后置条件是需要保持的。这是断言的典型应用场景，因为一旦我们发布了没有问题的代码到产品中，程序会是正确的，并且我们能安全的移除检查。

下面是建议的不要用断言的场景：

不要用它测试用户提供的数据
不要用断言来检查你觉得在你的程序的常规使用时会出错的地方。断言是用来检查非常罕见的问题。你的用户不应该看到任何断言错误，如果他们看到了，这是一个bug，修复它。
有的情况下，不用断言是因为它比精确的检查要短，它不应该是懒码农的偷懒方式。
不要用它来检查对公共库的输入参数，因为它不能控制调用者，所以不能保证调用者会不会打破双方的约定。
不要为你觉得可以恢复的错误用断言。换句话说，不用改在产品代码里捕捉到断言错误。
不要用太多断言以至于让代码很晦涩。

❻ selenium python 断言怎么写

断言就是判断是否跟预期结果一致，不一致的话，测试用例直接失败，程序便不再执行下去。

举个简单的例子。比如点击某个按钮会跳转到某个页面上，我们会设置断言为是否能成功跳转到这个页面上，验证的话，一般为这个页面的信息。如果都不跳转成功，那么页面信息就什么没有，那么验证也无从入手。

断言使用的主要是assertEqual的方法

如验证网络搜索的标题是否为“123_网络搜索”

self.assertEqual(u"123_网络搜索"，driver.title)
如要验证是否为false

self.assertFalse(driver.title)
如要验证是否为true

self.assertTrue(driver.title)
而验证为了保证失败也能正常运行下去，一般情况下都是在验证的基础上加异常捕获

如验证网络搜索的标题是否为“123_网络搜索”

try:
self.assertEqual(u"1234_网络搜索", driver.title)
except AssertionError as e:
print u"找不到这个标题"

❼ appium+python 断言和输出

其实就是检查页面某一固定的元素是否存在。可以用assert断言，当然也可以自己写if语句进行判断。assert用得比较多，举例说明：例如，登录成功后的界面，某个固定控件包含字符串“aaa”，找到，则证明登录成功。assertEqual('aaa',driver.find_elements_by_class_name("android.widget.EditText").text)assertEqual()只是其中一个方法。断言的用法还有很多，感兴趣可以网络一下。

❽ python的assert怎么用

1、assert断言用来声明某个条件是真的。
2、如果你非常确信某个你使用的列表中至少有一个元素，而你想要检验这一点，并且在它非真的时候引发一个错误，那么assert语句是应用在这种情形下的理想语句
3、当assert语句失败的时候，会引发一AssertionError

测试代码：
>>> mylist = ['item']
>>> assert len(mylist) >= 1
>>> mylist.pop()
'item'
>>> assert len(mylist) >= 1
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
AssertionError
>>>