一 、内置函数补充
1.isinstance函数：
isinstance(obj,cls)检查obj是否是类 cls 的对象
使用该函数来判断一个函数的类型
2. issubclass(sub, super)检查sub类是否是 super 类的派生类
class Foo(object):
pass
class Bar(Foo):
pass
issubclass(Bar, Foo)
二、反射
通过字符串来操作类与对象的属性，这种操作称为反射
class People:
country="China"
def __init__(self,name):
self.name=name
def tell(self):
print('%s is aaa' %self.name)
obj=People('egon')
1、hasattr #检测是否含有某属性
print(hasattr(obj,'name'))
print(hasattr(obj,'country'))
print(hasattr(obj,'tell'))
2、getattr #获取对应的属性
f=getattr(obj,'tell',None) # None为没有对应属性是的默认返回值
print(f == obj.tell)
f()
obj.tell()
3、setattr #设置属性等同修改操作
obj.age=18
setattr(obj,"age",18)
print(obj.__dict__)
4、delattr #删除属性
del obj.name
delattr(obj,"name")
print(obj.__dict__)
三、__str__方法、__del__方法 和 __call__方法
1. __str__是系统默认函数，在打印对象时自动触发函数执行
class People:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def __str__(self):
# print('========>')
return '<名字：%s 年龄：%s 性别：%s>' %(self.name,self.age,self.sex)
obj=People('egon',18,'male')
print(obj)
2. __del__也是系统默认函数在程序结束时，对象被删除的条件下，自动执行。
注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的
对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源，比如（打开
一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源3，这就用到了__del__。
实际使用示例：
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() #此时在清除对象之前自动执行归还系统资源
res=f.fobj.read()
print(res)
3.__call__ :对象后面加括号，触发执行。
构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__
方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
def __init__(self):
pass
def __str__(self):
return '123123'
def __del__(self):
pass
# 调用对象，则会自动触发对象下的绑定方法__call__的执行，
# 然后将对象本身当作第一个参数传给self，将调用对象时括号内的值
#传给*args与**kwargs
def __call__(self, *args, **kwargs):
print('__call__',args,kwargs)
obj=Foo()
obj(1,2,3,a=1,b=2,c=3)
四、元类
1. 一切皆为对象：
元类：类的类就是元类，
我们用class定义的类使用来产生我们自己的对象的
内置元类type是用来专门产生class定义的类的
2、用内置的元类type，来实例化得到我们的类
class_name='Chinese'
class_bases=(object,)
class_body="""
country="China"
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def speak(self):
print('%s speak Chinese' %self.name)
"""
class_dic={}
exec(class_body,{},class_dic)
# 类的三大要素class_name,class_bases,class_dic
3 、自定义元类： 自己可以控制类规范
class Mymeta(type):
# 来控制类Foo的创建
def __init__(self,class_name,class_bases,class_dic): #self=Foo
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={}
#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__()
5.单例模式：适用于值重复不会改变，可节省一定资源
方式一、
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
obj4=MySQL.singleton()
obj5=MySQL.singleton()
obj6=MySQL.singleton()
print(obj4 is obj5 is obj6)