Python3: 异常处理与 with 语句

淩亂°似流年 2021-09-21 22:40 365阅读 0赞

本文链接: [https://xiets.blog.csdn.net/article/details/115557506][https_xiets.blog.csdn.net_article_details_115557506]

[Python3 学习笔记（目录）][Python3]

# 1. 异常 #

## 1.1 异常捕获 ##

*  使用 try、except 语句处理异常：

try:                        # try 语句块
        ...                     # 其他 Python 代码
        a = 1 / 0               # 除数不能为0, 将抛出异常（抛出异常后, try 语句块中剩下的代码不会执行）
        ...                     # 其他 Python 代码
    except Exception as e:      # 捕获异常, Exception 表示可以捕获的异常类型, e 为接收异常实例的变量
        print(e)                # 处理异常
        pass

*  多个异常处理（一）

# 说明:
    # 多个 except 捕获异常的代码块, 只有一个与异常类型匹配的 except 会被执行, 
    # 如果抛出的异常类型没有一个 except 指定的类型匹配, 则直接抛给上层调用者。
    
    try:
        # Python 代码
        pass
    
    except NameError as e:          # 如果 try 代码块中抛出 NameError 类型的异常, 则此处捕获
        # 处理 NameError 类型的异常
        pass
    
    except ValueError:              # 接收异常实例的变量可以不写,
        # 处理 ValueError 类型的异常 # 如果 try 代码块中抛出 ValueError 类型的异常, 则此处捕获
        pass
    
    except:                         # 没有指定异常类型表示异常通配, 可以接收所有异常,
        # 处理其他类型的异常 # 如果 try 代码块中抛出其他类型的异常, 则此处捕获
        pass

*  多个异常处理（二）

try:
        # Python 代码
        pass
    
    except (NameError, ValueError) as e:            # 多个异常类型可以以 元祖 的方式声明,
        # 处理 NameError 或 ValueError 类型的异常 # 如果抛出 NameError 或 ValueError 类型的异常, 
        pass                                        # 则该 except 代码块捕获
    
    except:                                         # 其他异常的捕获
        # 其他异常的处理
        pass

*  except else 语句

try:
        # Python 代码
        pass
    
    except (NameError, ValueError, IOError) as e:
        # 处理异常
        pass
    
    except Exception as e:
        # 处理异常
        pass
    
    else:
        # 如果 try 代码块中没有抛出异常,
        # 则执行完 try 代码块后将执行 else 代码块
        pass

## 1.2 打印调用栈 ##

Python 自带 `traceback` 用于发送异常事打印调用栈信息:

import traceback
    
    def parse_int(text):
        try:
            return int(text)
        except Exception as e:
            traceback.print_exc()
    
    print(parse_int("123.5"))

输出到指定文件，默认输出到 `file=sys.stderr`:

traceback.print_exc(file=open("error.txt", "wt"))

## 1.3 手动抛出异常 ##

手动抛出异常使用 `raise` 语句，可以抛出一个 **异常的类型** 或 **异常类型的实例**。`Exception` 是所有非退出异常的公共基类，BaseException 是所有异常的公共基类，Exception 继承自 BaseException，其他非退出异常继承自 Exception，`raise` 只能抛出 `BaseException` 异常类型（包括其子类）或 异常类型的实例。

name = input("input name:")
    age = int(input("input age:"))
    
    try:
        # 抛出异常类型的实例
        if len(name) > 20:
            # 创建一个异常实例抛出, str 类型的参数表示异常的 message
            raise NameError("name length limit 1 ~ 20")
    
        if age <= 0:
            # 创建一个异常实例抛出
            raise ValueError("age must be > 0")
    
        # 也可以直接抛出一个异常的类型
        # raise Exception
    
    except ValueError as e:
        # 异常处理,
        # 捕获到异常对象后可以直接抛出
        raise e
    
    except NameError as e:
        # 异常处理,
        # 捕获到异常对象后可以对异常进行包装上另一个异常
        # 类型后再抛出, 异常类型的参数 e 表示包装该异常
        raise RuntimeError(e)
    
    except Exception as e:
        # 异常处理,
        # 在 except 代码块中抛出异常可以不写具体要抛出的异常对象,
        # 默认抛出 except 捕获到的异常对象
        raise
    
    
    
    if len(name) > 20:
        # 如果没有在 try 代码块中抛出异常并捕获, 则直接抛给上层调用者（抛出异常后后面的代码不在执行）
        raise NameError("name length limit 1 ~ 20")

## 1.4 清理行为（finally） ##

`finally` 代码块用于定义 try 代码块中处理后的一些清理行为（收尾工作）, 无论 try 中是否抛出异常, finally 始终都将会执行。例如在 try 中打开文件处理, 则无论处理过程是否发生异常, 都需要关闭文件, 则可以在 finally 中做关闭文件的处理。

try:
        # Python 代码
        pass
    
    except Exception as e:
        # 处理异常
        pass
    
    finally:
        # 无论在 try 代码块中是否有抛出异常, finally 代码块始终都会被执行;
        # finally 将在 try 和 except/else 执行完后执行;
        # 如果 try 或 except/else 中被 return, 则先计算出 return 的值,
        # 然后再执行 finally 后才会真正 return
        pass

也可以不要 except，直接 try finally:

try:
        # 没有 except, 如果发生异常, 将直接抛给上层调用者
        pass
    finally:
        # try 中抛出异常之前会先执行 finally 代码块
        pass

下面是打开并读取文件的处理:

f = None
    try:
        f = open("demo.txt")    # 打开文件
        s = f.read()            # 读取文件
        print(s)
    except:
        pass
    finally:
        if f != None:
            f.close()           # 关闭文件

## 1.5 自定义异常 ##

所有的异常类均直接或间接继承自 `Exception`，自定义异常示例:

import traceback
    
    
    class MyError(Exception):
        """ 自定义异常, 继承 Exception """
        def __init__(self, *args, **kwargs):
            pass
    
    
    try:
        raise MyError("my error")   # 抛出异常
    except MyError as e:
        print(e)                    # 输出: "my error"
        print(type(e))              # 输出: <class '__main__.MyError'>
        traceback.print_exc()       # 输出调用栈信息

# 5. `with` 语句 #

`with` 语句用于对 try except finally 的优化，让代码更加简洁美观。例如上面的贷款并读取文件，用 with 语句可以实现为:

# 在 with 语句块执行完后（无论是否发生异常）会自动关闭文件
    with open("demo.txt") as f:
        s = f.read()
        print(s)

with 语句是用于给 **上下文管理器** 的调用，标准模块中的许多模块也都支持 with，也可以自定义支持 with 语句的类。使类的对象支持 with，需要类实现 `__enter__` 和 `__exit__` 两个方法。上面使用 with 打开的文件实际上就是在 \_\_exit\_\_ 方法中被关闭。

## 5.1 with 语句的执行原理 ##

with obj as f:
        # f.method(...)
        pass
    
    # 1. obj 表示一个对象（或是一个表达式, 结果为一个对象）
    #
    # 2. 调用 obj 对象的 __enter__ 方法, 返回值赋值给 as 右边的变量 f, 
    # 即: f = obj.__enter__()
    #
    # 3. 执行 with 代码块中的代码
    #
    # 4. 执行完 with 代码块中的代码后, 无论是否发生异常, 调用 obj 的 __exit__ 方法, 
    # 即: obj.__exit__(...)

上面代码相当于:

obj = ...
    f = obj.__enter__()
    try:
        # f.method(...)
        pass
    finally:
        obj.__exit__(...)

as 也可以省略:

with obj:
        # obj.method(...)
        pass

## 5.2 自定义支持 with 上下文管理器的类 ##

class Demo:
    
        def __enter__(self):
            """ 执行 with 语句块时, 将先调用 __enter__ 方法, 执行预先需要处理的代码, 返回值将赋值给 as 右边的变量（通常返回自己） """
            print("enter")
            return self
    
        def test(self):
            # raise Exception("exc value")
            print("test")
    
        def __exit__(self, exc_type, exc_val, exc_tb):
            """ 执行完 with 语句块后会调用 __exit__ 方法, 执行清理工作, 如果 with 语句块中抛出异常, 则 exc_type, exc_val, exc_tb 三个参数 分别表示抛出异常的 异常类型、异常对象的值、异常对象的 traceback 对象, 如果没有抛出异常, 则三个参数的值均为 None """
            print("exit", exc_type, exc_val, exc_tb)
    
    
    with Demo() as d:           # obj = Demo(); d = obj.__enter__()
        d.test()                # with 语句块中如果发生异常, 则执行完 __exit__ 后抛给上层调用者
                                # obj.__exit__(...)
    
    
    # 执行完后将输出:
    # enter
    # test
    # exit None None None

## 5.3 使用生成器 yield 定义上下文管理器 ##

from contextlib import contextmanager       # 导入上下文管理器
    
    
    @contextmanager             # 用上下文管理器装饰函数
    def test():
        print("__enter__")      # yield 之前的代码相当于 __enter__
        yield "Hello"           # yield 指定的对象即为执行 with 语句赋值给 as 右边变量的对象
        print("__exit__")       # yield 之后的代码相当于 __exit__
    
    
    with test() as v:
        print(v)                # v 的值为 "Hello"
    
    
    # 执行顺序:
    # 1. 执行 yield 之前的代码;
    # 2. yield 右边的对象赋值给 as 右边的变量 v, 然后执行 with 代码块;
    # 3. 执行 yield 之后的代码。
    # PS:
    # 如果第 2 步中抛出异常, 则第 3 步不执行, 直接把异常抛给上层调用者。

[https_xiets.blog.csdn.net_article_details_115557506]: https://xiets.blog.csdn.net/article/details/115557506
[Python3]: https://xiets.blog.csdn.net/article/details/109266600