• 异常处理的格式： ```python try: a = 1 b = 0 print(a/b) c except ZeroDivisionError: print(‘0不能被除’)

except NameError: print(‘变量未声明’)

  2. - 常用的异常处理类型：
  3. | 异常名称 | 描述 |
  4. | :--- | :--- |
  5. | BaseException | 所有异常的基类 |
  6. | SystemExit | 解释器请求退出 |
  7. | KeyboardInterrupt | 用户中断执行(通常是输入^C) |
  8. | Exception | 常规错误的基类 |
  9. | StopIteration | 迭代器没有更多的值 |
  10. | GeneratorExit | 生成器(generator)发生异常来通知退出 |
  11. | StandardError | 所有的内建标准异常的基类 |
  12. | ArithmeticError | 所有数值计算错误的基类 |
  13. | FloatingPointError | 浮点计算错误 |
  14. | OverflowError | 数值运算超出最大限制 |
  15. | ZeroDivisionError | 除(或取模)零 (所有数据类型) |
  16. | AssertionError | 断言语句失败 |
  17. | AttributeError | 对象没有这个属性 |
  18. | EOFError | 没有内建输入,到达EOF 标记 |
  19. | EnvironmentError | 操作系统错误的基类 |
  20. | IOError | 输入/输出操作失败 |
  21. | OSError | 操作系统错误 |
  22. | WindowsError | 系统调用失败 |
  23. | ImportError | 导入模块/对象失败 |
  24. | LookupError | 无效数据查询的基类 |
  25. | IndexError | 序列中没有此索引(index) |
  26. | KeyError | 映射中没有这个键 |
  27. | MemoryError | 内存溢出错误(对于Python 解释器不是致命的) |
  28. | NameError | 未声明/初始化对象 (没有属性) |
  29. | UnboundLocalError | 访问未初始化的本地变量 |
  30. | ReferenceError | 弱引用(Weak reference)试图访问已经垃圾回收了的对象 |
  31. | RuntimeError | 一般的运行时错误 |
  32. | NotImplementedError | 尚未实现的方法 |
  33. | SyntaxError | Python 语法错误 |
  34. | IndentationError | 缩进错误 |
  35. | TabError | Tab 和空格混用 |
  36. | SystemError | 一般的解释器系统错误 |
  37. | TypeError | 对类型无效的操作 |
  38. | ValueError | 传入无效的参数 |
  39. | UnicodeError | Unicode 相关的错误 |
  40. | UnicodeDecodeError | Unicode 解码时的错误 |
  41. | UnicodeEncodeError | Unicode 编码时错误 |
  42. | UnicodeTranslateError | Unicode 转换时错误 |
  43. | Warning | 警告的基类 |
  44. | DeprecationWarning | 关于被弃用的特征的警告 |
  45. | FutureWarning | 关于构造将来语义会有改变的警告 |
  46. | OverflowWarning | 旧的关于自动提升为长整型(long)的警告 |
  47. | PendingDeprecationWarning | 关于特性将会被废弃的警告 |
  48. | RuntimeWarning | 可疑的运行时行为(runtime behavior)的警告 |
  49. | SyntaxWarning | 可疑的语法的警告 |
  50. | UserWarning | 用户代码生成的警告 |
  53. - 万能异常处理：当一个程序中写了很多个异常类型后会造成程序的冗余的时候或者常规的异常处理不了的时候，需要一个万能的异常处理程序来处理。格式为：except Exception as e，Exception是所有异常类的基类，变量名e表示的是触发异常的类型。
  54. ```python
  55. try:
  56.     a = 1
  57.     b = 2
  58.     c
  59. except Exception as e:
  60.     print(e, type(e))
  62. '''
  63. name 'c' is not defined   <class 'NameError'>
  65. '''

