Py修行路 python基础 （十八） 反射 内置attr 包装
一、isinstance 和 issubclass
1、isinstance(obj,cls)检查是否obj是否是类 cls 的对象。
2、issubclass(sub, super)检查sub类是否是 super 类的派生类。
判断结果为布尔值：是返回True，不是返回False
1 class Bar: #定义父类 2 pass 3 class Foo(Bar): #定义子类 继承 Bar 4 pass 5 6 class A: #定义类 A 7 pass 8 9 obj=Foo() #实例化 10 a = A() #实例化 11 #isinstance 12 print(isinstance(obj,Foo)) #查看obj是否是类Foo的对象 13 print(isinstance(obj,Bar)) #查看obj是否是类Bar的对象 14 print(isinstance(a,A)) #查看a是否是类A的对象 15 print(isinstance(a,Foo)) #查看a是否是类Foo的对象 16 #issubclass 17 print(Foo.__bases__) #之前查看继承的方式 18 print(issubclass(Foo,Bar)) #查看类Foo 是否是类Bar的子类 19 print(issubclass(A,Bar)) #查看类A 是否是类Bar的子类 20 21 #执行结果： 22 True 23 True 24 True 25 False 26 (<class '__main__.Bar'>,) 27 True 28 False
二、反射：getattr,setattr,delattr,hasattr
1、定义：
反射：主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。
python面向对象中的反射：通过字符串的形式，操作对象的相关的属性。python中的一切事物都是对象（都可以使用反射）。
2、应用：
1) hasattr 查找
hasattr(object,'name') 应用于类或对象，查看有没有所对应的方法。实质还是从类或对象的名称空间去查找。判断结果返回布尔值，有为True,没有为False.
2)getattr 获取
getattr(object,name，‘返回值’) 通过字符串获取 查看有没有这个属性，获取绑定方法。
实质还是从类或对象的名称空间去查找，有的话返回为函数内存地址，加()就能运行。
3)setattr 设置
setattr(x,y,v) x=类或对象， y='字符串类型的属性名'，v=value 值 实质是给类或是对象添加数据属性。
4)delattr 删除
delattr(x,y) x = 类或对象，y = '字符串类型的属性名' 删除类或是对象内的某个属性！
#coding = utf-8 #通过字符串的形式，为类或是对象添加属性 class People: #定义一个类 country = 'China' def __init__(self,name): self.name = name def test(self): print('test') p = People('zh') #实例化 #hasattr h = hasattr(p,'name') #查看对象p有没有name属性 print(h) #打印布尔值 #执行结果： True #getattr(object,name,default=None(or'自定义的值')) print(p.__dict__) #查看对象的名称空间 print(People.__dict__) #查看类的名称空间 g = getattr(p,'name') #获取对象name方法 g1 = getattr(p,'test') #获取对象test的绑定方法 g2 = getattr(People,'test') #获取类test方法 g3 = getattr(People,'work',"没有此方法！") #获取类work方法，没有打印value值 print(g,g1,g2,g3) #打印 g1() #执行对象对应的方法，不需要传值 g2(p) #执行类对应的方法，需要传值 #执行结果： {'name': 'zh'} {'__module__': '__main__', 'country': 'China', '__init__': <function People.__init__ at 0x00000000028EC9D8>, 'test': <function People.test at 0x00000000028ECA60>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None} zh <bound method People.test of <__main__.People object at 0x00000000028FF208>> <function People.test at 0x00000000028ECA60> 没有此方法！ test test #setattr()只能更改类或是对象内的 数据属性，函数属性没法变更。 print(p.__dict__) #设置前查看对象的名称空间 setattr(p,'sex','male') #设置sex属性 setattr(p,'age',18) #设置age属性 print(p.__dict__) #设置后查看对象的名称空间 print(p.sex,p.age) #打印 #执行结果： {'name': 'zh'} {'name': 'zh', 'sex': 'male', 'age': 18} male 18 #delattr print(p.__dict__) #删除前查看对象的名称空间 delattr(p,'age') #删除 对象 的数据属性 print(p.__dict__) #删除操作完成，在对象的名称空间查看 #执行结果： {'name': 'zh', 'sex': 'male', 'age': 18} {'name': 'zh', 'sex': 'male'}
5)反射当前位置的模块成员。
此处先明确两个概念：
脚本文件：将程序写到一个文件中，以***.py的方式保存，使用的时候 利用python ***.py进行执行，该文件就称为脚本文件。
模块：import 模块名 导入的文件就是模块，文件名就是模块名。
在当前位置获取当前文件中定义的函数，如果直接将本文件以模块的形式导入文件中，程序执行直接触发递归，无法实现功能，此时在自己位置就不能导入自己的模块。此时就需要把本文件转成一个脚本模块，既可以导入到别的模块或文件中用，另外该模块自己也可执行。所以就需要使用下面的方法：
方法：import sys #导入sys模块
this_modules = sys.modules[__name__](有返回值) 获取一个模块，将当前位置的文件转成一个脚本模块（有具体的文件地址）
print(__name__)
注意：__name__的用法： 如果我们是直接在本文件执行，那该文件中'__name__' == '__main__'，但是如果从另外一个.py文件通过import导入该文件的时候，这时__name__的值就是我们这个py文件的名字而不是__main__。（有一种加上保护锁的感觉）
import sys #导入sys模块 def add(): print('add') def change(): print('change') def search(): print('search') def delete(): print('delete') this_module = sys.modules[__name__] #利用sys模块中的modules方法，将本文件转成脚本模块 print(this_module) #查看 print(__name__) #查看__name__ while True: m = input('input something:').strip() if not m :continue if hasattr(this_module,m): #判断输入的内容在不在模块 类中 func = getattr(this_module,m) #获取这个方法，拿到返回值 func() #执行函数 else: print('没有此方法！') #执行结果： <module '__main__' from 'F:/py_fullstack_s4/day31/__name__及反射的用途.py'> __main__ input something:add add input something:work 没有此方法！
3、反射的好处：
好处一：可以利用反射实现可插拔机制。
可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，即事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能。不影响其他人员对程序的调用和开发。
class FtpClient: 'ftp客户端,但是还没有实现具体的功能' def __init__(self,addr): print('正在连接服务器[%s]' %addr) self.addr=addr def get(self): print('get------->')
import ftpclient #将文件以模块形式导入 '''ftp服务端，需要用到客户端的功能''' f1=ftpclient.FtpClient('192.168.1.1') #调用文件中的类 if hasattr(f1,'get'): #判断是否有这功能 func_get=getattr(f1,'get') #获取功能，得到返回值（对应函数的内存地址） func_get() #执行函数 else: print('---->不存在此方法') print('处理其他的逻辑')
正在连接服务器[192.168.1.1]
get------->
好处二：通过字符串动态导入模块
#不推荐利用__import__(字符串) 的方法,官方推荐importlib.import_module(字符串)的方式 import importlib # m = input('please input something:') t = importlib.import_module('time') print(t.time()) #执行结果： 1493024228.788776
三、内置attr：__getattr__,__setattr__,__delattr__
大前提：类内部设置
1、__setattr__
以函数方式，设置在类内部，实例化传值自动触发，直接获取为对象设置的属性，导致对象的名称空间中无法找到方法。
class Foo: def __init__(self,name): #初始化属性 self.name = name def __setattr__(self, key, value): # 拿到实例化的值 print('---setattr---key:%s,value:%s'%(key,value)) #self.__dict__[key] = value #在对象的名称空间中添加方法 #调用__setattr__的方法 f = Foo('zh') #类的实例化 f.age = 18 #给类定义一个数据属性 print(f.__dict__) #打印当前字典 #执行结果： ---setattr---key:name,value:zh ---setattr---key:age,value:18 {}
利用此种方法可以加上自己的限制，然后再通过 self.__dict[key]=value 的方法 添加到对象的名称空间中。
2、__delattr__
删除某个属性，但不会真正删除。若删除的话必须通过 self.__dict__.pop(item) 在方法字典中 删除 。
3、__getattr__ （特别注意该内置函数的方法！！！）
类内该属性不存在的情况下，才会触发执行，返回None；只要有该方法，就不执行。
class Foo: def __init__(self,x): #初始化属性 self.name = x # self.name = x ------------> self = self;key = name; value = x def __setattr__(self, key, value): # 自动触发，获取self.属性名=值 self = self;key = 属性名;value = 值 print('---setattr---key:%s,value:%s'%(key,value)) self.__dict__[key] = value #在对象的名称空间中添加方法 def __delattr__(self, item):# 删除某项属性 print('delattr:%s'%item) print(f.__dict__) #打印当前对象的名称空间 self.__dict__.pop(item) #删除对象内的方法 def __getattr__(self, item): # 没有方法触发 print('getattr---> %s %s'%(item,type(item))) #调用__setattr__的方法 f = Foo('zh') #类的实例化 f.age = 18 #给类定义一个数据属性 print(f.__dict__) #打印当前字典 #执行结果： ---setattr---key:name,value:zh ---setattr---key:age,value:18 {'name': 'zh', 'age': 18} #调用__delattr__的方法 del f.age print(f.__dict__) #执行结果： delattr:age {'name': 'zh', 'age': 18} {'name': 'zh'} #调用__getattr__的方法 print(f.name) print(f.azcw) #执行结果： zh getattr---> azcw <class 'str'> None
四、二次加工标准类型
1、包装：基于继承实现对标准数据类型的包装对已有的数据类型进行包装，新增/改写方些方法，用以定制我们自己的数据类型。
实质：创建一个新的类，给数据类型格外添加新的功能或是判断的功能。
class List(list): #以列表为例 def append(self, p_object): #重新定义append方法，只允许添加数据类型 if not isinstance(p_object,int): #判断 添加的数据是不是数据类型 raise TypeError('must be int') super().append(p_object) #原定义的其他功能默认不动 l = List([1,2,3,4]) print(l) l.append(5) print(l) l.append('a') print(l) #执行结果： [1, 2, 3, 4] [1, 2, 3, 4, 5] File "F:/py_fullstack_s4/day31/定义自己的数据类型.py", line 12, in <module> l.append('a') File "F:/py_fullstack_s4/day31/定义自己的数据类型.py", line 5, in append raise TypeError('must be int') TypeError: must be int
#基于继承的原理，定义自己的数据类型。 #虽然更改了列表的append方法，但是对列表的其他功能没有改变 class List(list): #以列表为例 def append(self, p_object): #重新定义append方法 if not isinstance(p_object,int): #判断 添加的数据是不是数据类型 raise TypeError('must be int') super().append(p_object) #原定义的其他功能默认不动 l = List([1,2,3,4]) print(l) l.append(5) print(l) # l.append('a') # print(l) l.insert(0,-1) #列表的插入方法不改变 l.insert(1,'abc') print(l) #执行结果： [1, 2, 3, 4] [1, 2, 3, 4, 5] [-1, 'abc', 1, 2, 3, 4, 5]
2、授权：实现授权的关键点，就是覆盖__getattr__的方法
对系统已经定义的函数进行包装的过程叫做授权，函数不再是类，有继承的方式，而是所有需要添加的功能由类中再定义，判断结束再写入该函数。已存在的功能默认执行。
实质：创建一个新的类，给函数格外添加新的功能或是判断的功能。
#不能用继承,来实现open函数的功能 # f=open('a.txt','w') # print(f) # f.write('1111111') #授权的方式实现定制自己的数据类型 import time class Open: def __init__(self,filepath,m='r',encode='utf-8'): #初始化定义open函数的默认属性 self.filepath=filepath self.mode=m self.encoding=encode self.x = open(filepath, mode=m, encoding=encode) #定义结束，以这种方式执行原函数 def write(self,line): #重新定义写的功能：每行写入的同时也写入时间 print('f自己的write',line) #打印要添加的内容 t=time.strftime('%Y-%m-%d %X') #时间，格式：年-月-日 具体时间 self.x.write('%s %s' %(t,line)) #利用原函数写入新内容 def __getattr__(self, item): #关于其他内容 print('=------>',item,type(item)) return getattr(self.x,item) #返回原函数方法的形式，以原函数对应的这个的方法执行。 #在类中定义好的方法，实例化进行调用 f=Open('b.txt','a+') #实例化方法 print(f) #查看f的类型 f.write('hello world!\n') #执行绑定方法，在文件中写入内容 f.close() #关闭文件，此方法未定义，执行__getattr__方法，利用原函数的方法 #未在类中定义的方法，通过触发__getattr__的方式，来执行原函数的功能！ f=Open('b.txt','r+') #实例化方法 print(f.read) #查看未定义方法read 的类型 print(f.read()) #执行方法 self.x.read() print('=-=====>',f.read()) #文件读完之后打印 f.seek(0) #将光标移动到初始开始位置 print(f.read()) #再次打印文件中的内容 # f.flush() f.close() #关闭文件，此方法未定义，执行__getattr__方法，利用原函数的方法 #执行结果： <__main__.Open object at 0x00000000028AA908> f自己的write hello world! =------> close <class 'str'> =------> read <class 'str'> <built-in method read of _io.TextIOWrapper object at 0x000000000241AB40> =------> read <class 'str'> 2017-04-24 18:07:07 hello world! =------> read <class 'str'> =-=====> =------> seek <class 'str'> =------> read <class 'str'> 2017-04-24 18:07:07 hello world! =------> close <class 'str'>
