Python基础知识(六)：异常处理

太过爱你忘了你带给我的痛 2023-10-05 12:15 33阅读 0赞

## 01\_异常的本质\_调试核心理念 ##

在实际工作中，我们遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求;你的程序要打开某个文件，这个文件可能不存在或者文件格式不对;你要读取数据库的数据，数据可能是空的;我们的程序再运行着，但是内存或硬盘可能满了等等。  
软件程序在运行过程中，非常可能遇到刚刚提到的这些问题，我们称之为异常，英文是：Exception，意思是例外。遇到这些例外情况，或者叫异常，我们怎么让写的程序做出合理的处理，而不至于程序崩溃呢?我们本章就要讲解这些问题。  
如果我们要拷贝一个文件，在没有异常机制的情况下，我们需要考虑各种异常情况，伪代码如下：  
【示例6-1】伪代码使用if 处理程序中可能出现的各种情况

#将d:/a.txt 拷贝到e:盘
    if "d:/a.txt"这个文件存在:
        if e 盘的空间大于a.txt 文件长度:
            if 文件复制一半IO 流断掉:
                停止copy，输出：IO 流出问题！
            else:
                copyFile("d:/a.txt","e:/a.txt")
        else:
            print("e 盘空间不够存放a.txt！")
    else:
        print("a.txt 不存在！")

###### 这种方式，有两个坏处： ######

1.  逻辑代码和错误处理代码放一起!
2.  程序员本身需要考虑的例外情况较复杂，对程序员本身要求较高!  
    那么，我们如何解决应对异常情况呢? python 的异常机制给我们提供了方便的处理方式。如上情况，如果是用python 的异常机制来处理，示意代码如下(仅限示意，不能运行)：

#将d:/a.txt 拷贝到e:盘
    try:
        copyFile("d:/a.txt","e:/a.txt")
    except:
        print("文件无法拷贝")

###### 异常机制本质： ######

异常指程序运行过程中出现的非正常现象，例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。  
所谓异常处理，就是指程序在出现问题时依然可以正确的执行剩余的程序，而不会因为异常而终止程序执行。  
python 中，引进了很多用来描述和处理异常的类，称为异常类。异常类定义中包含了该类异常的信息和对异常进行处理的方法。下面较为完整的展示了python 中内建异常类的继承层次：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center]  
我们处理一下，遇到的第一个异常：

#测试简单的0 不能做除数异常
    a = 3/0

执行上面程序，控制台打印：

Traceback (most recent call last):
    File "C:/Users/Administrator/PycharmProjects/mypro_exception/my01.py", line 1, in <module>
    a = 3/0
    ZeroDivisionError: division by zero
    Process finished with exit code 1

python 中一切都是对象，异常也采用对象的方式来处理。处理过程：

1.  抛出异常：在执行一个方法时，如果发生异常，则这个方法生成代表该异常的一个对象，停止当前执行路径，并把异常对象提交给解释器。
2.  捕获异常：解释器得到该异常后，寻找相应的代码来处理该异常。

## 02\_try\_except基本结构 ##

###### try…一个except 结构 ######

try…except 是最常见的异常处理结构。结构如下(其中e为产生的异常对象)：

try:
        被监控的可能引发异常的语句块
    except BaseException [as e]:
        异常处理语句块

try 块包含着可能引发异常的代码，except 块则用来捕捉和处理发生的异常。  
执行的时候，如果try 块中没有引发异常，则跳过ecept 块继续执行后续代码；  
执行的时候，如果try块中发生了异常，则跳过try 块中的后续代码，跳到相应的except 块中处理异常；异常处理完后，继续执行后续代码。

###### 遇到异常的执行顺序： ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 1]  
我们可以看到，程序执行到引发异常的语句时，直接掉到except 异常处理语句块进行处理；处理完毕后，继续执行下面的程序。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 2]  
try 语句块没有发生异常，则正常执行完try 块后跳过except 异常处理语句块，继续往下执行。

【示例01】循环输入数字，如果不是数字则处理异常；直到输入88，则结束循环。

while True:
        try:
            x = int(input("请输入一个数字："))
            print("您入的数字是",x)
            if x==88:
                print("退出程序")
                break
        except:
            print("异常：输入的不是一个数字")
       print('继续接下来的程序')

执行结果：

