python 面向对象高级应用（三）

目录：

• isinstance(obj,cls)和issubclass(sub,super)
• 反射
• __setattr__,__delattr__,__getattr__
• 二次加工标准类型(包装)
• __getattribute__
• 描述符(__get__,__set__,__delete__)
• property
• __setitem__,__getitem,__delitem__
• __str__,__repr__,__format__
• __slots__
• __next__和__iter__实现迭代器协议
• __doc__
• __module__和__class__
• __del__
• __enter__和__exit__
• __call__
• metaclass

一、isinstance(obj,cls)和issubclass(sub,super)

1、isinstance(obj,cls)检查是否obj是否是类 cls 的对象

 class Foo(object):
     pass

 obj = Foo()

 isinstance(obj, Foo)

2、issubclass(sub, super)检查sub类是否是 super 类的派生类

 class Foo(object):
     pass

 class Bar(Foo):
     pass

 issubclass(Bar, Foo)

二、反射

1、反射定义：反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

2、python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

四个可以实现自省的函数：

hasatter(object, name) : 判断object中有没有一个name字符串对应的方法或属性,检查成员

getattr(object, name, default=None): 获取成员

setattr(x, y, v):设置成员

delattr(x, y):删除成员

 class Foo(object):

     def __init__(self):
         self.name = 'abc'

     def func(self):
         return 'ok'

 obj = Foo()
 #获取成员
 ret = getattr(obj, 'func')#获取的是个对象
 r = ret()
 print(r)
 #检查成员
 ret = hasattr(obj,'func')#因为有func方法所以返回True
 print(ret)
 #设置成员
 print(obj.name) #设置之前为:abc
 ret = setattr(obj,'name',19)
 print(obj.name) #设置之后为:19
 #删除成员
 print(obj.name) #abc
 delattr(obj,'name')
 print(obj.name) #报错

a.应用实例（一）：使用格式

 class BlackMedium:
     feature='Ugly'
     def __init__(self,name,addr):
         self.name=name
         self.addr=addr

     def sell_house(self):
         print('%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼' %self.name)
     def rent_house(self):
         print('%s 黑中介租房子啦,傻逼才租呢' %self.name)

 b1=BlackMedium('万成置地','回龙观天露园')

 #检测是否含有某属性
 print(hasattr(b1,'name'))
 print(hasattr(b1,'sell_house'))

 #获取属性
 n=getattr(b1,'name')
 print(n)
 func=getattr(b1,'rent_house')
 func()

 # getattr(b1,'aaaaaaaa') #报错
 print(getattr(b1,'aaaaaaaa','不存在啊'))

 #设置属性
 setattr(b1,'sb',True)
 setattr(b1,'show_name',lambda self:self.name+'sb')
 print(b1.__dict__)
 print(b1.show_name(b1))

 #删除属性
 delattr(b1,'addr')
 delattr(b1,'show_name')
 delattr(b1,'show_name111')#不存在,则报错

 print(b1.__dict__)

b.应用实例（二）：类也是对象，即可以反射

 class Foo(object):

     staticField = "old boy"

     def __init__(self):
         self.name = 'wupeiqi'

     def func(self):
         return 'func'

     @staticmethod
     def bar():
         return 'bar'

 print getattr(Foo, 'staticField')
 print getattr(Foo, 'func')
 print getattr(Foo, 'bar')

c.应用实例（三）：反射当前模块成员

 import sys

 def s1():
     print 's1'

 def s2():
     print 's2'

 this_module = sys.modules[__name__]

 hasattr(this_module, 's1')
 getattr(this_module, 's2')

d.应用实例（四）：导入其他模块，利用反射查找该模块是否存在某个方法

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 def test():
     print('from the test')

test_module

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 """
 程序目录：
     module_test.py
     index.py

 当前文件：
     index.py
 """

 import module_test as obj

 #obj.test()

 print(hasattr(obj,'test'))

 getattr(obj,'test')()

3、反射的优点

a.实现可插拔机制.

有俩程序员，一个lili，一个是egon，lili在写程序的时候需要用到egon所写的类，但是egon去跟女朋友度蜜月去了，还没有完成他写的类，lili想到了反射，使用了反射机制lili可以继续完成自己的代码，等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。

总之反射的好处就是，可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能

 class FtpClient:
     'ftp客户端,但是还么有实现具体的功能'
     def __init__(self,addr):
         print('正在连接服务器[%s]' %addr)
         self.addr=addr

 #from module import FtpClient
 f1=FtpClient('192.168.1.1')
 if hasattr(f1,'get'):
     func_get=getattr(f1,'get')
     func_get()
 else:
     print('---->不存在此方法')
     print('处理其他的逻辑')

b.动态导入模块（基于反射当前模块成员）.

 '''
 动态导入模块
 路径
 |-import_lib
 --|-metaclass.py
 '''
 import importlib  # 导入importlib内置库

 importlib.import_module("import_lib.metaclass") #得到上述路径文件

三、__setattr__,__delattr__,__getattr__

　　类的属性操作，__dict__的重写方法。可修改

1、__setattr__,__delattr__,__getattr__(等同于setattr，delattr，getattr)，它的用法如下：

__setattr__ 添加/修改属性会触发执行

__delattr__ 删除属性的时候会触发

__getlattr__ 只有在使用点调用属性且属性不存在的时候才会触发。（新式类独有）

 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

四、二次加工标准类型(包装)

1、包装：

python为大家提供了标准数据类型，以及丰富的内置方法，其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型，新增/改写方法，这就用到了我们刚学的继承/派生知识（其他的标准类型均可以通过下面的方式进行二次加工）如：

 # List继承列表类，他继承了python解释器list列表的所有功能
 # class List(list):
 #     pass
 #
 # l=List([1,2,3])
 # print(l)
 # l.append(4)
 # print(l)

通过继承，可修改添加为：

 class List(list):
     def __init__(self,item,tag=False):
         super().__init__(item)
         self.tag=tag
     # 重写列表类的append方法，只允许添加str类型，不然报错
     def append(self, p_object):
         # print(p_object)
         if not isinstance(p_object,str):
             raise TypeError('%s must be str' %p_object)
         super(List,self).append(p_object)

     # 添加获取中间值方法，@property可当声明静态变量调用
     @property
     def mid(self):
         mid_index=len(self)//2
         return self[mid_index]

     # 必须修改tag，才能清空列表
     def clear(self):
         if not self.tag:
             raise PermissionError('not permissive')
         super().clear()
         self.tag=False

 # l=List([1,2,3])
 # l.append(4)
 # l.append('aaaaa')
 # l.append('aaaaa')
 # print(l)

 # print(l.mid)
 # l=[1,2,3,4,5,56,6,7,7]
 #
 # mid_index=len(l)//2
 # print(l[mid_index])

 # l.insert(0,123123123123123)
 # print(l)

 # l.tag=True
 # l.clear()
 # print(l)

