python之异常处理

异常处理

一、异常处理介绍

什么是异常？

异常就是程序运行的时候发生的错误信号，在程序出错时，会产生一个异常，异常是一个对象，则会抛出异常，程序的运行就会终止。

异常处理的三个特征：

• 异常的追踪信息，显示那个文件，第几行出现错误

• 异类的类型，类型即类，一种类型标识一种错误

• 异常的内容，具体的错误信息

  

为何处理异常？

• 为了增强程序的健壮性，即便是程序运行过程中出错了，也不要终止程序, 而是捕捉异常并处理：将出错信息记录到日志内

两种产出异常的因素

• 语法上的错误示例：

  >>> print(aaa)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  NameError: name 'aaa' is not defined
  
  

  语法上的错误(SyntaxError)在程序执行之前就应该避免，或者说就不应该有这种错误

• 逻辑的错误

  #TypeError
  res=1+"3"
  print(res)  #  TypeError: 不支持的操作数类型:'int'和'str'
  dic={[1]:3} ## TypeError: unhashable类型:“列表
  
  #ValueError
  int("hello")    # ValueError: 以10为基数的int()无效的文字:'hello'
  
  # IndexError
  li = [1, 2, 3]
  li[4]  # IndexError: 列表索引超出范围
  
  # KeyError
  dic = {'name': '派大星'}
  dic['NAME']  # KeyError: 'NAME'
  
  int.mama # AttributeError: 类型对象“int”没有属性“mama”
  int.淘小欣 # AttributeError: 类型对象“int”没有属性“淘小欣”
  # ZeroDivisionError
  1 / 0  # ZeroDivisionError: 除数不能为0
  
  # ZeroDivisionError
  1 / 0  # ZeroDivisionError: 除数不能为0
  
  

  逻辑上的错误可以分为可控制的逻辑错误，应该尽量解决，避免，而对于不可控制的逻辑错误，我们就需要使用异常处理try…except…

二、异常种类

在python中不同的异常使用不同的类型去标识，一个异常类型标识一种异常

常见异常类型

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

python所有标准异常

• 常用异常也包含在内

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

更多其他异常

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

三、异常处理的用法

• 针对逻辑上的异常又分成两种处理方式

1.如果错误的条件是可以预知的，我们可以使用if进行处理，在错误之前进行预防

age = input("请输入你要猜的年龄》》：")
if age.isdigit():   # 输入的只要不是数字就会出错
    age =int(age)
    if age > 18:
        print("猜大了")
    elif age <18 :
        print("猜小了")

    else:
        print("恭喜你，答对了")

else:
    print("输入有误，必须输入数字~~~")

2.当错误发生的条件不可预知，则需要使用try…except进行异常之后的处理

print('''╭══╮╭═══════╮
  ╭╯滴滴滴 ║   程序运行啦！
  ╰⊙ ═ ⊙╯╰═⊙═⊙══⊙╯''')
l=[1,3,5]
try:
    print(l[5])
except IndexError as I :
    print(I)

print('''╭══╮╭═══════╮
  ╭╯滴滴滴 ║   程序运行结束啦！
  ╰⊙ ═ ⊙╯╰═⊙═⊙══⊙╯''')


'''输出如下：
╭══╮╭═══════╮
  ╭╯滴滴滴 ║   程序运行啦！
  ╰⊙ ═ ⊙╯╰═⊙═⊙══⊙╯
list index out of range
╭══╮╭═══════╮
  ╭╯滴滴滴 ║   程序运行结束啦！
  ╰⊙ ═ ⊙╯╰═⊙═⊙══⊙╯
'''

四、try…except…的用法

1.单异常:一个异常类只能处理指定的异常, 如果非指定异常则无法检测, 程序崩溃

try:
    子代码块
except 异常类型:
    捕捉到异常后执行的代码.
    
# 多异常都使用相同的处理方式
try:
    子代码块
except (异常类型1,异常类型2...):
    捕捉到异常后执行的代码.
    
# 万能异常
try:
    子代码块
except Exception as e:  # Exception任意异常都能捕获到.
    所有的异常都会触发处理

# 无法预知异常
try:
    子代码块
finally:
    无论被监测的子代码块有无异常发生，都会执行finally的子代码块。
    
🥩代码示例
l = [1,2,3]
try:
    print(l[5])
except  KeyError as I:
    print(I)
# 抛出异常 : IndexError: list index out of range

2.多异常：多分支检测异常

try:
    子代码块
except 异常类型1 as e:  # as会将异常信息赋值给后面的变量名.
    捕捉到异常类型1会执行的代码.
except 异常类型2:
    捕捉到异常类型2会执行的代码.
...

🍿多异常使用相同处理方式
try:
    子代码块
except (异常类型1,异常类型2...) as e:
    捕捉到其中任一异常后执行的代码.
except 异常类型3:
    pass
...

🍟代码示例：
l = [1,2,3]
try:
    print(l[5])
except  KeyError as K:
    print(K)
except ValueError as V:
    print(V)
except IndexError as I:
    print(I)
 # list index out of range

3.万能异常：Exception

🍳万能异常伪代码示例
try:
    子代码块
except Exception as e:  # Exception任意异常都能捕获到.
    所有的异常都会触发处理