请输入一个数字：66
    您入的数字是 66
    继续接下来的程序
    请输入一个数字：ddd
    异常：输入的不是一个数字
    继续接下来的程序
    请输入一个数字：99
    您入的数字是 99
    继续接下来的程序

【示例02】循环输入数字，如果不是数字则处理异常；直到输入88，则结束循环。

while True:
        try:
            x = int(input("请输入一个数字："))
            print("您入的数字是", x)
            if x == 88:
                print("退出程序")
                break
        except BaseException as e:
            print("异常：输入的不是一个数字")
            print('抛出的异常对象 e = ' + str(e))
    
        print('继续接下来的程序')

执行结果：

请输入一个数字：66
    您入的数字是 66
    继续接下来的程序
    请输入一个数字：ddd
    异常：输入的不是一个数字
    抛出的异常对象 e = invalid literal for int() with base 10: 'ddd'
    继续接下来的程序
    请输入一个数字：99
    您入的数字是 99
    继续接下来的程序

## 03\_try\_多个except结构 ##

上面的结构可以捕获所有的异常，工作中也很常见。但是，从经典理论考虑，一般建议尽量捕获可能出现的多个异常（按照先子类后父类的顺序），并且针对性的写出异常处理代码。为了避免遗漏可能出现的异常，可以在最后增加BaseException。结构如下：

try:
        被监控的、可能引发异常的语句块
    except Exception1:
        处理Exception1 的语句块
    except Exception2:
        处理Exception2 的语句块
    ...
    except BaseException：
        处理可能遗漏的异常的语句块

【示例】多个except 结构

try:
        a = input("请输入被除数：")
        b = input("请输入除数：")
        c = float(a) / float(b)
        print(c)
    except ZeroDivisionError:
        print("异常：除数不能为0")
    except TypeError:
        print("异常：除数和被除数都应该为数值类型")
    except NameError:
        print("异常：变量不存在")
    except BaseException as e:
        print(e)
        print(type(e))

执行结果：

请输入被除数：10
    请输入除数：0
    异常：除数不能为0

## 04\_try…except…else 结构 ##

try…except…else 结构增加了“else 块”。  
如果try 块中没有抛出异常，则执行else 块。  
如果try 块中抛出异常，则执行except 块，不执行else 块。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 3]  
【示例】try…except…else 结构执行测试

while True:
        try:
            a = input("请输入被除数：")
            b = input("请输入除数：")
            c = float(a) / float(b)
        except BaseException as e:
            print('except语句块---->抛出的异常对象 e = ' + str(e))
        else:
            print("else语句块---->除的结果是：", c)
        print('后续语句块')

运行结果：

请输入被除数：3
    请输入除数：0
    except语句块---->抛出的异常对象 e = float division by zero
    后续语句块
    请输入被除数：3
    请输入除数：6
    else语句块---->除的结果是： 0.5
    后续语句块

## 05\_try…except…finally 结构 ##

try…except…finally 结构中，finally 块无论是否发生异常都会被执行；通常用来释放try 块中申请的资源。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 4]  
【示例01】try…except…finally 结构简单测试

while True:
        try:
            a = input("请输入一个被除数：")
            b = input("请输入一个除数：")
            c = float(a) / float(b)
        except BaseException as e:
            print('except语句块---->抛出的异常对象 e = ' + str(e))
        else:
            print("else语句块---->除的结果是：", c)
        finally:
            print("我是finally 中的语句，无论发生异常与否，都执行！")
        print('后续语句块')

运行结果：

请输入一个被除数：3
    请输入一个除数：0
    except语句块---->抛出的异常对象 e = float division by zero
    我是finally 中的语句，无论发生异常与否，都执行！
    后续语句块
    请输入一个被除数：3
    请输入一个除数：6
    else语句块---->除的结果是： 0.5
    我是finally 中的语句，无论发生异常与否，都执行！
    后续语句块

【示例02】try…except…finally 打开文件(finally中的代码肯定会执行，所以其中的代码中的文件关闭操作也得用try…except结构包裹)

try:
        f = open("d:/adddd.txt","r")
        content = f.readline()
        print(content)
    except:
        print("文件未找到")
    finally:
        print("run in finally。关闭资源")
        try:
            f.close()
        except BaseException as e:
            print(e)
    
    print("程序执行结束！")

###### return 语句和异常处理问题 ######

由于return 有两种作用：结束方法运行、返回值。我们一般不要将return 语句放到try、except、else、finally 块中，会发生一些意想不到的错误。建议放到方法最后。

## 06\_常见异常汇总和说明 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 5]

<table> 
 <thead> 
  <tr> 
   <th>异常名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ArithmeticError</td> 
   <td>所有数值计算错误的基类</td> 
  </tr> 
  <tr> 
   <td>AssertionError</td> 
   <td>断言语句失败</td> 
  </tr> 
  <tr> 
   <td>AttributeError</td> 
   <td>对象没有这个属性</td> 
  </tr> 
  <tr> 
   <td>BaseException</td> 
   <td>所有异常的基类</td> 
  </tr> 
  <tr> 
   <td>DeprecationWarning</td> 
   <td>关于被弃用的特征的警告</td> 
  </tr> 
  <tr> 
   <td>EnvironmentError</td> 
   <td>操作系统错误的基类</td> 
  </tr> 
  <tr> 
   <td>EOFError</td> 
   <td>没有内建输入,到达EOF 标记</td> 
  </tr> 
  <tr> 
   <td>Exception</td> 
   <td>常规错误的基类</td> 
  </tr> 
  <tr> 
   <td>FloatingPointError</td> 
   <td>浮点计算错误</td> 
  </tr> 
  <tr> 
   <td>FutureWarning</td> 
   <td>关于构造将来语义会有改变的警告</td> 
  </tr> 
  <tr> 
   <td>GeneratorExit</td> 
   <td>生成器(generator)发生异常来通知退出</td> 
  </tr> 
  <tr> 
   <td>ImportError</td> 
   <td>导入模块/对象失败</td> 
  </tr> 
  <tr> 
   <td>IndentationError</td> 
   <td>缩进错误</td> 
  </tr> 
  <tr> 
   <td>IndexError</td> 
   <td>序列中没有此索引(index)</td> 
  </tr> 
  <tr> 
   <td>IOError</td> 
   <td>输入/输出操作失败</td> 
  </tr> 
  <tr> 
   <td>KeyboardInterrupt</td> 
   <td>用户中断执行(通常是输入^C)</td> 
  </tr> 
  <tr> 
   <td>KeyError</td> 
   <td>映射中没有这个键</td> 
  </tr> 
  <tr> 
   <td>LookupError</td> 
   <td>无效数据查询的基类</td> 
  </tr> 
  <tr> 
   <td>MemoryError</td> 
   <td>内存溢出错误(对于Python 解释器不是致命的)</td> 
  </tr> 
  <tr> 
   <td>NameError</td> 
   <td>未声明/初始化对象(没有属性)</td> 
  </tr> 
  <tr> 
   <td>NotImplementedError</td> 
   <td>尚未实现的方法</td> 
  </tr> 
  <tr> 
   <td>OSError</td> 
   <td>操作系统错误</td> 
  </tr> 
  <tr> 
   <td>OverflowError</td> 
   <td>数值运算超出最大限制</td> 
  </tr> 
  <tr> 
   <td>OverflowWarning</td> 
   <td>旧的关于自动提升为长整型(long)的警告</td> 
  </tr> 
  <tr> 
   <td>PendingDeprecationWarning</td> 
   <td>关于特性将会被废弃的警告</td> 
  </tr> 
  <tr> 
   <td>ReferenceError</td> 
   <td>弱引用(Weak reference)试图访问已经垃圾回收了的对象</td> 
  </tr> 
  <tr> 
   <td>RuntimeError</td> 
   <td>一般的运行时错误</td> 
  </tr> 
  <tr> 
   <td>RuntimeWarning</td> 
   <td>可疑的运行时行为(runtime behavior)的警告</td> 
  </tr> 
  <tr> 
   <td>StandardError</td> 
   <td>所有的内建标准异常的基类</td> 
  </tr> 
  <tr> 
   <td>StopIteration</td> 
   <td>迭代器没有更多的值</td> 
  </tr> 
  <tr> 
   <td>SyntaxError Python</td> 
   <td>语法错误</td> 
  </tr> 
  <tr> 
   <td>SyntaxWarning</td> 
   <td>可疑的语法的警告</td> 
  </tr> 
  <tr> 
   <td>SystemError</td> 
   <td>一般的解释器系统错误</td> 
  </tr> 
  <tr> 
   <td>SystemExit</td> 
   <td>解释器请求退出</td> 
  </tr> 
  <tr> 
   <td>TabError Tab</td> 
   <td>和空格混用</td> 
  </tr> 
  <tr> 
   <td>TypeError</td> 
   <td>对类型无效的操作</td> 
  </tr> 
  <tr> 
   <td>UnboundLocalError</td> 
   <td>访问未初始化的本地变量</td> 
  </tr> 
  <tr> 
   <td>UnicodeDecodeError Unicode</td> 
   <td>解码时的错误</td> 
  </tr> 
  <tr> 
   <td>UnicodeEncodeError Unicode</td> 
   <td>编码时错误</td> 
  </tr> 
  <tr> 
   <td>UnicodeError Unicode</td> 
   <td>相关的错误</td> 
  </tr> 
  <tr> 
   <td>UnicodeTranslateError Unicode</td> 
   <td>转换时错误</td> 
  </tr> 
  <tr> 
   <td>UserWarning</td> 
   <td>用户代码生成的警告</td> 
  </tr> 
  <tr> 
   <td>ValueError</td> 
   <td>传入无效的参数</td> 
  </tr> 
  <tr> 
   <td>Warning</td> 
   <td>警告的基类</td> 
  </tr> 
  <tr> 
   <td>WindowsError</td> 
   <td>系统调用失败</td> 
  </tr> 
  <tr> 
   <td>ZeroDivisionError</td> 
   <td>除(或取模)零(所有数据类型)</td> 
  </tr> 
 </tbody> 