2、授权：

授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。

实现授权的关键点就是覆盖__getattr__方法。主要针对，python标准库中，不是类属性的工具模块如：函数属性，修改。

范例为：open方法

 import time
 class Open:
     def __init__(self,filepath,mode='r',encoding='utf-8'):
         self.filepath=filepath
         self.mode=mode
         self.encoding=encoding
         self.f=open(self.filepath,mode=self.mode,encoding=self.encoding)

     #写入每行增加日期
     def write(self,msg):
         t=time.strftime('%Y-%m-%d %X')
         self.f.write('%s %s\n' %(t,msg))

     #其他除了write的方法,都反射会原来工具处理
     def __getattr__(self, item):
         # print(item,type(item))
         return getattr(self.f,item)
 obj=Open('a.txt','w+',encoding='utf-8')

范例二：open方法

 # 我们来加上b模式支持
 class FileHandle:
     def __init__(self,filename,mode='r',encoding='utf-8'):
         if 'b' in mode:
             self.file=open(filename,mode)
         else:
             self.file=open(filename,mode,encoding=encoding)
         self.filename=filename
         self.mode=mode
         self.encoding=encoding

     # 我们来加上b（二进制）模式支持
     def write(self,line):
         if 'b' in self.mode:
             if not isinstance(line,bytes):
                 raise TypeError('must be bytes')
         self.file.write(line)

     def __getattr__(self, item):
         return getattr(self.file,item)

     def __str__(self):
         if 'b' in self.mode:
             res="<_io.BufferedReader name='%s'>" %self.filename
         else:
             res="<_io.TextIOWrapper name='%s' mode='%s' encoding='%s'>" %(self.filename,self.mode,self.encoding)
         return res
 f1=FileHandle('b.txt','wb')
 # f1.write('你好啊啊啊啊啊') #自定制的write,不用在进行encode转成二进制去写了,简单,大气
 f1.write('你好啊'.encode('utf-8'))
 print(f1)
 f1.close()

练习：使用授权重写list的方法

 #练习一
 class List:
     def __init__(self,seq):
         self.seq=seq

     def append(self, p_object):
         ' 派生自己的append加上类型检查，覆盖原有的append'
         if not isinstance(p_object,int):
             raise TypeError('must be int')
         self.seq.append(p_object)

     @property
     def mid(self):
         '新增自己的方法'
         index=len(self.seq)//2
         return self.seq[index]

     def __getattr__(self, item):
         return getattr(self.seq,item)

     def __str__(self):
         return str(self.seq)

 l=List([1,2,3])
 print(l)
 l.append(4)
 print(l)
 # l.append('3333333') #报错，必须为int类型

 print(l.mid)

 #基于授权，获得insert方法
 l.insert(0,-123)
 print(l)

 #练习二
 class List:
     def __init__(self,seq,permission=False):
         self.seq=seq
         self.permission=permission
     def clear(self):
         if not self.permission:
             raise PermissionError('not allow the operation')
         self.seq.clear()

     def __getattr__(self, item):
         return getattr(self.seq,item)

     def __str__(self):
         return str(self.seq)
 l=List([1,2,3])
 # l.clear() #此时没有权限，抛出异常

 l.permission=True
 print(l)
 l.clear()
 print(l)

 #基于授权，获得insert方法
 l.insert(0,-123)
 print(l)

五、__getattribute__

__getattriute__与__getattr_意思相反，不管只要使用点调用属性不管存不存在，都会执行。且当__getattribute__与__getattr__同时存在,只会执行__getattrbute__,除非__getattribute__在执行过程中抛出异常AttributeError。

 #_*_coding:utf-8_*_
 __author__ = 'Linhaifeng'

 class Foo:
     def __init__(self,x):
         self.x=x

     def __getattr__(self, item):
         print('执行的是我')
         # return self.__dict__[item]
     def __getattribute__(self, item):
         print('不管是否存在,我都会执行')
         raise AttributeError('哈哈')

 f1=Foo(10)
 f1.x
 f1.xxxxxx

六、描述符(__get__,__set__,__delete__)

1、描述符

描述符本质就是一个新式类,在这个新式类中,至少实现了__get__(),__set__(),__delete__()中的一个,这也被称为描述符协议

__get__():调用一个属性时,触发
__set__():为一个属性赋值时,触发
__delete__():采用del删除属性时,触发

定义一个描述符

 class Foo: #在python3中Foo是新式类,它实现了三种方法,这个类就被称作一个描述符
     def __get__(self, instance, owner):
         pass
     def __set__(self, instance, value):
         pass
     def __delete__(self, instance):
         pass

2、描述符的作用

描述符的作用是用来代理另外一个类的属性的(必须把描述符定义成这个类的类属性，不能定义到构造函数中)

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Shu Yang Wang
 # Date: 2017/6/19

 #描述符Str
 class Str:
     def __get__(self, instance, owner):
         print('Str调用')
     def __set__(self, instance, value):
         print('Str设置...')
     def __delete__(self, instance):
         print('Str删除...')

 #描述符Int
 class Int:
     def __get__(self, instance, owner):
         print('Int调用')
     def __set__(self, instance, value):
         print('Int设置...')
     def __delete__(self, instance):
         print('Int删除...')

 class People:
     name=Str()
     age=Int()
     def __init__(self,name,age): #name被Str类代理,age被Int类代理,
         self.name=name
         self.age=age

 #何地？：定义成另外一个类的类属性

 #何时？：且看下列演示

 p1=People('alex',18)
 '''
 Str设置...
 Int设置...
 '''

 #描述符Str的使用
 p1.name
 p1.name='egon'
 del p1.name
 '''
 Str调用
 Str设置...
 Str删除...
 '''

 #描述符Int的使用
 p1.age
 p1.age=18
 del p1.age
 '''
 Int调用
 Int设置...
 Int删除...
 '''

 #我们来瞅瞅到底发生了什么
 print(p1.__dict__)
 print(People.__dict__)
 '''
 {}
 {'__module__': '__main__', 'name': <__main__.Str object at 0x0000009B9AB899E8>, 'age': <__main__.Int object at 0x0000009B9AB89A20>, '__init__': <function People.__init__ at 0x0000009B9AB8BBF8>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}
 '''

 #补充
 print(type(p1) == People) #type(obj)其实是查看obj是由哪个类实例化来的
 print(type(p1).__dict__ == People.__dict__)
 '''
 True
 True
 '''

