魔术方法 反射

反射(reflection)：指的是运行时获取类型定义信息。一个对象能够在运行时像照镜子一样反射出其类型信息；也就是说能够通过一个对象，找到自己的type、class、attribute、或method的能力，称为反射或者自省。 具有反射能力的函数：type、isinstance、callable、dir、getattr。 运行时和编译时不同，指的是程序倍加在到内存中执行的时候。

反射相关的函数和方法

class Point:
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __repr__(self):
        return 'Point({},{})'.format(self.x,self.y)

    def show(self):
        print(self)

p1 = Point(5,9)
p2 = Point(7,3)
print(repr(p1),repr(p2),sep ='\n')
print(p1.__dict__)
setattr(p1,'y',16)
setattr(p1,'z',10)
print(getattr(p1,'__dict__'))
#动态调用方法
if hasattr(p1,'show'):
    getattr(p1,'show')()
#动态增加方法，为类增加方法
if not hasattr(Point,'add'):
    setattr(Point,'add',lambda self,other: Point(self.x+other.x,self.y+other.y))

print(Point.add)
print(p1.add)
print(p1.add(p2))
#为实例增加方法，未绑定
if not hasattr(p1,'sub'):
    setattr(p1,'sub',lambda self,other: Point(self.x-other.x,self.y-other.y))
print(p1.sub(p1,p2))
print(p1.sub)
print(p1.__dict__)
print(Point.__dict__)

这种动态增加属性的方式使运行时改变类或者实例的方式，但是装饰器或Mixin都是定义时就决定了，一次反射能力具有更大的灵活性。 上面代码中通过dict访问对象的属性，本质上也是利用的反射的能力。

• 练习 运用对象方式来实现分发器：

class Dispather:
    def __init__(self):
        self._run()

    def cmd1(self):
        print("I'm a command")

    def cmd2(self):
        print("I'm command2")
    def _run(self):
        while True:
            cmd = input('enter a command: ')
            if cmd.strip() == 'quit':
                break
            getattr(self,cmd,lambda :print('Unknown this command {}'.format(cmd)))()
Dispather()

反射相关的魔术方法

1. __getatte__()

class Base:
    n = 0

class Point(Base):
    z = 6
    def __init__(self,x,y):
        self.x = x
        self.y = y
    def show(self):
        print(self.x,self.y)
        
    def __getattr__(self, item):
        return "misssing {}".format(item)
p1 = Point(7,9)
print(p1.x)
print(p1.z,p1.n)
print(p1.t)

一个累的属性会按照集成关系查找，如果找不到就会执行魔法方法getattr，如果没有这个方法就会返回AttributeError异常，表示找不到属性 查找顺序：对象字典 ——> 类字典 ——> 类祖先的字典 ——>调用getattr

2. __setattr__()

class Base:
    n = 0


class Point(Base):
    z = 6

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def show(self):
        print(self.x, self.y)

    def __getattr__(self, item):
        return "misssing {}".format(item)

    def __setattr__(self, key, value):
         print('setattr {} = {}'.format(key,value))


p1 = Point(7, 9)
print(p1.x) #missing,实例通过“.”设置属性，如同self.x = x，就会调用setattr，属性要加到实例的字典中就要自己完成
print(p1.z, p1.n)
print(p1.t)
p1.x =50
print(p1.__dict__)
p1.__dict__['x'] = 60
print(p1.x)
print(p1.__dict__)

魔法方法setattr可以拦截对实例属性的增加修改操作如果要设置生效，需要自己操作实例的字典。

3. __delattr__()

class Point:
    Z = 99
    def __init__(self,x,y):
        self.x = x
        self.y = y
    def __delattr__(self, item):
        print('can not del {}'.format(item))
p = Point(14,5)
del p.x
p.z =15
del p.z
del p.Z
print(Point.__dict__)
print(p.__dict__)
del Point.Z
print(Point.__dict__)

可以阻止通过实例删除属性的操作。但是通过类异常可以删除属性。

5. __getattribute__

class Base:
    n=84
class Point(Base):
    z = 99
    def __init__(self,x,y):
        self.x = x
        self.y = y
    def __getattribute__(self, item):
        return "missint {}".format(item)

    def __delattr__(self, item):
        print('can not del {}'.format(item))
p = Point(14,5)
print(p.__dict__)
print(p.x)
print(p.z)
print(p.n)
print(p.t)
print(Point.__dict__)
print(Point.z)

魔法方法getattribute中为了避免无线递归，他的视线应该永远调用基类的同名方法以访问需要的任何属性，例如object.getattribute(self,name). 注意：除非明确知道getattribute用来做什么，否则不要使用

总结:

属性查找顺序 实例调用getattribute ——> 实例字典 ——> 类的字典 ——> 祖先类的字典 ——> 调用getattr

描述器Desciptors

描述器的表现

用到三个魔术方法：__get__、__set__、__delete__ self指代当前实例；instance时owner的实例；owner是属性实例所属的类。

1. object.__get__(self,instance,owner)
2. object.__set__(self,instance,value)
3. object.__delete__(self,instance)

class A:
    def __init__(self):
        self.a1 = 'a1'
        print('A.init')