注意：万能异常可以作为常规异常的分支，但是必须放在所有except分支的最后，不能放在前边。

  • 多分支常规、万能异常处理
    以元组的形式编写异常的类型，进行一场处理 ```python

try: name = ‘alex’ a = 1 b = [][3]

except (NameError, IndexError) as e: print(e)

  1. # 元组中可以写多个一场的类型，从左往右判断

‘’’ list index out of range ‘’’

  2. - 多分支进阶一：<br />在异常处理后边加上else,如果前边的程序没有异常，则执行else语句中的内容，else中的内容一般都是程序反馈或者日志记录内容
  4. ```python
  5. import logging
  6. logging.basicConfig(
  7.     level=logging.DEBUG, 
  8.     format = '%(asctime)s %(lineno)d %(levelname)s %(message)s',
  9.     datefmt = '%a, %d, %b %Y %H:%M:%S'
  10.     )
  12. try:
  13.     name = 'alex'
  14.     a = 1
  15.     b = [1, 3, 4, 5][3]
  17. except (NameError, IndexError) as e:
  18.     print(e)
  20. else:
  21.     logging.debug('调试信息')
  23. '''
  24. Sun, 16, Feb 2020 12:39:26 35 DEBUG 调试信息
  25. # %(message)s控制的是debug()中的信息是否显示
  26. '''
  • 多分支进阶二：
    finally下的内容是无论之前的程序是否有异常都会执行的程序，多用在操作系统、网络编程中占用资源的归还工作，例如关闭文件句柄。或者是try语句中有返回值需要处理的
  1. import logging
  2. logging.basicConfig(
  3.     level=logging.DEBUG, 
  4.     format = '%(asctime)s %(lineno)d %(levelname)s %(message)s',
  5.     datefmt = '%a, %d, %b %Y %H:%M:%S'
  6.     )
  8. try:
  9.     name = 'alex'
  10.     a = 1
  11.     b = [1, 3, 4, 5][3]
  13. except (NameError, IndexError) as e:
  14.     print(e)
  16. else:
  17.     logging.debug('调试信息')
  18. finally:
  19.     print('无论程序是否有异常都要执行的程序')
  21. '''
  22. Sun, 16, Feb 2020 12:46:01 35 DEBUG 调试信息
  23. 无论程序是否有异常都要执行的程序
  24. '''
  • 主动抛出异常
    主动抛出异常需要使用raise，如果raise没有任何异常类型/信息，则上边程序的异常类型是什么就抛出什么，如果后边定义有异常类型/信息，则抛出定义好的。 ```python try: name = ‘alex’ a = 1 b = [][3]

except ValueError: raise

else: logging.debug(‘调试信息’) finally: print(‘无论程序是否有异常都要执行的程序’)

‘’’ IndexError: list index out of range

注意：设置的是ValueError，但是程序却抛出了一个IndexError的异常，这个异常就是程序真正的异常类型

‘’’

  2. - 自定义异常类型
  3.    - 自定义异常必须继承Exception类
  4.    - 编写一个**init**(self, msg)方法，传一个msg参数
  5.    - raise 实例化自定义类对象
  6. ```python
  7. class NewException(Exception):
  8.     def __init__(self, msg):
  9.         self.msg = msg
  11. raise NewException('这是一个自定义的异常')
  12. # 抛出异常
  14. '''
  15. Traceback (most recent call last):
  16.   File "/Volumes/workspace/python-study/re_st/异常处理.py", line 43, in <module>
  17.     raise NewException('这是一个自定义的异常')
  18. __main__.NewException: 这是一个自定义的异常
  19. # 成功抛出自定义异常
  20. '''

  • 断言
    断言更多的使用到源码中，日常工作中用到很少，assert 条件来实现判断，如果条件为True则执行后续的程序，如果为False则不执行并报错，assert后的程序不需要缩进。

    1. assert True
    2. print('这是一个断言程序')

  • 总结
    在实际的开发过程中，应该尽量少的使用异常处理，能通过逻辑进行规避的尽量通过逻辑规避掉，即使使用异常处理，也应该是对某一句或者几句话进行处理，而不应该是对大量代码进行异常处理。当测试等各个工作都完成后，最后再在程序的外层添加一个大的异常处理，这个异常处理是为了避免用户在使用的过程中出现问题导致程序崩溃。