python中的异常处理

python中的异常处理

1. 程序中错误的分类

   • 语法错误

     # 错误示例
     print a(sd）
     

     这样的错误必须在执行之前就加以改正，python解释器的语法检测也会检测出来给予用户提醒。

   • 逻辑错误

     # 错误实例
     # 不能完成计算，因为input输入的为str类型，无法与int类型进行+运算
     num=input(">>: ")
     num += 1
     

2. python中的异常

   • 异常就是程序运行时发生错误的信号，异常发生之后，异常之后的代码就不执行了。

   • python中的异常中的种类

     • 常用异常

       常出现的异常

       # 触发IndexError
       l=['hah','heihei']
       l[3]
       

       # 触发KeyError
       dic={'name':'hah'}
       dic['age']
       

       # 触发ValueError
       s='hah'
       int(s)
       

       常用异常

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

       更多异常

       ArithmeticError		AssertionError		AttributeError
       BaseException		BufferError			BytesWarning
       DeprecationWarning
       EnvironmentError	EOFError			Exception
       FloatingPointError	FutureWarning
       GeneratorExit
       ImportError			ImportWarning		IndentationError
       IndexError			IOError
       KeyboardInterrupt	KeyError
       LookupError
       MemoryError
       NameError			NotImplementedError
       OSError				OverflowError
       PendingDeprecationWarning	
       ReferenceError		RuntimeError		RuntimeWarning
       StandardError		StopIteration		SyntaxError
       SyntaxWarning		SystemError			SystemExit
       TabError			TypeError
       UnboundLocalError	UnicodeDecodeError	UnicodeEncodeError	
       UnicodeError		UnicodeTranslateError	UnicodeWarning
       UserWarning
       ValueError
       Warning
       ZeroDivisionError
       

3. 异常处理

   1. 什么是异常处理？

      简单来说就是程序员专门写一段捕捉异常的代码，如果成功捕捉就进入处理异常的分支，执行特定逻辑，使程序可以继续运行不至于崩溃。

   2. 为什么进行异常处理？

      我们需要提供一种处理机制来提高所写代码的容错性

   3. 如何进行异常处理？

      须知：异常处理不能处理语法错误引发的异常。

      1. if 判断式

         例如：

         num=input('>>: ') #输入一个字符串试试
         int(num)
         # 我们知道如果输入的不是纯数字就会报错 》》》 ValueError：……
         

         我们使用 if 判断式来处理上述问题

         num=input('>>: ') #输入一个字符串试试
         if num1.isdigit():
             int(num) #我们的主逻辑放到了这里,其余的判断句都属于异常处理
         elif num.isspace():
             print('输入的是空格,就执行这里的逻辑')
         elif len(num) == 0:
             print('输入的是空,就执行这里的逻辑')
         else:
             print('其他情情况,执行这里的逻辑')
         

         但是上述处理存在问题：

         1. 为了处理其他情况（异常的情况）加上太多 elif ，这些代码与主逻辑并无关系，所以造成我们写的代码可读性差。
         2. 这只是一个input语句，如果出现多个，那岂不是都需要多次判断，这就会造成我们写的代码特别冗长。

         总结：

         1. 首先 if 判断式是可以进行异常处理的，但只能针对某一段代码，对于不同的代码段的相同类型的错误你需要写重复的if来进行处理。
         2. 多次使用if 判断式，这些判断语句与主逻辑无关，会造成代码的可读性极差。

      2. 正题来了 >> python中异常处理特定的语法结构

         • 基本语法

           try:
                被检测的代码块
           except 异常类型：
                try中一旦检测到异常，就执行这个位置的逻辑
           

           例如上述问题：

           num=input('>>: ')
           try:
               int(num)
           except ValueError:
               print('您输入的不是纯数字！')
           

         • 须知：只能用来处理指定的异常情况，非指定异常则无法处理。

           num=input('>>: ')
           try:
               int(num)
           except IndexError :
               print('您输入的不是纯数字！')
             
           # 未捕捉到异常，程序直接报错。
           

         • 多分支结构

           s1 = 'hah'
           try:
               int(s1)
           except IndexError as e:
               print(e)
           except KeyError as e:
               print(e)
           except ValueError as e:
               print(e)
           

         • 万能异常：Exception （捕捉任意异常）

           s1 = 'hah'
           try:
               int(s1)
           except Exception as e:
               print(e)
           

           有人可能会有疑问：既然有了万能异常，那我还要其他形式干嘛?

           说的没错，只是我们应该分俩种情况来看（相信聪明的人已经想出来了，就是你了++)：

           • 当无论出现什么异常，我们统一丢弃，或者使用同一段代码去处理他，那就放心使用Exception吧
           • 当我们想针对不同的异常执行不同的逻辑时，那就需要用到分支了

         • try exception else finally 结构

           s1 = 'hah'
           try:
               int(s1)
           except IndexError as e:
               print(e)
           except KeyError as e:
               print(e)
           except ValueError as e:
               print(e)
               
           else:
               print('try内代码块没有异常则执行这一部分代码')
           finally:
               print('无论异常与否,都会执行该模块,通常是进行清理工作')
           

         • 主动抛出异常 —— raise

           try:
               raise ValueError('qaq')
           except ValueError as e:
               print(e)	# qaq
           

         • 自定义异常

           class QaqError(BaseException):
               def __init__(self,info):
                   self.msg = info
               def __str__(self):
                   return self.msg
           
           try:
               raise QaqError('qaq')
           except QaqError as e:
               print(e)		# qaq
           

         • 总结：

           1. 真正逻辑与错误处理分开，代码更易组织，更清晰，复杂的工作任务更容易实现。
           2. 使代码不至于由于一些小的疏忽而使程序意外崩溃了。
           3. 同样会导致代码的可读性差，所以尽量少用。