反射 & 命令分发器

　　

运行时,区别于编译时,指的是程序被加载到内存中执行的时候

反射,reflection,指的是运行时获取类型定义的信息

一个对象能够在运行时,像找镜子一样,反射处其类型信息

在Python中,能够通过一个对象,找出其type,class,attribute,method的能力,称为反射或自省

具有反射能力的函数: type()      isinstance()        callable()        dir()            getattr()

def dispatcher():
    cmds={}
    def reg(cmd,fn):
        if isinstance(cmd,(str,)):
            cmds.setdefault(cmd,fn)
        else:
            raise TypeError('TypeError')
        print(cmds)

    def run():
        while True:
            cmd=input('cmd: ').strip()
            if cmd.lower() == 'q':
                return
            print(cmds.get(cmd,default)())

    def default():
        print('default')
    return reg,run

reg,run=dispatcher()
reg('b1',lambda :print(11111111))
reg('b2',lambda :222)
print(run())

class Dispatcher:
    def cmd1(self):
        return 'cmd1'
    def reg(self,cmd,fn):
        if isinstance(cmd,(str,)):
            # setattr(self.__class__,cmd,fn)
            setattr(type(self),cmd,fn)
        else:
            raise TypeError

    def run(self):
        while True:
            cmd=input('commmand: ').strip()
            if cmd.upper() == 'Q':
                return
            print(getattr(self,cmd,self.default)())

    def default(self):
        return 'default'
b=Dispatcher()
b.reg('cmd2',lambda self:22222222)
b.reg('cmd3',lambda self:333333333333)
b.run()

class Dispatcher:
    def __init__(self):
        print('aaaaaaaaaa')
        self._run() # 初始化时就调用实例的_run方法(类的)
        print(self.__dict__)
        print('bbbbbbbbbbbbbbbb')
        # self.b
    def cmd1(self):
        return 'cmd1'
    def cmd2(self):
        return 'cmd2'

    def _run(self):
        while True:
            cmd=input('cmd: ').strip()
            if cmd.lower() == 'q':
                return
            print(getattr(self,cmd,lambda : 'default')())

Dispatcher()
# print(b.__dict__)

 

反射相关的函数和方法

一个Point类,查看它的实例属性,动态增加其属性

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

    def __str__(self):
        return 'Point:{{{}:{}}}'.format(self.x,self.y)
    def show(self):
        print('show:{{{}:{}}}'.format(self.x,self.y))

p=Point(22,33)
print(str(p))
print(p.__dict__)
p.__dict__['y']=44
print(p.__dict__)
p.z=10
print(p.__dict__)
print(dir(p),type(dir(p)))
print(p.__dir__())

上面的例子,访问方式不优雅,Python提供了内置函数

内建函数	意义
getattr(object,name[,default])	通过name访问object属性,属性不存在,返回default,未设置default,抛出AttributeError,name必须为字符串
setattr(object,name,value)	object属性存在,覆盖,不存在,新增
hasattr(object,name)	判断对象是否有name的属性,name必须为str

 

用上面方法重写代码

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

    def __str__(self):
        return 'Point:{{{}:{}}}'.format(self.x,self.y)
    def show(self):
        print(self)

p1=Point(11,22)
p2=Point(33,44)
print(repr(p1),repr(p2),sep='\n')
print(p1.__dict__)
setattr(p1,'y',999)
setattr(p1,'z',888)
print(getattr(p1,'__dict__'))
print(p1.__dict__)
# 动态调用方法
if hasattr(p1,'show'):
    p1.show()
if hasattr(p1,'uiop'):
    p1.uiop()
#动态增加方法
# 为类增加方法
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,p1))
print(p1.sub) # 未绑定需手动传参self
print(p1)
def fn(self,other):
    self.x=self.x-other.x
    self.y=self.y-other.y
    return self

if hasattr(p1,'sub'):
    setattr(p1,'sub',lambda self,other:exec('self.x=self.x-other.x;self.y=self.y-other.y'))
    # setattr(p1,'sub',fn)

print(p1.sub)
print(p1.sub(p1,p1))
print(p1)

print(p1.__dict__)
print(Point.__dict__)

 

 

 

反射相关的魔术方法

__getattr__       __setattr__         __delattr__

__getattr__:

class Base:
    n=00
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 '{} object missing {}'.format(self.__class__.__name__,item)

p1=Point(11,22)
print(p1.x)
print(p1.z)
print(p1.n)
# print(p1.mm)
print(getattr(p1,'uio','uioopp'))
# 使用getattr()时,如果类存在__getattr__魔术方法,可不设置default,如果未设置default,也不存在__getattr__则会抛异常
# 直接访问属性时,没有__getattr__直接抛异常

属性会按照继承关系找,找不到,执行__getattr__方法,如果没有这个方法,抛出AttributeError异常,表示找不到该属性

