7、面向对象高级应用一

object.__get__(self,instance,owner)
object.__set__(self,instance,value)
object.__delete__(self,instance)
# 参数详解
    # self：代指当前类的实例，即描述器的实例；
    # instance：instance是owner的实例；
    # owner：owner是属性的所属的类；
# 可以看到__get__或者__set__他们的形参，不仅有self还有instance，在面向对象里面，self实际就是当前实例的instance，那么这里又多出一个instance，由此可以看出，这是两个类之间的调用；

class A:
    def __init__(self):
        self.a1='a1'
        print("A init")
class B:
    x=A()
    def __init__(self):
        print("B init")
print(B.x.a1)
b=B()
print(b.x.a1)
# A init
# a1
# B init
# a1

class A:
    def __init__(self):
        self.a1='a1'
        print("A init")
    def __get__(self, instance, owner):
        print(self,instance,owner)
class B:  # 属主类，即owner
    x=A() 
    def __init__(self):
        print("B init")
print(B.x) # 当访问属主类中的描述器属性时，会转为描述器类的__get__方法，所以访问B.x的返回结果为None
# A init
# <__main__.A object at 0x102e5ae80> None <class '__main__.B'>
# None

class A:
    def __init__(self):
        self.a1='a1'
        print("A init")
    def __get__(self, instance, owner):
        print(self,instance,owner)
        return self
class B:
    x=A()
    def __init__(self):
        print("B init")
print(B.x)
# A init
# <__main__.A object at 0x102c7ae80> None <class '__main__.B'>
# <__main__.A object at 0x102c7ae80>   # 拿到了一个A的实例对象

class A:
    def __init__(self):
        self.a1='a1'
        print("A init")
    def __get__(self, instance, owner):
        print(self,instance,owner)
        return self
class B:
    x=A()
    def __init__(self):
        print("B init")
b=B()
print(b.x)
# A init
# B init
# <__main__.A object at 0x102e7ae80> <__main__.B object at 0x104806f28> <class '__main__.B'>
# <__main__.A object at 0x102e7ae80>

class A:
    def __init__(self):
        self.a1='a1'
        print("A init")
    def __get__(self, instance, owner):
        print(self,instance,owner)
        return self
class B:
    def __init__(self):
        self.x=A()
        print("B init")
b=B()
print(b.x)  # 一旦描述器存在于属主类的实例属性时，将不会走描述器，所以它就按照正常流程走，直接返回了一个A的实例，并没有走描述器类的__get__方法
# A init
# B init
# <__main__.A object at 0x102b63748>

class A:
    def __init__(self):
        self.a1='a1'
        print("A init")
    def __get__(self, instance, owner):
        print("get",self,instance,owner)
        return self
    def __set__(self, instance, value):
        print("set",self,instance,value)
class B:
    x=A()
    def __init__(self):
        self.x=1
        print("B init")
b=B()
print(b.x)
# A init
# set <__main__.A object at 0x10267ae48> <__main__.B object at 0x10580f4e0> 1
# B init
# get <__main__.A object at 0x10267ae48> <__main__.B object at 0x10580f4e0> <class '__main__.B'>
# <__main__.A object at 0x10267ae48>

class A:
    def __init__(self):
        self.a1='a1'
        print("A init")
    def __get__(self, instance, owner):
        print("get",self,instance,owner)
        return self
    def __set__(self, instance, value):
        print("set",self,instance,value)
class B:
    x=A()
    def __init__(self):
        print("B init")
b=B()
b.x=1
# A init
# B init
# set <__main__.A object at 0x102d83dd8> <__main__.B object at 0x10580f4e0> 1

class A:
    def __init__(self):
        self.a1='a1'
        print("A init")
    def __get__(self, instance, owner):
        print("get",self,instance,owner)
        return self
    def __set__(self, instance, value):
        print("set",self,instance,value)
        instance.__dict__['x']=value  # 使用字典的方式，将属性加入属主的实例字典
class B:
    x=A()
    def __init__(self):
        self.x=1
        print("B init")
b=B()
print(b.x)
print(b.__dict__) # {'x': 1}

class A:
    def __init__(self):
        self.a1='a1'
        print("A init")
    def __get__(self, instance, owner):
        print("get",self,instance,owner)
        return self
    def __set__(self, instance, value):
        if instance: # 只要instance不为空，就说明是在修改描述器，只要是在修改，就显示告诉用户，不允许修改
            raise AttributeError("can't set attribute")
