26 - 面向对象高级-上下文管理-反射

26 - 面向对象高级-上下文管理-反射

 

目录

 

1 上下文管理

文件IO操作可以对文件对象使用上下文管理,它主要使用with..as..语法.

with open('123.txt') as f:
    print(f)

要想自己写的类实现上下文管理,那么需要用到两个方法__exit__和__enter__.

方法意义
__enter__进入与此对象相关的上下文,如果存放该方法,with语法会把该方法的返回值绑定到as子句中指定的变量上
__exit__退出与此对象相关的上下文
class Text:

    def __enter__(self):
        print('enter------')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit-------')

with Text() as f :
    print('进来了')
print('出来了')


# enter------

# 进来了

# exit-------

# 出来了

实例化对象的时候,并不会调用__enter__方法,只有进入with语句体中,才会调用__enter__方法,然后执行语句体,最后离开with语句块的时候,再调用__exit__方法.

with可以开启一个上下文运行环境,在执行前做一些准备工作,执行后,做一些收尾工作,它并不会开启一个新的作用域.

1.1 上下文管理的安全性

class Text:

    def __enter__(self):
        print('enter------')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit-------')

with Text() as f :
    raise Exception


# Traceback (most recent call last):

# enter------

#   File "E:/Python - base - code/chapter08面向对象/练习3.py", line 169, in <module>

#     raise Exception

# exit-------

# Exception

我们可以看到,with语句体中当异常抛出时,__exit__已经可以执行完毕,所以上下文管理是安全的.

1.2 返回值

class Text:

    def __enter__(self):
        print('enter------')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit-------')

with Text() as f :
    print(f)   # None

这里之所以是None,是因为,__enter__函数的返回值为None,所以如果哪些类的实例化属性或实例本身要在with语句内部使用,可以在__enter__函数中进行返回.

class Text:
    def __init__(self):
        self.name = 'daxin'

    def __enter__(self):
        print('enter------')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit-------')

with Text() as f:
    print(f.name)   # daxin

1.3 方法的参数

方法的参数如下:

  • __enter__(self):没有其他参数
  • __exit__(self, exc_type, exc_val, exc_tb): 这三个参数都与异常有关系,如果上下文管理内部没有产生异常,那么三个属性的值都为None,否则
    • exc_type: 异常类型
    • exc_val: 异常的值
    • exc_tb: 异常的追踪信息

注意:__exit__函数的返回值很重要,当返回值等效为True,表示压制异常(异常不会上报),等效False时,表示不压制异常(此时异常会上报)

class A:
    def __init__(self):
        pass

    def __enter__(self):
        print('Enter ~~~~~')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit ~~~~~')
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        return True

with A():
    raise Exception('Test')


# Enter ~~~~~

# <class 'Exception'>

# Test

# <traceback object at 0x000001E4D0A5C808>

因为__exit__方法return 了True,所以异常被压制,所以不会异常崩溃。

1.4 计算函数的运行时间

下面来计算一个函数的运行时间,主要有两个办法:

  1. 装饰器(一般人都能想到)
  2. 上下文管理期(一般人很难想到)

装饰器版本:

import time
import random
import datetime
import functools

def timer(fn):
    @functools.wraps(fn)  # 拷贝属性信息
    def wrapper(*args, **kwargs):
        start = datetime.datetime.now()
        res = fn(*args, **kwargs)
        stop = (datetime.datetime.now() - start).total_seconds()
        print(stop)
        return res

    return wrapper

@timer
def add(x, y):
    time.sleep(random.randrange(1, 5))
    return x + y

add(4,5)

装饰器版本2:类装饰器

import time
import random
import datetime
import functools

class Timer:

    def __init__(self,fn):
        self.fn = fn
        functools.wraps(fn)(self)  # 拷贝用户函数属性信息

    def __call__(self, *args, **kwargs):
        start = datetime.datetime.now()
        res = self.fn(*args,**kwargs)
        stop = (datetime.datetime.now() - start).total_seconds()
        print('The fn run time is {}'.format(stop))
        return res

@Timer
def add(x, y):
    '''from add function'''
    time.sleep(random.randrange(1, 5))
    return x + y

print(add(4,5))
print(add.__name__)

上下文管理器方法1:

import time
import random
import datetime

def add(x, y):
    time.sleep(random.randrange(1, 5))
    return x + y

