python 面向对象进阶 1 isinstance(obj,cls)和issubclass(sub,super) 2 反射 3 __setattr__,__delattr__,__getattr__
isinstance(obj,cls) obj是否是cls的对象或cls子类的对象
issubclass(sub,super) sub是否是super的子类
cls.__bases__ 获取cls的父类
class A:
pass
class B(A):
pass
print(issubclass(B,A)) #True
print(B.__bases__)
b=B()
print(isinstance(b,B)) #True
2 反射
反射也叫自省，主要设置程序可以访问、检测和修改它本身状态或行为的一种能力。
2.1 python中面向对象的反射
Python中是通过字符串的形式来操作对象相关的属性。python 中一切皆对象（都可以使用反射）
具体的做法是：将字符串映射成命令
四个实现自省的函数
2.1.1 hasattr
hasattr(object,name)
判断object是否有名字是name的属性。
等价于 name in object.__dict__
#!/user/bin/env python
# -*- coding:utf-8 -*-
class Foo:
camp="foo"
def __init__(self,name):
self.name=name
def test1(self):
print("test1")
f=Foo("zzz")
#不用反射来，访问属性
# print(f.name)
# f.name="yyy"
# print(f.name)
#使用反射
#hasattr
print(f.__dict__)
print(hasattr(f,"name")) #判断f对象的名称空间里，有么有"name"这个属性,等价于"name" in f.__dict__
print("name" in f.__dict__) #True
print("camp" in Foo.__dict__) #True
2.1.2 getattr
getattr(object, name, default=None)
获取object名称空间里的"name"属性的值，如果存在，就返回该值；不存在，就返回default。
等价于：object.name (object.__dict__["name"])
#getattr
print(f.name)
print(getattr(f,"name")) #获取f对象名称空间里"name"属性的值，等价于 f.name <======> f.__dict__["name"]
print(getattr(f,"age",-1)) #获取f对象名称空间里"age"属性的值，如果不存在，就返回-1
#print(f.age) #AttributeError: 'Foo' object has no attribute 'age'
print(Foo.camp) #foo
print(Foo.__dict__["camp"]) #foo
### 2.1.3 setattr
setattr(object, name, value)
修改对象object的name属性值为value。
等价于：object.name=value
#setattr
setattr(f,"name","yyy") #等价于f.name="yyy" <=====>f.__dict__["name"]="yyy"
print(getattr(f,"name"))
setattr(Foo,"camp","fooo")
Foo.camp="fooo"
#Foo.__dict__["camp"]="fooo" #TypeError: 'mappingproxy' object does not support item assignment
print(getattr(Foo,"camp"))
2.1.4 delattr
delattr(object,name)
删除object对象的名称空间下的名叫name的属性
等价于：del object.name
#delattr
delattr(f,"name") #等价于del f.name <=====>f.__dict__.pop("name")
#print(f.name)
2.2 反射的两种形式
2.2.1 基于类和对象的反射
class Foo(object):
staticField = "old boy"
def __init__(self):
self.name = 'wupeiqi'
def func(self):
return 'func'
@staticmethod
def bar():
return "bar"
print(getattr(Foo,'staticField'))
print(getattr(Foo,'func'))
print(getattr(Foo,'bar'))
结果：
old boy
<function Foo.func at 0x000001EDF525BB70>
<function Foo.bar at 0x000001EDF525BBF8>
2.2.2 基于模块的反射
在python中，每一个.py文件都是一个模块，而模块都是一个个对象。
#!/user/bin/env python
# -*- coding:utf-8 -*-
import sys
class Foo:
def __init__(self,name):
self.name = name
def get_name(self):
return self.name
#获取模块的名称
#print(__name__)
this_module=sys.modules[__name__]
print(this_module) #获取本文件的模块对象，通过该对象可以调用本文件下的变量、函数、类等
#print(sys.modules)
print(hasattr(this_module,"Foo"))
print(getattr(this_module,"Foo"))
结果：
__main__
<module '__main__' from 'D:/devtools/workspace/python/PycharmProjects/py_fulstack_s4/day32 面向对象的进阶/基于模块的反射.py'>
True
<class '__main__.Foo'>
2.3 反射的用途(好处)
2.3.1 实现可插拔机制
可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能。
#!/user/bin/env python
# -*- coding:utf-8 -*-
class FtpClient:
def __init__(self, addr):
print("正在连接服务器[%s]" % addr)
self.addr = addr
#def get():
#!/user/bin/env python
# -*- coding:utf-8 -*-
from developer_one import FtpClient
f1=FtpClient("192.168.1.1")
if hasattr(f1,"get"):
func_get=getattr(f1,"get")
func_get()
else:
print("不存在此方法")
print("处理其他的逻辑")
#即使调用的developer_one中FtpClient模块的功能“get”有没有完成，都不影响程序的正常执行。这就叫可插拔机制。
2.3.2 用字符串导入模块
m=input(">>").strip() #官方不推荐
m1=__import__(m)
print(m1.time())
import importlib #官方推荐方案
t=importlib.import_module("time")
2.4 日常中的“反射”
#!/user/bin/env python
# -*- coding:utf-8 -*-
def delete():
print("delete")
def add():
print("add")
def search():
print("search")
def modify():
print("modify")
file_dict={ #相当于对象的名称空间
"delete":delete,
"add":add,
"search":search,
"modify":modify,
}
while True:
choice=input(">>:").strip()
if not choice:continue
if choice in file_dict: #相当于hasattr(file_dict,choice)
func=file_dict[choice] #getattr(file_dict,choice)
func()
3 __setattr__,__delattr__,__getattr__
3.1 __setattr__
__setattr__ #在对象进行赋值（包括类的初始化）操作时，会自动调用
#!/user/bin/env python
# -*- coding:utf-8 -*-
class Foo:
def __init__(self,name):
self.name=name
def __setattr__(self, key, value): #对对象的属性进行赋值（包括类的初始化）操作时，会自动调用
print("key : %s , value : %s "%(key,value)) #key : name , value : zhang
print("key type:",type(key)) #key type: <class 'str'>
#为什么key的类型是str? 我们说了什么时候会自动调用这个函数。是在对象进行赋值的时候，其中有赋值操作的是，初始化f时。f=Foo("zhang"),在内存里面真正执行的是：f.__dict__["name"]="zhang"。所以说key是一个str类型。
print("value type:",type(value)) #value type: <class 'str'>
#print(self.key) #AttributeError: 'Foo' object has no attribute 'key'
#self.key=value #RecursionError: maximum recursion depth exceeded
#setattr(self,key,value) #RecursionError: maximum recursion depth exceeded
self.__dict__[key]=value
f=Foo("zhang")
结果：
key : name , value : zhang
key type: <class 'str'>
value type: <class 'str'>
__getattr__ age
3.2 __delattr__
__delattr__是在执行删除del object.name时，自动调用
class Foo:
def __init__(self,name):
self.name=name
def __delattr__(self,item): #在执行对象属性的删除操作时，会调用
#del self.item #RecursionError: maximum recursion depth exceeded while calling a Python object
#del self.__dict__[item]
self.__dict__.pop(item)
f=Foo("zhang")
del f.name
#print(f.name)
3.3 __getattr__
__getattr__ 查找的对象属性不存在，才会触发__getattr__；查找的对象属性存在，不会触发
class Foo:
def __init__(self,name):
self.name=name
def __getattr__(self,item): #查找的对象属性不存在，才会触发__getattr__；查找的对象属性存在，不会触发
print("__getattr__",item)
f=Foo("zhang")
f.name #未执行__getattr__
f.age #__getattr__ age
#print(f.name)
结果：
__getattr__ age
3.4 用途
1 二次加工标准类型
关键在于继承。
class List(list):
def append(self, obj):
if not isinstance(obj,int):
raise TypeError("must be int!")
super().append(obj)
def insert(self, index, obj):
if not isinstance(obj,int):
raise TypeError("must be int!")
super().insert(index,obj)
li=List((1,2,3))
#li.insert(2,"-1")
li.insert(2,-1)
print(li)
2 以授权的方式实现定制数据类型
#!/user/bin/env python
# -*- coding:utf-8 -*-
class List:
def __init__(self,li):
self.x=list(li)
def append(self,s):
if isinstance(s,str):
self.x.append(s)
else:
raise TypeError("传入列表的必须是字符串！")
@property
def mid(self):
print("列表的中间值：",self.x[int(len(self.x)/2)])
def __getattr__(self,item):
if hasattr(self.x,item):
return getattr(self.x,item)
else:
raise NameError("属性名错误！")
def __str__(self): #通过__str__来隐藏.x
return str(self.x)
li=List((1,2,3,4))
li.append("s")
print(li)
li.mid
li.pop(3)
print(li)
结果：
[1, 2, 3, 4, 's']
列表的中间值： 3
[1, 2, 3, 's']