一 什么是异常

异常是程序发生错误的信号。程序一旦出现错误，便会产生一个异常，若程序中没有处理它，就会抛出该异常，程序的运行也随之终止。

而错误分成两种，一种是语法上的错误SyntaxError，这种错误应该在程序运行前就修改正确

  1. >>> if  
  2.   File "<stdin>", line 1
  3.     if
  4.      ^
  5. SyntaxError: invalid syntax

另一类就是逻辑错误，常见的逻辑错误如

  1. # TypeError：数字类型无法与字符串类型相加
  2. 1+’2’
  3. # ValueError：当字符串包含有非数字的值时，无法转成int类型
  4. num=input(">>: ") #输入hello
  5. int(num)
  6. # NameError：引用了一个不存在的名字x
  7. x
  8. # IndexError：索引超出列表的限制
  9. l=['egon','aa']
  10. l[3]
  11. # KeyError：引用了一个不存在的key
  12. dic={'name':'egon'}
  13. dic['age']
  14. # AttributeError：引用的属性不存在
  15. class Foo:
  16.     pass
  17. Foo.x
  18. # ZeroDivisionError：除数不能为0
  19. 1/0

二 异常处理

为了保证程序的容错性与可靠性，即在遇到错误时有相应的处理机制不会任由程序崩溃掉，我们需要对异常进行处理，处理的基本形式为

  1. try:
  2.     被检测的代码块
  3. except 异常类型：
  4.     检测到异常，就执行这个位置的逻辑

举例

  1. try:
  2.     print('start...')
  3.     print(x) # 引用了一个不存在的名字，触发异常NameError
  4.     print('end...')
  5. except NameError as e: # as语法将异常类型的值赋值给变量e，这样我们通过打印e便可以知道错误的原因
  6.     print('异常值为：%s' %e)
  7. print('run other code...')
  8. #执行结果为
  9. start...
  10. 异常值为：name 'x' is not defined
  11. run other code...

本来程序一旦出现异常就整体结束掉了，有了异常处理以后，在被检测的代码块出现异常时，被检测的代码块中异常发生位置之后的代码将不会执行，取而代之的是执行匹配异常的except子代码块，其余代码均正常运行。
当被检测的代码块中有可能触发不同类型的异常时，针对不同类型的异常：
如果我们想分别用不同的逻辑处理，需要用到多分支的except（类似于多分支的elif，从上到下依次匹配，匹配成功一次便不再匹配其他）

  1. try:
  2.     被检测的代码块
  3. except NameError:
  4.     触发NameError时对应的处理逻辑
  5. except IndexError:
  6.     触发IndexError时对应的处理逻辑
  7. except KeyError:
  8.     触发KeyError时对应的处理逻辑

举例

  1. def convert_int(obj):
  2.     try:
  3.         res=int(obj)
  4.     except ValueError as e:
  5.         print('ValueError: %s' %e)
  6.         res=None
  7.     except TypeError as e:
  8.         print('TypeError: %s' %e)
  9.         res=None
  10.     return res
  11. convert_int('egon') # ValueError: invalid literal for int() with base 10: 'egon'
  12. convert_int({'n':1}) # TypeError: int() argument must be a string, a bytes-like object or a number, not 'dict'

如果我们想多种类型的异常统一用一种逻辑处理，可以将多个异常放到一个元组内，用一个except匹配

  1. try:
  2.     被检测的代码块
  3. except (NameError,IndexError,TypeError):
  4.     触发NameError或IndexError或TypeError时对应的处理逻辑

举例

  1. def convert_int(obj):
  2.     try:
  3.         res=int(obj)
  4.     except (ValueError,TypeError):
  5.         print('argument must be number or numeric string')
  6.         res=None
  7.     return res
  8. convert_int('egon') # argument must be number or numeric string
  9. convert_int({'n':1}) # argument must be number or numeric string

如果我们想捕获所有异常并用一种逻辑处理，Python提供了一个万能异常类型Exception

  1. try:
  2.     被检测的代码块
  3. except NameError:
  4.     触发NameError时对应的处理逻辑
  5. except IndexError:
  6.     触发IndexError时对应的处理逻辑
  7. except Exception:
  8.     其他类型的异常统一用此处的逻辑处理

在多分支except之后还可以跟一个else（else必须跟在except之后，不能单独存在），只有在被检测的代码块没有触发任何异常的情况下才会执行else的子代码块

  1. try:
  2.     被检测的代码块
  3. except 异常类型1:
  4.     pass
  5. except 异常类型2:
  6.     pass
  7. ......
  8. else:
  9.     没有异常发生时执行的代码块