3、描述符的分类：

a.数据描述符： 至少实现一个__get__() 、__set__()

 class Foo:
     def __set__(self, instance, value):
         print('set')
     def __get__(self, instance, owner):
         print('get')

b.非数据描述符

 class Foo:
     def __get__(self, instance, owner):
         print('get')

4、使用注意

a.描述符本身应该定义成新式类,被代理的类也应该是新式类

b.必须把描述符定义成这个类的类属性，不能为定义到构造函数中

c.要严格遵循该优先级,优先级由高到底分别：类属性--〉数据描述符--〉实例属性--〉非数据描述符--〉找不到的属性触发__getattr__()

1）类属性--〉数据描述符

 #描述符Str
 class Str:
     def __get__(self, instance, owner):
         print('Str调用')
     def __set__(self, instance, value):
         print('Str设置...')
     def __delete__(self, instance):
         print('Str删除...')

 class People:
     name=Str()
     def __init__(self,name,age): #name被Str类代理,age被Int类代理,
         self.name=name
         self.age=age

 #基于上面的演示,我们已经知道,在一个类中定义描述符它就是一个类属性,存在于类的属性字典中,而不是实例的属性字典

 #那既然描述符被定义成了一个类属性,直接通过类名也一定可以调用吧,没错
 People.name #恩,调用类属性name,本质就是在调用描述符Str,触发了__get__()

 People.name='egon' #那赋值呢,我去,并没有触发__set__()
 del People.name #赶紧试试del,我去,也没有触发__delete__()
 #结论:描述符对类没有作用-------->傻逼到家的结论

 '''
 结果：
 Str调用
 原因:描述符在使用时被定义成另外一个类的类属性,因而类属性比二次加工的描述符伪装而来的类属性有更高的优先级
 People.name #恩,调用类属性name,找不到就去找描述符伪装的类属性name,触发了__get__()

 People.name='egon' #那赋值呢,直接赋值了一个类属性,它拥有更高的优先级,相当于覆盖了描述符,肯定不会触发描述符的__set__()
 del People.name #同上
 '''

2）数据描述符--〉实例属性

 #描述符Str
 class Str:
     def __get__(self, instance, owner):
         print('Str调用')
     def __set__(self, instance, value):
         print('Str设置...')
     def __delete__(self, instance):
         print('Str删除...')

 class People:
     name=Str()
     def __init__(self,name,age): #name被Str类代理,age被Int类代理,
         self.name=name
         self.age=age

 p1=People('egon',18)

 #如果描述符是一个数据描述符(即有__get__又有__set__),那么p1.name的调用与赋值都是触发描述符的操作,于p1本身无关了,相当于覆盖了实例的属性
 p1.name='egonnnnnn'
 p1.name
 print(p1.__dict__)#实例的属性字典中没有name,因为name是一个数据描述符,优先级高于实例属性,查看/赋值/删除都是跟描述符有关,与实例无关了
 del p1.name
 '''
 结果：
 Str设置...
 Str设置...
 Str调用
 {'age': 18}
 Str删除...
 '''

3）实例属性--〉非数据描述符

 # class Foo:
 #     def __set__(self, instance, value):
 #         print('set')
 #     def __get__(self, instance, owner):
 #         print('get')
 # class Room:
 #     name=Foo()
 #     def __init__(self,name,width,length):
 #         self.name=name
 #         self.width=width
 #         self.length=length
 #
 #
 # #name是一个数据描述符,因为name=Foo()而Foo实现了get和set方法,因而比实例属性有更高的优先级
 # #对实例的属性操作,触发的都是描述符的
 # r1=Room('厕所',1,1)
 # r1.name
 # r1.name='厨房'
 '''
 set
 get
 set
 '''

 # class Foo:
 #     def __get__(self, instance, owner):
 #         print('get')
 # class Room:
 #     name=Foo()
 #     def __init__(self,name,width,length):
 #         self.name=name
 #         self.width=width
 #         self.length=length

 # #name是一个非数据描述符,因为name=Foo()而Foo没有实现set方法,因而比实例属性有更低的优先级
 # #对实例的属性操作,触发的都是实例自己的
 # r1=Room('厕所',1,1)
 # r1.name
 # r1.name='厨房'
 '''
 没有任何触发
 '''

4）非数据描述符--〉找不到的属性触发__getattr__()

 class Foo:
     def func(self):
         print('我胡汉三又回来了')

     def __getattr__(self, item):
         print('找不到了当然是来找我啦',item)
 f1=Foo()

 f1.xxxxxxxxxxx

5、描述符使用实例

众所周知，python是弱类型语言，即参数的赋值没有类型限制，下面我们通过描述符机制来实现类型限制功能

 # class Str:
 #     def __init__(self,name):
 #         self.name=name
 #     def __get__(self, instance, owner):
 #         print('get--->',instance,owner)
 #         return instance.__dict__[self.name]
 #
 #     def __set__(self, instance, value):
 #         print('set--->',instance,value)
 #         instance.__dict__[self.name]=value
 #
 #     def __delete__(self, instance):
 #         print('delete--->',instance)
 #         instance.__dict__.pop(self.name)
 #
 #
 # class People:
 #     name=Str('name')
 #     def __init__(self,name,age,salary):
 #         self.name=name
 #         self.age=age
 #         self.salary=salary
 #
 # p1=People('egon',18,3231.3)
 '''
 set---> <__main__.People object at 0x0000009A73999A20> egon

 '''

 #调用
 # print(p1.__dict__)
 # p1.name
 '''
 {'name': 'egon', 'age': 18, 'salary': 3231.3}
 get---> <__main__.People object at 0x0000009A73999A20> <class '__main__.People'>
 '''

 #赋值
 # print(p1.__dict__)
 # p1.name='egonlin'
 # print(p1.__dict__)
 '''
 {'name': 'egon', 'age': 18, 'salary': 3231.3}
 set---> <__main__.People object at 0x0000009A73999A20> egonlin
 {'name': 'egonlin', 'age': 18, 'salary': 3231.3}
 '''

 #删除
 # print(p1.__dict__)
 # del p1.name
 # print(p1.__dict__)

 '''
 {'name': 'egonlin', 'age': 18, 'salary': 3231.3}
 delete---> <__main__.People object at 0x0000009A73999A20>
 {'age': 18, 'salary': 3231.3}
 '''

