一 isinstance与issubstance:
isinstance判断的是obj是否是cls的对象：
class Foo: def __init__(self,name): self.name=name def tell(self): print('self') obj=Foo('egon') print(isinstance(obj,Foo))
issubstance判断的是子类与父类的关系与否：必须是类与类之间的比较
issubstance（Foo,object）
二 反射：
什么叫反射：python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
内置方法：
下面是反射的一些操作：hasattr，getattr，setattr，delattr：
class Foo: country='China' def __init__(self,name): self.name=name def tell(self): print('tell info') obj=Foo('egon') # print(hasattr(Foo,'country')) # print(hasattr(Foo,'tell')) # print(hasattr(obj,'country')) # print(hasattr(Foo,'tell')) # print(getattr(Foo,'country'))
print(getattr(obj,'tell',None)) #从obj中取‘tell’属性，如果没有的话会报错，所以我们为了防止报错应该在后面加上‘None’
setattr(Foo,'age',19) # 为Foo设置age=19
print(Foo.__dict__) # 类对象调用__dict__方法得到的是其下所有的属性以及对应的值。
delattr(Foo,'age') # 删除Foo中的属性age
print(Foo.__dict__)
下面我们说一种getattr与hasattr连用的方式：
class Foo: # def __init__(self): # while True: # cmd=input(':').strip() # if hasattr(self,cmd): # func=getattr(self,cmd) # func() # def download(self): # print('download...') # def upload(self): # print('upload....') #
三 内置的方法：__str__ ,__del__ ,__call__，__getattr__是一些满足条件自动触发。其中__getattr__是在对象调一个不存在的属性的时候执行的。
__str__所表达的意思就是：
在print打印类的对象的时候会自动触发，__str__下的代码运行。
class People: def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def __str__(self): print('=====================================') return ''' name:%s age:%s sex:%s '''%(self.name,self.age,self.sex) obj=People('feng',18,'male') print(People)#
print(obj)#相当于打印print（obj.__dict__()）
__del__：
一般用于回收系统资源，在内存中的对象被删除之前，会触发__del__先回收系统资源。
例1： import time class People: def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def __del__(self):#在对象被删除的条件下，自动回收系统资源。 print('__del__') obj=People('eogn',18,'female') del obj time.sleep(5) 例2： class Mysql: # def __init__(self,ip,port): # self.ip=ip # self.port=port # self.conn=connect(ip,port) # 申请系统资源 # # def __del__(self): # self.conn.close() # # obj=Mysql('1.1.1.1',3306) class MyOpen: def __init__(self,filepath,mode="r",encoding="utf-8"): self.filepath=filepath self.mode=mode self.encoding=encoding self.fobj=open(filepath,mode=mode,encoding=encoding) def __str__(self): msg=""" filepath:%s mode:%s encoding:%s """ %(self.filepath,self.mode,self.encoding) return msg def __del__(self): self.fobj.close() # f=open('a.txt',mode='r',encoding='utf-8') f=MyOpen('aaa.py',mode='r',encoding='utf-8') # print(f.filepath,f.mode,f.encoding) # print(f) # print(f.fobj) res=f.fobj.read() print(res)
__call__：调用对象就会触发__call__，也就是在对象后面加括号（）。
class Foo: def __init__(self): pass def __str__(self): return '324' def __del__(self): pass def __call__(self, *args, **kwargs): print('__call__',*args,**kwargs) obj=Foo() # print(obj) obj(1,2,3,a=2)
四 元类
元类：类的类就是元类
我们一般用class来定义一个类，从而实例化出一系列对象，
内置的元类type是用来专门产生class定义的类的。那么从这里我们可以看出类就是类型。
1 补充exec：
code=''' x=1 y=2 z=3 ''' global_dic={} local_dic={} 字符串中的代码没有声明全局，那么就是局部global x---》x=12 exec (code,{全局名称空间},{局部名称空间}) exec(code,global_dic,local_dic) exec会运行code的代码将产生的全局的名字放到全局名称空间 print(global_dic) print(local_dic) code=''' x=1 y=2 def f1(self,a,b): pass ''' local_dic={} exec(code,{},local_dic) print(local_dic)##{'x': 1, 'y': 2, 'f1': <function f1 at 0x000000FEFBB12E18>} exec是用来运行字符串中的代码，产生的名字放在名称空间中，如果声明了全局名称空间，那么就放到全局里面， 否则就默认为局部名称。
创建类的两种方式：
第一种：直接用class产生
class Chinese: country='China' def __init__(self,name,age): self.name=name self.age=age def talk(self): print('%s is talking' %self.name) print(type(Chinese))#<class 'type'>我们可以看出Chinese就是类，
第二种：手动模拟class创建类的过程，通过元类type来产生
type中有三个参数：在实例化的过程type（what，bases=None，dict=None）分别代表了：类名，类的基类，类的名称空间。也就是类的三要素。
类的组成：类名，类的基类，类的名称空间，其实就是在定义阶段产生的名字放在类所在的名称空间。 类名 class_name='Chinese' 类的基类 class_bases=(object,)#这里必须要加一个逗号’，‘ 类体 class_body=""" country='China' def __init__(self,name,age): self.name=name self.age=age def talk(self): print('%s is talking' %self.name) """ class_dic={} exec(class_body,globals(),class_dic)步骤一（先处理类体->名称空间）：类体定义的名字都会存放于类的名称空间中（一个局部的名称空间）， 我们可以事先定义一个空字典，然后用exec去执行类体的代码（exec产生名称空间的过程与真正的class过程类似，只是后者会将__开头的属性变形）， 生成类的局部名称空间，即填充字典 print(class_dic)输出结果为{'country': 'China', 'talk': <function talk at 0x101a560c8>, '__init__': <function __init__ at 0x101a56668>} Foo=type(class_name,class_bases,class_dic) #实例化type得到对象Foo，即我们用class定义的类Foo，通过type得到的就是一个类， 跟我们用class来定义是一样的。 print(Foo) print(type(Foo)) print(isinstance(Foo,type)) # 得到的结果为： ''' <class '__main__.Chinese'> <class 'type'> True '''
我们还可以自定义一个元类type：
#4 、自定义元类： # class Mymeta(type): # # 来控制类Foo的创建 # def __init__(self,class_name,class_bases,class_dic): #self=Foo # # print(class_name) # # print(class_bases) # # print(class_dic) # if not class_name.istitle(): # raise TypeError('类名的首字母必须大写傻叉') # # if not class_dic.get('__doc__'): # raise TypeError('类中必须写好文档注释，大傻叉') # # super(Mymeta,self).__init__(class_name,class_bases,class_dic) # # # 控制类Foo的调用过程，即控制实例化Foo的过程 # def __call__(self, *args, **kwargs): #self=Foo,args=(1111,) kwargs={} # # print(self) # # print(args) # # print(kwargs) # # #1 造一个空对象obj # obj=object.__new__(self) # # #2、调用Foo.__init__,将obj连同调用Foo括号内的参数一同传给__init__ # self.__init__(obj,*args,**kwargs) # # return obj # # # # #Foo=Mymeta('Foo',(object,),class_dic) # class Foo(object,metaclass=Mymeta): # """ # 文档注释 # """ # x=1 # def __init__(self,y): # self.Y=y # # def f1(self): # print('from f1') # # # obj=Foo(1111) #Foo.__call__() # # # print(obj) # # print(obj.y) # # print(obj.f1) # # print(obj.x)
单例模式：也就是说当很多个实例化产生对象的结果是一样的情况下，我们可以使用单例模式，通过绑定@classmethod，让相同的对象都指向同一个地址，节省内存空间。
import settings class MySQL: __instance=None def __init__(self,ip,port): self.ip=ip self.port=port @classmethod def singleton(cls): if not cls.__instance: obj=cls(settings.IP, settings.PORT) cls.__instance=obj return cls.__instance obj1=MySQL('1.1.1.2',3306) obj2=MySQL('1.1.1.3',3307) obj3=MySQL('1.1.1.4',3308) # obj4=MySQL(settings.IP,settings.PORT) # print(obj4.ip,obj4.port) obj4=MySQL.singleton() obj5=MySQL.singleton() obj6=MySQL.singleton() print(obj4 is obj5 is obj6)
单例模式三种方法：
import setting class Mysql: __instance=None def __init__(self,host,port): self.host=host self.port=port @classmethod def singleton(cls): if not cls.__instance: cls.__instance=cls(setting.HOST,setting.PORT) return cls.__instance obj1=Mysql('1.1.1.2',3306) obj2=Mysql('1.1.1.3',3307) print(obj1 is obj2) #False obj3=Mysql.singleton() obj4=Mysql.singleton() print(obj3 is obj4) #True #方式二：定制元类实现单例模式 import setting class Mymeta(type): def __init__(self,name,bases,dic): #定义类Mysql时就触发 # 事先先从配置文件中取配置来造一个Mysql的实例出来 self.__instance = object.__new__(self) # 产生对象 self.__init__(self.__instance, setting.HOST, setting.PORT) # 初始化对象 # 上述两步可以合成下面一步 # self.__instance=super().__call__(*args,**kwargs) super().__init__(name,bases,dic) def __call__(self, *args, **kwargs): #Mysql(...)时触发 if args or kwargs: # args或kwargs内有值 obj=object.__new__(self) self.__init__(obj,*args,**kwargs) return obj return self.__instance class Mysql(metaclass=Mymeta): def __init__(self,host,port): self.host=host self.port=port obj1=Mysql() # 没有传值则默认从配置文件中读配置来实例化，所有的实例应该指向一个内存地址 obj2=Mysql() obj3=Mysql() print(obj1 is obj2 is obj3) obj4=Mysql('1.1.1.4',3307) # 方式三:定义一个装饰器实现单例模式 import setting def singleton(cls): #cls=Mysql _instance=cls(setting.HOST,setting.PORT) def wrapper(*args,**kwargs): if args or kwargs: obj=cls(*args,**kwargs) return obj return _instance return wrapper @singleton # Mysql=Singleton(Mysql) class Mysql: def __init__(self,host,port): self.host=host self.port=port obj1=Mysql() obj2=Mysql() obj3=Mysql() print(obj1 is obj2 is obj3) #True obj4=Mysql('1.1.1.3',3307) obj5=Mysql('1.1.1.4',3308) print(obj3 is obj4) #Fals