python 描述符 上下文管理协议 类装饰器 property metaclass

Posted 2021-02-11 风追海浪

1.描述符

#!/usr/bin/python env
# coding=utf-8
# 数据描述符__get__ __set__ __delete__
\'\'\'
描述符总结

描述符是可以实现大部分python类特性中的底层魔法,包括@classmethod,@staticmethd,@property甚至是__slots__属性

描述符是很多高级库和框架的重要工具之一,描述符通常是使用到装饰器或者元类的大型框架中的一个组件

注意事项:
    一 描述符本身应该定义成新式类,被代理的类也应该是新式类
    二 必须把描述符定义成这个类的类属性，不能为定义到构造函数中
    三 要严格遵循该优先级,优先级由高到底分别是
        1.类属性
        2.数据描述符
        3.实例属性
        4.非数据描述符
        5.找不到的属性触发__getattr__()

描述符分2种
1.数据描述符：至少有get set方法
2.非数据描述符：没有set方法


\'\'\'
class Str:
    def __init__(self, name,val_type):
        self.name = name
        self.val_type = val_type
    # instance 实例对象 owner实例的类
    def __get__(self, instance, owner):
        print(\'get方法\', instance, owner)
        return instance.__dict__[self.name]
    # instance 实例对象 value实例的值
    def __set__(self, instance, value):
        print(\'set方法\', instance, value)
        if not isinstance(value, self.val_type):
            raise TypeError("%s 的数据类型不是 %s" % (value, self.val_type))
        instance.__dict__[self.name] = value

    def __delete__(self, instance):
        print(\'delete方法\', instance)
        instance.__dict__.pop(self.name)


class People:
    # 描述符
    name = Str(\'name\', str)
    age = Str(\'age\', int)
    salary = Str(\'salary\', int)


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


p1 = People(\'wangwu\', 12, 98921)

# 调用
print(p1.__dict__)
# print(p1)
# p1.name

# #赋值
# print(p1.__dict__)
# p1.name=\'egonlin\'
# print(p1.__dict__)
#
# #删除
# print(p1.__dict__)
# del p1.name
# print(p1.__dict__)

 

2.上下文管理协议

操作文件对象写法

1 with open(\'a.txt\') as f:
2 　　\'代码块\'

上述叫做上下文管理协议，即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法

# 上下文管理协议 with
\'\'\'
# with open(\'filename\') as f:
#     代码块
1.with.obj ---> obj.__enter__(), return val
2.as f ----> f=val
3.with obj as f === f=obj.__enter()
4.执行
1)没有异常时，all code运行后，__exit__ 三个参数都为None
2）有异常时，从异常的的位置触发__exit__
   a。如果exit的返回值为True,吞掉了异常
   b.反之，抛出异常
   c.exit的代码执行完毕代表了整个with语句执行完毕
\'\'\'
class Foo:
    def __init__(self, name):
        self.name = name

    def __enter__(self):  # 出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量
        return self

    # exc_type 异常类：NameError
    # exc_val 异常值：name \'abc异常abc\' is not defined
    # exc_tb 追踪信息： Traceback后面的内容
    # Traceback(most recent call last):
    # NameError: name \'abc异常abc\' is not defined
    def __exit__(self, exc_type, exc_val, exc_tb):  # with里有异常时 触发改函数
        print("%s %s %s" % (exc_type, exc_val, exc_tb))
        return True  # 如果__exit()返回值为True,那么异常会被清空，就好像啥都没发生一样，with后的语句正常执行

with Foo(\'a.txt\') as f:
    print(f)
    # print(abc异常abc)
    print(f.name)
print("*"*100)

 

# 上下文管理实例
class Open:
    def __init__(self,filepath,mode=\'r\',encoding=\'utf-8\'):
        self.filepath=filepath
        self.mode=mode
        self.encoding=encoding

    def __enter__(self):
        # print(\'enter\')
        self.f=open(self.filepath,mode=self.mode,encoding=self.encoding)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        # print(\'exit\')
        self.f.close()
        return True 
    def __getattr__(self, item):
        return getattr(self.f,item)

with Open(\'a.txt\',\'w\') as f:
    print(f)
    f.write(\'aaaaaa\')
    f.wasdf #抛出异常，交给__exit__处理

3.类装饰器

# 函数装饰器范式
# def wrap(func):
#     def wrapper(*args, **kwargs):
#         func(*args, **kwargs)
#         return True
#     return wrapper

# 无参类装饰器范式
# def wrap(cls):
#     return cls

# 有参类装饰器范式
# def wrap(**kwargs):
#     def wrapper(obj):
#         # 操作kwargs
#         return obj
#     return wrapper

# 有参类装饰器
class Check_type:
    def __init__(self, name, val_type):
        self.name = name
        self.val_type = val_type

    # instance 实例对象 owner实例的类
    def __get__(self, instance, owner):
        # print(\'get方法\', instance, owner)
        return instance.__dict__[self.name]

    # instance 实例对象 value实例的值
    def __set__(self, instance, value):
        # print(\'set方法\', instance, value)
        if not isinstance(value, self.val_type):
            raise TypeError("%s的数据类型不是 %s" % (value, self.val_type))
        instance.__dict__[self.name] = value

    def __delete__(self, instance):
        # print(\'delete方法\', instance)
        instance.__dict__.pop(self.name)


def Typed(**kwargs):  # kwargs ===> name=str, age= int, salary=int
    def wrapper(obj):
        for key, val in kwargs.items():
            # 描述符 val是key的类型
            # val = Check_type(\'val\', str)
            setattr(obj, key, Check_type(key, val))
        return obj
    return wrapper

@Typed(y=2, x=1, z=3)
class Foo:
    pass

@Typed(name=\'wangwu\')
class foo:
    pass

@Typed(name=str, age=int, salary=int)  # @warpper -->People=warper(people)
class People:
    # 描述符
    # name = Str(\'name\', str)
    # age = Str(\'age\', int)
    # salary = Str(\'salary\', int)
    def __init__(self, name, age, salary):
        self.name = name
        self.age = age
        self.salary = salary


print(People.__dict__)
p1 = People(\'wangwu\', "d", 98921)


# 调用
print(p1.__dict__)

4.仿property

# 类装饰器
# class Cls_property:
#     def __init__(self,func):
#         self.func = func
# 仿property类装饰器


class Cls_property:
    def __init__(self, func):
        # print("func属性 %s " %(func))
        self.func = func

    # 描述get有两个参数 第一个是实例 第二个是类
    def __get__(self, instance, owner):
        # val = self.func()
        print(\'get---->\')
        print(\'instance: %s\' % instance)  # 实例对象 r1
        print(\'owner: %s\' % owner)  # 类 Room
        if instance is None:
            return self
        res = self.func(instance)
        # property延时计算
        setattr(instance, self.func.__name__, res)
        return res
    # 加上set 数据描述符
    # def __set__(self, instance, value):
    #     pass


class Room:
    tag = 168

    def __init__(self, owner, width, length):
        self.owner = owner
        self.width = width
        self.length = length

    # @cls_property
    @Cls_property  # area=property(area)
    def area(self):
        return self.width * self.length

    # @cls_property
    @property  # area=property(area)
    def area1(self):
        return self.width * self.length

    # 类方法 能访问类的属性不能访问实例属性
    @classmethod
    def test_tag(cls, x):
        print(cls)
        print("from test_tag %s %s" % (cls.tag, x))

    # 静态方法  不能访问类、实例属性
    @staticmethod
    def action(a, b, c):
        print("%s %s %s" % (a, b, c))

    # 类可以调用，实例不可调用test
    def test(cls, x):
        print(cls)
        print("from test_tag %s %s" % (cls.tag, x))

    @property  # <property object at 0x01FE80F0>
    def pro_test(self):
        return "pro_test"


r1 = Room(\'zq\', 1, 100)
print(r1.__dict__)  # 没找到area属性值 那就调用代理的Roo的area值
print(r1.area)
print(r1.__dict__)  # 没找到area属性值 那就调用代理的Roo的area值
print(r1.area)
print(r1.area)
print(r1.area)
# print(Room.__dict__[\'area\'])

# print(Room.area)
# print(Room.pro_test)

# 一个静态属性property本质就是实现了get，set，delete三种方法
# 方法一
class Foo:
    @property
    def AAA(self):
        print(\'get的时候运行我啊\')

    @AAA.setter
    def AAA(self,value):
        print(\'set的时候运行我啊\', value)

    @AAA.deleter
    def AAA(self):
        print(\'delete的时候运行我啊\')

#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA=\'aaa\'
del f1.AAA
print("<----------------------->")

# 方法二
class Foo:
    def get_AAA(self):
        print(\'get的时候运行我啊\')

    def set_AAA(self,value):
        print(\'set的时候运行我啊\', value)

    def delete_AAA(self):
        print(\'delete的时候运行我啊\')
    AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA=\'aaa\'
del f1.AAA

5.元类 metaclass

元类是类的类，是类的模板

元类的实例是类，类的实例是 对象

type是python的一个内建元类 ，用来控制生成类，python中任何class定义的类其实都是type类实例化的对象

# 创建类有2种方法
# metaclass
# 类的默认元类是type
# 1.
class Foo:
    pass
# tpye(str)
t = type(Foo)
print(t)
# print(t.__dict__)

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

# s三个参数 类名 (父类，), {属性字典}
# 2.type(类名,(object,),{})
t = type(\'t\', (object,), {\'a\': 1, \'__init__\': __init__, \'test\': test})
print(t.__dict__)  # {\'a\': 1, \'__weakref__\': <attribute \'__weakref__\' of \'t\' objects>, \'__init__\': <function __init__ at 0x002C4738>, \'__module__\': \'__main__\', \'test\': <function test at 0x00703660>, \'__doc__\': None, \'__dict__\': <attribute \'__dict__\' of \'t\' objects>}
print(t)  # <class \'__main__.t\'>
print("------------------------->")


# 自定义元类
class Mytype(type):
    def __init__(self, *args, **kwargs):
        print("元类的自定义类")
        # for i in args:
        #     print(i)

    def __call__(self, *args, **kwargs):  # self == Foo
        # print("__call__函数：",self)
        obj = object.__new__(self)  # object.__nee__(Foo) --> 产生 f1 产生实例obj
        # print("obj产生: ",obj)
        self.__init__(obj, *args, **kwargs)  # Foo.__init__()
        return obj


class Foo(metaclass=Mytype):  # Mytype(传了4个参数: self,Foo,(),{})-->触发mytype __init__
    def __init__(self, name):
        self.name = name  # f1.name = name


print(Foo)
f1 = Foo(\'wangwu\')
print(f1)
# print(f1.__dict__)

 

 

参考：http://www.cnblogs.com/linhaifeng/articles/6204014.html#_label15