添加限制功能：

 class Typed:
     def __init__(self,name,expected_type):
         self.name=name
         self.expected_type=expected_type
     def __get__(self, instance, owner):
         print('get--->',instance,owner)
         if instance is None:
             return self
         return instance.__dict__[self.name]

     def __set__(self, instance, value):
         print('set--->',instance,value)
         if not isinstance(value,self.expected_type):
             raise TypeError('Expected %s' %str(self.expected_type))
         instance.__dict__[self.name]=value
     def __delete__(self, instance):
         print('delete--->',instance)
         instance.__dict__.pop(self.name)

 class People:
     name=Typed('name',str)
     age=Typed('name',int)
     salary=Typed('name',float)
     def __init__(self,name,age,salary):
         self.name=name
         self.age=age
         self.salary=salary

 #p1=People(123,18,3333.3)
 #p1=People('egon','18',3333.3)
 p1=People('egon',18,3333.3)

通过类装饰器来实现，中级版：

 class Typed:
     def __init__(self,name,expected_type):
         self.name=name
         self.expected_type=expected_type
     def __get__(self, instance, owner):
         print('get--->',instance,owner)
         if instance is None:
             return self
         return instance.__dict__[self.name]

     def __set__(self, instance, value):
         print('set--->',instance,value)
         if not isinstance(value,self.expected_type):
             raise TypeError('Expected %s' %str(self.expected_type))
         instance.__dict__[self.name]=value
     def __delete__(self, instance):
         print('delete--->',instance)
         instance.__dict__.pop(self.name)

 def typeassert(**kwargs):
     def decorate(cls):
         print('类的装饰器开始运行啦------>',kwargs)
         for name,expected_type in kwargs.items():
             setattr(cls,name,Typed(name,expected_type))
         return cls
     return decorate
 @typeassert(name=str,age=int,salary=float) #有参:1.运行typeassert(...)返回结果是decorate,此时参数都传给kwargs 2.People=decorate(People)
 class People:
     def __init__(self,name,age,salary):
         self.name=name
         self.age=age
         self.salary=salary

 print(People.__dict__)
 p1=People('egon',18,3333.3)

ps.类装饰器

　　a.无参

 def decorate(cls):
     print('类的装饰器开始运行啦------>')
     return cls

 @decorate #无参:People=decorate(People)
 class People:
     def __init__(self,name,age,salary):
         self.name=name
         self.age=age
         self.salary=salary

 p1=People('egon',18,3333.3)

　　b.有参

 def typeassert(**kwargs):
     def decorate(cls):
         print('类的装饰器开始运行啦------>',kwargs)
         return cls
     return decorate
 @typeassert(name=str,age=int,salary=float) #有参:1.运行typeassert(...)返回结果是decorate,此时参数都传给kwargs 2.People=decorate(People)
 class People:
     def __init__(self,name,age,salary):
         self.name=name
         self.age=age
         self.salary=salary

 p1=People('egon',18,3333.3)

6、总结

描述符是可以实现大部分python类特性中的底层魔法,包括@classmethod,@staticmethd,@property甚至是__slots__属性描述父是很多高级库和框架的重要工具之一,描述符通常是使用到装饰器或者元类的大型框架中的一个组件.

7、利用描述符原理完成一个自定制@property,实现延迟计算（本质就是把一个函数属性利用装饰器原理做成一个描述符：类的属性字典中函数名为key，value为描述符类产生的对象）

a.@property用法回顾

 class Room:
     def __init__(self,name,width,length):
         self.name=name
         self.width=width
         self.length=length

     @property
     def area(self):
         return self.width * self.length

 r1=Room('alex',1,1)
 print(r1.area)

b.自己实现@property功能

 class Lazyproperty:
     def __init__(self,func):
         self.func=func
     def __get__(self, instance, owner):
         print('这是我们自己定制的静态属性,r1.area实际是要执行r1.area()')
         if instance is None:
             return self
         return self.func(instance) #此时你应该明白,到底是谁在为你做自动传递self的事情

 class Room:
     def __init__(self,name,width,length):
         self.name=name
         self.width=width
         self.length=length

     @Lazyproperty #area=Lazyproperty(area) 相当于定义了一个类属性,即描述符
     def area(self):
         return self.width * self.length

 r1=Room('alex',1,1)
 print(r1.area)

c.实现延迟计算

 class Lazyproperty:
     def __init__(self,func):
         self.func=func
     def __get__(self, instance, owner):
         print('这是我们自己定制的静态属性,r1.area实际是要执行r1.area()')
         if instance is None:
             return self
         else:
             print('--->')
             value=self.func(instance)
             setattr(instance,self.func.__name__,value) #计算一次就缓存到实例的属性字典中
             return value

 class Room:
     def __init__(self,name,width,length):
         self.name=name
         self.width=width
         self.length=length

     @Lazyproperty #area=Lazyproperty(area) 相当于'定义了一个类属性,即描述符'
     def area(self):
         return self.width * self.length

 r1=Room('alex',1,1)
 print(r1.area) #先从自己的属性字典找,没有再去类的中找,然后出发了area的__get__方法
 print(r1.area) #先从自己的属性字典找,找到了,是上次计算的结果,这样就不用每执行一次都去计算

d.去掉装饰类的返回值，缓存失败

 #缓存不起来了

 class Lazyproperty:
     def __init__(self,func):
         self.func=func
     def __get__(self, instance, owner):
         print('这是我们自己定制的静态属性,r1.area实际是要执行r1.area()')
         if instance is None:
             return self
         else:
             value=self.func(instance)
             instance.__dict__[self.func.__name__]=value
             return value
         # return self.func(instance) #此时你应该明白,到底是谁在为你做自动传递self的事情
     def __set__(self, instance, value):
         print('hahahahahah')

 class Room:
     def __init__(self,name,width,length):
         self.name=name
         self.width=width
         self.length=length

     @Lazyproperty #area=Lazyproperty(area) 相当于定义了一个类属性,即描述符
     def area(self):
         return self.width * self.length

 print(Room.__dict__)
 r1=Room('alex',1,1)
 print(r1.area)
 print(r1.area)
 print(r1.area)
 print(r1.area) #缓存功能失效,每次都去找描述符了,为何,因为描述符实现了set方法,它由非数据描述符变成了数据描述符,数据描述符比实例属性有更高的优先级,因而所有的属性操作都去找描述符了

