Python中类的魔术方法之上下文管理

Python中类的魔术方法之上下文管理

上下文管理

文件IO操作可以对文件对象使用上下文管理，使用with…as语法。
示例：

with open("text") as f:
    pass

仿照上面例子写一个自己的类，实现上下文管理

class Point:
    pass

with Point() as p: AttributeError:__exit__
    pass

提示属性错误，没有__exit__,看了需要这个属性
某些版本会显示没有__enter__

上下文管理对象与管理的安全

当一个对象同时实现了__enter__()和__exit__()方法，它就属于上下文管理的对象

方法	等价语法	意义
__enter__(self)	with obj() as c:pass进入语句块之前执行	进入与此对象相关的上下文，如果存在该方法，with语法会把该方法的返回值绑定到as子句中指定的变量上
__exit__(self, exc_type, exc_value, traceback)	with obj() as c:pass退出时执行	退出与此对象相关的上下文。时执行

简单示例：

class Point:
    def __init__(self):
        print("init------------")

    def __enter__(self):
        print("enter~~~~~~~~~~~~")
        return "abc" #返回值决定了as 后面变量的值

    def __exit__(self,exc_type,exc_val,exc_tb):
        print("exit ================")

with Point() as p:
    print("with in p = {}".format(p))

• 调用步骤：
  1. 先实例化with语句后面的对象obj。
  2. 调用对象obj中的__enter__(self)方法。如果有 as 语句将__enter__方法的返回值赋值该as后面的变量。
  3. 执行with下面面的语句体
  4. 离开with语句块的时候，调用__exit__(self,exc_type,exc_val,exc_tb)方法。如果with语句体内执行时发生异常，会被捕获并传入__exit__(self,exc_type,exc_val,exc_tb)的参数中。如果__exit__的返回值为等效于False表示不压制异常。反之压制异常。
• 注意：with并不会开启一个新的作用域。
• 方法参数
  1. __enter__(self)#方法没有其他参数。
  2. __exit__(self,exc_type,exc_value,exc_tb) #有3个参数
     • 如果没有异常，3个参数的值都为None，如果有异常，参数意义如下：
     • exc_type #异常类型
     • exc_value #异常的值
     • exc_tb #异常的追踪信息
     • 返回值：等效True的值为压制异常；否则，继续抛出异常

示例：演示异常

class Point:
    def __init__(self):
        print("init ----------")

    def __enter__(self):
        print("enter @@@@@@@@@@")
        return self #增加返回值

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(1,exc_type)
        print(2,exc_val)
        print(3,exc_tb)
        print("exit ==============")
        # return ""
        return "a"

with Point() as p:
    print("in with ------------")
    raise Exception("error")
    print("with over")

print("执行完成。。。。")

示例：用类来做装饰器，实现运行时间统计

import time,functools,datetime

class Xdd_Timeit:
    """
    时间统计类，也可以作为装饰器单独统计单个函数运行时长
    """

    def __init__(self,fn):
        """
        初始化方法
        :param fn: 需要统计的函数
        """
        functools.update_wrapper(self,fn)
        self.fn = fn
        self.starttime = None
        self.stoptime = None

    #with语句开始时默认调用的方法
    def __enter__(self):
        self.starttime = datetime.datetime.now()
        return self

    #with语句结束后默认调用的方法
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.stoptime = datetime.datetime.now()
        print("{} 总运行时长：{}".format(self.fn.__name__,(self.stoptime-self.starttime).total_seconds()))

    #使得类对象是个可调用函数
    def __call__(self, *args, **kwargs):
        start = datetime.datetime.now()
        sum = self.fn(*args, **kwargs)
        sound = datetime.datetime.now() - start
        print("{} 运行时长：{}".format(self.fn.__name__,sound.total_seconds()))
        return sum

@Xdd_Timeit
def add(x,y):
    time.sleep(1)
    return x+y

with Xdd_Timeit(add) as a:
    print(a(4,5),a(5,6),a(7,8))
    print(add(4,5),add(5,6),add(7,8))

上下文应用场景

1. 增强功能
   • 在代码执行的前后增加代码，以增强其功能。类似装饰器的功能。
2. 资源管理
   • 打开了资源需要关闭，例如文件对象、网络连接、数据库连接等
3. 权限验证
   • 在执行代码之前，做权限的验证，在 enter 中处理

contextlib.countextmanager上下文管理装饰器

1. contextlib.contextmanager
   • 它是一个装饰器实现上下文管理，装饰一个函数，而不是像类一样实现__enter__和__exit__方法。
   • 对装饰的函数有要求：必须有yield，也就是这个函数必须返回一个生成器，且只有yield一个值。

from contextlib import contextmanager

@contextmanager
def foo():
    print("enter") #相当于__enter__()
    yield 5  #yield 的值只能有一个，作为__enter__的返回值
    print("exit") #相当于__exit__()

with foo() as f:
    print("with start-------")
    print(f)
    print("with stop----------")

• f接受yield的返回值。
• 如果with中有异常，那么上面例子中不能保证exit的执行。需要在foo函数中增加try finally

from contextlib import contextmanager

@contextmanager
def foo():
    print("enter")
    try:
        yield 5
    except :
        print("异常被捕获")
    finally:
        print("exit")

with foo() as f:
    print(f)
    raise Exception()

1. 当yield发生处为生成器函数增加了上下文管理。这是为函数增加上下文机制的方式。
   • 把yield之前的当做__enter__方法执行
   • 把yield之后的当做__exit__方法执行
   • 把yield的值作为__enter__的返回值

• 应用举例：实现时间统计

from contextlib import contextmanager
import datetime,time

@contextmanager
def foo(fn):
    start = datetime.datetime.now()
    try:
        yield fn
    except:
        raise
    finally:
        stop = (datetime.datetime.now()- start).total_seconds()
        print("运行时长：{}".format(stop))
    
def add(x,y):
    time.sleep(1)
    return x+y

with foo(add) as a:
    print(a(2,3),a(1,2))
    print(add(4,5),add(5,6))

• 总结：
  如果业务逻辑简单可以使用函数加contextlib.contextmanager装饰器方式，如果业务复杂，用类的方式加 __enter__和__exit__ 方法方便