🍕代码示例：
l=["name","age","hobby"]
try:
    print(l[6])
except KeyError as E  :
    print(E)        #list index out of range

4.多分支异常与万能异常

• 如果你对检测异常的代码无论出现什么异常, 都使用一种逻辑去处理它, 那么直接使用万能异常就行了

• 如果你的需求是对不同的异常进行不同的处理, 那么就应该使用多分支异常处理

• 当然你也可以在多分支后面再来一个 Exception, 即你设置的不同异常都没有捕获到再使用 Exception 捕获

  l=["name","age","hobby"]
  try:
      print(l[6])
  except KeyError as K   :
      print(f"key--->{K}")
  
  except ValueError as V:
      print(f"Val--->{V}")
  
  except Exception as E:
      print(f"Exc--->{E}")
  '''
  print(f"Exc--->{E}")
  '''
  

5.try…else… : 没有发生异常执行

l=["name","age","hobby"]
try:
    print(l[1])
except  KeyError as K:
    print(f"key--->{K}")
except ValueError as V:
    print(f"Val--->{V}")
except Exception as E:
    print(f"Exc--->{E}")
else:
    print("什么异常都没有")
'''
age
什么异常都没有
'''

6.try…finally : 无论有没有发生异常都执行

🌹没有异常
l=["name","age","hobby"]
try:
    print(l[1])
except  KeyError as K:
    print(f"key--->{K}")
finally:
    print("没有异常")
'''
age
没有异常
'''

💕出现异常
l=["name","age","hobby"]
try:
    print(l[9])
except  IndexError as I:
    print(f"key--->{I}")
finally:
    print("出现异常")
'''
key--->list index out of range
出现异常
'''

**finally不会处理异常，出现异常会先执行finally内的代码，然后终止子代码块执行。通常应该将被监测代码中回收系统资源的部分放到这里。**比如关闭文件，关闭数据库连接等。

一个 try 必须对应一个 except , 而 else 和 finally 是可选的

7. raise …语句主动抛出异常

我们可以使用raise语句自己触发异常，raise语法格式如下

def people(age:int):
    if age < 18:
        raise Exception("It has to be greater than 18") # 后面的代码不会再执行
    print("我不会执行")

people(12) 
# 抛出异常 : Exception: It has to be greater than 18

主动异常检测测试

try:
    raise TypeError("类型错误")
except Exception as E:
    print(E)  # 类型错误

8.断言 : assert

断言语句assert expression，断定表达式expression成立，否则触发异常AssertionError，与raise-if-not的语义相同

😎通常我们断言
li = [1,2,3,4,5]
if li[3] != 9:
    raise Exception("断言失败")
# 抛出异常 : Exception: 断言失败

👼以上的事情我们可以使用"assert" 来完成
li = [1,2,3,4,5]
assert li[3] == 9
print("后续代码不执行")

9.自定义异常

内置异常不符合期望时，可以通过继承内置的异常类来自定义异常类。自定义异常类型必须继承 BaseException

class Permission(BaseException):
    def __init__(self,msg):
        self.msg = msg

li = ["派大星","海绵宝宝","章鱼哥"]
for i in li:
    if i == "派大星":
        raise Permission("权限不允许你打印'派大星'")
    else:
        print(i)
# 抛出异常 : __main__.Permission: 权限不允许你打印'派大星'

10、任意异常

通常用于某些无法预知异常类型的时候。

try:
    子代码块
except Exception:  # Exception能匹配任意异常
    任意异常都会触发执行.

五.异常处理的完整语法

print('start...')
try:
    # 有可能会抛出异常的子代码块，任何一行抛异常，其下的代码都不会执行。
    被监测代码1
    被监测代码2
except 异常类型1 as e:	# as表示将异常信息赋值给后面的变量.
	处理异常的代码
except 异常类型2 as e:
	处理异常的代码
except 异常类型3 as e:
	处理异常的代码
...可以有多个except...

except (异常类型4,异常类型5,异常类型6) as e:
	处理异常的代码
except Exception as e:
	处理异常的代码
else:
	若被监测的子代码块没有异常发生,则会执行else的子代码块。
finally:
	无论被监测的子代码块有无异常发生，都会执行finally的子代码块。

print('end...')

注意：else不能单独与try配合使用；else可以不用，如果必须在except后面使用。

try:
    f = open('a.txt','rb')
    f.write()
except BaseException as e:
    print(e.args)  # ('write',)
finally:
    f.close()

以r模式打开文件不能向文件写入内容，所以会抛异常，e会接收到异常的内容。

异常是附加给程序的一种异常处理的逻辑，与主要程序的工作是没有关系的，过多的异常处理语句会导致代码可读性变差，只有在错误发生的条件无法预知的情况下，才应该使用异常处理。

六、总结

• try…except… 可以把错误处理和真正的工作分开来
• 代码更易组织，更清晰，复杂的工作任务更容易实现
• 毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了

七、异常处理的缺点和应该使用的场景

try…except… 是你附加给你的程序的一种异常处理的逻辑，与你的主要的工作是没有关系的，这种东西加的多了，会导致你的代码可读性变差

只有在错误发生的条件无法预知的情况下，才应该加上try…except…

八、参考资料

• https://docs.python.org/zh-cn/3/library/exceptions.html?highlight=exception#Exception