8、利用描述符原理完成一个自定制@classmethod

 class ClassMethod:
     def __init__(self,func):
         self.func=func

     def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,
         def feedback():
             print('在这里可以加功能啊...')
             return self.func(owner)
         return feedback

 class People:
     name='linhaifeng'
     @ClassMethod # say_hi=ClassMethod(say_hi)
     def say_hi(cls):
         print('你好啊,帅哥 %s' %cls.name)

 People.say_hi()

 p1=People()
 p1.say_hi()
 #疑问,类方法如果有参数呢,好说,好说

 class ClassMethod:
     def __init__(self,func):
         self.func=func

     def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,
         def feedback(*args,**kwargs):
             print('在这里可以加功能啊...')
             return self.func(owner,*args,**kwargs)
         return feedback

 class People:
     name='linhaifeng'
     @ClassMethod # say_hi=ClassMethod(say_hi)
     def say_hi(cls,msg):
         print('你好啊,帅哥 %s %s' %(cls.name,msg))

 People.say_hi('你是那偷心的贼')

 p1=People()
 p1.say_hi('你是那偷心的贼')

9、利用描述符原理完成一个自定制的@staticmethod

 class StaticMethod:
     def __init__(self,func):
         self.func=func

     def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,
         def feedback(*args,**kwargs):
             print('在这里可以加功能啊...')
             return self.func(*args,**kwargs)
         return feedback

 class People:
     @StaticMethod# say_hi=StaticMethod(say_hi)
     def say_hi(x,y,z):
         print('------>',x,y,z)

 People.say_hi(1,2,3)

 p1=People()
 p1.say_hi(4,5,6)

七、property:

一个静态属性property本质就是实现了get，set，delete三种方法。

1、用法：

 class Foo:
     @property
     def AAA(self):
         print('get的时候运行我啊')

     @AAA.setter
     def AAA(self,value):
         print('set的时候运行我啊')

     @AAA.deleter
     def AAA(self):
         print('delete的时候运行我啊')

 #只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
 f1=Foo()
 f1.AAA
 f1.AAA='aaa'
 del f1.AAA

2、老式用法：

 class Foo:
     def get_AAA(self):
         print('get的时候运行我啊')

     def set_AAA(self,value):
         print('set的时候运行我啊')

     def delete_AAA(self):
         print('delete的时候运行我啊')
     AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

 f1=Foo()
 f1.AAA
 f1.AAA='aaa'
 del f1.AAA

　　3、实例：

 class Goods:

     def __init__(self):
         # 原价
         self.original_price = 100
         # 折扣
         self.discount = 0.8

     @property
     def price(self):
         # 实际价格 = 原价 * 折扣
         new_price = self.original_price * self.discount
         return new_price

     @price.setter
     def price(self, value):
         self.original_price = value

     @price.deleter
     def price(self):
         del self.original_price

 obj = Goods()
 obj.price         # 获取商品价格
 obj.price = 200   # 修改商品原价
 print(obj.price)
 del obj.price     # 删除商品原价

 #实现类型检测功能

 #第一关：
 class People:
     def __init__(self,name):
         self.name=name

     @property
     def name(self):
         return self.name

 # p1=People('alex') #property自动实现了set和get方法属于数据描述符,比实例属性优先级高,所以你这面写会触发property内置的set,抛出异常

 #第二关：修订版

 class People:
     def __init__(self,name):
         self.name=name #实例化就触发property

     @property
     def name(self):
         # return self.name #无限递归
         print('get------>')
         return self.DouNiWan

     @name.setter
     def name(self,value):
         print('set------>')
         self.DouNiWan=value

     @name.deleter
     def name(self):
         print('delete------>')
         del self.DouNiWan

 p1=People('alex') #self.name实际是存放到self.DouNiWan里
 print(p1.name)
 print(p1.name)
 print(p1.name)
 print(p1.__dict__)

 p1.name='egon'
 print(p1.__dict__)

 del p1.name
 print(p1.__dict__)

 #第三关:加上类型检查
 class People:
     def __init__(self,name):
         self.name=name #实例化就触发property

     @property
     def name(self):
         # return self.name #无限递归
         print('get------>')
         return self.DouNiWan

     @name.setter
     def name(self,value):
         print('set------>')
         if not isinstance(value,str):
             raise TypeError('必须是字符串类型')
         self.DouNiWan=value

     @name.deleter
     def name(self):
         print('delete------>')
         del self.DouNiWan

 p1=People('alex') #self.name实际是存放到self.DouNiWan里
 p1.name=1

八、__setitem__,__getitem,__delitem__

在Python中，如果我们想实现创建类似于序列和映射的类，可以通过重写魔法方法__getitem__、__setitem__、__delitem__、__len__方法去模拟。

__getitem__(self,key):返回键对应的值。

__setitem__(self,key,value)：设置给定键的值

__delitem__(self,key):删除给定键对应的元素。

__len__():返回元素的数量

 class Foo:
     def __init__(self,name):
         self.name=name
     def __getitem__(self, item):
         print("getitem")
         return self.__dict__[item]
     def __setitem__(self, key, value):
         print("setitem",key,value)
         self.__dict__[key]=value
     def __delitem__(self, key):
         print('del obj[key]时,我执行')
         self.__dict__.pop(key)
 obj=Foo('shuyang')
 obj.name='shuyang666'
 print(obj.name)
 '''
 shuyang666
 '''
 print('-----------')
 obj['name']='shuyang666'
 '''
 setitem name shuyang666
 '''
 print(obj['name'])
 '''
 getitem
 shuyang666
 '''
 # print(obj.name)
 del obj['name']
 print(obj.__dict__)
 '''
 del obj[key]时,我执行
 {}
 '''

九、__str__,__repr__,__format__

　　1、__str__, __repr__, __format__ 方法

改变对象的字符串显示__str__,__repr__

自定制格式化字符串__format__

 ormat_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'))