</table>

## 07\_with上下文管理 ##

finally 块由于是否发生异常都会执行，通常我们放释放资源的代码。其实，我们可以通过with 上下文管理，更方便的实现释放资源的操作。  
with 上下文管理的语法结构如下：

with context_expr [ as var]：
        语句块

with 上下文管理可以自动管理资源，在with 代码块执行完毕后自动还原进入该代码之前的现场或上下文。不论何种原因跳出with 块，不论是否有异常，总能保证资源正常释放。极大的简化了工作，在文件操作、网络通信相关的场合非常常用。

【示例】with 上下文管理文件操作

with open("d:/bb.txt") as f:
        for line in f:
            print(line)

## 08\_trackback模块的使用\_异常写入日志文件 ##

###### 使用Traceback 模块打印异常信息 ######

import traceback
    
    try:
        print("step1")
        num = 1 / 0
    except:
        traceback.print_exc()

运行结果：

C:\Program_Files\Anaconda3520\python.exe D:/Workspaces_Python/MyTurtle.py
    Traceback (most recent call last):
      File "D:/Workspaces_Python/MyTurtle.py", line 5, in <module>
        num = 1 / 0
    ZeroDivisionError: division by zero
    step1
    
    Process finished with exit code 0

###### 使用traceback 将异常信息写入日志文件 ######

try:
        print("step1")
        num = 1 / 0
    except:
        with open("F:/a.log", "a") as f:
            traceback.print_exc(file=f)

## 09\_自定义异常类\_raise抛出异常 ##

程序开发中，有时候我们也需要自己定义异常类。自定义异常类一般都是运行时异常，通常继承Exception 或其子类即可。命名一般以Error、Exception 为后缀。  
自定义异常由raise 语句主动抛出。  
【示例】自定义异常类和raise 语句

# 测试自定义异常类
    class AgeError(Exception):  # 继承Exception
        def __init__(self, errorInfo):
            Exception.__init__(self)
            self.errorInfo = errorInfo
    
        def __str__(self):
            return ('self.errorInfo = ' + str(self.errorInfo)) + "---->年龄错误！应该在1-150 之间"
    
    
    # 测试代码
    if __name__ == "__main__":  # 如果为True，则模块是作为独立文件运行，可以执行测试代码
        age = int(input("输入一个年龄:"))
        if age < 1 or age > 150:
            raise AgeError(age) # 将age传递给errorInfo形参
        else:
            print("正常的年龄：", age)

运行结果：

C:\Program_Files\Anaconda3520\python.exe D:/Workspaces_Python/MyTurtle.py
    输入一个年龄:200
    Traceback (most recent call last):
      File "D:/Workspaces_Python/MyTurtle.py", line 15, in <module>
        raise AgeError(age) # 将age传递给errorInfo形参
    __main__.AgeError: self.errorInfo = 200---->年龄错误！应该在1-150 之间
    
    Process finished with exit code 1

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20201023194308495.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201023194448356.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201023194515388.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201023194736962.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201023194858504.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201023195011428.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center