class B:
    x=A()
    def __init__(self):
        print("B init")
b=B()
b.x=1
# A init
# B init
# Traceback (most recent call last):
#   File "/usr/local/Project/cce/Py/edu.py", line 22, in <module>
#     b.x=1
#   File "/usr/local/Project/cce/Py/edu.py", line 16, in __set__
#     raise AttributeError("can't set attribute")
# AttributeError: can't set attribute

class A():
    def __get__(self, instance, owner):
        return self
    def __set_name__(self, owner, name):
        print("__set_name__",name)
        self.name = name
class B():
    x=A()
print(B.x)
print(B.x.name)
# __set_name__ x
# <__main__.A object at 0x1101cdd90>
# x

class A():
    def __init__(self):
        self.stmd=100
        self.clmd=200
    @staticmethod
    def stmd(self):
        pass
    @classmethod
    def clmd(cls):
        pass
a=A()
print(a.stmd,A.stmd) # 100 <function A.stmd at 0x10580aa60>
print(a.clmd,A.clmd) # 200 <bound method A.clmd of <class '__main__.A'>>
# 类和实例相互不影响，即非数据描述器

class A():
    @property
    def get(self):
        pass
a=A()
a.get="cce"
# Traceback (most recent call last):
#   File "/usr/local/Project/cce/Py/edu.py", line 12, in <module>
#     a.get="cce"
# AttributeError: can't set attribute

class StaticMethod(object):
    def __init__(self,func):
        self.func=func
    def __get__(self, instance, owner):
        return self.func
class A:
    @StaticMethod # 等价于 stmd=StaticMethod(stmd), 所以stmd是一个类属性描述器
    def stmd(x,y):
        print(x+y)
a=A()
a.stmd(4,5)
# 9

from functools import partial
class ClassMethod(object):
    def __init__(self,func):
        self.func=func
    def __get__(self, instance, owner):
        return partial(self.func,owner)  # 或者使用 wraps(self.func)(owner)或者自定义偏函数
class A:
    @ClassMethod # 等价于 stmd=ClassMethod(stmd), 所以foo是一个类属性描述器
    def foo(cls,x,y):
        print(cls,x,y)
A.foo(1,2)
# <class '__main__.A'> 1 2

class TypeCheck(object):
    def __init__(self,typ):
        self.typ=typ
    def __get__(self, instance, owner):
        if instance:
            return instance.__dict__.get(self.name)  # 在使用实例访问时，将对应的属性值抛出
        return self
    def __set__(self, instance, value):
        if instance and isinstance(value,self.typ):
            instance.__dict__[self.name]=value
        else:
            raise TypeError  # 如果传入的类型不符合要求，就抛出异常
    def __set_name__(self, owner, name):
        self.name=name

class A(object):
    name = TypeCheck(str)
    age = TypeCheck(int)
    def __init__(self,name,age):
        self.name=name
        self.age=age
a=A("cce",18)
print(a.__dict__)
print(a.age)
# {'name': 'cce', 'age': 18}
# 18

import tracemalloc

tracemalloc.start() # 开始跟踪内存分配

x = [x for x in range(1000000)]
y = (x for x in range(1000000))

snapshot = tracemalloc.take_snapshot() # 对当前内存拍摄快照
stats = snapshot.statistics("lineno") # 快照对象的统计信息，得到的是一个list
for item in stats:
    print(item)
# /usr/local/Project/cce/Py/edu.py:11: size=35.0 MiB, count=999744, average=37 B
# /usr/local/Project/cce/Py/edu.py:12: size=136 B, count=2, average=68 B
# 由此，可以看出，元祖更加省内存

class A(object):
    __slots__ = ['x','y']  # 该类的实例可以创建的实例属性名称列表
    def __init__(self):
        self.x=1
        self.y=2
        self.z=3  # z不在__slots__的列表里面，所以当前类在初始化创建实例时，它无法为实例创建z这个实例属性
print(A())  # 同时，A的实例也没有__dict__的属性，实例字典从此消失
# Traceback (most recent call last):
#   File "/usr/local/Project/cce/Py/edu.py", line 14, in <module>
#     print(A( ))
#   File "/usr/local/Project/cce/Py/edu.py", line 13, in __init__
#     self.z=3
# AttributeError: 'A' object has no attribute 'z'