查找属性顺序为:
instance.__dict__       =>           instance.__class__.__dict__       =>       继承的祖先类(until object).__dict__           =>        调用getattr()

 

__setattr__

 

class Base:
    n=00
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 '{} object missing {}'.format(self.__class__.__name__,item)

    def __setattr__(self,key,value):
        print('setattr {}={}'.format(key,value)) # 覆盖 object的方法后,属性未写到dict中

p1=Point(11,22)
print(p1.x)
print(p1.z)
print(p1.n)
print(p1.mm)
p1.x=55
print(p1.__dict__)
p1.__dict__['x']=66 # 直接操作实例自身的属性__dic__不会调用__setattr__
print(p1.__dict__)
print(p1.x)

setattr(p1,'vv',888)
print(p1.__dict__)

实例通过 "." 或setattr设置属性,like self.x='xxxxxxx'       or         setattr(p1,'x','xxxxxxxxxxxx'),就会调用__setattr__()魔术方法,但是直接操作自身的字典,like      p1.__dict__['x']='xxxxxxxxxxxxx'

则不会触发__setattr__的执行

 

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 '{} object missing {}'.format(self.__class__.__name__,item)

    def __setattr__(self,key,value):
        print('setattr {}={}'.format(key,value)) # 覆盖 object的方法后,属性未写到dict中
        self.__dict__[key]=value # 执行写入操作

 

__setattr__方法,可以拦截对实例属性的增加,修改,如果要设置生效,需要手动操作实例的__dict__

 

 

__delattr__

 

class Ore:
    z=55
    def __init__(self,x,y):
        self.x=x
        self.y=y

    def __delattr__(self,item): # 实例方法
        print('Can not del {}'.format(item))

p=Ore(11,22)
del p.x
p.z=33
del p.z
print(Ore.__dict__)
print(p.__dict__)
del Ore.z
print(Ore.__dict__)
print(p.__dict__)

可以阻止通过实例删除属性的操作,但是通过类依然可以删除属性,因为这三个魔术方法都是针对实例

 

__getattribute__

 

class Base:n=00
class Ore(Base):
    z=66
    def __init__(self,x,y):
        self.x=x
        self.y=y

    def __getattr__(self,item):
        return '{} object missing {}'.format(self.__class__.__name__,item)

    def __getattribute__(self,item):
        return item

o=Ore(11,22)
print(o.__dict__)
print(o.x)
print(o.z)
print(o.mmmm)
print(Ore.__dict__)
print(Ore.z)

实例的所有属性访问,第一个都会调用__getattribute__方法,__getattribute__阻止了实例属性的查找,该方法返回计算后的值或者抛出一个AttributeError异常

它的return值将作为属性查找的结果,如果抛出AttributeError异常,则会直接调用__getattr__方法,表示属性没有找到

class Base:n=00
class Ore(Base):
    z=66
    def __init__(self,x,y):
        self.x=x
        self.y=y

    def __getattr__(self,item):
        return '{} object missing {}'.format(self.__class__.__name__,item)

    def __getattribute__(self,item):
        raise AttributeError('Attribute Not Found')
        return item

o=Ore(11,22)
print(o.__dict__)

 

 上图产生循环调用

修改代码

class Base:n=00
class Ore(Base):
    z=66
    def __init__(self,x,y):
        self.x=x
        self.y=y

    def __getattr__(self,item):
        return '{} object missing {}'.format(self,item)

    def __getattribute__(self,item):
        raise AttributeError('Attribute Not Found')
        return item

o=Ore(11,22)
print(o.__dict__)

print(o.x)
print(o.z)
print(o.mmmm)
print(Ore.__dict__)
print(Ore.z)

 

 所有的实例属性访问,先调用__getattribute__后直接raise AttributeError后调用了__getattr__方法

class Base:n=00
class Ore(Base):
    z=66
    def __init__(self,x,y):
        self.x=x
        self.y=y

    def __getattr__(self,item):
        return '{} object missing {}'.format(self,item)

    def __getattribute__(self,item):
        # raise AttributeError('Attribute Not Found')
        # return self.__dict__[item] # 会产生循环递归
        return object.__getattribute__(self,item) # 正确的返回方法

o=Ore(11,22)
print(o.__dict__)
print(o.x)
print(o.z)
print(o.mmmm)
print(Ore.__dict__)
print(Ore.z)

 

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

魔术方法	意义
__getattr__	通过搜索实例,实例的类,以及祖先类查不到该属性时调用
__setattr__	通过 "." 或 setattr(object,key,value)访问实例属性,进行增加,修改时调用
__delattr__	通过实例删除属性时调用
__getattribute__	实例的所有属性调用都从此方法起始

 

属性查找顺序:

__getattribute__()    =>       instance.__dict__          =>            instance.__class__.__dict__           =>          祖先类(until object).__dict__                 =>           __getattr__()