Skip to content
SRE运维进阶之路SRE运维进阶之路
github icon
    • 1 Python 简介

      • 1.1 初识Python
        • 1.2 Python 代码规范
          • 1.3 Python 虚拟环境
            • 1.4 使用 vscode 打造 python 开发环境
              • 1.5 pypi 配置国内镜像
              • 2 Python 基础

                • 2.1 Python基础语法
                  • 2.2 程序控制
                    • 2.3 Python数据类型

                      • 2.3.1 数值型
                        • 2.3.2 字符串 str
                          • 2.3.3 字节序列
                            • 2.3.4 列表 list & 元组 tuple
                              • 2.3.5 集合 set & 字典 dict
                            • 3 高级特性

                              • 3.1 线性结构特征 可迭代 & 切片
                                • 3.2 列表、集合、字典解析式
                                  • 3.3 生成器
                                    • 3.4 迭代器
                                    • 4 函数

                                      • 4.1 函数的定义 & 调用 & 返回值
                                        • 4.2 函数参数
                                          • 4.3 作用域
                                            • 4.4 递归函数
                                            • 5 函数式编程

                                              • 5.1 高阶函数
                                                • 5.2 返回函数
                                                  • 5.3 匿名函数
                                                    • 5.4 装饰器
                                                      • 5.5 偏函数
                                                      • 6 模块

                                                        • 6.1 Python 模块常用的几种安装方式
                                                          • 6.2 Python 的 setup.py 详解
                                                          • 7 IO编程

                                                            • 7.1 操作文件和目录
                                                              • 7.2 序列化和反序列化
                                                              • 8 异常、调试和测试

                                                                • 8.1 异常处理
                                                                  • 产生异常
                                                                    • 异常的捕获
                                                                      • 异常类及继承层次
                                                                        • BaseException 及子类
                                                                          • BaseException
                                                                            • SystemExit
                                                                              • KeyboardInterrupt
                                                                              • Exception及子类
                                                                                • 多种捕获
                                                                                  • as 子句
                                                                                    • finally子句
                                                                                      • else 子句
                                                                                        • 总结
                                                                                      • 9 面向对象编程

                                                                                        • 9.1 类、实例和封装
                                                                                          • 9.2 访问控制和属性装饰器
                                                                                            • 9.3 继承、多态和Mixin
                                                                                            • 10 进程和线程

                                                                                              • 10.1 多进程
                                                                                                • 10.2 多线程
                                                                                                  • 10.2 线程同步
                                                                                                  • 11 网络编程

                                                                                                    • 11.1 SocketServer
                                                                                                      • 11.2 TCP 编程
                                                                                                      • 11 魔术方法
                                                                                                        • 17 IO 模型
                                                                                                          • python 实际工作中的实例
                                                                                                          • 前端学习笔记

                                                                                                            8.1 异常处理

                                                                                                            author iconClaycalendar icon2021年5月11日category icon
                                                                                                            • Python
                                                                                                            timer icon大约 7 分钟

                                                                                                            此页内容
                                                                                                            • 产生异常
                                                                                                            • 异常的捕获
                                                                                                            • 异常类及继承层次
                                                                                                            • BaseException 及子类
                                                                                                              • BaseException
                                                                                                              • SystemExit
                                                                                                              • KeyboardInterrupt
                                                                                                            • Exception及子类
                                                                                                            • 多种捕获
                                                                                                            • as 子句
                                                                                                            • finally子句
                                                                                                            • else 子句
                                                                                                            • 总结

                                                                                                            # 8.1 异常处理

                                                                                                            错误 Error

                                                                                                            逻辑错误:算法写错了,例如加法写成了减法

                                                                                                            笔误:例如变量名写错了,语法错误

                                                                                                            函数或类使用错误,其实这也属于逻辑错误

                                                                                                            总之,错误是可以避免的

                                                                                                            异常 Exception

                                                                                                            本意就是意外情况

                                                                                                            这有个前提,没有出现上面说的错误,也就是说程序写的没有问题,但是在某些情况下,会出现一些意外,导致程序无法正常的执行下去。

                                                                                                            例如open函数操作一个文件,文件不存在,或者创建一个文件时已经存在了,或者访问一个网络文件,突然断网了,这就是异常,是个意外的情况。

                                                                                                            异常不可能避免

                                                                                                            错误和异常

                                                                                                            在高级编程语言中,一般都有错误和异常的概念,异常是可以捕获,并被处理的,但是错误是不能被捕获的。 举例 对比异常和错误

                                                                                                            with open('testabc') as f:
                                                                                                                pass
                                                                                                            # 异常
                                                                                                            Traceback (most recent call last):
                                                                                                              File "C:/Users/user/PycharmProjects/pr1/test1.py", line 1, in <module>
                                                                                                                with open('testabc') as f:
                                                                                                            FileNotFoundError: [Errno 2] No such file or directory: 'testabc'
                                                                                                                    
                                                                                                            def 0A():
                                                                                                                pass
                                                                                                            
                                                                                                            # 错误
                                                                                                              File "test1.py", line 1
                                                                                                                def 0A():
                                                                                                                    ^
                                                                                                            SyntaxError: invalid syntax
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10
                                                                                                            11
                                                                                                            12
                                                                                                            13
                                                                                                            14
                                                                                                            15
                                                                                                            16

                                                                                                            一个健壮的程序

                                                                                                            • 尽可能的避免错误
                                                                                                            • 尽可能的捕获、处理各种异常

                                                                                                            # 产生异常

                                                                                                            产生:

                                                                                                            • raise 语句显式的抛出异常
                                                                                                            • Python解释器自己检测到异常并引发它
                                                                                                            def foo():
                                                                                                                print('before')
                                                                                                                print(1/0) # 除零异常
                                                                                                                print('after')
                                                                                                            
                                                                                                            foo()
                                                                                                            
                                                                                                            def bar():
                                                                                                                print('before')
                                                                                                                raise Exception('my exception') # raise主动抛出异常
                                                                                                                print('after')
                                                                                                            bar()
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10
                                                                                                            11
                                                                                                            12

                                                                                                            程序会在异常抛出的地方中断执行,如果不捕获,就会提前结束程序(其实是终止当前线程的执行)

                                                                                                            # 异常的捕获

                                                                                                            try:
                                                                                                            	待捕获异常的代码块
                                                                                                            except [异常类型]:
                                                                                                            	异常的处理代码块
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            def foo():
                                                                                                                try:
                                                                                                                    print('before')
                                                                                                                    print(1/0) # 除零异常
                                                                                                                    print('after')
                                                                                                                except:
                                                                                                                    print('catch u')
                                                                                                                print('finished')
                                                                                                            
                                                                                                            foo()
                                                                                                            print('==== end ====')
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10
                                                                                                            11

                                                                                                            上例执行到 c = 1/0 时产生异常并抛出,由于使用了 try...except 语句块则捕捉到了这个异常,异常生成位置之后语句将不再执行,转而执行对应的 except 部分的语句,最后执行 try...except 语句块之外的语句。

                                                                                                            捕获指定类型的异常

                                                                                                            def foo():
                                                                                                                try:
                                                                                                                    print('before')
                                                                                                                    print(1/0) # 除零异常
                                                                                                                    print('after')
                                                                                                                except ArithmeticError:
                                                                                                                    print('catch u')
                                                                                                                print('finished')
                                                                                                            
                                                                                                            foo()
                                                                                                            print('==== end ====')
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10
                                                                                                            11

                                                                                                            # 异常类及继承层次

                                                                                                            # Python异常的继承
                                                                                                            BaseException
                                                                                                                +-- SystemExit
                                                                                                                +-- KeyboardInterrupt
                                                                                                                +-- GeneratorExit
                                                                                                                +-- Exception
                                                                                                                +-- RuntimeError
                                                                                                                | +-- RecursionError
                                                                                                                +-- MemoryError
                                                                                                                +-- NameError
                                                                                                                +-- StopIteration
                                                                                                                +-- StopAsyncIteration
                                                                                                                +-- ArithmeticError
                                                                                                                | +-- FloatingPointError
                                                                                                                | +-- OverflowError
                                                                                                                | +-- ZeroDivisionError
                                                                                                                +-- LookupError
                                                                                                                | +-- IndexError
                                                                                                                | +-- KeyError
                                                                                                                +-- SyntaxError
                                                                                                                +-- OSError
                                                                                                                | +-- BlockingIOError
                                                                                                                | +-- ChildProcessError
                                                                                                                | +-- ConnectionError
                                                                                                                | | +-- BrokenPipeError
                                                                                                                | | +-- ConnectionAbortedError
                                                                                                                | | +-- ConnectionRefusedError
                                                                                                                | | +-- ConnectionResetError
                                                                                                                | +-- FileExistsError
                                                                                                                | +-- FileNotFoundError
                                                                                                                | +-- InterruptedError
                                                                                                                | +-- IsADirectoryError
                                                                                                                | +-- NotADirectoryError
                                                                                                                | +-- PermissionError
                                                                                                                | +-- ProcessLookupError
                                                                                                                | +-- TimeoutError
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10
                                                                                                            11
                                                                                                            12
                                                                                                            13
                                                                                                            14
                                                                                                            15
                                                                                                            16
                                                                                                            17
                                                                                                            18
                                                                                                            19
                                                                                                            20
                                                                                                            21
                                                                                                            22
                                                                                                            23
                                                                                                            24
                                                                                                            25
                                                                                                            26
                                                                                                            27
                                                                                                            28
                                                                                                            29
                                                                                                            30
                                                                                                            31
                                                                                                            32
                                                                                                            33
                                                                                                            34
                                                                                                            35
                                                                                                            36

                                                                                                            # BaseException 及子类

                                                                                                            # BaseException

                                                                                                            所有内建异常类的基类是BaseException

                                                                                                            # SystemExit

                                                                                                            sys.exit()函数引发的异常,异常不捕获处理,就直接交给Python解释器,解释器退出。

                                                                                                            import sys
                                                                                                            print('before')
                                                                                                            sys.exit(1)
                                                                                                            print('SysExit')
                                                                                                            print('after') # 是否执行? 不执行
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            # 捕获这个异常
                                                                                                            import sys
                                                                                                            try:
                                                                                                                print('before')
                                                                                                                sys.exit(1)
                                                                                                                print('SysExit')
                                                                                                                print('after') 
                                                                                                            except SystemExit: # 换成Exception能否捕获 ,能
                                                                                                                print('SysExit')
                                                                                                            print('outer')  # 是否执行? 执行
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10

                                                                                                            如果except语句捕获了该异常,则继续向后面执行,如果没有捕获住该异常SystemExit,解释器直接退出程序。

                                                                                                            注意捕获前后程序退出状态码的变化。(捕获后状态码变为0)

                                                                                                            # KeyboardInterrupt

                                                                                                            对应的捕获用户中断行为Ctrl + C

                                                                                                            import time
                                                                                                            try:
                                                                                                                while True:
                                                                                                                    time.sleep(1)
                                                                                                                    print('running')
                                                                                                            except KeyboardInterrupt:
                                                                                                                print("Ctrl + c")
                                                                                                            print('=' * 30)
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8

                                                                                                            # Exception及子类

                                                                                                            Exception是所有内建的、非系统退出的异常的基类,自定义异常类应该继承自它

                                                                                                            SyntaxError 语法错误

                                                                                                            Python将这种错误也归到异常类下面的Exception下的子类,但是这种错误是不可捕获的

                                                                                                            def a():
                                                                                                                try:
                                                                                                                    0a = 5
                                                                                                                except:
                                                                                                                    pass
                                                                                                            a()
                                                                                                              File "test1.py", line 3
                                                                                                                0a = 5
                                                                                                                 ^
                                                                                                            SyntaxError: invalid syntax
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10

                                                                                                            ArithmeticError

                                                                                                            所有算术计算引发的异常,其子类有除零异常等

                                                                                                            LookupError

                                                                                                            使用映射的键或序列的索引无效时引发的异常的基类:IndexError, KeyError

                                                                                                            自定义异常类

                                                                                                            从 Exception 继承的类

                                                                                                            class MyException(Exception):
                                                                                                                pass
                                                                                                            
                                                                                                            try:
                                                                                                                raise MyException()
                                                                                                            except MyException: # 捕获自定义异常
                                                                                                                print('catch u')
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7

                                                                                                            # 多种捕获

                                                                                                            except 可以指定捕获的类型,捕获多种异常

                                                                                                            import sys
                                                                                                            class MyException(Exception):
                                                                                                                pass
                                                                                                            
                                                                                                            try:
                                                                                                                a = 1/0
                                                                                                                raise MyException()
                                                                                                                open('t')
                                                                                                                sys.exit(1)
                                                                                                            except ZeroDivisionError:
                                                                                                                print('zero')
                                                                                                            except ArithmeticError:
                                                                                                                print('arith')
                                                                                                            except MyException: # 捕获自定义异常
                                                                                                                print('catch u')
                                                                                                            except Exception:
                                                                                                                print('exception')
                                                                                                            except: # 写在最后,缺省捕获
                                                                                                                print('error')
                                                                                                            print('====end====')
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10
                                                                                                            11
                                                                                                            12
                                                                                                            13
                                                                                                            14
                                                                                                            15
                                                                                                            16
                                                                                                            17
                                                                                                            18
                                                                                                            19
                                                                                                            20

                                                                                                            捕获规则

                                                                                                            • 捕获是从上到下依次比较,如果匹配,则执行匹配的except语句块
                                                                                                            • 如果被一个except语句捕获,其他except语句就不会再次捕获了
                                                                                                            • 如果没有任何一个except语句捕获到这个异常,则该异常向外抛出
                                                                                                            • except: 称为缺省捕获,缺省捕获必须是最后一个捕获语句

                                                                                                            捕获的原则

                                                                                                            • 从小到大,从具体到宽泛

                                                                                                            # as 子句

                                                                                                            先看一个例子

                                                                                                            # raise 能抛出什么样的异常?
                                                                                                            class A: pass
                                                                                                            try:
                                                                                                                # 1/0
                                                                                                                raise 1
                                                                                                                # raise "abc"
                                                                                                                # raise A
                                                                                                                # raise A()
                                                                                                                # raise {}
                                                                                                            except:  # 写在最后,缺省捕获
                                                                                                                print('catch u')
                                                                                                            
                                                                                                            print('====end====')
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10
                                                                                                            11
                                                                                                            12
                                                                                                            13

                                                                                                            raise 真的什么类型都能抛出吗?

                                                                                                            被抛出的异常,应该是异常类的实例,如何获得这个对象呢?使用 as 子句

                                                                                                            # raise 能抛出什么样的异常?
                                                                                                            class A: pass
                                                                                                            try:
                                                                                                                # 1/0
                                                                                                                # raise 1
                                                                                                                raise "abc"
                                                                                                                # raise A
                                                                                                                # raise A()
                                                                                                                # raise {}
                                                                                                            except Exception as e:  # 写在最后,缺省捕获
                                                                                                                print(type(e), e)  # 抛出TypeError类型异常实例
                                                                                                            
                                                                                                            print('====end====')
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10
                                                                                                            11
                                                                                                            12
                                                                                                            13

                                                                                                            raise语句

                                                                                                            • raise后要求应该是BaseException类的子类或实例,如果是类,将被无参实例化。自定义应该是Exception子类

                                                                                                            • raise后什么都没有,表示抛出最近一个被激活的异常,如果没有被激活的异常,则抛类型异常。

                                                                                                              这种方式较少用,它用在except中

                                                                                                            # finally子句

                                                                                                            finally 最终,即最后一定要执行的,try...finally 语句块中,不管是否发生了异常,都要执行finally的部分

                                                                                                            try:
                                                                                                                f = open('test.tt')
                                                                                                            except FileNotFoundError as e:
                                                                                                                print('{} {} {}'.format(e.__class__, e.errno, e.strerror))
                                                                                                            finally:
                                                                                                                print('清理工作')
                                                                                                            	f.close() #
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7

                                                                                                            注意上例中的f的作用域,解决的办法是在外部定义 f

                                                                                                            finally 中一般放置资源的清理、释放工作的语句

                                                                                                            f = None
                                                                                                            try:
                                                                                                                f = open('test.tt')
                                                                                                            except Exception as e:
                                                                                                                print('{}'.format(e))
                                                                                                            finally:
                                                                                                                print('清理工作')
                                                                                                                if f:
                                                                                                                    f.close()
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9

                                                                                                            也可以在 finally 中再次捕捉异常

                                                                                                            try:
                                                                                                                f = open('test.tt')
                                                                                                            except FileNotFoundError as e:
                                                                                                                print('{} {} {}'.format(e.__class__, e.errno, e.strerror))
                                                                                                            finally:
                                                                                                                print('清理工作')
                                                                                                                try:
                                                                                                            	    f.close() #
                                                                                                                except Exception as e:
                                                                                                                    print(e)
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10

                                                                                                            语句嵌套和捕获

                                                                                                            • 异常语句内部可以嵌入到try块、except块、finally块中
                                                                                                            • 异常在内部产生后,如果没有捕获到,就会继续向外部抛出
                                                                                                            • 如果外部也没能捕获,将继续再向外部抛出,直至异常代码所在线程,导致线程崩溃
                                                                                                            • finally中有return、break语句,则异常就不会继续向外抛出
                                                                                                            try:
                                                                                                                try:
                                                                                                                    1/0
                                                                                                                except KeyError as e:
                                                                                                                    print(1, e)
                                                                                                                finally:
                                                                                                                    print(2, 'inner fin')
                                                                                                            except FileNotFoundError as e:
                                                                                                                print(3, e)
                                                                                                            finally:
                                                                                                                print(4, 'outer fin')
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10
                                                                                                            11

                                                                                                            # else 子句

                                                                                                            try:
                                                                                                                ret = 1 * 0
                                                                                                            except ArithmeticError as e:
                                                                                                                print(e)
                                                                                                            else:
                                                                                                                print('OK')
                                                                                                            finally:
                                                                                                                print('fin')
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8

                                                                                                            else 子句,没有任何异常发生,则执行

                                                                                                            # 总结

                                                                                                            try:
                                                                                                                <语句> #运行别的代码
                                                                                                            except <异常类>:
                                                                                                                <语句> # 捕获某种类型的异常
                                                                                                            except <异常类> as <变量名>:
                                                                                                                <语句> # 捕获某种类型的异常并获得对象
                                                                                                            else:
                                                                                                                <语句> #如果没有异常发生
                                                                                                            finally:
                                                                                                                <语句> #退出try时总会执行
                                                                                                            
                                                                                                            1
                                                                                                            2
                                                                                                            3
                                                                                                            4
                                                                                                            5
                                                                                                            6
                                                                                                            7
                                                                                                            8
                                                                                                            9
                                                                                                            10
                                                                                                            1. 如果try中语句执行时发生异常,搜索except子句,并执行第一个匹配该异常的except子句
                                                                                                            2. 如果try中语句执行时发生异常,却没有匹配的except子句,异常将被递交到外层的try,如果外层不处理这个异常,异常将继续向外层传递。如果都不处理该异常,则会传递到最外层,如果还没有处理,就终止异常所在的线程
                                                                                                            3. 如果在try执行时没有发生异常,如有else子句,可执行else子句中的语句
                                                                                                            4. 无论try中是否发生异常,finally子句最终都会执行
                                                                                                            edit icon编辑此页open in new window
                                                                                                            上次编辑于: 2021/6/18 08:28:06
                                                                                                            贡献者: clay-wangzhi
                                                                                                            备案号:冀ICP备2021007336号
                                                                                                            Copyright © 2023 Clay