反射/内置方法
issubclass和ininstance
# 判断第一个类是不是第二个类的子类,返回true或者false
class Foo:
pass
class Bar(Foo):
pass
class Tt(Bar):
pass
print(Bar.__bases__) # (<class '__main__.Foo'>,)
print(issubclass(Bar,Foo)) # True
print(issubclass(Tt,object)) # True
# 判断第一个参数是不是第二个参数的对象,返回true或者false
class Foo:
pass
class Tt():
pass
f=Foo()
print(isinstance(f,Foo)) # True
print(isinstance(f,Tt)) # False
反射
反射就是通过字符串来操作类或者对象的属性
-
反射本质就是在使用内置函数，其中反射有以下四个内置函数：
1. hasattr：判断一个方法是否存在与这个类中 2. getattr：根据字符串去获取obj对象里的对应的方法的内存地址，加"()"括号即可执行 3. setattr：通过setattr将外部的一个函数绑定到实例中 4. delattr：删除一个实例或者类中的方法
class Foo:
def run(self):
print('run')
def speak(self):
print('speak')
p=Foo()
# 输入字符串，执行字符串对应的方法
choice = input('请输入执行命令：')
if hasattr(p,choice):
run = getattr(p,choice)
run()
else:
print('该命令不存在！')
# 通过用户输入key和value往对象中赋值
key=input('请输入key:')
value=input('输入value:')
setattr(p,key,value)
print(p.age) # 默认用户输入age关键字
'''
请输入key:age
输入value:12
12
'''
#动态的往对象中放方法
def test():
print(1)
print(p.__dict__)
setattr(p,'test',test)
print(p.__dict__)
p.test()
'''
{}
{'test': <function test at 0x02D907C8>}
1
'''
# 动态删除p中属性为变量a的属性
p.name='lqz'
p.age=18
p.sex='male'
a=input('请输入要删除的属性:')
print(p.__dict__)
delattr(p,a)
print(p.__dict__)
'''
请输入要删除的属性:age
{'name': 'lqz', 'age': 18, 'sex': 'male'}
{'name': 'lqz', 'sex': 'male'}
'''
# 直接p.a是不对的
del p.a
内置方法
#__str__:如果不重写__str__ print打印会打印出内存地址
class Foo:
def __init__(self,name):
self.name=name
print(Foo('nick')) # <__main__.Foo object at 0x0078DFD0>
# __str__如果重写了，就会打印__str__方法返回的内容
class Foo:
def __init__(self,name):
self.name=name
def __str__(self):
return '['+self.name+']'
print(Foo('nick')) # [nick]
#__repr__ 跟str类似,在交互式命令下直接写变量名,会执行__repr__
#__setattr__,__delattr__,__getattr__(重要)
# 点拦截方法
#如果去对象中取属性,一旦取不到,会进入到__getattr__
#如果去对象中赋值属性,一旦取不到,会进入到__setattr__
#如果删除对象中的属性,会进入__delattr__
class Foo:
def __init__(self,name):
self.name=name
def __getattr__(self, item):
return '你傻逼啊,没有这个字段'
f=Foo('nick')
print(f.age) # 你傻逼啊,没有这个字段
class Foo:
def __init__(self,name):
self.name=name
def __setattr__(self, key, value):
print('6666')
f=Foo('nick')
f.sex='male' # 666
class Foo:
def __init__(self,name):
self.name=name
def __delattr__(self, item):
print('你想删除啥？')
f=Foo('nick')
del f.name
print(f.__dict__) # name属性并没有被删除
'''
你想删除啥？
{'name': 'nick'}
'''
# 写一个类继承字典,让它可以 . 取值,也可以中括号取值
class Mydict(dict):
def __init__(self,**kwargs):
super().__init__(**kwargs) # 继承了原dict的方法
def __getattr__(self, item):
return self[item]
def __setattr__(self, key, value):
self[key]=value
di=Mydict(name='lqz',age=18)
print(di['name'])
print(di.age)
di.sex='male'
di['sex']='male'
di.hobby = ['baskerball']
print(di.sex)
print(di['hobby'])
'''
lqz
18
male
['baskerball']
'''
# __item__系列 对象通过[] 中括号取值,赋值,删除值的时候,会调用
__setitem__:中括号赋值时触发
__getitem__:中括号取值时触发
__delitem__:中括号删除时触发
__delattr__:.删除时触发
class Foo:
def __init__(self, name):
self.name = name
def __getitem__(self, item):
print('getitem执行', self.__dict__[item])
def __setitem__(self, key, value):
print('setitem执行')
self.__dict__[key] = value
def __delitem__(self, key):
print('del obj[key]时，delitem执行')
self.__dict__.pop(key)
def __delattr__(self, item):
print('del obj.key时，delattr执行')
self.__dict__.pop(item)
f1 = Foo('sb')
f1['age'] = 18 # setitem执行
f1['name'] = 'tank' # setitem执行
f1['age'] # getitem执行
del f1.age # del obj.key时，delattr执行
del f1['age'] # del obj[key]时，delitem执行
print(f1.__dict__) # {'name': 'tank'}
#__call__ 对象加括号会调用它
class Foo:
def __call__(self):
print('xxxx')
f=Foo()
f() # xxxx