class Timer:

    def __init__(self):
        self.start = None

    def __enter__(self):
        self.start = datetime.datetime.now()

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.stop = (datetime.datetime.now() - self.start).total_seconds()
        print(self.stop)

with Timer():
    add(1, 3)

上下文管理版本2:将要计算的函数当作参数传入上下问管理器中

import time
import random
import datetime

def add(x, y):
    time.sleep(random.randrange(1, 5))
    return x + y

class Timer:

    def __init__(self, fn):
        self.fn = fn
        self.start = None

    def __enter__(self):
        self.start = datetime.datetime.now()
        return self.fn

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.stop = (datetime.datetime.now() - self.start).total_seconds()
        print(self.stop)

with Timer(add) as f:
    f(1, 3)

1.5 主要应用场景

根据上下文管理的特性,总结出三个常用的场景:

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

1.6 contextlib.contextmanager

        它是一个装饰器,用于实现上下文管理,它装饰一个函数,因为函数没有像类那样使用__enter__和__exit__来实现,所以使用contextlib.contextmanger可以使一个函数变为上下文管理器,但是对被装饰的函数有一个要求,必须包含yeild关键字,也就是说这个函数必须返回一个生成器,且只有yield一个值。

这个装饰器接受一个生成器作为参数

from contextlib import contextmanager

@contextmanager
def add(x, y):
    print('hello')
    yield x + y
    print('bye bye')

print('start')
with add(4, 5) as f:
    print(f)
print('end')


# start

# hello

# 9

# bye bye

# end

根据打印结果我们分析:

  1. 函数中yield语句前面的,在with语句执行时被触发。
  2. yield返回值被 as 语句交给了f。
  3. yield语句后面的,在退出with语句时执行。

当我们传入参数add(1, [5,]) 时,异常直接是函数异常退出了,并没有执行yield后面的类似__enter__方法的语句,怎么办呢?可以使用try,finally来捕捉

from contextlib import contextmanager

@contextmanager
def add(x, y):
    try:
        print('hello')
        yield x + y
    finally:
        print('bye bye')

print('start')
with add(1, [5,]) as f:
    print(f)
print('end')

这样就会打印yield后续语句,虽然会异常退出,但由于错误的参数由用户自主传递,那就让用户自己去解决吧。

业务逻辑简单,可以使用函数加contextlib.contextmanager装饰器实现,业务逻辑复杂的话,可以使用类加__enter__和__exit__来解决。

2 反射

一个对象能够在运行时,像照镜子一样,显示出其类型信息,这种方法叫做反射。换句话是反射可以在程序运行的同时获取类型定义的信息,比如通过一个对象,找出它的type、class、attribute或者method等。具有反射能力的函数有:type()、isinstance()、callable()、dir()、getattr()等。

2.1 反射相关的函数

内建函数含义
getattr(object, name[, default])通过name返回object的属性值。当属性不存在,将使用default返回。
如果没有设置default,则抛出AttributeError异常,name必须为字符串。
setattr(obj, name, value)obj的属性存在,则覆盖,不存在,则新增。
hasattr(obj, name)判断obj是否存在属性,name必须为字符串,返回值为bool类型
class Person:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def talk(self):
        print("{} is talking".format(self.name))

daxin = Person('daxin',20)
if hasattr(daxin,'name'):         # 判断daxin是否含有name属性
    print(getattr(daxin,'name'))  # 如果有,通过getattr获取name属性

if not hasattr(daxin,'sing'):     # 判断daxin没有sing方法
    setattr(daxin,'sing',lambda self:print("{} is singing".format(self.name)))  # 为实例绑定一个sing方法

daxin.sing()  # 实例调用

        直接调用时无法执行,提示缺少self参数,想一下,我们定义的方法通常是在类中定义的,在类中我们指定的self参数,在实例调用时会进行传递(因为是实例是绑定在方法上的),而我们绑定的sing方法是绑定在实例本身上的,所以这种情况下,是无法帮我们传递self参数的,所以我们在函数内部也无法调用实例的参数。

这种动态增加属性的方式是运行时改变类或者实例的方式,而装饰器或者Mixin是在定义时就决定了的,因此反射具有更大的灵活性。

命令分发器实例:

class Dispather:
    def __init__(self):
        pass

    def register(self, name, func):
        setattr(self, name, func)

    def run(self):
        while True:
            cmd = input('>>>: ').strip()
            if cmd.lower() == 'quit':
                break
            else:
                getattr(self, cmd.lower())()

