python3-元類

原文出處：http://www.cnblogs.com/linhaifeng/articles/8029564.html

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}

 

引子（類也是對象）

class Foo:
      pass

f1=Foo() #f1是通過Foo類實例化的對象

python中一切皆對象，類本身也是一個對象，當使用關鍵字class的時候，python解釋器在加載class的時候就會創建一個對象(這里的對象指的是類而非類的實例)， 因而我們可以將類當做一個對象去使用。

對象的使用：

1、都可以被引用，x=obj

2、都可以當做函數的參數傳入

3、都可以當做函數的返回值

4、都可以當做容器類的元素， l = [func, obj, 1]

上例可以看出f1是由Foo這個類產生的對象，而Foo本身也是對象，那它又是由哪個類產生的呢？

print(type(f1)) # 輸出：<class '__main__.Foo'> 表示，obj 對象由Foo類創建
print(type(Foo)) # 輸出：<type 'type'>

 

什么是元類？

元類是類的類， 是類的模板

元類是用來控制如何創建類的， 正如類是創建對象的模板一樣，而元類的主要目的是為了控制類的創建行為

元類的實例化結果是我們用class定義的類，正如類的實例為對象（f1對象是Foo類的一個實例， Foo類是type類的一個實例）

type是python的一個內建元類， 用來直接控制生成類， python中任何class定義的類其實都是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創建類的過程）：將創建類的步驟拆分開，手動去創建

#准備工作：

#創建類主要分為三部分

　　1 類名

　　2 類的父類

　　3 類的__dict__


#類名
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接收三個參數：

• 第一個參數是字符串'Foo',  表示類名
• 第二個參數是元組（object,）,表示所有的父類
• 第三個參數是字典，這里是一個孔子點，表示沒有定義屬性和方法

補充：若Foo類有繼承，即class Foo(Bar):.... 則等同於type('Foo',(Bar,),{})

 

類的幾個常用方法

1.__new__方法

__new__方法接受的參數和__init__一樣，但__init__實在類對象（創建一個空對象）創建之后調用，而__new__方法正式創建這個空對象的方法。__init__方法里面的self實際都是__new__所創建的空對象，__new__返回值就是已經實例化完的對象（__init__）,屬於類級別方法

 

2.__init__方法

__init__通常用於初始化一個實例，控制這個初始化的過程，比如添加一屬性，做一些額外的操作，發生在類實例（__new__創建出來的空對象）被創建完之后。它是實例級別的方法。無返回值。

 

3.__call__方法

構造方法的執行是創建對象出發的，即：對象=類名（）；而對於__call__方法的執行是實例化的時候‘對象=類名（）’觸發的。

 

自定義元類控制（實例化）類的行為

type是所有新式類的類,所有類都可以說是type創建的
object是所有新式類的父類

# 一個類沒有定義自己的元類，默認他的元類就是type， 除了使用元類type， 用戶也可以通過繼承type來自定義元類

#步驟一：如果說People=type(類名,類的父類們,類的名稱空間)，那么我們定義元類如下，來控制類的創建

class Mymeta(type):  # 繼承默認元類的一堆屬性
    def __init__(self, class_name, class_bases, class_dic):
        # 實例化類的時候，必須給 元類傳入  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)

# People這個類在創建的時候注明了他的元類是Mymeta，也就是我們定義的元類， 所以必須滿足我們的控制條件，類名首字母必須大寫， 必須要有文檔注釋切不能為空， 否則報出錯誤信息。

 

自定義元類控制類的調用        --->    （實例化）類的實例化對象的行為

#如果我們想控制類實例化的行為，那么需要先儲備知識__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): #繼承默認元類的一堆屬性

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、產生空對象obj
        obj=object.__new__(self)


        #2、調用People下的函數__init__，初始化obj
        self.__init__(obj,*args,**kwargs)


        #3、返回初始化好了的obj
        return obj

class Chinese(object,metaclass=Mymeta):
    '''
    中文人的類
    '''
    country='China'

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

    def talk(self):
        print('%s is talking' %self.name)




obj=Chinese('egon',age=18) #Chinese.__call__(Chinese,'egon',18)

print(obj.__dict__)

 

自定義元類來實現單例模式

實現方式一

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=MySQL()
# obj2=MySQL()
# obj3=MySQL()
#
# print(obj1)
# print(obj2)
# print(obj3)

obj1=MySQL.singleton()
obj2=MySQL.singleton()
obj3=MySQL.singleton()

print(obj1 is obj3)

實現方式二：

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): #obj=Chinese('egon',age=18)
        if not self.__instance:
            obj=object.__new__(self)
            self.__init__(obj)
            self.__instance=obj

        return self.__instance



class Mysql(object,metaclass=Mymeta):
    '''
    mysql xxx
    '''
    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)

 

再看屬性查找

在學習完元類后，其實我們用class自定義的類也全都是對象（包括object類本身也是元類type的 一個實例，可以用type(object)查看），我們學習過繼承的實現原理，如果把類當成對象去看，將下述繼承應該說成是：對象OldboyTeacher繼承對象Foo，對象Foo繼承對象Bar，對象Bar繼承對象object

class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    n=444

    def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'>
        obj=self.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj

class Bar(object):
    n=333

class Foo(Bar):
    n=222

class OldboyTeacher(Foo,metaclass=Mymeta):
    n=111

    school='oldboy'

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

    def say(self):
        print('%s says welcome to the oldboy to learn Python' %self.name)


print(OldboyTeacher.n) #自下而上依次注釋各個類中的n=xxx，然后重新運行程序，發現n的查找順序為OldboyTeacher->Foo->Bar->object->Mymeta->type

於是屬性查找應該分成兩層，一層是對象層（基於c3算法的MRO）的查找，另外一個層則是類層（即元類層）的查找

#查找順序：
#1、先對象層：OldoyTeacher->Foo->Bar->object
#2、然后元類層：Mymeta->type

依據上述總結，我們來分析下元類Mymeta中__call__里的self.__new__的查找

class Mymeta(type): 
    n=444

    def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'>
        obj=self.__new__(self)
        print(self.__new__ is object.__new__) #True


class Bar(object):
    n=333

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

class Foo(Bar):
    n=222

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

class OldboyTeacher(Foo,metaclass=Mymeta):
    n=111

    school='oldboy'

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

    def say(self):
        print('%s says welcome to the oldboy to learn Python' %self.name)


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


OldboyTeacher('egon',18) #觸發OldboyTeacher的類中的__call__方法的執行，進而執行self.__new__開始查找

總結，Mymeta下的__call__里的self.__new__在OldboyTeacher、Foo、Bar里都沒有找到__new__的情況下，會去找object里的__new__，而object下默認就有一個__new__，所以即便是之前的類均未實現__new__,也一定會在object中找到一個，根本不會、也根本沒必要再去找元類Mymeta->type中查找__new__

 我們在元類的__call__中也可以用object.__new__(self)去造對象

但我們還是推薦在__call__中使用self.__new__（self）去創造空對象，因為這種方式會檢索三個類OldboyTeacher->Foo->Bar,而object.__new__則是直接跨過了他們三個