isinstance和issubclass
isinstance(object, classinfo)检查是否obj是否是类 cls 的对象
isinstance(object, classinfo)
如果参数object是classinfo的实例，或者object是classinfo类的子类的一个实例， 返回True。如果object不是一个给定类型的的对象， 则返回结果总是False。
如果classinfo不表示一个类（类型对象）, 那么它要么是一个类的元组, 或者递归地包含这样的（由数据类型构成的）元组.其他的序列类型是不被允许的。
class Foo(object):
pass
obj = Foo()
print(isinstance(obj,Foo))
issubclass(sub, super)检查sub类是否是 super 类的派生类
class Foo(object): pass class Bar(Foo): pass issubclass(Bar, Foo)
反射：是用字符串类型的名字去操作变量
反射 就没有安全问题
1 什么是反射
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。
2 python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
四个可以实现自省的函数
下列方法适用于类和对象（一切皆对象，类本身也是一个对象）
反射对象中的属性和方法 hasattr getattr setattr delattr
class A: def func(self): print('in func') a = A() a.name = 'alex' a.age = 63
反射对象的属性
ret = getattr(a,'name') #getattr(a,'name')=a.name # 通过变量名的字符串形式取到的值
print(ret)
print(a.__dict__) #把属性和值按键值对的形式存放在字典内
'''
{'name': 'alex', 'age': 63}
'''
变量名 = input('>>>') # func #输入属性来取值 print(getattr(a,变量名)) print(a.__dict__[变量名]) #a.__dict__实际上是一个字典，按照键来取值
反射对象的方法 就是让函数执行
a.func() ret = getattr(a,'func') #getattr(a,'func')=a.func
ret()
反射类的属性
class A: price = 20 A.price print(getattr(A,'price')) #getattr(A,'price')=A.price
class Foo: f = '类的静态变量' def __init__(self,name,age): self.name=name self.age=age def say_hi(self): print('hi,%s'%self.name) obj=Foo('egon',73) #检测是否含有某属性 print(hasattr(obj,'name')) print(hasattr(obj,'say_hi')) #获取属性 n=getattr(obj,'name') print(n) func=getattr(obj,'say_hi') func() print(getattr(obj,'aaaaaaaa','不存在啊')) #报错 #设置属性 setattr(obj,'sb',True) setattr(obj,'show_name',lambda self:self.name+'sb') print(obj.__dict__) print(obj.show_name(obj)) #删除属性 delattr(obj,'age') delattr(obj,'show_name') delattr(obj,'show_name111')#不存在,则报错 print(obj.__dict__)
反射类的方法 ：classmethod staticmethod
class A: price = 20 @classmethod def func(cls): print('in func') A.func() if hasattr(A,'func'): #查找A。func存在不，不存在就报错 getattr(A,'func')() #getattr(A,'func')=A.func
模块
反射模块的属性
import my_module print(my_module.day)#模块名.属性名 print(getattr(my_module,'day'))
反射模块的方法
getattr(my_module,'read1')()
内置模块也能用
import time print(getattr(time,'time')()) print(getattr(time,'asctime')())
反射自己模块中的变量
import sys year = 2018 print(sys.modules['__main__'].year) print(getattr(sys.modules['__main__'],'year'))
反射自己模块中的函数
import sys def qqxing(): print('qqxinng') sys.modules['__main__'].qqxing() getattr(sys.modules['__main__'],'qqxing')()
变量名 = input('>>>')
getattr(sys.modules['__main__'],变量名)()
要反射的函数有参数怎么办？
import time print(time.strftime('%Y-%m-%d %H:%M:%S')) print(getattr(time,'strftime')('%Y-%m-%d %H:%M:%S'))
一个模块中的类能不能反射到？
#in my_module.py class A: print('nihao') #in my.py import my_module print(getattr(my_module,'A')())
setattr 修改设置属性
class A: name = '222' def __init__(self,name): self.name = name a = A('111')
print(A.name) print(a.name) setattr(a,'name','nezha') setattr(A,'name','alex') print(A.name) print(a.name) print(A.__dict__) print(a.__dict__)
delattr #删除一个变量
class A: name = '222' def __init__(self,name): self.name = name a = A('111') print(A.name) print(a.name) setattr(a,'name','nezha') setattr(A,'name','alex') print(A.name) print(a.name) delattr #删除一个变量 delattr(a,'name') print(a.name) delattr(A,'name') print(a.name)
内置的类方法
内置的类方法和内置的函数有着千丝万缕出的联系
双下方法
__str__和__repr__
改变对象的字符串显示__str__,__repr__
自定制格式化字符串__format__
object 里有一个__str__，一旦被调用，就返回调用这个方法的对象的内存地址 l = [1,2,3,4,5] # 实例化 实例化了一个列表类的对象 print(l) %s str() 直接打印 实际上都是走的__str__ %r repr() 实际上都是走的__repr__ repr 是str的备胎，但str不能做repr的备胎 print(obj)/'%s'%obj/str(obj)的时候，实际上是内部调用了obj.__str__方法，如果str方法有，那么他返回的必定是一个字符串 如果没有__str__方法，会先找本类中的__repr__方法，再没有再找父类中的__str__。 repr(),只会找__repr__,如果没有找父类的
#_*_coding:utf-8_*_ 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')) print(format(s1,'tna')) print(format(s1,'tan')) print(format(s1,'asfdasdffd'))
class B: def __str__(self): return 'str : class B' def __repr__(self): return 'repr : class B' b=B() print('%s'%b) print('%r'%b)
__del__
析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
__del__ class A: def __del__(self): # 析构函数: 在删除一个对象之前进行一些收尾工作 self.f.close() a = A() a.f = open() # 打开文件 第一 在操作系统中打开了一个文件 拿到了文件操作符存在了内存中 del a # a.f 拿到了文件操作符消失在了内存中 del a # del 既执行了这个方法，又删除了变量 引用计数
class Foo: def __del__(self): print('执行我了！') f1 = Foo() del f1 print('----->')
__call__
对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class A: def __init__(self,name): self.name = name def __call__(self): ''' 打印这个对象中的所有属性 :return: ''' for k in self.__dict__: print(k,self.__dict__[k]) a = A('alex')()
class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print('__call__') obj = Foo() # 执行 __init__ obj() # 执行 __call__
item系列
__getitem__\__setitem__\__delitem__
class Foo: def __init__(self,name,age,sex): self.name = name self.age = age self.sex = sex def __getitem__(self, item): #通过双下划方法可以不用通过print(f.name)来取值，用print(f['name'])类似字典的方式取值 if hasattr(self,item): return self.__dict__[item] def __setitem__(self, key, value): #设置修改属性，有就覆盖，没有就添加 self.__dict__[key] = value def __delitem__(self, key): #删除属性 del self.__dict__[key] f = Foo('egon',38,'男') print(f['name']) f['hobby'] = '男' print(f.hobby,f['hobby']) del f.hobby # object 原生支持 __delattr__ del f['hobby'] # 通过自己实现的 print(f.__dict__)
class Foo: def __init__(self,name): self.name=name def __getitem__(self, item): print(self.__dict__[item]) def __setitem__(self, key, value): self.__dict__[key]=value def __delitem__(self, key): print('del obj[key]时,我执行') self.__dict__.pop(key) def __delattr__(self, item): print('del obj.key时,我执行') self.__dict__.pop(item) f1=Foo('sb') f1['age']=18 f1['age1']=19 del f1.age1 del f1['age'] f1['name']='alex' print(f1.__dict__)
__new__
__init__ 初始化方法 __new__ 构造方法 : 创建一个对象 class A: def __init__(self): self.x = 1 print('in init function') def __new__(cls, *args, **kwargs): print('in new function') return object.__new__(A, *args, **kwargs) a1 = A() a2 = A() a3 = A() print(a1) print(a2) print(a3) print(a.x)