d = Dispather()
d.register('ls',lambda :print('hello world'))
d.run()

2.2 反射相关的魔术方法

魔术方法含义
__getattr__(self, name)定义当用户试图获取一个不存在的属性时的行为
__setattr__(self, name, value)定义当一个属性被设置时的行为
__delattr__(self, name)定义当一个属性被删除时的行为

2.2.1 getattr

class A:
    def __init__(self):
        pass

    def __getattr__(self, item):
        print('__getattr__')
        return 'daxin'

daxin = A()
print(daxin.name)


# __getattr__

# daxin

        访问daxin的一个属性name,如果不存在,最后会调用__getattr__方法,它的返回值就是结果。如果没有这个方法,就会抛出AttributeError异常,表示找不到属性。
        查找属性的顺序为:instance.__dict__ --> instance.__class__.__dict__ --> ... --> object的__dict__,找不到,调用实例的__getattr__

2.2.2 setattr

class A:
    def __init__(self):
        pass

    def __getattr__(self, item):
        print('__getattr__')
        return 'daxin'

    def __setattr__(self, key, value):
        self.key = value   # self.key依旧调用self.__setattr__方法
        # self.__dict__[key] = value 


daxin = A()
daxin.name = 'daxin'  # 调用__setattr__方法
print(daxin.name)

上面的代码无法执行,会产生递归是为什么呢?

  1. daxin.name = 'daxin' 这里会调用daxin的__setattr__方法。
  2. daxin的__stattr__方法内部使用self.key = value的方法赋值,这种方法等同于self.__setattr__ = value,所以会产生递归。
  3. 利用self.__dict__[key]的方式是直接操作实例的字典,所以不会引起递归。

__setattr__()方法,可以拦截对实例属性的增加、修改操作,如果要设置生效,需要自己修改操作实例的__dict__属性。

class Person:
    def __init__(self,name):
        self.name = name
        self.__dict__['a'] = 5

    def __getattr__(self, item):
        print('getattr~~~~~')
        return getattr(self,item)

    def __setattr__(self, key, value):
        print('setattr~~~~~~')
        self.__dict__[key] = value
        # setattr(self,key,value)  # 不能这样写,这样写等同于调用对象的__setattr__方法,会产生递归


daxin = Person('daxin')
print(daxin.name)
print(daxin.a)

结果只会输出1次getattr,因为初始化时,已经为字典创建了一个key,a,所以当访问实例属性a时,由于__dict__中存在,所以不会被__getattr__捕获。

setattr本质上也是通过 instance.attribute = value 的方式赋值的。

2.2.3 delattr

删除一个属性时,触发__delattr__方法的执行。可以阻止通过实例来删除属性的操作。

class Person:
    def __init__(self,name):
        self.name = name
        self.__dict__['a'] = 5

    def __getattr__(self, item):
        print('getattr~~~~~')
        return getattr(self,item)

    def __setattr__(self, key, value):
        print('setattr~~~~~~')
        self.__dict__[key] = value

    def __delattr__(self, item):
        print('delattr~~~~~~')
        del self.__dict__[item]  # 删除实例的属性, 也可以在这里啥也不做,提示不能删除,即可阻止实例的属性被删除。

daxin = Person('daxin')
print(daxin.name)
del daxin.a  # 触发实例的__delattr__方法的执行。

2.3 getattribute

魔术方法含义
__getattribute__(self, name)定义当该类的属性被访问时的行为

实例所有的属性访问,第一个都会调用__getattribute__方法。

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __getattr__(self, item):
        return 'getattr'

    def __getattribute__(self, item):
        pass
        # return 'ABC'
        # raise AttributeError('ABC')

daxin = Person('daxin',20)
print(daxin.name)

上面的例子得到以下结论:

  1. 当我们重写__getattribute__方法时,它的返回值就是我们属性访问的结果。
  2. 如果在__getattribute__方法中抛出AttributeErro异常,那么最好会执行__getattr__方法,因为属性没有找到。

__getattribute__方法中为了避免在该方法中无限递归,它的实现应该永远调用基类的同名方法以访问需要的任何属性(object.__getattribute__(self, name))。

实例属性查找顺序:
instance.__getattribute__() --> instance.__dict__ --> instance.__class__.__dict__ --> object.__dict__ --> instance.__getattr__

所有巧合的是要么是上天注定要么是一个人偷偷的在努力。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值