元類是python面向物件程式設計裡面很難理解的一個東西,所謂元類的就是類的類,它用來建立類,在python裡面,類也是一個物件！！！.元類的作用就是動態的建立類.

在python裡面type就是元類,我們所有的class定義類的語句都會被python解釋為使用用type來建立一個類.

廢話少說,首先看一下怎麼用元類來解決一個動態建立類的需求,要求我們對於某一型別的類的滿足某個條件的屬性名字都變成大寫!比如:

class test:
 a = 1
 b = 2
 c = 3

然後test裡面的屬性是A,B,C。當然這個需求比較奇怪,我們完全可以手動的把類屬性定義為大寫,但是如果對於類的動態建立要求比較高的話,自己定義類就會很麻煩.這個以後再說.

程式碼如下:

class TestMetaclass(type):
    def __new__(cls,name,bases,attrs):
        print(attrs)
        attr_names = [ (attr_name.upper(),value) for attr_name,value in attrs.items() if not attr_name.startswith('__')]
        print(attr_names)
        return super().__new__(cls,name,bases,attrs)
class
 
 Test(dict,metaclass = TestMetaclass):
    f1 = 1
    f2 = 2
    sS = 3

這樣得到的Test就是所有不以_開頭的屬性都是大寫.而且除了Test，任何從TestMetaclass繼承的類都是有這樣的效果.

=====================我是分隔線========================

下面給出一種元類真正用的比較多的需求,構建ORM,ORM全稱“Object Relational Mapping”，即物件-關係對映，就是把關係資料庫的一行對映為一個物件，也就是一個類對應一個表，這樣，寫程式碼更簡單，不用直接操作SQL語句。

[0]首先需要構建頂層的介面.我們希望這個框架能夠給我們提供這樣的介面.

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()

這樣很方便,因為我可以隨意建立其他的user1，user2等類,只需要呼叫相應的介面就可以執行相應的sql操作.但是這裡就對orm框架有一個要求,我們的資料庫的結構是不定的,可能另外的一個user1需要10個屬性,user2需要8個屬性,而且每個屬性還不一樣,這樣你就必須讓你的類在建立的時候執行一些你規定的操作,比如將所有的屬性都收集起來,然後執行sql操作的時候在使用.簡單的說就是抽象這些屬性,讓它們在orm框架中可以動態的建立和操作,而不是依靠屬性的名字.

所以現在先構建Field類,它用來描述各個屬性的名字和屬性型別,比如id屬性的名字就叫’id’，屬性的型別就是’bigint’（我們自己定義的）.

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

現在需要來編寫orm框架的核心內容:元類的繼承體系.

class ModelMetaclass(type):
    def __new__(cls,name,bases,attrs):
        if(name == 'Model'):#如果是Model類的話,就不需要做任何修改
            return super().__new__(cls,name,bases,attrs)
        mappings = dict()#建立一個對映字典,用來儲存當前建立的類的屬性
        for k,v in attrs.items():#遍歷所有屬性
            if(isinstance(v,Field)):#注意k都是str,v才可能是Filed型別.使用者定義的用來描述表的屬性,需要修改.其他的屬性不要亂動
                print('Found mapping: %s ==> %s' % (k,v ))
                mappings[k] = v#把這個屬性新增到mappings裡面，同時刪除attrs裡面的屬性,防止例項屬性和類屬性衝突
        for k in mappings.keys():
            attrs.pop(k)
        attrs['__mappings__'] = mappings#為attrs新增mappings這個屬性,就是把所有自定義的屬性都收集到attrs[__mapppings__]
        attrs['__table__'] = name#新增表的名字,這裡偷個懶,表的名字就是類的名字
        return super().__new__(cls,name,bases,attrs)
class Model(dict,metaclass = ModelMetaclass):
    def __init__(self, **kw):
        super(Model, self).__init__(**kw)

    def __getattr__(self, key):#目的是讓dict的keyerror變成attributeerror，因為使用getattr時處理的是AttributeError
        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 = []#fields用來儲存屬性的名字
        params = []#params用來
        args = []#args用來
        for k,v in self.__mappings__.items():
            fields.append(v.name)
            params.append('?')#新增佔位符
            args.append(getattr(self,k,None))#將例項屬性的值新增到args裡面
        sql = 'inser into %s (%s) value (%s)'%(self.__table__,','.join(fields),','.join(params))
        print('SQL %s'%sql)
        print('ARGS %s'%str(args))

這樣就完成了一個orm框架的初步結構