CrazyWing：Python自动化运维开发实战十7、Python异常

时间 2019-11-07

标签 crazywing python 自动化开发实战异常栏目 Python 繁體版

原文原文链接

导语：

在写代码的时候，常常会遇到异常。
python提供了两个功能来处理程序在运行中出现的异常和错误,可使用该功能来调试python程序。 python

异常处理
断言(Assertions)

经常使用异常：

Exception  它能够捕获任意(绝大部分)异常。
AttributeError 试图访问一个对象没有的树形，好比foo.x，可是foo没有属性x
IOError 输入/输出异常；基本上是没法打开文件 
ImportError 没法引入模块或包；基本上是路径问题或名称错误 
IndentationError 语法错误（的子类）,代码没有正确对齐 
IndexError 下标索引超出序列边界，好比当x只有三个元素，却试图访问x[5]
KeyError 试图访问字典里不存在的键 
KeyboardInterrupt Ctrl+C被按下 
NameError 使用一个还未被赋予对象的变量 
SyntaxError Python代码非法，代码不能编译(我的认为这是语法错误，写错了） 
TypeError 传入对象类型与要求的不符合 
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是因为另有一个同名的全局变量，致使你觉得正在访问它 
ValueError 传入一个调用者不指望的值，即便值的类型是正确的

python标准异常：

什么是异常？

异常便是一个事件，该事件会在程序执行过程当中发生，影响程序的正常执行。
通常状况下，在Python没法正常处理程序时就会发生一个异常,异常是Python对象，表示一
个错误。数据库

当Python脚本发生异常时咱们须要捕获处理它，不然程序会终止执行。 express

#!/usr/bin/env python
try:
    print "%d" % (5 / 0)
except ZeroDivisionError:
    print "除数不能为零"
else:
    print "没有报错"
print "这是异常以后的代码"  #若是没有上面的异常处理，下面的代码是不会执行的
for i in range(10):
    print i

捕捉异常:

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。 
若是你不想在异常发生时结束你的程序，只需在try里捕获它。 
语法： 
    try:
        <语句>                #运行别的代码
    except <名字>：
        <语句>                #若是在try部份引起了'name'异常
    except <名字>，<数据>:
        <语句>                #若是引起了'name'异常，得到附加的数据
    else:
        <语句>                #若是没有异常发生

try的工做原理

当开始一个try语句后，python就在当前程序的上下文中做标记，这样当异常出现时就可
以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。编程

1. 若是当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的
except子句，异常处理完毕，控制流就经过整个try语句（除非在处理异常时又引起新的异
常）。
2. 若是在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的
try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。
3. 若是在try子句执行时没有发生异常，python将执行else语句后的语句（若是有else的
话），而后控制流经过整个try语句。

例安全

打开一个文件，在该文件中的写入内容，且并未发生异常：
    try:
        fh = open("testfile", "w")
        fh.write("这是一个测试文件，用于测试异常!!")
    except IOError:
        print "Error: 没有找到文件或读取文件失败"
    else:
        print "内容写入文件成功"
        fh.close()

结果：
    # python test.py 
        内容写入文件成功
    # cat testfile       # 查看写入的内容
        这是一个测试文件，用于测试异常!! 

例
打开一个文件，在该文件中的内容写入内容，但文件没有写入权限，发生了异常：
    try:
        fh = open("testfile", "w")    
        fh.write("这是一个测试文件，用于测试异常!!")
    except IOError:
        print "Error: 没有找到文件或读取文件失败"
    else:
        print "内容写入文件成功"
        fh.close() 

在执行代码前为了测试方便，先去掉 testfile 文件的写权限
再执行以上代码：
    $ python test.py                                #注意这里用的是普通用户
    Error: 没有找到文件或读取文件失败

使用except不带任何异常类型

你能够不带任何异常类型使用except，以下实例：app

try:
        正常的操做
        ......................
     except:
        发生异常，执行这块代码
        ......................
     else:
        若是没有异常执行这块代码

以上方式try-except语句捕获全部发生的异常。但这不是一个很好的方式，咱们不能经过该程序
识别出具体的异常信息。由于它捕获全部的异常。运维

使用except带多种异常类型

也可使用相同的except语句来处理多个异常信息： ide

try:
        正常的操做
        ................
    except(Exception1[, Exception2[,...ExceptionN]]]):
       发生以上多个异常中的一个，执行这块代码
       ......................
    else:
        若是没有异常执行这块代码

try-finally 语句

try-finally 语句不管是否发生异常都将执行最后的代码。函数

try:
        <语句>
    finally:
        <语句>    #退出try时总会执行

例1:单元测试

try:
        fh = open("testfile", "w")
        fh.write("这是一个测试文件，用于测试异常!!")
    finally:
        print "Error: 没有找到文件或读取文件失败"

例2：

import  time    
try:
    f=file("文件.py")    
    while True:
        line = f.read()
        if len(line)==0:
            break
        time.sleep(2)
        print line,
finally:
    f.close()
    print "hello"

例3:

try:
        fh = open("testfile", "w")
        try:
            fh.write("这是一个测试文件，用于测试异常!!")
        finally:
            print "关闭文件"
            fh.close()
    except IOError:
        print "Error: 没有找到文件或读取文件失败"

