Python 异常

1. 异常的捕获

2. 异常的传递

3. 自定义异常

4. 异常中抛出异常

 

 

1. 异常的捕获

什么是异常？

当 Python 检测到一个错误时，解释器就无法继续执行了，并且会出现一些错误的提示，这就是所谓的"异常"。

基本语法：

try:
    # 可能产生异常的代码，放在try中
except IOError:  # 需要捕获的异常类型，如IOError
    # 产生异常时的处理方法

示例：捕获多种类型的异常

try:
    print('-----test--1---')
    open('123.txt', 'r') # 如果 123.txt 文件不存在，那么会产生 IOError 异常
    print('-----test--2---')
    print(num)  # 如果num变量没有定义，那么会产生 NameError 异常

# 如果想通过一次except捕获到多个异常可以用一个元组的方式
except (IOError, NameError) as errorMsg:
    # errorMsg 里会保存捕获到的错误信息
    print(errorMsg)

示例：捕获所有类型的异常

try:
    print('-----test--1---')
    open('123.txt', 'w') # 如果 123.txt 文件不存在，那么会产生 IOError 异常
    print('-----test--2---')
    print(num)  # 如果num变量没有定义，那么会产生 NameError 异常

# 捕获所有类型的异常并打印错误信息
except Exception as errorMsg:
# 若不需要打印具体错误信息则可仅使用except:

    # errorMsg 里会保存捕获到的错误信息
    print(errorMsg)

else

在 if 中，它的作用是当条件不满足时执行。

同样在 try...except... 中也是如此，即如果没有捕获到异常，那么就执行 else 中的事情。

try:
    num = 100
    print num
except NameError as errorMsg:
    print('产生错误了:%s' % errorMsg)
else:
    print('没有捕获到异常')

finally

try...finally... 语句用来表达这样的情况：

在程序中，如果有一段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用 finally，比如文件关闭，释放锁，把数据库连接返还给连接池等。

注意：

• 其实不加finally也不影响程序逻辑，其意义是可读性和完整性。
• 如果try块中执行到return时并不会直接返回结果，而是先去执行finally块，再返回先前的值，除非finally中有return，finally中的return会破坏程序的完整性且抑制方法产生的异常，不要使用。

示例：

try:
    f = open("test.txt")
    try:
        while 1:
            content = f.readline()
            if len(content) == 0:
                break
            print(content)
    except:
        pass
    finally:
        f.close()
        print("关闭文件")
except:
    print("没有这个文件")

获取具体的错误代码行及错误信息

import traceback

exception_info = ""
print("start: ")
try:
    print(1/0)  # 注释
except:
    traceback.print_exc()  # 将具体的错误代码行及错误信息打印到屏幕
    exception_info = traceback.format_exc()  #  将具体的错误代码行及错误信息存储到变量中
print("end: ")
print(exception_info)

执行结果：

start:
Traceback (most recent call last):
  File "code.txt", line 6, in <module>
    print(1/0)  # 注释
ZeroDivisionError: division by zero
end:
Traceback (most recent call last):
  File "code.txt", line 6, in <module>
    print(1/0)  # 注释
ZeroDivisionError: division by zero

 

2. 异常的传递

try 嵌套

在 try 嵌套中，如果里层的 try 没有捕获到这个异常，那么外层的 try 会接收到这个异常，然后进行处理，如果外层的 try 依然没有捕获到，那么再进行传递给外外层，以此类推。

try:
    f = open("test.txt")
    try:
        while 1:
            content = f.readline()
            if len(content) == 0:
                break
            print("文件内容为：{}".format(content))
            num
    finally:
        f.close()
        print("关闭文件")
except:
    print("没有这个文件")
finally:
    print("外层的finally")

执行结果：

文件内容为：Hello world.
关闭文件
没有这个文件
外层的finally

函数嵌套调用

• 如果一个异常是在一个函数中产生的，例如函数A调用函数B，函数B调用函数C，而异常是在函数C中产生的，那么如果函数C中没有对这个异常进行处理，那么这个异常会传递到函数B中，如果函数B有异常处理那么就会按照函数B的处理方式进行执行，如果函数B也没有异常处理，那么这个异常会继续传递，以此类推。如果所有的函数都没有处理，那么此时就会进行异常的默认处理，即报错。
• 注意观察以下结果，当调用test3函数时，在test1函数内部产生了异常，此异常被传递到test3函数中完成了异常处理，而当异常处理完后，并没有返回到函数test1中进行执行，而是在函数test3中继续执行。

def test1():
    print("1-1")
    print(num)
    print("1-2")
    
    
# 内部调用函数1，无异常处理机制
def test2():
    print("2-1")
    test1()
    print("2-2")
    
# 内部调用函数1，有异常处理机制
def test3():
    try:
        print("3-1")
        test1()
        print("3-2")
    except Exception as msg:
        print("捕获到了异常，内容为：{}".format(msg))
    print("3-3")
    
    
    
test3()
print("-----分割线-----")
test2()

执行结果：

3-1
1-1
捕获到了异常，内容为：name 'num' is not defined
3-3
-----分割线-----
2-1
1-1
Traceback (most recent call last):
  File "test.py", line 27, in <module>
    test2()
  File "test.py", line 10, in test2
    test1()
  File "test.py", line 3, in test1
    print(num)
NameError: name 'num' is not defined

 

3. 自定义异常

 可以用raise语句来引发一个自定义的异常。异常/错误对象必须有一个名字，且它们应该是Error或Exception类的子类。

示例：引发自定义异常

class ShortInputException(Exception):
    "自定义异常类"

    def __init__(self, length, atlease):
        super().__init__()
        self.length = length
        self.atlease = atlease
        

def main():
    try:
        s = input("请输入：")
        if len(s) < 3:
            # 引发一个自定义异常
            raise ShortInputException(len(s), 3)
    # result这个变量被绑定到了错误的实例
    except ShortInputException as result:
        print("ShortInputException：输入的长度是%d，至少应是%d" % (result.length, result.atlease))
    else:
        print("没有异常")
        

main()

执行结果：

请输入：ab
ShortInputException：输入的长度是2，至少应是3

以上程序中，关于代码 super().__init__() 的说明：

• 这一行代码，可以调用也可以不调用，建议调用，因为__init__()方法往往是用来对创建完的对象进行初始化工作，如果在子类中重写了父类的__init__()方法，意味着父类中的很多初始化工作没有做，这样就不能保证程序的稳定性。
• 所以在以后的开发中，如果重写了父类的__init__()方法，最好是先调用父类的这个方法，然后再添加自己的功能。

 

4. 异常中抛出异常

class Test:

    def __init__(self, switch):
        self.switch = switch  # 是否捕获异常的开关
        
    def calculate(self, a, b):
        try:
            return a / b
        except Exception as result:
            # 如果捕获异常的开关为开，则打印捕获信息
            if self.switch:
                print(result)
            # 否则，抛出异常（抛给外层异常处理机制）
            else:
                raise
                

t1 = Test(1)  # 打开开关
t1.calculate(1, 0)  
print("-------分割线--------")
t2 = Test(0)  # 关闭开关
t2.calculate(1, 0)

执行结果：

division by zero
-------分割线--------
Traceback (most recent call last):
  File "test.py", line 22, in <module>
    t2.calculate(1, 0)
  File "test.py", line 8, in calculate
    return a / b
ZeroDivisionError: division by zero