原文地址：http://www.cnblogs.com/tkqasn/p/6524879.html
一：类也是对象
类就是一组用来描述如何生成一个对象的代码。
类也是一个对象，只要你使用关键字class，python解释器在执行的时候就会创建一个对象。
下面这段代码：
class ObjectCreator(object):
pass
会在内存中创建一个对象，名字就是ObjectCreator，这个对象（类）自身拥有创建对象（类实例）的能力。
类的本质是一个对象，你可以拷贝它，可以将它赋给一个变量，将它作为参数传递给函数，可以为它增加属性。
以下为实例：
class ObjectCreator(object):
pass print(ObjectCreator) #打印一个类 def echo(data):
print(data) echo(ObjectCreator) #将类作为参数传递给函数 ObjectCreator.newAttribute = 'new attr' #为类添加新属性
print(hasattr(ObjectCreator,'newAttribute'))
print(ObjectCreator.newAttribute) ObjectCreatorCopy = ObjectCreator #将类复制给一个变量
print(ObjectCreatorCopy)
print(ObjectCreatorCopy()) '''
输出：
<class '__main__.ObjectCreator'>
<class '__main__.ObjectCreator'>
True
new attr
<class '__main__.ObjectCreator'>
<__main__.ObjectCreator object at 0x0000000001EA9860>
'''
二：动态的创建类
1 通过return class 动态的构建需要的类
类也是对象，所以我们再运行的时候动态的创建它们。在函数体中创建类：
def create_class(name):
if name == 'foo':
class Foo(object):
pass
return Foo
else:
class Berry(object):
pass
return Berry
my_class = create_class('foo')
print(my_class)#返回类
print(my_class())#返回类的实例 '''输出：
<class '__main__.create_class.<locals>.Foo'>
<__main__.create_class.<locals>
2 通过type函数构造类
上述方法需要你自己编写整个类的代码。由于类也是对象，所以也必须是通过什么东西来生成才对。
内置函数type可以让知道一个对象的类型是什么，like：
class Demo(object):
pass
print(type(100))
print(type('str'))
print(type(Demo))
print(type(Demo()))
'''
输出：
<class 'int'>
<class 'str'>
<class 'type'>
<class '__main__.Demo'>
'''
另外，type还可以动态的创建类。type可以接收一个类的描述作为参数，然后返回一个类。
type的语法：
type(类名，父类的元组（针对继承的情况，可以为空）， 包含属性的字典（名称和值）)
比如下面的代码：
class MyclassDemo(object):
pass
#可以手动通过type创建 MyclassDemo = type('MyclassDemo',(),{}) #返回一个类对象
print(MyclassDemo)
print(MyclassDemo())
'''
输出：
<class '__main__.MyclassDemo'>
<__main__.MyclassDemo object at 0x000000000213A3C8>
'''
下面通过一个例子看看type是如何创建类的：
#1 构建Foo类
class Foo(object):
bar = True
# 使用type构建Foo
Foo = type('Foo', (), {'bar': True})
print(Foo) # 2继承Foo类
class FooChild(Foo):
pass
# 使用type构建FooChild
FooChild = type('Foochild',(Foo,), {})
print(FooChild)
print(FooChild.bar) # 3为FooChild类增加方法
def echo_bar(self):
print(self.bar)
FooChild = type('FooChild',(Foo,),{'echo_bar': echo_bar})
print(hasattr(Foo,'echo_bar'))
print(hasattr(FooChild, 'echo_bar'))
my_foo = FooChild()
my_foo.echo_bar()
'''
输出：
<class '__main__.Foo'>
<class '__main__.Foochild'>
True
False
True
True
'''
可以看到，在python中，类也是对象，你可以动态的创建类。这就是当我们使用关键字class时python在幕后做的事，而这就是通过元类来实现的。
三：元类
1 什么是元类？
python中类也是对象，元类就是用来创建这些类（对象）的，元类是类的类，你可以这样理解：
MyClass = MetaClass() #元类创建类
MyObject = MyClass() #类创建对象 #MyClass通过type（）来创建出MyClass类，它就是type（）类的一个实例
函数type实际上是一个元类，type就是python在背后创建所有类的元类。现在想知道type为什么会全部采用小写形式而不是Type呢？好吧，我猜这是为了和str保持一致性，str是用来创建字符串对象的类，int是用来创建整数对象的类。type就是创建类对象的类。
你可以通过检查__class__属性来看到这一点。python中所有的东西 都是对象。这包括整数，字符串，函数以及类。它们全都是对象，而且是从一个类创建而来。
age = 33
print(age.__class__) name = 'alice'
print(name.__class__) def foo():
pass
print(foo.__class__) class Bar(object):
pass
b = Bar()
print(b.__class__) # 那么任何一个__class__的__class__属性又是什么呢？？
print(age.__class__.__class__)
print(foo.__class__.__class__)
print(b.__class__.__class__) '''
输出：
<class 'int'>
<class 'str'>
<class 'function'>
<class '__main__.Bar'>
<class 'type'>
<class 'type'>
<class 'type'>
'''
因此，元类就是创建类这种对象的东西，type就是python的内建元类，当然了，你也可以创建自己的元类。
2 __metaclass__属性
你可以在写一个类的时候为其添加__metaclass__属性，定义了__metaclass__就定义了这个类的元类。
class Foo(object): #py2
__metaclass__ = something class Foo(metaclass=something): #py3
__metaclass__ = something
例如：当我们在编写如下代码时：
class Foo(Bar):
pass
在该类定义的时候，它在内存中还没有生成，直到它被调用，python做了如下的操作：
1） Foo中有__metaclass__这个属性吗？如果有，python会在内存中通过__metaclass__创建一个名字为Foo的类对象。
2） 如果没有__metaclass__这个属性，它会继续在父类中寻找__metaclass__属性，并尝试做和前面同样的操作。
3）如果python在任何父类中都找不到__metaclass__，它就会在模块层次中去寻找__metaclass__，并尝试做同样的事情
4）如果还是找不到__metaclass__，python就会用内置的type来创建这个类对象。
现在的问题就是，你可以在__metaclass__中放置些什么代码呢？
答案就是：可以创建一个类的东西。那么什么可以用来创建一个类呢？type，或者任何使用到type或者子类化type的东西都可以。
三 自定义元类
元类的主要目的就是为了在创建类时能够自动的改变类。通常，你会为API做这样的事，你希望可以通过创建符合当前上下文的类。
假想一个很傻的例子，你决定在你的模块里所有类的属性都应该是大写形式。有好几种方法可以办到，但其中一种就是通过设定__metaclass__。采用这种方法，这个模块里所有类都会通过这个元类来创建，我们只需要告诉元类把所有的属性都改成大写形式就万事大吉了。
__metaclass__实际上可以被任意调用，它并不需要是一个正式的类。所以，我们这里就先以一个简单的函数作为例子开始。
1 使用函数当做元类
#元类会自动将你通常传给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)
return type(future_class_name,future_class_parents,uppercase_attr) class Foo(metaclass=upper_attr):
__metaclass__ = upper_attr
bar = 'bip' print(hasattr(Foo,'bar'))
print(hasattr(Foo,'BAR'))
print(Foo.BAR)
'''
输出：
False
True
bip
'''
2 使用class来当做元类
__metaclass__必须返回一个类
'''
请记住，type实际上是一个类，就像str和int一样，所以，你可以从type继承
__new__ 是在__init__之前被调用的特殊方法。 __new__是用来创建对象并返回之的方法，__new__（）是一个类方法
而__init__只是用来将传入的参数初始化给对象，它是在类创建之后执行的方法。
你很少用到__new__，除非你希望能够控制对象的创建。这里创建的对象是类，我们希望能够自定义它，所以我们这里改写__new__
如果你希望的话，你也可以在__init__中做些事情。还有一些高级的用法会涉及到改写__call__特殊方法。但是我们这里不用，下面我们可以单独讨论这个使用
'''
class UpperAttrMetaClass(type):
def __new__(uppersttr_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__方法。现在让我们这样去处理：
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, 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, 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)
四：使用原来创建ORM的实例
我们通过创建一个类似Django中的ORM来熟悉一下元类的使用，通常元类用来创建API是非常好得选择，使用元类编写很复杂，但是使用者可以非常简洁的调用API
class User(Model):
#定义类的属性到列的映射：
id = IntegerField('id')
name = StringField('name')
email = StringField('email')
password = StringField('password')
例如：
#创建一个实例：
u = User(id=12345, name='Alice', 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.items():
if isinstance(v,Field):
#保存类属性和列的映射关系到mappings字典
print('found mappings:%s==>%s' %(k, v))
mappings[k] = v '''# 保存类属性和列的映射关系到mappings字典
print('found mappings:%s==>%s' % (k, v))
mappings[k] = v'''
for k in mappings.keys():
#将类属性移除，使定义的类字段不污染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):
__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__.items():
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('SRGS: %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 mappings:id==><IntegerField:id>
found mappings:name==><StringField:username>
found mappings:email==><StringField:email>
found mappings:password==><StringField:password>
SQL: insert into user (id,username,email,password) values (?,?,?,?)
SRGS: [12345, 'Michael', 'test@orm.org', 'my-pwd']
'''
五：使用__new__ 方法和元类方式分别实现单例模式
1、__new__、__init__、__call__的介绍
__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
#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):
#__init__是一个实例方法，在对象创建后调用，对实例属性做初始化
print("excute __init") f1 = Foo()
'''
输出：
excute __new__
excute __init
'''
#可以看出new方法在init方法之前执行
子类如果重写__new__方法，一般依然要调用父类的__new__方法
class Child(Foo):
def __new__(cls, *args, **kwargs):
return super(Child, cls).__new__(cls, *args, **kwargs)
必须注意的是，类的__new__方法之后，必须生成本类的实例才能自动调用本类的__init__方法进行初始化，否则不会自动调用__init__.
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))
print(foo.name) '''
输出：
<class '__main__.Stranger'>
Traceback (most recent call last):
File "E:/py/awesome-python3-webapp/test/singleClass_demo.py", line 38, in <module>
print(foo.name)
AttributeError: 'Stranger' object has no attribute 'name'
'''
# 说明：如果new方法返回的不是本类的实例，那么本类（Foo）的init和
# 生成的类(Stranger)的init都不会被调用
2 实现单例模式：
依照python官方文档的说法，__new__方法主要是当你继承一些不可变的class时（比如int，str，tuple）时，提供给你一个自定义这些类的实例化过程的途径。还有就是实现自定义的metaclass。接下来我们分别通过这两种方式来实现单例模式。
简单来说，单例模式的原理就是通过在类属性中添加一个判定为ins_flag，通过这个flag判断是否已经被实例化过了，如果被实例化过了就返回该实例。
1）__new__方法实现单例实例
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）元类实现单例
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(metaclass=Singleton):
__metaclass__ = Singleton #在代码执行到这里的时候，元类中的__new__方法和__init__方法其实已经被执行了，而不是在Foo实例化的时候执行。且仅会执行一次。 foo1 = Foo()
foo2 = Foo()
print(Foo.__dict__)#'_Singleton__instance': <__main__.Foo object at 0x0000000002238B00>
#存在一个私有属性来保存属性，而不会污染Foo类（其实还是会污染，只是无法直接通过__instance属性访问）
print(foo1 is foo2) ''' 输出： __init__ __call__ __call__ {'__module__': '__main__', '__metaclass__': <class '__main__.Singleton'>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None, '_Singleton__instance': <__main__.Foo object at 0x0000000002238B00>} True '''
基于这个例子：
- 我们知道元类(Singleton)生成的实例是一个类(Foo),而这里我们仅仅需要对这个实例(Foo)增加一个属性(__instance)来判断和保存生成的单例。想想也知道为一个类添加一个属性当然是在__init__中实现了。
- 关于__call__方法的调用，因为Foo是Singleton的一个实例。所以Foo()这样的方式就调用了Singleton的__call__方法。不明白就回头看看上一节中的__call__方法介绍。
假如我们通过元类的__new__方法来也可以实现，但显然没有通过__init__来实现优雅，因为我们不会为了为实例增加一个属性而重写__new__方法。所以这个形式不推荐。
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(metaclass=Singleton):
__metaclass__ = Singleton foo1 = Foo()
foo2 = Foo()
print(Foo.__dict__)
print(foo1 is foo2) '''
输出：
__new__
__call__
__call__
{'__module__': '__main__', '__metaclass__': <class '__main__.Singleton'>, '_instance': <__main__.Foo object at 0x00000000021F8C88>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}
True
'''