异常的参数:

一个异常能够带上参数，可做为输出的异常信息参数。
你能够经过except语句来捕获异常的参数，以下所示：

try:
        正常的操做
        ......................
     except ExceptionType, Argument:
        你能够在这输出 Argument 的值...

变量接收的异常值一般包含在异常的语句中。在元组的表单中变量能够接收一个或者多个
值。
元组一般包含错误字符串，错误数字，错误位置。

例
如下为单个异常的实例：

#!/usr/bin/python
    def temp_convert(var):
        try:
            return int(var)
        except ValueError, Argument:
            print "参数没  有包含数字\n", Argument

    # 调用函数
    temp_convert("xyz")

以上程序执行结果以下：
    $ python test.py 
        参数没有包含数字
        invalid literal for int() with base 10: 'xyz'

触发异常

可使用raise语句本身触发异常
raise语法格式：

raise [Exception [, args [, traceback]]]

语句中Exception是异常的类型（例如，NameError）参数是一个异常参数值。该参数是可
选的，若是不提供，异常的参数是"None"。
最后一个参数是可选的（在实践中不多使用），若是存在，是跟踪异常对象。

例
一个异常能够是一个字符串，类或对象。 Python的内核提供的异常，大多数都是实例化的
类，这是一个类的实例的参数。
定义一个异常：

def functionName( level ):
    if level < 1:
        raise Exception("Invalid level!", level)
        # 触发异常后，后面的代码就不会再执行

注意：为了可以捕获异常，"except"语句必须有用相同的异常来抛出类对象或者字符串。
例如咱们捕获以上异常，"except"语句以下：

try:
        正常逻辑
    except "Invalid level!":
        触发自定义异常    
    else:
        其他代码

例

#!/usr/bin/python
    def mye( level ):
        if level < 1:
            raise Exception("Invalid level!", level)
            # 触发异常后，后面的代码就不会再执行
    try:
        mye(0)                # 触发异常
    except "Invalid level!":
        print 1
    else:
        print 2

输出结果：
    $ python test.py 
    Traceback (most recent call last):
      File "test.py", line 11, in <module>
        mye(0)
      File "test.py", line 7, in mye
        raise Exception("Invalid level!", level)
    Exception: ('Invalid level!', 0)

用户自定义异常:

经过建立一个新的异常类，程序能够命名它们本身的异常。异常应该是典型的继承自
Exception类，经过直接或间接的方式。
如下为与RuntimeError相关的实例,实例中建立了一个类，基类为RuntimeError，用于在
异常触发时输出更多的信息。
在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于建立Networkerror
类的实例。

class Networkerror(RuntimeError):
        def __init__(self, arg):
            self.args = arg
    在你定义以上类后，你能够触发该异常，以下所示：
    try:
        raise Networkerror("Bad hostname")
    except Networkerror,e:
        print e.args

万能异常

在python的异常中，有一个万能异常：Exception，它能够捕获任意异常。
例：

#cat  aa.py
    s1 = 'hello'
    try:
        int(s1)
    except Exception,e:
        print e

执行结果：  
    #python aa.py 
    invalid literal for int() with base 10: 'hello'

既然有这个万能异常，其余异常是否是就能够忽略了?固然不是，对于特殊处理或提醒的异常须要先定义，最后定义Exception来确保程序正常运行。
例：

s1 = 'hello'
    try:
        int(s1)
    except KeyError,e:
        print '键错误'
    except IndexError,e:
        print '索引错误'
    except Exception, e:
        print '错误'

======================================

assert断言

使用assert断言是学习python一个很是好的习惯，assert断言句语格式及用法很简单。在没完善一个程序以前，咱们不知道程序在哪里会出错，与其让它在运行最崩溃，不如在出现错误条件时就崩溃，这时候就须要assert断言的帮助。

assert断言的做用

assert断言是声明其布尔值必须为真的断定，若是发生异常就说明表达示为假。能够理解assert断言语句为raise-if-not，用来测试表示式，其返回值为假，就会触发异常。
assert断言语句的语法格式
assert expression

一些assert用法的语句供参考：

assert 1==1
assert 2+2==2*2
assert len(['my boy',12])<10
assert range(4)==[0,1,2,3]

如何为assert断言语句添加异常参数

assert的异常参数，其实就是在断言表达式后添加字符串信息，用来解释断言并更好的知道是哪里出了问题。格式以下：

assert expression [, arguments]

什么时候使用断言

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，最好可以尽早发现，因此咱们为它进行一个测试，可是又不想减慢代码运行速度。因此就用断言，由于它能在开发时打开，在产品阶段关闭。

一个非变量的例子多是，若是你的函数但愿在它开始时有数据库的链接，而且承诺在它返回的时候仍然保持链接，这就是函数的不变量：

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，修复它。
有的状况下，不用断言是由于它比精确的检查要短，它不该该是懒码农的偷懒方式。
不要用它来检查对公共库的输入参数，由于它不能控制调用者，因此不能保证调用者会不会打破双方的约定。
不要为你以为能够恢复的错误用断言。换句话说，不用改在产品代码里捕捉到断言错误。
不要用太多断言以致于让代码很晦涩。

CrazyWing：Python自动化运维开发实战 十7、Python异常

导语：