2、issubclass和isinstance

 class A:
     pass

 class B(A):
     pass

 print(issubclass(B,A)) #B是A的子类,返回True

 a1=A()
 print(isinstance(a1,A)) #a1是A的实例

十、__slots__

1、__slots__：

是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)。使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的)

2、__slots__的应用场景：

字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__dict__。当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个。字典,这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给实例添加新的属性了,只能使用在__slots__中定义的那些属性名。

3、注意事项:

__slots__的很多特性都依赖于普通的基于字典的实现。另外,定义了__slots__后的类不再 支持一些普通类特性了,比如多继承。大多数情况下,你应该只在那些经常被使用到 的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象 。关于__slots__的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用__slots__可以达到这样的目的,但是这个并不是它的初衷。更多的是用来作为一个内存优化工具。

4、写法示例：

 class Foo:
     __slots__='x'

 f1=Foo()
 f1.x=1
 f1.y=2#报错
 print(f1.__slots__) #f1不再有__dict__

 class Bar:
     __slots__=['x','y']

 n=Bar()
 n.x,n.y=1,2
 n.z=3#报错

5、具体详解：

http://blog.csdn.net/sxingming/article/details/52892640

十一、__next__和__iter__实现迭代器协议

在__iter__函数中将使__next__中的StopIteration raise的条件归零，则可以循环迭代实例。

1、自增：

 class Foo:
     def __init__(self,start,stop):
         self.num=start
         self.stop=stop
     def __iter__(self):
         return self
     def __next__(self):
         if self.num >= self.stop:
             raise StopIteration   # for 不报错
         n=self.num
         self.num+=1
         return n

 f=Foo(1,5)
 from collections import Iterable,Iterator
 print(isinstance(f,Iterator)) #是否是一个迭代器

 for i in Foo(1,5):
     print(i) 

2、range步长：

 class Range:
     def __init__(self,n,stop,step):
         self.n=n
         self.stop=stop
         self.step=step

     def __next__(self):
         if self.n >= self.stop:
             raise StopIteration
         x=self.n
         self.n+=self.step
         return x

     def __iter__(self):
         return self

 for i in Range(1,7,3): #
     print(i)

3、斐波那契数列：

 class Fib:
     def __init__(self):
         self._a=0
         self._b=1

     def __iter__(self):
         return self

     def __next__(self):
         self._a,self._b=self._b,self._a + self._b
         return self._a

 f1=Fib()

 print(f1.__next__())
 print(next(f1))
 print(next(f1))

 for i in f1:
     if i > 100:
         break
     print('%s ' %i,end='')

 斐波那契数列

十二、__doc__

1、显示‘ ’ ‘’‘ ’‘’注释信息

 class Foo:
     '我是描述信息'
     pass

 print(Foo.__doc__)

2、该属性无法被继承

 class Foo:
     '我是描述信息'
     pass

 class Bar(Foo):
     pass
 print(Bar.__doc__) #该属性无法继承给子类

十三、__module__和__class__

__module__ 表示当前操作的对象在那个模块

__class__     表示当前操作的对象的类是什么

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 class C:

     def __init__(self):
         self.name = ‘SB'

 from lib.aa import C

 obj = C()
 print obj.__module__  # 输出 lib.aa，即：输出模块
 print obj.__class__      # 输出 lib.aa.C，即：输出类

十四、__del__

　　析构方法：当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

 class Foo:

     def __del__(self):
         print('执行我啦')

 f1=Foo()
 del f1
 print('------->')

 #输出结果
 执行我啦
 ------->

十五、__enter__和__exit__

1、上下文管理协议__enter__、 __exit__(with open('a.txt') as f:)

即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法

 # class Foo:
 #     def __init__(self, name):
 #         self.name = name
 #     def __enter__(self):
 #         print('__enter__')
 #         return self
 #
 #     def __exit__(self, exc_type, exc_val, exc_tb):
 #         print('__exit__')
 #
 #
 # with Foo() as x: #x=Foo()
 #     print(x)
 #     print('=>')
 #     print('=>')
 #     print('=>')
 #     print('=>')

2、模拟with...open

 class Open:
     def __init__(self,filepath,mode='r',encoding='utf-8'):
         self.filepath=filepath
         self.mode=mode
         self.encoding=encoding

     def __enter__(self):
         # print('enter')
         self.f=open(self.filepath,mode=self.mode,encoding=self.encoding)
         return self.f

     def __exit__(self, exc_type, exc_val, exc_tb):
         # print('exit')
         self.f.close()
         return True
     def __getattr__(self, item):
         return getattr(self.f,item)

 with Open('a.txt','w') as f:
     print(f)
     f.write('aaaaaa')
     f.wasdf #抛出异常，交给__exit__处理

ps.__exit__()中的三个参数分别代表异常类型，异常值和追溯信息,with语句中代码块出现异常，则with后的代码都无法执行

如果__exit()返回值为True,那么异常会被清空，就好像啥都没发生一样，with后的语句正常执行。

3、用途：

a.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预

b.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，你无须再去关系这个问题，这将大有用处

十六、__call__

1、__call__:

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

 class Foo:

     def __init__(self):
         pass

     def __call__(self, *args, **kwargs):

         print('__call__')

 obj = Foo() # 执行 __init__
 obj()       # 执行 __call__

十七、metaclass(元类)

1、exec(srt, global,local)的内置方法：

参数一：字符串形式的命令

参数二：全局作用域

参数三：局部作用域

exec会在指定的局部作用域内执行字符串内的代码，除非明确地使用global关键字。

 g={
     'x':1,
     'y':2,
     'teachers':{'egon','alex','yuanhao','wupeiqi'}
 }
 l={'birds':[1,2,3]}

 # exec("""
 # def func():
 #     global x
 #     x='egon'
 # func()
 # """,g,l)
 # print(g)
 # print(l)

 exec("""
 global x
 x='egon'
 """,g,l)
 print(g)
 print(l)

2、类也是对象

python中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例)，因而我们可以将类当作一个对象去使用，同样满足第一类对象的概念，可以：

• • 把类赋值给一个变量
  • 把类作为函数参数进行传递
  • 把类作为函数的返回值
  • 在运行时动态地创建类

 # class Foo:
 #     pass

 # obj=Foo()
 # print(type(obj))
 #
 # print(type(Foo))
 # def func():
 #     class Foo:
 #         pass
 #
 #     print(Foo)
 #
 # func()

