元類metaclass

時間 2019-11-19

標籤 metaclass 简体版

原文原文鏈接

閱讀目錄python

一知識儲備

exec：三個參數

參數一：字符串形式的命令

參數二：全局做用域（字典形式），若是不指定，默認爲globals()

參數三：局部做用域（字典形式），若是不指定，默認爲locals()

#能夠把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}

exec的使用

二引子（類也是對象）

class Foo:
    pass

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

python中一切皆是對象，類自己也是一個對象，當使用關鍵字class的時候，python解釋器在加載class的時候就會建立一個對象(這裏的對象指的是類而非類的實例)，於是咱們能夠將類看成一個對象去使用，一樣知足第一類對象的概念，能夠：算法

把類賦值給一個變量sql
把類做爲函數參數進行傳遞app
把類做爲函數的返回值ide
在運行時動態地建立類函數

上例能夠看出f1是由Foo這個類產生的對象，而Foo自己也是對象，那它又是由哪一個類產生的呢？post

1 #type函數能夠查看類型，也能夠用來查看對象的類，兩者是同樣的
2 print(type(f1)) # 輸出：<class '__main__.Foo'>     表示，obj 對象由Foo類建立
3 print(type(Foo)) # 輸出：<type 'type'>

三什麼是元類？

元類是類的類，是類的模板學習

元類是用來控制如何建立類的，正如類是建立對象的模板同樣，而元類的主要目的是爲了控制類的建立行爲this

元類的實例化的結果爲咱們用class定義的類，正如類的實例爲對象(f1對象是Foo類的一個實例，Foo類是 type 類的一個實例)spa

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 類體


#類名
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,),{})

五自定義元類控制類的行爲

#一個類沒有聲明本身的元類，默認他的元類就是type，除了使用元類type，用戶也能夠經過繼承type來自定義元類（順便咱們也能夠瞅一瞅元類如何控制類的行爲，工做流程是什麼）

#知識儲備：
    #產生的新對象 = object.__new__(繼承object類的子類)








#步驟一：若是說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) {}

        #一、實例化People，產生空對象obj
        obj=object.__new__(self)


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


        #三、返回初始化好了的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) {}

        #一、調用self，即People下的函數__new__，在該函數內完成：一、產生空對象obj 二、初始化 三、返回obj
        obj=self.__new__(self,*args,**kwargs)

        #二、必定記得返回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}






#步驟五：基於元類實現單例模式
# 單例：即單個實例，指的是同一個類實例化屢次的結果指向同一個對象，用於節省內存空間
# 若是咱們從配置文件中讀取配置來進行實例化，在配置相同的狀況下，就不必重複產生對象浪費內存了
#settings.py文件內容以下
HOST='1.1.1.1'
PORT=3306

#方式一:定義一個類方法實現單例模式
import settings

class Mysql:
    __instance=None
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def singleton(cls):
        if not cls.__instance:
            cls.__instance=cls(settings.HOST,settings.PORT)
        return cls.__instance


obj1=Mysql('1.1.1.2',3306)
obj2=Mysql('1.1.1.3',3307)
print(obj1 is obj2) #False

obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True



#方式二：定製元類實現單例模式
import settings

class Mymeta(type):
    def __init__(self,name,bases,dic): #定義類Mysql時就觸發

        # 事先先從配置文件中取配置來造一個Mysql的實例出來
        self.__instance = object.__new__(self)  # 產生對象
        self.__init__(self.__instance, settings.HOST, settings.PORT)  # 初始化對象
        # 上述兩步能夠合成下面一步
        # self.__instance=super().__call__(*args,**kwargs)


        super().__init__(name,bases,dic)

    def __call__(self, *args, **kwargs): #Mysql(...)時觸發
        if args or kwargs: # args或kwargs內有值
            obj=object.__new__(self)
            self.__init__(obj,*args,**kwargs)
            return obj

        return self.__instance




class Mysql(metaclass=Mymeta):
    def __init__(self,host,port):
        self.host=host
        self.port=port



obj1=Mysql() # 沒有傳值則默認從配置文件中讀配置來實例化，全部的實例應該指向一個內存地址
obj2=Mysql()
obj3=Mysql()

print(obj1 is obj2 is obj3)

obj4=Mysql('1.1.1.4',3307)



#方式三:定義一個裝飾器實現單例模式
import settings

def singleton(cls): #cls=Mysql
    _instance=cls(settings.HOST,settings.PORT)

    def wrapper(*args,**kwargs):
        if args or kwargs:
            obj=cls(*args,**kwargs)
            return obj
        return _instance

    return wrapper


@singleton # Mysql=singleton(Mysql)
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port

obj1=Mysql()
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3) #True

obj4=Mysql('1.1.1.3',3307)
obj5=Mysql('1.1.1.4',3308)
print(obj3 is obj4) #False

Egon 5步帶你學會元類

六再看屬性查找

結合python繼承的實現原理+元類從新看屬性的查找應該是什麼樣子呢？？？

在學習完元類後，其實咱們用class自定義的類也全都是對象（包括object類自己也是元類type的一個實例，能夠用type(object)查看），咱們學習過繼承的實現原理，如今若是將下述繼承說成是：對象Foo繼承對象B，對象B繼承對象A，對象A繼承對象object

class A(object):
    n=333

class B(A):
    n=222

class Foo(B):
    n=333

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

class Mymeta(type):
    n=444
    def __call__(self, *args, **kwargs):
        obj = self.__new__(self)  # self=Foo
        # obj = object.__new__(self)  # self=Foo
        self.__init__(obj, *args, **kwargs)
        return obj

class A(object):
    n=333
    # pass

class B(A):
    n=222
    # pass
class Foo(B,metaclass=Mymeta):  # Foo=Mymeta(...)
    n=111
    def __init__(self, x, y):
        self.x = x
        self.y = y


print(Foo.n) 
#查找順序：
#一、先對象層：Foo->B->A->object
#二、而後元類層：Mymeta->type

咱們在元類的__call__中也能夠用object.__new__(self)去造對象，先從object本身的名稱空間找，因爲它沒有繼承任何其餘對象，全部直接找到它的類，object的類也是type，因而也找到type中的__new__，與此時的self.__new__（self）其實查找的最終目標是同樣的

但咱們仍是推薦在__call__中使用self.__new__（self）去創造空對象，由於這種方式會檢索Foo->Mymeta->type,我麼能夠在Foo或Mymeta中定製__new__,而object.__new__則是直接跨過了Foo和Mymeta

七練習題

練習一：在元類中控制把自定義類的數據屬性都變成大寫

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

View Code

練習二：在元類中控制自定義的類無需__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__)

View Code

練習三：在元類中控制自定義的類產生的對象相關的屬性所有爲隱藏屬性

class Mymeta(type):
    def __init__(self,class_name,class_bases,class_dic):
        #控制類Foo的建立
        super(Mymeta,self).__init__(class_name,class_bases,class_dic)

    def __call__(self, *args, **kwargs):
        #控制Foo的調用過程，即Foo對象的產生過程
        obj = self.__new__(self)
        self.__init__(obj, *args, **kwargs)
        obj.__dict__={'_%s__%s' %(self.__name__,k):v for k,v in obj.__dict__.items()}

        return obj

class Foo(object,metaclass=Mymeta):  # Foo=Mymeta(...)
    def __init__(self, name, age,sex):
        self.name=name
        self.age=age
        self.sex=sex


obj=Foo('egon',18,'male')
print(obj.__dict__)