异常处理

一、异常处理介绍

什么是异常？

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

异常处理的三个特征：

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

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

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

  

为何处理异常？

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

两种产出异常的因素

• 语法上的错误示例：

  >>> 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中不同的异常使用不同的类型去标识，一个异常类型标识一种异常

常见异常类型

python所有标准异常

• 常用异常也包含在内

更多其他异常

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