Python 元类

前提

newinitcall的介绍

在讲到使用元类创建单例模式之前,比需了解new这个内置方法的作用,在上面讲元类的时候我们用到了new方法来实现类的创建。然而我在那之前还是对new这个方法和init方法有一定的疑惑。因此这里花点时间对其概念做一次了解和区分。

new

该方法负责创建一个实例对象,在对象被创建的时候调用该方法它是一个类方法。new方法在返回一个实例之后,会自动的调用init方法,对实例进行初始化。如果new方法不返回值,或者返回的不是实例,那么它就不会自动的去调用init方法。

init

该方法负责将该实例对象进行初始化,在对象被创建之后调用该方法,在new方法创建出一个实例后对实例属性进行初始化。init方法可以没有返回值。

call

该方法其实和类的创建过程和实例化没有多大关系了,定义了call方法才能被使用函数的方式执行。

#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
excute __new__
excute __init
#====可以看出new方法在init方法之前执行

type

type(类名, 父类的元组(针对继承的情况,可以为空),包含属性的字典(名称和值))

元类的作用是产生类实例

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()            # 你可以通过这个类创建类实例,也就是对象
#输出:<__main__.Foo object at 0x1085ed950

在Python中,类也是对象,你可以动态的创建类。这就是当我们使用关键字class时Python在幕后做的事情,而这就是通过元类来实现的

元类

什么是元类

通过上文的描述,我们知道了Python中的类也是对象。元类就是用来创建这些类(对象)的,元类就是类的类,你可以这样理解为:

MyClass = MetaClass()    #元类创建
MyObject = MyClass()     #类创建实例
实际上MyClass就是通过type()来创创建出MyClass类,它是type()类的一个实例;同时MyClass本身也是类,也可以创建出自己的实例,这里就是MyObject

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)如果Python没有找到metaclass,它会继续在父类中寻找metaclass属性,并尝试做和前面同样的操作。
3)如果Python在任何父类中都找不到metaclass,它就会在模块层次中去寻找metaclass,并尝试做同样的操作。
4)如果还是找不到metaclass,Python就会用内置的type来创建这个类对象。

现在的问题就是,你可以在metaclass中放置些什么代码呢?
答案就是:可以创建一个类的东西。那么什么可以用来创建一个类呢?type,或者任何使用到type或者子类化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' 

使用class来当做元类

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

#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):
    '''定义元类, __new__必须要有返回值,返回实例化出来的实例,此处返回Model类实例'''
    def __new__(cls, name, bases, attrs):
        if name=='Model':
            # 实例化出
            # super(ModelMetaclass,cls) 等于type
            '''
            __new__()方法接收到的参数依次是:
            1、当前准备创建的类的对象;
            2、类的名字;
            3、类继承的父类集合;
            4、类的方法或者属性集合。
            '''
            cc = super(ModelMetaclass,cls).__new__(cls, name, bases, attrs)
            return cc
        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__类属性
        dd = super(ModelMetaclass,cls).__new__(cls, name, bases, attrs)
        return dd

#三、编写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='[email protected]', password='my-pwd')
# 保存到数据库:
u.save()

元类是生成类的类 所以都放在初始化new函数中,让生成类更加灵活。

元类单例模式

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

元类实现单例

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

你可能感兴趣的:(Python 元类)