1. isinstance
isinstance(obj,cls)检查obj是否是类 cls 的对象
print(isinstance(1, int)) print(isinstance(1.0, float)) print(isinstance('aa', str))
上面都是True
print(isinstance('aa', (int,list,str)))
只要是后面元组中的一个,就返回True
2. issubclass
issubclass(sub, super)检查sub类是否是 super 类的派生类
class A: pass class B(A): pass class C(B): pass class D: pass print(issubclass(B,A)) print(issubclass(C,A)) print(issubclass(D,A)
结果是:
True True False
子类的子类,进行判断,返回也是True,不能用实例化的对象进行判断,例如:b=B(),issubclass(b,A) ,这样有语法错误
反射
python中的反射功能是由以下四个内置函数提供:hasattr、getattr、setattr、delattr
class A: def __init__(self,name,age): self.names=name self.ages=age def info(self): print('name: %s, age: %d' %(self.names,self.ages)) @staticmethod def static_func(): print('static method') a=A('egon',18) print(hasattr(a,'name')) #判断是否有name属性,False print(hasattr(a,'names')) #判断是否有names属性,True #获取属性 n = getattr(a,'names') print(n) #egon func = getattr(a,'info') func() #name: egon, age: 18 m = getattr(a,'bbbbb','不存在') #如果属性不存在,返回第三个字段内容 print(m) #不存在 m = getattr(a,'bbbbb',None) print(m) #None #设置属性 setattr(a,'names','alex') print(a.__dict__) #{'names': 'alex', 'ages': 18} setattr(a,'n','alex') print(a.__dict__) #{'names': 'alex', 'ages': 18, 'n': 'alex'} 新增了一个n属性 #删除属性 #delattr(a,'ddd') #删除的属性不存在会报错 delattr(a,'names') print(a.__dict__) #{'ages': 18, 'n': 'alex'} 已经删除掉了names #可以直接获取类的属性 f = getattr(A,'static_func') f() #static method
__setattr__,__delattr__,__getattr__
__getattr__只有在使用点调用属性且属性不存在的时候才会触发
__delattr__删除属性的时候会触发
__setattr__添加/修改属性会触发它的执行
class Foo: x=1 def __init__(self,y): self.y=y def __getattr__(self, item): print('----> from getattr:你找的属性不存在') def __setattr__(self, key, value): print('----> from setattr') # self.key=value #这就无限递归了,你好好想想 # self.__dict__[key]=value #应该使用它 def __delattr__(self, item): print('----> from delattr') # del self.item #无限递归了 self.__dict__.pop(item) #__setattr__添加/修改属性会触发它的执行 f1=Foo(10) print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值 f1.z=3 print(f1.__dict__) # #__delattr__删除属性的时候会触发 f1.__dict__['a']=3#我们可以直接修改属性字典,来完成添加/修改属性的操作 del f1.a print(f1.__dict__) # # #__getattr__只有在使用点调用属性且属性不存在的时候才会触发 f1.xxxxxx f1.__dict__['a']=3 f1.a
__setitem__,__getitem,__delitem__
当已字典的形式操作类属性的时候,会进入以上函数
class Foo: def __init__(self,name): self.name=name def __getitem__(self, item): print('--------getitem',self.__dict__[item]) def __setitem__(self, key, value): #f1['age']=18,当以操作字典的形式进行操作时,会进入该函数 print('--------setitem') self.__dict__[key]=value def __delitem__(self, key): #del f1['age']已字典形式删除时进入函数 print('del obj[key]时,我执行') self.__dict__.pop(key) def __delattr__(self, item): #del f1.age1,obj.xxx 进行操作时,进入函数 print('del obj.key时,我执行') self.__dict__.pop(item) f1=Foo('sb') f1['age']=18 #--------setitem f1['age1']=19 #--------setitem del f1.age1 #del obj.key时,我执行 del f1['age'] #del obj[key]时,我执行 f1['name']='alex' #--------setitem print(f1.__dict__) #{'name': 'alex'}
__str__,__repr__,__format__
改变对象的字符串显示__str__,__repr__
自定制格式化字符串__format__
format_dict={ 'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型 'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址 'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名 } class School: def __init__(self,name,addr,type): self.name=name self.addr=addr self.type=type def __repr__(self): return 'School(%s,%s)' %(self.name,self.addr) def __str__(self): return '(%s,%s)' %(self.name,self.addr) def __format__(self, format_spec): # if format_spec if not format_spec or format_spec not in format_dict: format_spec='nat' fmt=format_dict[format_spec] return fmt.format(obj=self) s1=School('oldboy1','北京','私立') print('from repr: ',repr(s1)) print('from str: ',str(s1)) print(s1) ''' str函数或者print函数--->obj.__str__() repr或者交互式解释器--->obj.__repr__() 如果__str__没有被定义,那么就会使用__repr__来代替输出 注意:这俩方法的返回值必须是字符串,否则抛出异常 ''' print(format(s1,'nat')) #oldboy1-北京-私立 print(format(s1,'tna')) #私立:oldboy1:北京 print(format(s1,'tan')) #私立/北京/oldboy1 print(format(s1,'asfdasdffd')) #oldboy1-北京-私立
__doc__
class Foo: '我是描述信息' pass class Bar(Foo): pass print(Bar.__doc__) #该属性无法继承给子类 None print('---------------') print(Foo.__doc__) #我是描述信息
__del__
析构方法,当对象在内存中被释放时,自动触发执行。
class Foo: def __del__(self): print('执行我啦') f1=Foo() # del f1 print('------->')
结果是:
------->
执行我啦