元類（metaclass）

1、儲備知識exec

　　儲備知識exec：有下面三個參數

　　參數一：字符串形式的命令
　　參數二：全局做用域（字典形式），若是不指定默認使用globals()
　　參數三：局部做用域(字典形式)，若是不指定默認就使用locals()

# 格式：exec(object, 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(object, globals, locals)

2、類也是對象，一切皆對象

class Foo:
      pass

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

　　python一切皆對象，類自己也是一個對象，當使用關鍵字class的時候，python解釋器在加載class的時候就會建立一個對象(這裏的對象指的是類而非類的實例)，於是咱們能夠將類看成一個對象去使用，一樣知足第一類對象的概念，對象能夠怎麼用？
　　一、均可以被引用，x=obj（類賦值給一個變量）
　　二、均可以看成函數的參數傳入（類做爲函數參數進行傳遞）
　　三、均可以看成函數的返回值（把類做爲函數的返回值）
　　四、均可以看成容器類的元素，l=[func, time, obj, 1] （在運行時動態地建立類）
　　換句話說，符合上述條件就是一個對象，若是類Foo自己就是對象，那須要探究Foo是由哪一個類產生的。

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

3、元類概念

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

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

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

　　type是python的一個內建元類，用來直接控制生成類，python中任何class定義的類其實都是type類實例化的對象

4、建立類的兩種方式

一、使用class關鍵字

class Chinese:  # 這個類實際上是元類實例化的一個對象
    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（也能夠自定義）來產生類Chinese

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

5、自定義元類控制類的行爲

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

egon5步學會元類：

　　知識儲備： 產生的新對象 = 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__方法，才能控制類實例化行爲

　　__call__()的做用是使實例可以像函數同樣被調用，同時不影響實例自己的生命週期（__call__()不影響一個實例的構造和析構）。

　　__call__()能夠用來改變實例的內部成員的值。

class Foo:
    pass

obj=Foo()
obj()
# 沒有__call__方法前，obj() 報錯：TypeError: 'Foo' object is not callable（不可調用）



class Foo:
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)
    pass

obj=Foo()
obj(1, 2, 3, a=1, b=2, c=3)
"""
<__main__.Foo object at 0x101eb6390>
(1, 2, 3)
{'a': 1, 'b': 2, 'c': 3}
"""

__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類實例化行爲

　　總結：若是說類People是元類type的實例，那麼在元類type內確定也有一個__call__，會在調用People('egon',18)時觸發執行，而後返回一個初始化好了的對象obj。

步驟三：自定義元類，控制類的調用（即實例化）的過程

class Mymeta(type):   # 自定義元類，大多數屬性依然是繼承的type
    def __init__(self, class_name, class_bases, class_dic):
        # print(class_name)  # 類名：Chinese
        # print(class_bases)  # 基類：(<class 'object'>,)
        # print(class_dic)  # 類的名稱空間：{'__module__': '__main__', '__qualname__': 'Chinese', 'country': 'China', '__init__': <function Chinese.__init__ at 0x101f201e0>, 'talk': <function Chinese.talk at 0x101f20378>}

        # 自訂製控制類的行爲
        if not class_name.istitle():  # istitle()判斷首字母大寫
            raise TypeError('類名的首字母必須大寫')# 主動報錯的關鍵字是raise

        if '__doc__' not in class_dic or not class_dic['__doc__'].strip():
            raise TypeError("必須有註釋，且註釋不能爲空")

        super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父類功能

    def __call__(self, *args, **kwargs):  # obj = Chinese('egon',age=18)
        print(self)  # self = Chinese
        print(args)   # args = ('egon',)
        print(kwargs)   # kwargs = {'age': 18}

        # 第一件事：實例化先造一個空對象obj
        obj = object.__new__(self)
        # 第二件事：初始化obj
        self.__init__(obj, *args, **kwargs)
        # 第三件事：返回obj
        return obj

class Chinese(object, metaclass=Mymeta):  # 元類爲Mymeta的類的建立可受人控制
    """
    中國人的類
    """
    country = 'China'

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

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

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

obj = Chinese('egon', age=18)   # 實例化的行爲
"""
<class '__main__.Chinese'>
('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}

__new__函數

步驟五：基於元類實現單例模式,好比數據庫對象,實例化時參數都同樣,就不必重複產生對象,浪費內存

方式一：

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

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

print(obj1 is obj3)
"""
True
"""

定義一個類方法實現單例模式

方式二：

class Mymeta(type):
    def __init__(self, class_name, class_bases, class_dic):
        if not class_name.istitle():  # istitle()判斷首字母大寫
            raise TypeError('類名的首字母必須大寫')  # 主動報錯的關鍵字是raise

        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:Mysql
            self.__init__(obj)
            self.__instance=obj
        return self.__instance

class Mysql(object, metaclass=Mymeta):
    """
    mysql
    """
    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)  # "True"

定製元類實現單例模式

方式三：

#settings.py文件內容以下
HOST='1.1.1.1'
PORT=3306

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

定義一個裝飾器實現單例模式