12、反射方法

1、isinstance(obj,cls) 和 issubclass(sub,super)

isinstance(obj,cls)检查是否obj是否是类 cls 的对象

class Foo(object):
    pass
obj = Foo()
print(isinstance(obj,Foo))

输出结果：True

issubclass(sub, super)检查sub类是否是 super 类的派生类

class Foo(object):
    pass
class Bar(Foo):
    pass
print(issubclass(Bar,Foo))

输出结果为：True

2、反射

2.1、什么是反射？

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。

这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

2.2、python 面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

四个可以实现自省的函数 下列方法适用于类和对象（一切皆对象，类本身也是一个对象）

2.1、hasattr(object , name)   判断object 中有没有一个name字符串对应的方法或属性 #检测属性

# 反射:通过字符串映射到对象的属性

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

    def talk(self):
        print('%s is talking' % self.name)

obj = People('alex', 18)
print(obj.name)  # print(obj.__dict__['name'])
print(obj.age)   # print(obj.age)
print(obj.__dict__)

print(obj.talk)  # 绑定到对象 <bound method People.talk of <__main__.People object at 0x024339B0>>


# hasattr(object,name)
# 判断object中有没有一个name字符串对应的方法或属性
print(hasattr(obj, 'name'))  # obj.name  # obj.__dict__['name']    #输出结果为True
print(hasattr(obj, 'talk'))     # obj.talk  # obj.__dict__['name'] # 输出结果为True

print(obj.__dict__)
print(People.__dict__)

2.2、getattr(object ,name,default=None)取出object中name字符串对应的方法或属性(该方法必须存在)   #获取属性

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

    def talk(self):
        print('%s is talking' % self.name)

obj = People('alex', 18)

# print(obj.__dict__)
# print(People.__dict__)
print(getattr(obj, 'name'))
print(getattr(obj, 'talk')) ## talk函数的内存地址

alex
<bound method People.talk of <__main__.People object at 0x00000000026D6DA0>>

 2.3、setattr(object,name,value)  # 增，设置属性

class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk(self):
        print(f"{self.name} is talking")
obj = People('alex',18)
print(setattr(obj,'sex','male'))
print(obj.__dict__)

None
{'name': 'alex', 'age': 18, 'sex': 'male'}

2.4、delattr（obj,name） # 删除属性

class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk(self):
        print(f"{self.name} is talking")
obj = People('alex',18)
print(delattr(obj,'age'))
print(obj.__dict__)

None
{'name': 'alex'}

2.5、四个方法的使用演示

class BlackMedium:
    feature='Ugly'
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr

    def sell_house(self):
        print('%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼' %self.name)
    def rent_house(self):
        print('%s 黑中介租房子啦,傻逼才租呢' %self.name)

b1=BlackMedium('万成置地','回龙观天露园')

#检测是否含有某属性
print(hasattr(b1,'name'))
print(hasattr(b1,'sell_house'))

#获取属性
n=getattr(b1,'name')
print(n)
func=getattr(b1,'rent_house')
func()

# getattr(b1,'aaaaaaaa') #报错
print(getattr(b1,'aaaaaaaa','不存在啊'))

#设置属性
setattr(b1,'sb',True)
setattr(b1,'show_name',lambda self:self.name+'sb')
print(b1.__dict__)
print(b1.show_name(b1))

#删除属性
delattr(b1,'addr')
delattr(b1,'show_name')
delattr(b1,'show_name111')#不存在,则报错

print(b1.__dict__)

 3、反射的好处

好处一：实现可插拔机制

有俩程序员，一个lili，一个是egon，lili在写程序的时候需要用到egon所写的类，但是egon去跟女朋友度蜜月去了，还没有完成他写的类，lili想到了反射，使用了反射机制lili可以继续完成自己的代码，等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。

总之反射的好处就是，可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能

egon还没有实现全部功能

class FtpClient:
    'ftp客户端,但是还么有实现具体的功能'
    def __init__(self,addr):
        print('正在连接服务器[%s]' %addr)
        self.addr=addr
不影响lili的代码编写

#from module import FtpClient
f1=FtpClient('192.168.1.1')
if hasattr(f1,'get'):
    func_get=getattr(f1,'get')
    func_get()
else:
    print('---->不存在此方法')
    print('处理其他的逻辑')

输出结果：

正在连接服务器[192.168.1.1]
---->不存在此方法
处理其他的逻辑

好处二：动态导入模块（基于反射当前模块成员）

 5、反射的应用

class Service:
    def run(self):
        while True:
            to_input = input('>>:').strip()
            cmds = to_input.split()
            if hasattr(self,cmds[0]):
                func = getattr(self,cmds[0])
                func(cmds)
    def get(self,cmds):
        print('get-----------',cmds)
    def put(self,cmds):
        print('put----------',cmds)
obj = Service()
obj.run()

>>:get a.txt
get----------- ['get', 'a.txt']
>>:put a.txt
put---------- ['put', 'a.txt']
>>: