十五、元类 和__metaclass__
一：知识储备
exec
exec：三个参数
参数一：字符串形式的命令
参数二：全局作用域（字典形式），如果不指定，默认为globals()
参数三：局部作用域（字典形式），如果不指定，默认为locals()
exec的应用：
#可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中
g={
'x':1,
'y':2
}
l={}
exec('''
global x,z
x=100
z=200
m=300
''',g,l)
print(g) #{'x': 100, 'y': 2,'z':200,......}
print(l) #{'m': 300}
__call__方法：对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('__call__')
obj = Foo() # 执行 __init__
obj() # 执行 __call__
__call__的应用：
# 知识储备__call__方法
class Foo:
def __call__(self, *args, **kwargs):
print(self)
print(args)
print(kwargs)
obj = Foo()
obj(1,2,3,a=1,b=2,c=3)
# 结果：
# <__main__.Foo object at 0x000002AFE077B160>
# (1, 2, 3)
# {'a': 1, 'b': 2, 'c': 3}
__new__方法：
知识储备：
产生的新对象 = object.__new__(继承object类的子类)
obj.__new__(cls)
二：引子（类也是对象）
在理解元类之前，我们需要掌握Python中的类（class）。
在大部分语言中，类仅仅是描述如何去产生一个对象的代码片段，在Python中也一样。
#!/usr/bin/env python #coding:utf-8 class ObjectCreator(object): pass my_object = ObjectCreator() print(my_object) #<__main__.ObjectCreator object at 0x000001EED430C320>
但是类在Python不仅仅是这样，类也是对象。
当你使用关键字class时，Python执行它并创建了一个对象，如下：
class Foo:
pass
f1=Foo() #f1是通过Foo类实例化的对象
python中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例)，因而我们可以将类当作一个对象去使用，同样满足第一类对象的概念，可以：
把类赋值给一个变量
能复制类
为类增加属性
把类作为函数参数进行传递
把类作为函数的返回值
在运行时动态地创建类
上例可以看出f1是由Foo这个类产生的对象，而Foo本身也是对象，那它又是由哪个类产生的呢？
#type函数可以查看类型，也可以用来查看对象的类，二者是一样的
print(type(f1)) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类创建
print(type(Foo)) # 输出：<type 'type'>
例如：
#!/usr/bin/env python #coding:utf-8 class ObjectCreator(object): pass def echo(o): print(o) my_object = ObjectCreator() print(my_object) #<__main__.ObjectCreator object at 0x000001EED430C320>
#you can print a class because it's an object print(ObjectCreator) #<class '__main__.ObjectCreator'>
# you can pass a class as a parameter echo(ObjectCreator) # print(hasattr(ObjectCreator, 'new_attribute')) #False
ObjectCreator.new_attribute = 'foo' # you can add attributes to a class print(hasattr(ObjectCreator, 'new_attribute')) #True print(ObjectCreator.new_attribute) # foo
ObjectCreatorMirror = ObjectCreator # 你可以将类赋值给一个变量
print(ObjectCreatorMirror.new_attribute) #foo print(ObjectCreatorMirror()) #<__main__.ObjectCreator object at 0x0000026490F99390>
2.1 动态的创建类
1、通过return class动态的构建需要的类
因为类是对象，你能动态的创建他们，就像其他对象一样。
首先，你可以在函数中使用class创建一个类，如下：
#!/usr/bin/env python #coding:utf-8 def choose_class(name): if name == 'foo': class Foo(object): pass return Foo # # 返回的是类，不是类的实例else: class Bar(object): pass return Bar MyClass = choose_class('foo') # # 函数返回的是类，不是类的实例 print(MyClass) # 你可以通过这个类创建类实例，也就是对象 print(MyClass())
#python2 # <class '__main__.Foo'> # <__main__.Foo object at 0x0000000003103390> #python3 #<class '__main__.choose_class.<locals>.Foo'> #<__main__.choose_class.<locals>.Foo object at 0x0000015EE7E78C50>
2、通过type函数构造类
但是这不够动态，因为你仍然需要去完整的定义这个类。
因为类是对象，他们肯定能用其他方式生成。
当你使用class这个关键字的时候，Python自动创建了这个对象，但是正如在Python中做的大部分事情一样，Python同时提供了手动触发的方式。
还记得函数type吗？一个古老而又有用的函数，一个能够让我们知道一个对象的类型是什么，就像这样：
>>> print(type(1)) <type 'int'> >>> print(type("1")) <type 'str'> >>> print(type(ObjectCreator)) <type 'type'> >>> print(type(ObjectCreator())) <class '__main__.ObjectCreator'>
type 还有一个完全不同的功能，它也动态的创建对象，type能够接受一个类的描述作为参数，然后返回一个类。
（我知道，根据传入参数的不同，同一个函数拥有两种完全不同的用法是一件很傻的事情，但这在Python中是为了保持向后兼容性）
type的语法：
type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)
例如：
>>> class MyShinyClass(object): ... pass
能用这种方式手动创建，
>>> MyShinyClass = type('MyShinyClass', (), {}) ## 返回一个类对象 returns a class object >>> print(MyShinyClass) <class '__main__.MyShinyClass'> >>> print(MyShinyClass()) #创建一个该类的实例 create an instance with the class <__main__.MyShinyClass object at 0x8997cec>
你将注意到，我们使用”MyShinyClass“作为这个类的名称，同样作为变量的名称，并将类引用赋值给它。它们可能有点区别，但是没必要把事情搞复杂。
type接受一个字典去定义类的属性，因此：
>>> class Foo(object): ... bar = True
能这样表达：
>>> Foo = type('Foo', (), {'bar':True})
而且被用来作为一个普通的类。
>>> print(Foo) <class '__main__.Foo'> >>> print(Foo.bar) True >>> f = Foo() >>> print(f) <__main__.Foo object at 0x8a9b84c> >>> print(f.bar) True
当然，你也能继承他，因此：
>>> class FooChild(Foo): ... pass
等价于
>>> FooChild = type('FooChild', (Foo,), {}) >>> print(FooChild) <class '__main__.FooChild'> >>> print(FooChild.bar) # bar is inherited from Foo True
最终，你需要添加给这个类添加一些方法。仅需要定义好函数，并将它赋值给一个属性即可。
>>> def echo_bar(self): ... print(self.bar) ... >>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar}) >>> hasattr(Foo, 'echo_bar') False >>> hasattr(FooChild, 'echo_bar') True >>> my_foo = FooChild() >>> my_foo.echo_bar() True
而且，甚至在类动态创建之后，你也能添加更多的方法，就像给一个普通创建的类对象添加方法一样。
>>> def echo_bar_more(self): ... print('yet another method') ... >>> FooChild.echo_bar_more = echo_bar_more >>> hasattr(FooChild, 'echo_bar_more') True
如你所见：在Python中，类也是对象，而且你能动态地创建一个类。
这就是当你使用class这个关键字时Python所做的，Python使用元类来完成这项工作
接下来我们通过一个具体的例子看看type是如何创建类的，范例：
#!/usr/bin/env python #coding:utf-8 #1、构建Foo类 #构建目标代码 class Foo(object): bar = True #使用type构建 Foo = type('Foo', (), {'bar':True}) #2.继承Foo类 #构建目标代码： class FooChild(Foo): pass #使用type构建 FooChild = type('FooChild', (Foo,),{}) print FooChild #输出：<class '__main__.FooChild'> print FooChild.bar # bar属性是由Foo继承而来 #输出：True #3.为Foochild类增加方法 def echo_bar(self): print self.bar FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar}) print hasattr(Foo, 'echo_bar') #输出：False print hasattr(FooChild, 'echo_bar') #输出：True my_foo = FooChild() my_foo.echo_bar() #输出：True
可以看到，在Python中，类也是对象，你可以动态的创建类。这就是当我们使用关键字class时Python在幕后做的事情，而这就是通过元类来实现的。
三：什么是元类？
1、什么是元类
元类是类的类，是类的模板
元类是用来控制如何创建类的，正如类是创建对象的模板一样，而元类的主要目的是为了控制类的创建行为
元类的实例化的结果为我们用class定义的类，正如类的实例为对象(f1对象是Foo类的一个实例，Foo类是 type 类的一个实例)
type是python的一个内建元类，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象
例子1：在python2中
#!/usr/bin/env python
#coding:utf-8
class C(object):
pass
class CC:
pass
print type(C) #<type 'type'>
print type(CC) #<type 'classobj'>
import types
print type(CC) is types.ClassType #True
执行结果：
<type 'type'>
<type 'classobj'>
True
可以直接通过type创建类。type构造函数接受3个位置参数：name、bases与attrs。其中name参数(一个字符串）仅仅是类的名称。bases参数是该类的基类的元组。attrs参数是类中所有属性的字典。
例子2：
#!/usr/bin/env python #coding:utf-8 class Mymeta(type): def __init__(self, class_name, class_bases, class_dic): if not class_name.istitle(): raise TypeError('类名的首字母必须大写') if '__doc__' not in class_dic or not class_dic['__doc__'].strip(): raise TypeError('必须有注释，且注释不能为空') super(Mymeta, self).__init__(class_name, class_bases, class_dic) class Chinese(object, metaclass=Mymeta): ''' 有注释 ''' country = 'china' def __init__(self, name, age): self.name = name self.age = age def talk(self): print('%s is talking' % self.name) # 实例化 #chinese = Mymeta(class_name,class_bases,class_dic)
通过上文的描述，我们知道了Python中的类也是对象。元类就是用来创建这些类（对象）的，元类就是类的类，你可以这样理解为
MyClass = MetaClass() #元类创建 MyObject = MyClass() #类创建实例 #实际上MyClass就是通过type()来创创建出MyClass类，它是type()类的一个实例；同时MyClass本身也是类，也可以创建出自己的实例，这里就是MyObject
所以我们可以这样做：
MyClass = type('MyClass', (), {})
这是因为函数type实际上是一个元类。type就是Python在背后用来创建所有类的元类。现在你想知道那为什么type会全部采用小写形式而不是Type呢？好吧，我猜这是为了和str保持一致性，str是用来创建字符串对象的类，而int是用来创建整数对象的类。type就是创建类对象的类。你可以通过检查__class__属性来看到这一点。Python中所有的东西，注意，我是指所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象，而且它们都是从一个类创建而来。
age = 35 age.__class__ #输出：<type 'int'> name = 'bob' name.__class__ #输出：<type 'str'> def foo(): pass foo.__class__ #输出：<type 'function'> class Bar(object): pass b = Bar() b.__class__ #输出：<class '__main__.Bar'> 对于任何一个__class__的__class__属性又是什么呢？ a.__class__.__class__ #输出：<type 'type'> age.__class__.__class__ #输出：<type 'type'> foo.__class__.__class__ #输出：<type 'type'> b.__class__.__class__ #输出：<type 'type'>
因此，元类就是创建类这种对象的东西， type就是Python的内建元类，当然了，你也可以创建自己的元类
2、__metaclass__属性
你可以在写一个类的时候为其添加__metaclass__属性,定义了__metaclass__就定义了这个类的元类。
class Foo(object): #py2 __metaclass__ = something… class Foo(metaclass=something): #py3 __metaclass__ = something…
如果你这样做的话，Python将使用这个元类去创建类Foo
小心，这有陷阱。
你首先写了class Foo(object)，但是这个类对象Foo在内存中并没有被创建。Python将在类定义中寻找__metaclass__如果Python发现了它，Python将使用它去创建类对象Foo，如果没有，Python将使用type去创建这个类。重温几次。
例如：当我们写如下代码时 :
class Foo(Bar): pass
在该类并定义的时候，它还没有在内存中生成，知道它被调用。Python做了如下的操作：
1）Foo中有__metaclass__这个属性吗？如果是，Python会在内存中通过__metaclass__创建一个名字为Foo的类对象（我说的是类对象，请紧跟我的思路）。 2）如果Python没有找到__metaclass__，它会继续在父类中寻找__metaclass__属性，并尝试做和前面同样的操作。（对于类，不继承任何东西，基础的老式类） 3）如果Python在任何父类中都找不到__metaclass__，它就会在模块层次中去寻找__metaclass__，并尝试做同样的操作，即它将使用Bar（第一个父类）自己的元类（可能是type）去创建类对象。 4）如果还是找不到__metaclass__,Python就会用内置的type来创建这个类对象。 这里小心__metaclass__属性将不会被继承，父类的元类（Bar.__class__）会被继承。
如果Bar使用了一个用type（不是type.__new__()）创建Bar的__metaclass__属性，那么它的子类将会继承这个行为。
现在的问题就是，你可以在__metaclass__中放置些什么代码呢？
答案就是：可以创建一个类的东西。那么什么可以用来创建一个类呢？type，或者任何使用到type或者子类化type的东西都可以。
四：创建类的两种方式
方式一：使用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)
方式二：手动模拟class创建类的过程：将创建类的步骤拆开，手动去创建
#准备工作： #创建类主要分为三部分 类名 类的父类 类体 #类名 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) """
步骤一（先处理类体->名称空间）：
类体定义的名字都会存放于类的名称空间中（一个局部的名称空间），我们可以事先定义一个空字典，然后用exec去执行类体的代码（exec产生名称空间的过程与真正的class过程类似，只是后者会将__开头的属性变形），生成类的局部名称空间，即填充字典
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
我们看到，type 接收三个参数：
第 1 个参数是字符串 ‘Foo’，表示类名
第 2 个参数是元组 (object, )，表示所有的父类
第 3 个参数是字典，这里是一个空字典，表示没有定义属性和方法
补充：若Foo类有继承，即class Foo(Bar):.... 则等同于type('Foo',(Bar,),{})
五：自定义元类控制类的行为
5.1 自定义元类
元类的主要目的就是为了当创建类时能够自动地改变类。通常，你会为API做这样的事情，你希望可以创建符合当前上下文的类。假想一个很傻的例子，你决定在你的模块里所有的类的属性都应该是大写形式。有好几种方法可以办到，但其中一种就是通过在模块层设定__metaclass__。采用这种方法，这个模块中的所有类都会通过这个元类来创建，我们只需要告诉元类把所有的属性都改成大写形式就万事大吉了。
幸运的是，__metaclass__实际上可以被任意调用，它并不需要是一个正式的类（在名字中带有类，但是不必要是一个类，区分一下，但是这很有用）。
所以，我们这里就先以一个简单的函数作为例子开始。
1、使用函数当做元类
# coding=utf-8 # 适用于python2 # 元类将自动获取到相同的你经常传给`type`的参数。 # 即参数列表与`type`的一致。 def upper_attr(future_class_name, future_class_parents, future_class_attr): """ 将属性名转为大写后，返回一个类对象。 """ # 筛选出所有不以__开头的属性，转为大写。 uppercase_attr = {} for name, val in future_class_attr.items(): if not name.startswith('__'): uppercase_attr[name.upper()] = val else: uppercase_attr[name] = val # 使用type创建类 return type(future_class_name, future_class_parents, uppercase_attr) __metaclass__ = upper_attr # 这将影响这个模块内的所有类。 class Foo(): # 虽然全局的 __metaclass__ 对 “object”无效 # 但是我们可以在这里定义 __metaclass__ 而不是仅仅影响这个类。 # 这将影响“object”的children bar = 'bip' print(hasattr(Foo, 'bar')) # Out: False print(hasattr(Foo, 'BAR')) # Out: True f = Foo() print(f.BAR) # Out: 'bip'
或者：
#!/usr/bin/env python #coding:utf-8 # 元类会自动将你通常传给‘type’的参数作为自己的参数传入 def upper_attr(future_class_name, future_class_parents, future_class_attr): '''返回一个类对象，将属性都转为大写形式''' #选择所有不以'__'开头的属性 attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__')) # 将它们转为大写形式 uppercase_attr = dict((name.upper(), value) for name, value in attrs) #通过'type'来做类对象的创建 return type(future_class_name, future_class_parents, uppercase_attr)#返回一个类 class Foo(object): __metaclass__ = upper_attr bar = 'bip' print hasattr(Foo, 'bar') # 输出: False print hasattr(Foo, 'BAR') # 输出:True f = Foo() print f.BAR # 输出:'bip'
2、使用class来当做元类
由于__metaclass__必须返回一个类。
现在，我们用一个真实的类作为元类去做相同的事情。
# coding=utf-8 # 记住`type`事实上是一个类似于`str`和`int`的类 # 所以你能继承它 class UpperAttrMetaclass(type): # __new__ 方法在 __init__ 前执行，这个方法创建对象并返回。 # __init__方法仅仅初始化作为参数传入的对象。 # 你很少使用__new__方法，除非你想控制类是如何创建的。 # 这里创建的对象是一个类，我们想自定义它，因此需要覆盖 __new__。 # 你也能在__init__中做一些事情，如果愿意的话。 # 一些高级用法还包括覆盖__call__方法，这里不使用。 def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr): uppercase_attr = {} for name, val in future_class_attr.items(): if not name.startswith('__'): uppercase_attr[name.upper()] = val else: uppercase_attr[name] = val return type(future_class_name, future_class_parents, uppercase_attr)
或者：
# 请记住，'type'实际上是一个类，就像'str'和'int'一样。所以，你可以从type继承 # __new__ 是在__init__之前被调用的特殊方法，__new__是用来创建对象并返回之的方法，__new_()是一个类方法 # 而__init__只是用来将传入的参数初始化给对象，它是在对象创建之后执行的方法。 # 你很少用到__new__，除非你希望能够控制对象的创建。这里，创建的对象是类，我们希望能够自定义它，所以我们这里改写__new__ # 如果你希望的话，你也可以在__init__中做些事情。还有一些高级的用法会涉及到改写__call__特殊方法，但是我们这里不用，下面我们可以单独的讨论这个使用 class UpperAttrMetaClass(type): def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr): attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__')) uppercase_attr = dict((name.upper(), value) for name, value in attrs) return type(future_class_name, future_class_parents, uppercase_attr)#返回一个对象，但同时这个对象是一个类
但是，这种方式其实不是OOP。我们直接调用了type，而且我们没有改写父类的__new__方法。现在让我们这样去处理:
# coding=utf-8 class UpperAttrMetaclass(type): def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr): uppercase_attr = {} for name, val in future_class_attr.items(): if not name.startswith('__'): uppercase_attr[name.upper()] = val else: uppercase_attr[name] = val # 重用了type.__new__方法，这种写法是OOP的 return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr)
或者：
class UpperAttrMetaclass(type): def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr): attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__')) uppercase_attr = dict((name.upper(), value) for name, value in attrs) # 复用type.__new__方法 # 这就是基本的OOP编程，没什么魔法。由于type是元类也就是类，因此它本身也是通过__new__方法生成其实例，只不过这个实例是一个类. return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr)
你可能已经注意到了有个额外的参数upperattr_metaclass，这并没有什么特别的。类方法的第一个参数总是表示当前的实例，就像在普通的类方法中的self参数一样。当然了，为了清晰起见，这里的名字我起的比较长。但是就像self一样，所有的参数都有它们的传统名称。因此，在真实的产品代码中一个元类应该是像这样的：
class UpperAttrMetaclass(type): def __new__(cls, clsname, bases, dct): uppercase_attr = {} for name, val in dct.items(): if not name.startswith('__'): uppercase_attr[name.upper()] = val else: uppercase_attr[name] = val return type.__new__(cls, clsname, bases, uppercase_attr)
或者：
class UpperAttrMetaclass(type): def __new__(cls, name, bases, dct): attrs = ((name, value) for name, value in dct.items() if not name.startswith('__') uppercase_attr = dict((name.upper(), value) for name, value in attrs) return type.__new__(cls, name, bases, uppercase_attr)
我们使用super让代码看上去更清晰一些，
class UpperAttrMetaclass(type): def __new__(cls, clsname, bases, dct): uppercase_attr = {} for name, val in dct.items(): if not name.startswith('__'): uppercase_attr[name.upper()] = val else: uppercase_attr[name] = val return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)
或者：
class UpperAttrMetaclass(type): def __new__(cls, name, bases, dct): attrs = ((name, value) for name, value in dct.items() if not name.startswith('__')) uppercase_attr = dict((name.upper(), value) for name, value in attrs) return super(UpperAttrMetaclass, cls).__new__(cls, name, bases, uppercase_attr)
以上就是全部了，关于元类已经没有什么内容了。
使用元类的代码复杂的原因并不在于元类本身，而是因为你经常使用元类去做一些扭曲的事情，操纵继承，遍历属性（vars）例如__dict__等等。
事实上，元类在做一些黑科技时非常有用，因此往往是一些复杂的东西。但是就元类本身而言，是简单的。
拦截类的创建。
修改类。
返回修改后的类。
5.2 自定义元类控制类的行为
一个类没有声明自己的元类，默认他的元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类（顺便我们也可以瞅一瞅元类如何控制类的行为，工作流程是什么）
步骤一：如果说People=type(类名,类的父类们,类的名称空间)，那么我们定义元类如下，来控制类的创建
class Mymeta(type): # 继承默认元类的一堆属性
def __init__(self, class_name, class_bases, class_dic):
if '__doc__' not in class_dic or not class_dic.get('__doc__').strip():
raise TypeError('必须为类指定文档注释')
if not class_name.istitle():
raise TypeError('类名首字母必须大写')
super(Mymeta, self).__init__(class_name, class_bases, class_dic)
class People(object, metaclass=Mymeta):
country = 'China'
def __init__(self, name, age):
self.name = name
self.age = age
def talk(self):
print('%s is talking' % self.name)
步骤二：如果我们想控制类实例化的行为，那么需要先储备知识__call__方法的使用
class People(object,metaclass=type):
def __init__(self,name,age):
self.name=name
self.age=age
def __call__(self, *args, **kwargs):
print(self,args,kwargs)
# 调用类People，并不会出发__call__
obj=People('egon',18)
# 调用对象obj(1,2,3,a=1,b=2,c=3)，才会出发对象的绑定方法obj.__call__(1,2,3,a=1,b=2,c=3)
obj(1,2,3,a=1,b=2,c=3)
#打印：<__main__.People object at 0x10076dd30> (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}
#总结：如果说类People是元类type的实例，那么在元类type内肯定也有一个__call__，
会在调用People('egon',18)时触发执行，然后返回一个初始化好了的对象obj
步骤三：自定义元类，控制类的调用（即实例化）的过程
class Mymeta(type): #继承默认元类的一堆属性
def __init__(self,class_name,class_bases,class_dic):
if not class_name.istitle():
raise TypeError('类名首字母必须大写')
super(Mymeta,self).__init__(class_name,class_bases,class_dic)
def __call__(self, *args, **kwargs):
#self=People
print(self,args,kwargs) #<class '__main__.People'> ('egon', 18) {}
#1、实例化People，产生空对象obj
obj=object.__new__(self)
#2、调用People下的函数__init__，初始化obj
self.__init__(obj,*args,**kwargs)
#3、返回初始化好了的obj
return obj
class People(object,metaclass=Mymeta):
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}
步骤四：
class Mymeta(type): #继承默认元类的一堆属性
def __init__(self,class_name,class_bases,class_dic):
if not class_name.istitle():
raise TypeError('类名首字母必须大写')
super(Mymeta,self).__init__(class_name,class_bases,class_dic)
def __call__(self, *args, **kwargs):
#self=People
print(self,args,kwargs) #<class '__main__.People'> ('egon', 18) {}
#1、调用self，即People下的函数__new__，在该函数内完成：1、产生空对象obj 2、初始化 3、返回obj
obj=self.__new__(self,*args,**kwargs)
#2、一定记得返回obj，因为实例化People(...)取得就是__call__的返回值
return obj
class People(object,metaclass=Mymeta):
country='China'
def __init__(self,name,age):
self.name=name
self.age=age
def talk(self):
print('%s is talking' %self.name)
def __new__(cls, *args, **kwargs):
obj=object.__new__(cls)
cls.__init__(obj,*args,**kwargs)
return obj
obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}
步骤五：基于元类实现单例模式,比如数据库对象,实例化时参数都一样,就没必要重复产生对象,浪费内存
class Mysql:
__instance=None
def __init__(self,host='127.0.0.1',port='3306'):
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='3306'):
self.host=host
self.port=port
obj1=Mysql()
obj2=Mysql()
print(obj1 is obj2)
例子2：
#单例模式
class MySQL:
__instance = None #__instance = obj1
def __init__(self):
self.host = '127.0.0.1'
self.port = 3306
@classmethod
def singleton(cls):
if not cls.__instance:
obj =cls()
cls.__instance = obj
return cls.__instance
def conn(self):
pass
def execute(self):
pass
#obj1和obj2的内存地址是一样的，
# obj1 = MySQL()
# obj2 = MySQL()
# print(obj1)
# print(obj2)
# obj1 = MySQL.singleton()
# obj2 = MySQL.singleton()
# print(obj1)
# print(obj2)
# 结果：
# <__main__.MySQL object at 0x000002A1EF60CA58>
# <__main__.MySQL object at 0x000002A1EF60CA58>
#实现方式二，元类的方式
class Mymeta(type):
def __init__(self,class_name,class_bases,class_dic):
if not class_name.istitle():
raise TypeError('类名的首字母必须大写')
if '__doc__' not in class_dic or not class_dic['__doc__'].strip():
raise TypeError('必须有注释，且注释不能为空')
super(Mymeta,self).__init__(class_name,class_bases,class_dic)
self.__instance =None
def __call__(self, *args, **kwargs):
if not self.__instance:
obj = object.__new__(self)
self.__init__(obj)
self.__instance = obj
return self.__instance
class Mysql(object,metaclass=Mymeta):
'''必须有注释'''
def __init__(self):
self.host = '127.0.0.1'
self.port = 3306
def conn(self):
pass
def execute(self):
pass
obj1 =Mysql()
obj2 =Mysql()
obj3 =Mysql()
print(obj1 is obj2 is obj3)
# True
5.3 为什么使用元类时用类不要函数？
因为__metaclass__能够接受任何可调用的东西，为什么要去使用明显更为复杂的类呢？
这么做有几个原因：
目的更明确，当你阅读UpperAttrMetaclass(type)，你知道接下来会发生什么。 更OOP。元类能够继承元类，覆盖父类的方法。元类甚至能使用元类。 一个类的子类可以是它的元类的实例如果你指定了一个元类类（metaclass-class），而不是一个元类函数（metaclass-function）。 能更好地组织代码。你从来没有像上面的例子这样试验性地使用元类。元类经常用于一些复杂场景。为了代码可读性，将好几个方法组织在一个类中的能力是非常重要的。 你能覆盖__new__，__init__和__call__，这些方法将允许你做不同的事情。即时即经常只需要修改__new__，一些人觉得使用__init__更舒服。 它们被称为元类，实际就应该和它的名称一致。
5.4 为什么使用元类
现在最大的问题，为什么要使用这么晦涩的容易出错的特性？
通常不要用：
元类是深魔法，99%的用户都不需要关心它。如果你在想是否需要它们，就不要用（需要元类的人确切地知道需要它，无需解释）。
元类主要的使用场景是创建API，一个典型的例子是Django的ORM。
它允许你去这样定义：
class Person(models.Model):
name = models.CharField(max_length=30)
age = models.IntegerField()
但是如果你这样做：
guy = Person(name='bob', age='35')
print(guy.age)
它将不会返回一个IntegerFiled对象，它将返回一个int，而且甚至直接传给数据库。
这是可能的，因为models.Model定义了__metaclass__而且进行了一些特殊处理，将你刚刚简单几句话定义的Person转变为数据库字段的复杂钩子。
Django通过使用元类暴露简单的API，让一些复杂的事情看上去简单，通过这些API背后重新创建代码去做真实的事情。
我们通过创建一个类似Django中的ORM来熟悉一下元类的使用，通常元类用来创建API是非常好的选择，使用元类的编写很复杂但使用者可以非常简洁的调用API。
#我们想创建一个类似Django的ORM，只要定义字段就可以实现对数据库表和字段的操作。 class User(Model): # 定义类的属性到列的映射： id = IntegerField('id') name = StringField('username') email = StringField('email') password = StringField('password')
例如：
# 创建一个实例： u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd') # 保存到数据库： u.save()
接下来我么来实现这么个功能：
#coding:utf-8 #一、首先来定义Field类，它负责保存数据库表的字段名和字段类型： class Field(object): def __init__(self, name, column_type): self.name = name self.column_type = column_type def __str__(self): return '<%s:%s>' % (self.__class__.__name__, self.name) class StringField(Field): def __init__(self, name): super(StringField, self).__init__(name, 'varchar(100)') class IntegerField(Field): def __init__(self, name): super(IntegerField, self).__init__(name, 'bigint') #二、定义元类，控制Model对象的创建 class ModelMetaclass(type): '''定义元类''' def __new__(cls, name, bases, attrs): if name=='Model': return super(ModelMetaclass,cls).__new__(cls, name, bases, attrs) mappings = dict() for k, v in attrs.iteritems(): # 保存类属性和列的映射关系到mappings字典 if isinstance(v, Field): print('Found mapping: %s==>%s' % (k, v)) mappings[k] = v for k in mappings.iterkeys(): #将类属性移除，使定义的类字段不污染User类属性，只在实例中可以访问这些key attrs.pop(k) attrs['__table__'] = name.lower() # 假设表名和为类名的小写,创建类时添加一个__table__类属性 attrs['__mappings__'] = mappings # 保存属性和列的映射关系，创建类时添加一个__mappings__类属性 return super(ModelMetaclass,cls).__new__(cls, name, bases, attrs) #三、编写Model基类 class Model(dict): __metaclass__ = ModelMetaclass def __init__(self, **kw): super(Model, self).__init__(**kw) def __getattr__(self, key): try: return self[key] except KeyError: raise AttributeError(r"'Model' object has no attribute '%s'" % key) def __setattr__(self, key, value): self[key] = value def save(self): fields = [] params = [] args = [] for k, v in self.__mappings__.iteritems(): fields.append(v.name) params.append('?') args.append(getattr(self, k, None)) sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params)) print('SQL: %s' % sql) print('ARGS: %s' % str(args)) #最后，我们使用定义好的ORM接口，使用起来非常的简单。 class User(Model): # 定义类的属性到列的映射： id = IntegerField('id') name = StringField('username') email = StringField('email') password = StringField('password') # 创建一个实例： u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd') # 保存到数据库： u.save() #输出 # Found mapping: email==><StringField:email> # Found mapping: password==><StringField:password> # Found mapping: id==><IntegerField:id> # Found mapping: name==><StringField:username> # SQL: insert into User (password,email,username,id) values (?,?,?,?) # ARGS: ['my-pwd', 'test@orm.org', 'Michael', 12345]
5.5 最后一点
首先，你知道类是能够创建实例的对象。
事实上，类本身就是对象，元类也是。
>>> class Foo(object): pass >>> id(Foo) 142630324
Python中一切皆对象，而且他们也是类的实例或类的实例。
除了type
type确实是自己的元类，这只用Python是产生不了的，这是在实现层面做的。
第二，元类是复杂的。你可能想去使用他们去做简单的类修改。你能使用2种其他的技术去做这件事。
猴子补丁（monkey patching） 类装饰器（class decorators）
类修改99%的场景适合以上方式。
但是98%的场景，根本不需要去修改类。
5.6 Python3补充
Python3和Python2中元类使用有区别。
以下是使用元类实现追踪类定义顺序的例子。
class MyMeta(type): counter = 0 def __init__(cls, name, bases, dic): type.__init__(cls, name, bases, dic) cls._order = MyMeta.counter MyMeta.counter += 1 class MyType(object): # Python 2 __metaclass__ = MyMeta class MyType(metaclass=MyMeta): # Python 3 pass
Python3中元类有2个关键的方法。
__prepare__
__new__
__prepare__让你提供一个自定义的字典（例如OrderedDict）作为元类创建时的命名空间。无论选择什么命名空间，都必须返回一个实例。如果没有实现__prepare__，将会使用一个普通的dict。
class Meta(type): def __prepare__(metaclass, cls, bases): return dict() def __new__(metacls, cls, bases, clsdict): return super().__new__(metacls, cls, bases, clsdict)
六、 用__new__方法和元类方式分别实现单例模式
1、__new__、__init__、__call__的介绍
在讲到使用元类创建单例模式之前，比需了解__new__这个内置方法的作用，在上面讲元类的时候我们用到了__new__方法来实现类的创建。然而我在那之前还是对__new__这个方法和__init__方法有一定的疑惑。因此这里花点时间对其概念做一次了解和区分。
__new__方法负责创建一个实例对象，在对象被创建的时候调用该方法它是一个类方法。__new__方法在返回一个实例之后，会自动的调用__init__方法，对实例进行初始化。如果__new__方法不返回值，或者返回的不是实例，那么它就不会自动的去调用__init__方法。
__init__ 方法负责将该实例对象进行初始化，在对象被创建之后调用该方法，在__new__方法创建出一个实例后对实例属性进行初始化。__init__方法可以没有返回值。
__call__方法其实和类的创建过程和实例化没有多大关系了，定义了__call__方法才能被使用函数的方式执行。
例如： class A(object): def __call__(self): print "__call__ be called" a = A() a() #输出 #__call__ be called
打个比方帮助理解：如果将创建实例的过程比作建一个房子。
那么class就是一个房屋的设计图，他规定了这个房子有几个房间，每个人房间的大小朝向等。这个设计图就是累的结构
__new__就是一个房屋的框架，每个具体的房屋都需要先搭好框架后才能进行专修，当然现有了房屋设计才能有具体的房屋框架出来。这个就是从类到类实例的创建。
__init__就是装修房子的过程，对房屋的墙面和地板等颜色材质的丰富就是它该做的事情，当然先有具体的房子框架出来才能进行装饰了。这个就是实例属性的初始化，它是在__new__出一个实例后才能初始化。
__call__就是房子的电话，有了固定电话，才能被打电话嘛（就是通过括号的方式像函数一样执行）。
例如：
#!/usr/bin/env python #coding:utf-8 class Foo(object): def __new__(cls, *args, **kwargs): #__new__是一个类方法，在对象创建的时候调用 print "excute __new__" return super(Foo,cls).__new__(cls,*args,**kwargs) def __init__(self,value): #__init__是一个实例方法，在对象创建后调用，对实例属性做初始化 print "excute __init" self.value = value f1 = Foo(1) print f1.value f2 = Foo(2) print f2.value #输出===： # excute __new__ # excute __init # 1 # excute __new__ # excute __init # 2 # #====可以看出new方法在init方法之前执行
子类如果重写__new__方法，一般依然要调用父类的__new__方法。
class Child(Foo): def __new__(cls, *args, **kwargs): return suyper(Child, cls).__new__(cls, *args, **kwargs)
必须注意的是，类的__new__方法之后，必须生成本类的实例才能自动调用本类的__init__方法进行初始化，否则不会自动调用__init__.
#!/usr/bin/env python #coding:utf-8 class Foo(object): def __init__(self, *args, **kwargs): print "Foo __init__" def __new__(cls, *args, **kwargs): return object.__new__(Stranger, *args, **kwargs) class Stranger(object): def __init__(self,name): print "class Stranger's __init__ be called" self.name = name foo = Foo("test") print type(foo) #<class '__main__.Stranger'> print foo.name #AttributeError: 'Stranger' object has no attribute 'name' #说明：如果new方法返回的不是本类的实例，那么本类（Foo）的init和生成的类(Stranger)的init都不会被调用
2.实现单例模式：
依照Python官方文档的说法，__new__方法主要是当你继承一些不可变的class时(比如int, str, tuple)， 提供给你一个自定义这些类的实例化过程的途径。还有就是实现自定义的metaclass。接下来我们分别通过这两种方式来实现单例模式。当初在看到cookbook中的元类来实现单例模式的时候对其相当疑惑，因此才有了上面这些对元类的总结。
简单来说，单例模式的原理就是通过在类属性中添加一个单例判定位ins_flag，通过这个flag判断是否已经被实例化过了,如果被实例化过了就返回该实例。
1)__new__方法实现单例：
#!/usr/bin/env python #coding:utf-8 class Singleton(object): def __new__(cls, *args, **kwargs): if not hasattr(cls,"_instance"): cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs) return cls._instance s1 = Singleton() s2 = Singleton() print s1 is s2 #True
因为重写__new__方法，所以继承至Singleton的类，在不重写__new__的情况下都将是单例模式。
2）元类实现单例
当初我也很疑惑为什么我们是从写使用元类的__init__方法，而不是使用__new__方法来初为元类增加一个属性。其实我只是上面那一段关于元类中__new__方法迷惑了，它主要用于我们需要对类的结构进行改变的时候我们才要重写这个方法。
#!/usr/bin/env python #coding:utf-8 class Singleton(type): def __init__(self, *args, **kwargs): print "__init__" self.__instance = None super(Singleton,self).__init__(*args, **kwargs) def __call__(self, *args, **kwargs): print "__call__" if self.__instance is None: self.__instance = super(Singleton,self).__call__(*args, **kwargs) return self.__instance class Foo(object): __metaclass__ = Singleton #在代码执行到这里的时候，元类中的__new__方法和__init__方法其实已经被执行了，而不是在Foo实例化的时候执行。且仅会执行一次。 foo1 = Foo() foo2 = Foo() print Foo.__dict__ #_Singleton__instance': <__main__.Foo object at 0x100c52f10> 存在一个私有属性来保存属性，而不会污染Foo类（其实还是会污染，只是无法直接通过__instance属性访问） print foo1 is foo2 # True # 输出 # __init__ # __call__ # __call__ # {'__module__': '__main__', '__metaclass__': <class '__main__.Singleton'>, '_Singleton__instance': <__main__.Foo object at 0x100c52f10>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None} # True
基于这个例子：
我们知道元类(Singleton)生成的实例是一个类(Foo),而这里我们仅仅需要对这个实例(Foo)增加一个属性(__instance)来判断和保存生成的单例。想想也知道为一个类添加一个属性当然是在__init__中实现了。
关于__call__方法的调用，因为Foo是Singleton的一个实例。所以Foo()这样的方式就调用了Singleton的__call__方法。不明白就回头看看上一节中的__call__方法介绍。
假如我们通过元类的__new__方法来也可以实现，但显然没有通过__init__来实现优雅，因为我们不会为了为实例增加一个属性而重写__new__方法。所以这个形式不推荐。
#!/usr/bin/env python #coding:utf-8 class Singleton(type): def __new__(cls, name,bases,attrs): print "__new__" attrs["_instance"] = None return super(Singleton,cls).__new__(cls,name,bases,attrs) def __call__(self, *args, **kwargs): print "__call__" if self._instance is None: self._instance = super(Singleton,self).__call__(*args, **kwargs) return self._instance class Foo(object): __metaclass__ = Singleton foo1 = Foo() foo2 = Foo() print Foo.__dict__ print foo1 is foo2 # True # 输出 # __new__ # __call__ # __call__ # {'__module__': '__main__', '__metaclass__': <class '__main__.Singleton'>, '_instance': <__main__.Foo object at 0x103e07ed0>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None} # True
七、Python中的单例模式的几种实现方式及优化
单例模式
单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。
在 Python 中，我们可以用多种方法来实现单例模式
实现单例模式的几种方式
1.使用模块
其实，Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做：
mysingleton.py
class Singleton(object): def foo(self): pass singleton = Singleton()
将上面的代码保存在文件 mysingleton.py 中，要使用时，直接在其他文件中导入此文件中的对象，这个对象即是单例模式的对象
2.使用装饰器
def Singleton(cls): _instance = {} def _singleton(*args, **kargs): if cls not in _instance: _instance[cls] = cls(*args, **kargs) return _instance[cls] return _singleton @Singleton class A(object): a = 1 def __init__(self, x=0): self.x = x a1 = A(2) a2 = A(3)
3.使用类
class Singleton(object): def __init__(self): pass @classmethod def instance(cls, *args, **kwargs): if not hasattr(Singleton, "_instance"): Singleton._instance = Singleton(*args, **kwargs) return Singleton._instance
一般情况，大家以为这样就完成了单例模式，但是这样当使用多线程时会存在问题
class Singleton(object): def __init__(self): pass @classmethod def instance(cls, *args, **kwargs): if not hasattr(Singleton, "_instance"): Singleton._instance = Singleton(*args, **kwargs) return Singleton._instance import threading def task(arg): obj = Singleton.instance() print(obj) for i in range(10): t = threading.Thread(target=task,args=[i,]) t.start()
程序执行后，打印结果如下：
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
看起来也没有问题，那是因为执行速度过快，如果在init方法中有一些IO操作，就会发现问题了，下面我们通过time.sleep模拟
我们在上面__init__方法中加入以下代码：
def __init__(self):
import time
time.sleep(1)
重新执行程序后，结果如下
<__main__.Singleton object at 0x034A3410>
<__main__.Singleton object at 0x034BB990>
<__main__.Singleton object at 0x034BB910>
<__main__.Singleton object at 0x034ADED0>
<__main__.Singleton object at 0x034E6BD0>
<__main__.Singleton object at 0x034E6C10>
<__main__.Singleton object at 0x034E6B90>
<__main__.Singleton object at 0x034BBA30>
<__main__.Singleton object at 0x034F6B90>
<__main__.Singleton object at 0x034E6A90>
问题出现了！按照以上方式创建的单例，无法支持多线程
解决办法：加锁！未加锁部分并发执行,加锁部分串行执行,速度降低,但是保证了数据安全
import time
import threading
class Singleton(object):
_instance_lock = threading.Lock()
def __init__(self):
time.sleep(1)
@classmethod
def instance(cls, *args, **kwargs):
with Singleton._instance_lock:
if not hasattr(Singleton, "_instance"):
Singleton._instance = Singleton(*args, **kwargs)
return Singleton._instance
def task(arg):
obj = Singleton.instance()
print(obj)
for i in range(10):
t = threading.Thread(target=task,args=[i,])
t.start()
time.sleep(20)
obj = Singleton.instance()
print(obj)
打印结果如下：
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
这样就差不多了，但是还是有一点小问题，就是当程序执行时，执行了time.sleep(20)后，下面实例化对象时，此时已经是单例模式了，但我们还是加了锁，这样不太好，再进行一些优化，把intance方法，改成下面的这样就行：
@classmethod
def instance(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):
with Singleton._instance_lock:
if not hasattr(Singleton, "_instance"):
Singleton._instance = Singleton(*args, **kwargs)
return Singleton._instance
这样，一个可以支持多线程的单例模式就完成了
完整代码：
import time import threading class Singleton(object): _instance_lock = threading.Lock() def __init__(self): time.sleep(1) @classmethod def instance(cls, *args, **kwargs): if not hasattr(Singleton, "_instance"): with Singleton._instance_lock: if not hasattr(Singleton, "_instance"): Singleton._instance = Singleton(*args, **kwargs) return Singleton._instance def task(arg): obj = Singleton.instance() print(obj) for i in range(10): t = threading.Thread(target=task,args=[i,]) t.start() time.sleep(20) obj = Singleton.instance() print(obj)
这种方式实现的单例模式，使用时会有限制，以后实例化必须通过
obj = Singleton.instance()
如果用
obj=Singleton()
这种方式得到的不是单例
4.基于__new__方法实现（推荐使用，方便）
通过上面例子，我们可以知道，当我们实现单例时，为了保证线程安全需要在内部加入锁
我们知道，当我们实例化一个对象时，是先执行了类的__new__方法（我们没写时，默认调用object.__new__），实例化对象；然后再执行类的__init__方法，对这个对象进行初始化，所有我们可以基于这个，实现单例模式
import threading class Singleton(object): _instance_lock = threading.Lock() def __init__(self): pass def __new__(cls, *args, **kwargs): if not hasattr(Singleton, "_instance"): with Singleton._instance_lock: if not hasattr(Singleton, "_instance"): Singleton._instance = object.__new__(cls) return Singleton._instance obj1 = Singleton() obj2 = Singleton() print(obj1,obj2) def task(arg): obj = Singleton() print(obj) for i in range(10): t = threading.Thread(target=task,args=[i,]) t.start()
打印结果如下：
<__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0> <__main__.Singleton object at 0x038B33D0>
采用这种方式的单例模式，以后实例化对象时，和平时实例化对象的方法一样
obj = Singleton()
5.基于metaclass方式实现
相关知识：
""" 1.类由type创建，创建类时，type的__init__方法自动执行，类() 执行type的 __call__方法(类的__new__方法,类的__init__方法) 2.对象由类创建，创建对象时，类的__init__方法自动执行，对象()执行类的 __call__ 方法 """
例子：
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
pass
obj = Foo()
# 执行type的 __call__ 方法，调用 Foo类（是type的对象）的 __new__方法，用于创建对象，然后调用 Foo类（是type的对象）的 __init__方法，用于对对象初始化。
obj() # 执行Foo的 __call__ 方法
元类的使用
class SingletonType(type): def __init__(self,*args,**kwargs): super(SingletonType,self).__init__(*args,**kwargs) def __call__(cls, *args, **kwargs): # 这里的cls，即Foo类 print('cls',cls) obj = cls.__new__(cls,*args, **kwargs) cls.__init__(obj,*args, **kwargs) # Foo.__init__(obj) return obj class Foo(metaclass=SingletonType): # 指定创建Foo的type为SingletonType def __init__(self，name): self.name = name def __new__(cls, *args, **kwargs): return object.__new__(cls) obj = Foo('xx')
实现单例模式
import threading class SingletonType(type): _instance_lock = threading.Lock() def __call__(cls, *args, **kwargs): if not hasattr(cls, "_instance"): with SingletonType._instance_lock: if not hasattr(cls, "_instance"): cls._instance = super(SingletonType,cls).__call__(*args, **kwargs) return cls._instance class Foo(metaclass=SingletonType): def __init__(self,name): self.name = name obj1 = Foo('name') obj2 = Foo('name') print(obj1,obj2)
八：练习题
练习题一：在元类中控制把自定义类的数据属性都变成大写
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}
'''
练习题二：在元类中控制自定义的类无需__init__方法
1.元类帮其完成创建对象，以及初始化操作；
2.要求实例化时传参必须为关键字形式，否则抛出异常TypeError: must use keyword argument
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__)
在大多数编程语言中，类就是用来描述如何生成一个对象的代码块，在python中类也是一个对象，这个（类）对象自身拥有创建对象（类实例）的能力。
因为他的本质是一个对象：
可以将它赋值给一个变量
可以拷贝他
可以增加属性
可以作为参数进行传递
可以在运行时动态的创建他们
可以在函数中创建类，只需要使用class关键字即可
当使用class关键字的时候，Python解释器会自动的创建这个对象，Python还提供了手动处理的方法：type()。
type是一个生成类对象的类工厂，实际上也是一个类，专门构建对象的类称为元类：
__metaclass__属性
可以为类添加一个__metaclass__属性，通过在基类的列表中指定metaclass关键字，例如：
class Foo(object): __metaclass__=something
当解释器解析后class Foo(object)，类对象Foo并没有创建，Python会在类定义中寻找__metaclass__属性，用它创建，如果找到了，Python就会用它来创建Foo，没有就会使用type来创建。
class Foo(Bar)： pass
如果Foo没有__metaclass__属性，会继续父类Bar中递归地继续寻找__metaclass__属性，尝试之前操作。
元类：
http://www.cnblogs.com/wj-1314/p/8716575.html
https://www.cnblogs.com/tkqasn/p/6524879.html
单例模式：
https://www.cnblogs.com/huchong/p/8244279.html