class B:
    x =A()
    def __init__(self):
        print('b.init')
print('-'*20)
print(B.x.a1)
print('========================')
b = B()
print(b.x.a1)

根据运行结果来看，类加载的时候，类变量需要先生成，而类B的属性是类A的实例，所以先初始化类A，然后依次执行。

class A:
    def __init__(self):
        self.a1 = 'a1'
        print('A.init')

    def __get__(self, instance, owner):
        print('A.get {} {} {}'.format(self,instance,owner))

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

print('-'*20)
print(B.x)
#print(B.x.a1)
print('========================')
b = B()
print(b.x)
#print(b.x.a1)

因为定义了__get__方法，类A就变成了描述器，对类B或者类B的实例的x属性读取，称为对类A的实例的访问，就会调用__get__方法。__get__方法的三个参数分别是：self是类A的实例，owner是类B，instance是类B的实例。根据上面的结果得到给__get__一个返回值self就可以解决报错的问题。

描述器定义

Python中，一个类实现了__set__、__delete__、__get__三个方法1中的任意一个就是描述符。如果仅实现了__get__方法就是非数据描述器；同时实现了__get__、__set__就是数据描述符。如果一个类的类属性设置为描述器，那么它被称为owner属主。

属性的访问顺序

class A:
    def __init__(self):
        self.a1 = 'a1'
        print('A.init')

    def __get__(self, instance, owner):
        print('A.get {} {} {}'.format(self,instance,owner))
        return self

    def __set__(self, instance, value):
        print('A.set {} {} {}'.format(self,instance,value))
        self.data = value

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


print('-'*20)
print(B.x)
print(B.x.a1)
print('========================')
b = B()
print(b.x)
print(b.x.a1)

当在类B初始化时增加x属性后,抛出异常类型str没有a1属性，这是因为类B的势力中的x属性覆盖了类的属性x，我们在类A上增加set魔法方法后返回变成了a1。 总结出属性查找顺序：实例的字典优先于费数据描述器；数据描述器优先于实例的字典。 b.x = 500，这是调用数据描述器的set方法，或者调用非数据描述器的实例覆盖。 B.x = 500，赋值即定义，这是覆盖类属性

本质（进阶）

class A:
    def __init__(self):
        self.a1 = 'a1'
        print('A.init')

    def __get__(self, instance, owner):
        print('A.get {} {} {}'.format(self,instance,owner))
        return self

    # def __set__(self, instance, value):
    #     self.data = value

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

b=B()
print(b.x)
print(b.y)
#print(b.x.a1)
print('字典')
print(b.__dict__)
print(B.__dict__)

根据上述代码中禁用set方法前后字典的不同结果发现，数据描述器只是没有把B初始化函数时的x属性添加到实例字典中，造成了该属性如果是数据描述器优先访问的假象。其实属性访问顺序从没变过。

Python中的描述器

Python中的静态方法和类方法都是非数据描述器的实现。因此实例可以重新定义和覆盖方法。这允许单个实例获取与同一类的其他势力不同的行为。 property()函数是一个数据描述器的实现。因此实例不能覆盖属性的行为。

• 练习

1. 实现staticmathod

class StaticMethod:
    def __init__(self,fn):
        self._fn = fn

    def __get__(self, instance, owner):
        return self._fn
class A:
    @StaticMethod
    def stmd():
        print('Static method')

A.stmd()
A().stmd()

2. 实现classmethod

from functools import partial
class ClassMethod:
    def __init__(self,fn):
        self._fn = fn

    def __get__(self, instance, owner):
        print(self,instance,owner)
        return partial(self._fn,owner)
class A:
    @ClassMethod
    def stmd(cls):
        print('Static method')

A.stmd()
A().stmd()

3. 对实例的数据进行校验，使用描述器实现

class Person:
    def __init__(self,name:str,age:int):
        params = ((name,str),(age,int))
        if not self.checkdata(params):
            raise TypeError
        self.name =name
        self.age =age
    def checkdata(self,params):
        for p,t in params:
            if not isinstance(p,t):
                return False
        return True
### 上述写法代码耦合太高，里边有硬编码，而且不标准，较为丑陋。使用描述器接和装饰器让代码和类表现的像内置类型一样。

import inspect

class CheckType:
    def __init__(self,name,type):
        self.name = name
        self.type = type

    def __get__(self, instance, owner):
        if instance is not None:
            return instance.__dict__[self.name]
        return self
	#此处判断传进的参数是否符合注解要求
    def __set__(self, instance, value):
        if not isinstance(value,self.type):
            raise TypeError
        instance.__dict__[self.name] = value

def typeassert(cls):
    params = inspect.signature(cls).parameters
    for name,param in params.items():
        if param.annotation != param.empty:
	        #相当于是cls.name = CheckType(name,param.annotation)
            setattr(cls,name,CheckType(name,param.annotation))
    return cls

@typeassert    #装饰器是为了给Person类加两个CheckType实例的类属性
class Person:
    def __init__(self,name:str,age:int):
        self.name = name
        self.age = age

p = Person('jerry',20)
print(p)
print(p.__dict__)
print(Person.__dict__)