3、元类：

元类是类的类，是类的模板。元类是用来控制如何创建类的，正如类是创建对象的模板一样，而元类的主要目的是为了控制类的创建行为。元类的实例化的结果为我们用class定义的类，正如类的实例为对象(f1对象是Foo类的一个实例，Foo类是 type 类的一个实例)type是python的一个内建元类，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象。

4、创建类的两种方式

a.使用class关键字：

 # class Chinese(object):
 #     country='China'
 #     def __init__(self,name,age):
 #         self.name=name
 #         self.age=age
 #     def talk(self):
 #         print('%s is talking' %self.name)
 # print(Chinese)
 # print(Chinese.__dict__)
 # print(Chinese.__bases__)

b.手动使用tpye创建类。

准备工作：

创建类主要分为三部分
　　1 类名
　　2 类的父类
　　3 类体

 #类名
 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)
 print(class_dic)
 #{'country': 'China', 'talk': <function talk at 0x101a560c8>, '__init__': <function __init__ at 0x101a56668>}

第二步：调用元类type（也可以自定义）来产生类Chinense

 Foo=type(class_name,class_bases,class_dic) #实例化type得到对象Foo，即我们用class定义的类Foo

 print(Foo)
 print(type(Foo))
 print(isinstance(Foo,type))
 '''
 <class '__main__.Chinese'>
 <class 'type'>
 True
 '''

ps.这样我们就手动生成了一个可调用的类对象。

type 接收三个参数：

第 1 个参数是字符串 ‘Foo’，表示类名
第 2 个参数是元组 (object, )，表示所有的父类
第 3 个参数是字典，这里是一个空字典，表示没有定义属性和方法

补充：若Foo类有继承，即class Foo(Bar):.... 则等同于type('Foo',(Bar,),{})

5、一个类没有声明自己的元类，默认他的元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类（顺便我们也可以瞅一瞅元类如何控制类的创建，工作流程是什么）

所以类实例化的流程都一样,与三个方法有关:(大前提,任何名字后加括号,都是在调用一个功能,触发一个函数的执行,得到一个返回值)

a.obj=Foo(),会调用产生Foo的类内的__call__方法,Foo()的结果即__call__的结果
b.调用__call__方法的过程中，先调用Foo.__new__,得到obj，即实例化的对象，但是还没有初始化
c.调用__call__方法的过程中，如果Foo.__new__()返回了obj，再调用Foo.__init__,将obj传入,进行初始化（否则不调用Foo.__init__）

ps:

__new__更像是其他语言中的构造函数,必须有返回值,返回值就实例化的对象
__init__只是初始化函数,必须没有返回值,仅仅只是初始化功能,并不能new创建对象

a.在我们自定义的元类内，__new__方法在产生obj时用type.__new__(cls,*args,**kwargs),用object.__new__(cls)抛出异常：TypeError: object.__new__(Mymeta) is not safe, use type.__new__()
b.在我们自定义的类内，__new__方法在产生obj时用object.__new__(self)

6、元类控制创建类：

 class Mymeta(type):
     def __init__(self):
         print('__init__')

     def __new__(cls, *args, **kwargs):
         print('__new__')

     def __call__(self, *args, **kwargs):
         print('__call__')

 class Foo(metaclass=Mymeta):
     pass

 print(Foo)
 '''
 打印结果:
 __new__
 None
 '''

 '''
 分析Foo的产生过程,即Foo=Mymeta()，会触发产生Mymeta的类内的__call__，即元类的__call__:
     Mymeta加括号,会触发父类的__call__,即type.__call__
     在type.__call__里会调用Foo.__new__
     而Foo.__new__内只是打印操作,没有返回值,因而Mymeta的结果为None,即Foo=None
 '''

 class Mymeta(type):
     def __init__(self,name,bases,dic):
         for key,value in dic.items():
             if key.startswith('__'):
                 continue
             if not callable(value):
                 continue
             if not value.__doc__:
                 raise TypeError('%s 必须有文档注释' %key)
         type.__init__(self,name,bases,dic)

     def __new__(cls, *args, **kwargs):
         # print('__new__')
         obj=type.__new__(cls,*args,**kwargs)
         return obj

     def __call__(self, *args, **kwargs):
         # print('__call__')
         pass

 # Foo=Mymeta()
 class Foo(metaclass=Mymeta):
     def f1(self):
         'from f1'
         pass

     def f2(self):
         pass

 '''
 抛出异常
 TypeError: f2 必须有文档注释
 '''

7、元类控制类创建对象

 class Mymeta(type):
     def __call__(self, *args, **kwargs):
         #self=<class '__main__.Foo'>
         #args=('egon',)
         #kwargs={'age':18}
         obj=self.__new__(self) #创建对象:Foo.__new__(Foo)
         self.__init__(obj,*args,**kwargs) #初始化对象:Foo.__init__(obj,'egon',age=18)
         return obj #一定不要忘记return
 class Foo(metaclass=Mymeta):
     def __init__(self,name,age):
         self.name=name
         self.age=age

     def __new__(cls, *args, **kwargs):
         return object.__new__(cls,*args,**kwargs)

 obj=Foo('egon',age=18) #触发Mymeta.__call__

 print(obj.__dict__)

ps.单例模式：比如数据库对象,实例化时参数都一样,就没必要重复产生对象,浪费内存

 #单例模式,比如数据库对象,实例化时参数都一样,就没必要重复产生对象,浪费内存
 class Mysql:
     __instance=None
     def __init__(self,host='127.0.0.1',port=''):
         self.host=host
         self.port=port

     @classmethod
     def singleton(cls,*args,**kwargs):
         if not cls.__instance:
             cls.__instance=cls(*args,**kwargs)
         return cls.__instance

 obj1=Mysql()
 obj2=Mysql()
 print(obj1 is obj2) #False

 obj3=Mysql.singleton()
 obj4=Mysql.singleton()
 print(obj3 is obj4) #True

 #单例模式,比如数据库对象,实例化时参数都一样,就没必要重复产生对象,浪费内存
 class Mymeta(type):
     def __init__(self,name,bases,dic): #定义类Mysql时就触发
         self.__instance=None
         super().__init__(name,bases,dic)

     def __call__(self, *args, **kwargs): #Mysql(...)时触发

         if not self.__instance:
             self.__instance=object.__new__(self) #产生对象
             self.__init__(self.__instance,*args,**kwargs) #初始化对象
             #上述两步可以合成下面一步
             # self.__instance=super().__call__(*args,**kwargs)

         return self.__instance
 class Mysql(metaclass=Mymeta):
     def __init__(self,host='127.0.0.1',port=''):
         self.host=host
         self.port=port

 obj1=Mysql()
 obj2=Mysql()

 print(obj1 is obj2)