此外try还可以与finally连用，从语法上讲finally必须放到else之后，但可以使用try-except-finally的形式，也可以直接使用try-finally的形式。无论被检测的代码块是否触发异常，都会执行finally的子代码块，因此通常在finally的子代码块做一些回收资源的操作，比如关闭打开的文件、关闭数据库连接等
python try: 被检测的代码块 except 异常类型1: pass except 异常类型2: pass ...... else: 没有异常发生时执行的代码块 finally: 无论有无异常发生都会执行的代码块
举例

  1. f=None
  2. try:
  3.     f=open(‘db.txt’,'r',encoding='utf-8')
  4.     s=f.read().strip()
  5.     int(s)  # 若字符串s中包含非数字时则会触发异常ValueError
  6.     # f.close() # 若上面的代码触发异常，则根本不可能执行到此处的代码，应该将关闭文件的操作放到finally中
  7. finally:
  8.     if f: # 文件存在则f的值不为None
  9.         f.close()

在不符合Python解释器的语法或逻辑规则时，是由Python解释器主动触发的各种类型的异常，而对于违反程序员自定制的各类规则，则需要由程序员自己来明确地触发异常，这就用到了raise语句，raise后必须是一个异常的类或者是异常的实例

  1. class Student:
  2.     def __init__(self,name,age):
  3.         if not isinstance(name,str):
  4.             raise TypeError('name must be str')
  5.         if not isinstance(age,int):
  6.             raise TypeError('age must be int')
  7.         self.name=name
  8.         self.age=age
  9. stu1=Student(4573,18) # TypeError: name must be str
  10. stu2=Student('egon','18') # TypeError: age must be int

在内置异常不够用的情况下，我们可以通过继承内置的异常类来自定义异常类

  1. class PoolEmptyError(Exception): # 可以通过继承Exception来定义一个全新的异常
  2.     def __init__(self,value='The proxy source is exhausted'): # 可以定制初始化方法
  3.         super(PoolEmptyError,self).__init__()
  4.         self.value=value
  5.     def __str__(self): # 可以定义该方法用来定制触发异常时打印异常值的格式
  6.         return '< %s >' %self.value
  7. class NetworkIOError(IOError): # 也可以在特定异常的基础上扩展一个相关的异常
  8.     pass
  9. raise PoolEmptyError # __main__.PoolEmptyError: < The proxy source is exhausted >
  10. raise NetworkIOError('连接被拒绝') # __main__.NetworkIOError: 连接被拒绝

最后，Python还提供了一个断言语句assert expression，断定表达式expression成立，否则触发异常AssertionError，与raise-if-not的语义相同，如下

  1. age='18'
  2. # 若表达式isinstance(age,int)返回值为False则触发异常AssertionError
  3. assert isinstance(age,int)
  4. # 等同于
  5. if not isinstance(age,int):
  6.     raise AssertionError

三 何时使用异常处理

在了解了异常处理机制后，本着提高程序容错性和可靠性的目的，读者可能会错误地认为应该尽可能多地为程序加上try…except…，这其是在过度消费程序的可读性，因为try…except本来就是你附加给程序的一种额外的逻辑，与你的主要工作是没有多大关系的。
如果错误发生的条件是“可预知的”，我们应该用if来进行”预防”，如下

  1. age=input('input your age>>: ').strip()
  2. if age.isdigit(): # 可预知只有满足字符串age是数字的条件，int(age)才不会触发异常，
  3.     age=int(age)
  4. else:
  5.     print('You must enter the number')

如果错误发生的条件“不可预知”，即异常一定会触发，那么我们才应该使用try…except语句来处理。例如我们编写一个下载网页内容的功能，网络发生延迟之类的异常是很正常的事，而我们根本无法预知在满足什么条件的情况下才会出现延迟，因而只能用异常处理机制了

  1. import requests
  2. from requests.exceptions import ConnectTimeout # 导入requests模块内自定义的异常
  3. def get(url):
  4.     try:
  5.         response=requests.get(url,timeout=3)#超过3秒未下载成功则触发ConnectTimeout异常
  6.         res=response.text
  7.     except ConnectTimeout:
  8.         print('连接请求超时')
  9.         res=None
  10.     except Exception:
  11.         print('网络出现其他异常')
  12.         res=None
  13.     return res
  14. get('https://www.python.org')