魔术方法2--上下文管理

最新推荐文章于 2022-12-01 10:44:53 发布
最新推荐文章于 2022-12-01 10:44:53 发布
阅读量98 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41827944/article/details/102803711
版权

魔术方法2

上下文管理对象

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

import time

class Point:
    def __init__(self):
        print('init ~~~~~~~~~~~~~~~')
        time.sleep(1)
        print('init over')
        
    def __enter__(self):
        print('enter ~~~~~~~~~~~~~~')
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit ========================')
        
with Point() as p:
    print('in with------------')
    
    time.sleep(2)
    print('with over')
    
print('=============end==============')


init ~~~~~~~~~~~~~~~
init over
enter ~~~~~~~~~~~~~~
in with------------
with over
exit ========================
=============end==============

实例化对象的时候，并不会调用enter，进入with语句块调用__enter__方法，然后执行语句体，最后离开with语句块的时候，调用__exit__方法。

with可以开启一个上下文运行环境，在执行前做一些准备工作，执行后做一些收尾工作。

注意：with并不开启一个新的作用域。

上下文管理的安全性

看看异常对上下文的影响

import time

class Point:
    def __init__(self):
        print('init ~~~~~~~~')
        time.sleep(1)
        print('init over')
        
    def __enter__(self):
        print('enter ~~~~~~~~')
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit =============')
        
with Point() as p:
    print('in with ---------')
    raise Exception('error')
    time.sleep(2)
    print('with over')
    
print('=============end===============')

init ~~~~~~~~
init over
enter ~~~~~~~~
in with ---------
exit =============



---------------------------------------------------------------------------

Exception                                 Traceback (most recent call last)

<ipython-input-6-a9563eb44b9a> in <module>
     15 with Point() as p:
     16     print('in with ---------')
---> 17     raise Exception('error')
     18     time.sleep(2)
     19     print('with over')


Exception: error

可以看出enter和exit照样执行，上下文管理是安全的。

极端的例子

调用sys.exit(),它会退出当前解释器。

打开Python解释器，在里面敲入sys.exit(),窗口直接关闭了。也就是说碰到这一句，Python运行环境直接退出了。

import time

class Point:
    def __init__(self):
        print('init ~~~~~~~~')
        time.sleep(1)
        print('init over')
        
    def __enter__(self):
        print('enter ~~~~~~~~')
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit =============')
        
with Point() as p:
    print('in with ---------')
    import sys
    sys.exit(1)
    time.sleep(2)
    print('with over')
    
print('=============end===============')

init ~~~~~~~~
init over
enter ~~~~~~~~
in with ---------
exit =============



An exception has occurred, use %tb to see the full traceback.


SystemExit: 1



d:\miniconda3\lib\site-packages\IPython\core\interactiveshell.py:3334: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.
  warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)

从执行结果来看，依然执行了__exit__函数，哪怕是退出Python运行环境。

说明上下文管理很安全。

with语句

# t3.py文件中写入下面代码
class Point:
    def __init__(self):
        print('init ~~~~~~~~')
        
    def __enter__(self):
        print('enter ~~~~~~~~')
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit =============')
        
f = open('t3.py')
with f as p:
    print(f)
    print(p)
    print(f is p)
    print(f == p)  
    
# p = f = None  

p = Point()
with p as f:
    print('in with ------------')
    print(p == f)  # enter方法将自己的返回值赋给了f
    print('with over')
    
print('=========end============')

<_io.TextIOWrapper name='t3.py' mode='r' encoding='cp936'>
<_io.TextIOWrapper name='t3.py' mode='r' encoding='cp936'>
True
True
init ~~~~~~~~
enter ~~~~~~~~
in with ------------
False
with over
exit =============
=========end============

问题在于__enter__上，它将自己的返回值赋给了f。修改上例

class Point:
    def __init__(self):
        print('init ~~~~~~~~')
        
    def __enter__(self):
        print('enter ~~~~~~~~')
        return self  # 增加返回值
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit =============')
        

p = Point()
with p as f:
    print('in with ------------')
    print(p == f)  # enter方法将自己的返回值赋给了f
    print('with over')
    
print('=========end============')