8、自制元类：

 class Mytype(type):
     def __init__(self,class_name,bases=None,dict=None):
         print("Mytype init--->")
         print(class_name,type(class_name))
         print(bases)
         print(dict)

     def __call__(self, *args, **kwargs):
         print('Mytype call---->',self,args,kwargs)
         obj=self.__new__(self)
         self.__init__(obj,*args,**kwargs)
         return obj

 class Foo(object,metaclass=Mytype):#in python3
     #__metaclass__ = MyType #in python2
     x=1111111111
     def __init__(self,name):
         self.name=name

     def __new__(cls, *args, **kwargs):
         return super().__new__(cls)
         # return object.__new__(cls) #同上

 f1=Foo('name')
 print(f1.__dict__)

 #纯净版
 class Mytype(type):
     def __init__(self,what,bases=None,dict=None):
         print('mytype init')

     def __call__(self, *args, **kwargs):
         obj=self.__new__(self)
         self.__init__(obj,*args,**kwargs)
         return obj

 class Foo(object,metaclass=Mytype):
     x=1111111111

     def __init__(self,name):
         self.name=name

     def __new__(cls, *args, **kwargs):
         return super().__new__(cls)

 f1=Foo('egon')

 print(f1.__dict__)

 #精简版
 class Mytype(type):
     def __init__(self,what,bases=None,dict=None):
         print(what,bases,dict)

     def __call__(self, *args, **kwargs):
         print('--->')
         obj=object.__new__(self)
         self.__init__(obj,*args,**kwargs)
         return obj
 class Room(metaclass=Mytype):
     def __init__(self,name):
         self.name=name

 r1=Room('alex')
 print(r1.__dict__)

9、元类总结：

 #元类总结
 class Mymeta(type):
     def __init__(self,name,bases,dic):
         print('===>Mymeta.__init__')

     def __new__(cls, *args, **kwargs):
         print('===>Mymeta.__new__')
         return type.__new__(cls,*args,**kwargs)

     def __call__(self, *args, **kwargs):
         print('aaa')
         obj=self.__new__(self)
         self.__init__(self,*args,**kwargs)
         return obj

 class Foo(object,metaclass=Mymeta):
     def __init__(self,name):
         self.name=name
     def __new__(cls, *args, **kwargs):
         return object.__new__(cls)

 '''
 需要记住一点:名字加括号的本质(即,任何name()的形式),都是先找到name的爹,然后执行:爹.__call__

 而爹.__call__一般做两件事:
 1.调用name.__new__方法并返回一个对象
 2.进而调用name.__init__方法对儿子name进行初始化
 '''

 '''
 class 定义Foo,并指定元类为Mymeta,这就相当于要用Mymeta创建一个新的对象Foo,于是相当于执行
 Foo=Mymeta('foo',(...),{...})
 因此我们可以看到,只定义class就会有如下执行效果
 ===>Mymeta.__new__
 ===>Mymeta.__init__
 实际上class Foo(metaclass=Mymeta)是触发了Foo=Mymeta('Foo',(...),{...})操作,
 遇到了名字加括号的形式,即Mymeta(...),于是就去找Mymeta的爹type,然后执行type.__call__(...)方法
 于是触发Mymeta.__new__方法得到一个具体的对象,然后触发Mymeta.__init__方法对对象进行初始化
 '''

 '''
 obj=Foo('egon')
 的原理同上
 '''

 '''
 总结:元类的难点在于执行顺序很绕,其实我们只需要记住两点就可以了
 1.谁后面跟括号,就从谁的爹中找__call__方法执行
 type->Mymeta->Foo->obj
 Mymeta()触发type.__call__
 Foo()触发Mymeta.__call__
 obj()触发Foo.__call__
 2.__call__内按先后顺序依次调用儿子的__new__和__init__方法
 '''

10、元类示例：

a.在元类中控制把自定义类的数据属性都变成大写

 class Mymetaclass(type):
     def __new__(cls,name,bases,attrs):
         update_attrs={}
         for k,v in attrs.items():
             if not callable(v) and not k.startswith('__'):
                 update_attrs[k.upper()]=v
             else:
                 update_attrs[k]=v
         return type.__new__(cls,name,bases,update_attrs)

 class Chinese(metaclass=Mymetaclass):
     country='China'
     tag='Legend of the Dragon' #龙的传人
     def walk(self):
         print('%s is walking' %self.name)

 print(Chinese.__dict__)
 '''
 {'__module__': '__main__',
  'COUNTRY': 'China',
  'TAG': 'Legend of the Dragon',
  'walk': <function Chinese.walk at 0x0000000001E7B950>,
  '__dict__': <attribute '__dict__' of 'Chinese' objects>,
  '__weakref__': <attribute '__weakref__' of 'Chinese' objects>,
  '__doc__': None}
 '''

b.在元类中控制自定义的类无需__init__方法

1.元类帮其完成创建对象，以及初始化操作；
2.要求实例化时传参必须为关键字形式，否则抛出异常TypeError: must use keyword argument for key function；
3.key作为用户自定义类产生对象的属性，且所有属性变成大写

 class Mymetaclass(type):
     # def __new__(cls,name,bases,attrs):
     #     update_attrs={}
     #     for k,v in attrs.items():
     #         if not callable(v) and not k.startswith('__'):
     #             update_attrs[k.upper()]=v
     #         else:
     #             update_attrs[k]=v
     #     return type.__new__(cls,name,bases,update_attrs)

     def __call__(self, *args, **kwargs):
         if args:
             raise TypeError('must use keyword argument for key function')
         obj = object.__new__(self) #创建对象，self为类Foo

         for k,v in kwargs.items():
             obj.__dict__[k.upper()]=v
         return obj

 class Chinese(metaclass=Mymetaclass):
     country='China'
     tag='Legend of the Dragon' #龙的传人
     def walk(self):
         print('%s is walking' %self.name)

 p=Chinese(name='egon',age=18,sex='male')
 print(p.__dict__)