init ~~~~~~~~
enter ~~~~~~~~
in with ------------
True
with over
exit =============
=========end============

with语法，会调用with后的对象的__enter__方法，如果有as，则将该方法的返回值赋给as子句的变量。

上例，可以等价为f = p.__enter__()

方法的参数

__enter__方法 没有其他参数

__exit__方法有三个参数：

  • __exit__(self, exc_type, exc_value, exc_tb)

这三个参数都与异常有关，这三个参数都为None

如果有异常，参数意义如下：

  • exc_type，异常类型
  • exc_value,异常的值
  • exc_tb,异常的追踪信息
  • __exit__方法返回一个等效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 1
        
        
p = Point()
with p as f:
    print('in with ------------')
    raise Exception('Error')
    print('with over')
    
print('=========end============')

init ~~~~~~~~
enter ~~~~~~~~
in with ------------
1 <class 'Exception'>
2 Error
3 <traceback object at 0x0000023295B70588>
exit ============
=========end============

练习

为加法函数计时

方法1、使用装饰器显示该函数的执行时长

方法2、使用上下文管理方法来显示该函数的执行时长

装饰器实现
import time
import datetime
from functools import wraps


def timeit(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        start = datetime.datetime.now()
        ret = fn(*args, **kwargs)
        delta = (datetime.datetime.now() - start).total_seconds()
        print(delta)
        return ret
    return wrapper

@timeit
def add(x, y):
    time.sleep(2)
    return x + y

print(add(4, 5))


2.003499
9
上下文实现
import time
import datetime
from functools import wraps


def timeit(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        start = datetime.datetime.now()
        ret = fn(*args, **kwargs)
        delta = (datetime.datetime.now() - start).total_seconds()
        print(delta)
        return ret
    return wrapper

@timeit
def add(x, y):
    time.sleep(2)
    return x + y


class Timeit:
    
    def __init__(self, fn):
        self.fn = fn
        
    def __enter__(self):
        self.start = datetime.datetime.now()
        return self.fn
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        delta = (datetime.datetime.now() - self.start).total_seconds()
        print(delta)
        
with Timeit(add) as f:
    print(add(4, 6))

2.000753
10
2.000753
将类当作装饰器用
import time
import datetime
from functools import wraps


class Timeit:
    
    def __init__(self, fn):
        self.fn = fn
        
    def __enter__(self):
        self.start = datetime.datetime.now()
        return self.fn
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        delta = (datetime.datetime.now() - self.start).total_seconds()
        print(delta)
        
    def __call__(self, *args):
        self.start = datetime.datetime.now()
        ret = self.fn(*args)
        self.delta = (datetime.datetime.now() - self.start).total_seconds()
        print(self.delta)
        return ret
 

@Timeit
def add(x, y):
    time.sleep(2)
    return x + y

add(4, 5)
print(add.__doc__)
# print(add.__name__)  # 异常，没有此属性

2.00617
None



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-24-afc72ebf40ba> in <module>
     32 add(4, 5)
     33 print(add.__doc__)
---> 34 print(add.__name__)  # 异常，没有此属性


AttributeError: 'Timeit' object has no attribute '__name__'

思考

如何解决文档字符串问题？

方法一：直接修改__doc__

class Timeit:
    def __init__(self, fn=None):
        self.fn = fn
        # 把函数对象的文档字符串赋给类
        self.__doc__ = fn.__doc__

方法二：使用functools.wraps函数

import time
import datetime
from functools import wraps


class Timeit:
    """This is A Class"""
    
    def __init__(self, fn):
        self.fn = fn
        # 把函数对象的文档字符串赋给类
        # self.__doc__ = fn.__doc__
        # update+wrapper(self, fn)
        wraps(fn)(self)
        
    def __enter__(self):
        self.start = datetime.datetime.now()
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        delta = (datetime.datetime.now() - self.start).total_seconds()
        print(delta)
        
    def __call__(self, *args):
        self.start = datetime.datetime.now()
        ret = self.fn(*args)
        delta = (datetime.datetime.now() - self.start).total_seconds()
        print(delta)
        return ret
 

@Timeit
def add(x, y):
    """this is add function"""
    time.sleep(2)
    return x + y

print(add(10, 5))
print(add.__doc__)

print(Timeit(add).__doc__)

2.000463
15
this is add function
this is add function

上面的类既可以用在上下文管理，又可以用作装饰器

上下文应用场景

1、增强功能

  • 在代码执行的前后增加代码，以增强其功能。类似装饰器的功能

2、资源管理

  • 打开了资源需要关闭，例如文件对象，网络连接、数据库连接等

3、权限验证

  • 在执行代码之前，做权限的验证，在__enter__中处理

contextlib.contextmanager

contextlib.contextmanager

它是一个装饰器实现上下文管理，装饰一个函数，而不用像类一样实现__enter__和__exit__方法。

对下面的函数有要求：必须有yield，也就是这个函数必须返回一个生成器，且只有yield一个值。

也就是这个装饰器接受一个生成器对象作为参数

当yield发生处生成器函数增加了上下文管理。这就是为函数增加上下文机制的方式。

  • 把yield之前的当作__enter__方法执行
  • 把yield之后的当作__exit__方法执行
  • 把yield的值作为__enter__的返回值
import contextlib
import datetime
import time

@contextlib.contextmanager
def add(x, y):  # 为生成器函数增加了上下文管理
    start = datetime.datetime.now()
    try:
        time.sleep(2)
        yield x + y  # yield 5,yield的值只能有一个，作为`__enter__`方法的返回值
    finally:
        delta = (datetime.datetime.now() - start).total_seconds()
        print(delta)
        
with add(4, 5) as f:
#     raise Exception()
    print(f)

2.000723



---------------------------------------------------------------------------

Exception                                 Traceback (most recent call last)

<ipython-input-28-fdd9d911ac66> in <module>
     14 
     15 with add(4, 5) as f:
---> 16     raise Exception()
     17     print(f)


Exception:

总结：

如果业务逻辑简单可以使用函数加contextlib.contextmanager装饰器方式，如果业务复杂，用类的方式加__enter__和__exit__方法方便。
卡布奇诺不卡
关注
Python 上下文管理 魔术方法
weixin_44983653的博客
04-06 426
Python 上下文管理 魔术方法1、上下文管理对象1.1 注意事项1.2 示例2、异常对上下文的影响3、`with...as...`语句4、方法参数5、显示函数执行时长5.1 装饰器函数5.2 使用上下文5.3 使用上下文和类调用5.4 装饰器类6、上下文应用6.1 应用场景6.2 `contextlib.contextmanager`6.3 示例 16.4 示例 2 1、上下文管理对象 当一个对象同时实现了__enter__()和__exit__()方法，它就属于上下文管理的对象。 __enter_
解决tensorflow报错：IPython\core\interactiveshell.py:2918: UserWarning: To exit: use 'exit', 'quit'
muli
07-03 4907
解决tensorflow报错：IPython\core\interactiveshell.py:2918: UserWarning: To exit: use ‘exit’, ‘quit’ 具体报错如下： 用 %tb追踪如下： 修改代码如下： def main(argv=None): # 声明处理MNIST数据集的类，这个类在初始化时会自动下载数据 mnis...
Python0902-魔术方法-上下文管理
米娅爸
05-22 206
上下文管理 文件IO操作可以对文件对象使用上下文管理，使用with … as 语法。 with open('test') as f: pass 仿照上例写一个自己的类，实现上下文管理 class Point: pass with Point() as f: # AttributeError: __exit__ pass 提示属性错误， 没有e...
Python--魔术方法--上下文管理
python_lqx的博客
05-25 386
魔术方法上下文管理上下文管理对象上下文管理的安全性with语句方法的参数练习装饰器实现上下文实现可调用对象实现上下文应用场景contextlib.contextmanager总结 上下文管理 文件IO操作可以对文件对象使用上下文管理，使用with..as语法 with open('test') as f: pass 仿照上例写一个自己的类，实现上下文管理 class Point： pass ...
魔术方法2-上下文管理
jjliu的博客
12-01 121
当一个对象同时实现了__enter__()和__exit__()方法，它就属于上下文管理的对象。
魔术方法-上下文管理
刘振的博客
05-25 203
魔术方法 上下文管理 文件IO操作可以对文件对象使用上下文管理,使用with…as语法 上下文管理对象 方法 意义 __enter__ 进入与此对象相关的上下文.如果存在该方法,with语法会把该方法的返回值作为绑定到as子句中指定的变量上 __exit__ 退出与此对象相关的上下文 实例化对象的时候,并不会调用enter,进入with语句块调用__enter__方法,然后...
Python中类的魔术方法之上下文管理
兰枫
05-26 328
文章目录类的魔术方法之上下文管理上下文管理上下文管理对象与管理的安全上下文应用场景contextlib.countextmanager上下文管理装饰器 类的魔术方法之上下文管理 上下文管理 文件IO操作可以对文件对象使用上下文管理，使用with…as语法。 示例： with open("text") as f: pass 仿照上面例子写一个自己的类，实现上下文管理 class Point...
魔术方法之上下文管理
weixin_45473299的博客
11-06 112
魔术方法之上下文管理 文件IO操作可以对文件对象使用上下文管理，使用with as语法。 with open('test') as f: pass 仿照上例写一个自己的类，实现上下文管理 class A: pass with A() as f:#AttributeError:__enter__ pass 提示属性错误，没有__enter__,看来需要这个类属性,某些版本会显...
python中的魔术方法、上下文管理
野马
06-26 248
1.可调用对象 2.上下文管理 2.1 上下文管理的安全性 2.2 上下文应用场景 3.反射
php代码-魔术方法php
07-16
在PHP编程语言中，"魔术方法"是一类特殊的方法，它们在特定的上下文或条件触发时自动调用。这些方法的名字以双下划线（__）开头，使得它们在普通函数或方法中脱颖而出。本篇文章将深入探讨PHP中的魔术方法，以及它们...
python 魔术方法_with语句安全上下文
weixin_44568633的博客
01-26 218
文章目录python 魔术方法一、 特殊属性查看属性 __dir__二、 创建,初始化与销毁1.面试常问: python 中__new__ , __init__ , __call__的区别?2.当我们新建一个对象 x=someclass() 的时候,经历的步骤:3.应用范例:（1）new魔术方法实现单例模式（2）call魔术方法实现缓存（3）call魔术方法实现类装饰器应用范例三: call魔术方...
python：Fastapi - 依赖项中使用上下文管理器
一名小测试
05-12 927
什么是上下文管理器 上下文管理器是您可以在with语句中使用的任何 Python 对象 例如：您可以使用with关键字读取文件 withopen("./file.txt")asf: data=f.read() print(data) 运行时，open("./file.txt")会创建一个称为上下文管理器的对象。 当with块完成时，它确保关闭文件，即使有异常。 如自定义上下文管理器，那类中必须要有下面两个魔术方法 def__enter__(sel...
基于asp.net的工作流程审批系统设计与实现.docx
09-30
基于asp.net的工作流程审批系统设计与实现.docx
这是各种对象检测数据集的预处理相关工具脚本的集合.zip
09-30
这是各种对象检测数据集的预处理相关工具脚本的集合
基于asp.net的驾校理论考试网上模拟系统设计与实现.docx
09-30
基于asp.net的驾校理论考试网上模拟系统设计与实现.docx
基于Python与Shell的阿里巴巴智能运维竞赛排名14设计源码
09-30
该项目为阿里巴巴智能运维竞赛排名14的设计源码，采用Python和Shell两种编程语言，共包含27个文件，包括2个Python脚本、1个PDF文档、1个Markdown文件、1个文本文件、1个CSV文件、1个Shell脚本以及5个特定数据模型文件。该解决方案旨在提升运维效率，适用于大型企业的智能运维场景。
DRF完整项目及uwsgi部署配置
最新发布
09-30
DRF完整项目及uwsgi部署配置
2022国庆旅游消费趋势报告.pdf
09-30
2022国庆旅游消费趋势报告.pdf
Python进阶：GIL锁、复制机制与上下文管理
此外，还涉及了Python中的对象复制（浅拷贝和深拷贝），私有属性的创建，魔法方法（魔术方法）的应用，属性访问控制，上下文管理器，对象的序列化，以及运算符相关的魔术方法等。 GIL锁： GIL（全局解释器锁）是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值