真实的国产乱ⅩXXX66竹夫人,五月香六月婷婷激情综合,亚洲日本VA一区二区三区,亚洲精品一区二区三区麻豆

成都創(chuàng)新互聯(lián)網(wǎng)站制作重慶分公司

09-07元類

[TOC]

為石龍等地區(qū)用戶提供了全套網(wǎng)頁設(shè)計(jì)制作服務(wù)，及石龍網(wǎng)站建設(shè)行業(yè)解決方案。主營業(yè)務(wù)為成都網(wǎng)站建設(shè)、做網(wǎng)站、石龍網(wǎng)站設(shè)計(jì)，以傳統(tǒng)方式定制建設(shè)網(wǎng)站，并提供域名空間備案等一條龍服務(wù)，秉承以專業(yè)、用心的態(tài)度為用戶提供真誠的服務(wù)。我們深信只要達(dá)到每一位用戶的要求，就會(huì)得到認(rèn)可，從而選擇與我們長期合作。這樣，我們也可以走得更遠(yuǎn)！

一 元類介紹

插圖：惡搞圖47
09-07 元類

什么是元類呢？一切源自于一句話：python中一切皆為對(duì)象。讓我們先定義一個(gè)類，然后逐步分析

class StanfordTeacher(object):
    school='Stanford'

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

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

所有的對(duì)象都是實(shí)例化或者說調(diào)用類而得到的（調(diào)用類的過程稱為類的實(shí)例化），比如對(duì)象t1是調(diào)用類StanfordTeacher得到的

t1=StanfordTeacher('lili',18)
print(type(t1)) #查看對(duì)象t1的類是

如果一切皆為對(duì)象，那么類StanfordTeacher本質(zhì)也是一個(gè)對(duì)象，既然所有的對(duì)象都是調(diào)用類得到的，那么StanfordTeacher必然也是調(diào)用了一個(gè)類得到的，這個(gè)類稱為元類

于是我們可以推導(dǎo)出===>產(chǎn)生StanfordTeacher的過程一定發(fā)生了：StanfordTeacher=元類(...)

print(type(StanfordTeacher)) # 結(jié)果為，證明是調(diào)用了type這個(gè)元類而產(chǎn)生的StanfordTeacher，即默認(rèn)的元類為type

插圖：元類與類、對(duì)象的關(guān)系

09-07 元類

插圖：惡搞圖50
09-07 元類

二 class關(guān)鍵字創(chuàng)建類的流程分析

上文我們基于python中一切皆為對(duì)象的概念分析出：我們用class關(guān)鍵字定義的類本身也是一個(gè)對(duì)象，負(fù)責(zé)產(chǎn)生該對(duì)象的類稱之為元類（元類可以簡稱為類的類），內(nèi)置的元類為type

class關(guān)鍵字在幫我們創(chuàng)建類時(shí)，必然幫我們調(diào)用了元類StanfordTeacher=type(...)，那調(diào)用type時(shí)傳入的參數(shù)是什么呢？必然是類的關(guān)鍵組成部分，一個(gè)類有三大組成部分，分別是

1、類名class_name='StanfordTeacher'

2、基類們class_bases=(object,)

3、類的名稱空間class_dic，類的名稱空間是執(zhí)行類體代碼而得到的

調(diào)用type時(shí)會(huì)依次傳入以上三個(gè)參數(shù)

綜上，class關(guān)鍵字幫我們創(chuàng)建一個(gè)類應(yīng)該細(xì)分為以下四個(gè)過程

插圖：元類原理之類的創(chuàng)建流程
09-07 元類

插圖：惡搞圖48
09-07 元類

補(bǔ)充：exec的用法

#exec：三個(gè)參數(shù)

#參數(shù)一：包含一系列python代碼的字符串

#參數(shù)二：全局作用域（字典形式），如果不指定，默認(rèn)為globals()

#參數(shù)三：局部作用域（字典形式），如果不指定，默認(rèn)為locals()

#可以把exec命令的執(zhí)行當(dāng)成是一個(gè)函數(shù)的執(zhí)行，會(huì)將執(zhí)行期間產(chǎn)生的名字存放于局部名稱空間中
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}

插圖：惡搞圖51
09-07 元類

四 自定義元類控制類StanfordTeacher的創(chuàng)建

一個(gè)類沒有聲明自己的元類，默認(rèn)他的元類就是type，除了使用內(nèi)置元類type，我們也可以通過繼承type來自定義元類，然后使用metaclass關(guān)鍵字參數(shù)為一個(gè)類指定元類

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

# StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})
class StanfordTeacher(object,metaclass=Mymeta): 
    school='Stanford'

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

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

插圖：惡搞圖49
09-07 元類

自定義元類可以控制類的產(chǎn)生過程，類的產(chǎn)生過程其實(shí)就是元類的調(diào)用過程,即StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})，調(diào)用Mymeta會(huì)先產(chǎn)生一個(gè)空對(duì)象StanfordTeacher，然后連同調(diào)用Mymeta括號(hào)內(nèi)的參數(shù)一同傳給Mymeta下的__init__方法，完成初始化，于是我們可以

class Mymeta(type): #只有繼承了type類才能稱之為一個(gè)元類，否則就是一個(gè)普通的自定義類
    def __init__(self,class_name,class_bases,class_dic):
        # print(self) #
        # print(class_bases) #(,)
        # print(class_dic) #{'__module__': '__main__', '__qualname__': 'StanfordTeacher', 'school': 'Stanford', '__init__': , 'say': }
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父類的功能

        if class_name.islower():
            raise TypeError('類名%s請(qǐng)修改為駝峰體' %class_name)

        if '__doc__' not in class_dic or len(class_dic['__doc__'].strip(' \n')) == 0:
            raise TypeError('類中必須有文檔注釋，并且文檔注釋不能為空')

# StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})
class StanfordTeacher(object,metaclass=Mymeta): 
    """
    類StanfordTeacher的文檔注釋
    """
    school='Stanford'

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

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

插圖：惡搞圖52、惡搞圖53、惡搞圖54
09-07 元類

09-07 元類

09-07 元類

五 自定義元類控制類StanfordTeacher的調(diào)用

儲(chǔ)備知識(shí)：__call__

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

obj=Foo()
#1、要想讓obj這個(gè)對(duì)象變成一個(gè)可調(diào)用的對(duì)象，需要在該對(duì)象的類中定義一個(gè)方法__call__方法，該方法會(huì)在調(diào)用對(duì)象時(shí)自動(dòng)觸發(fā)
#2、調(diào)用obj的返回值就是__call__方法的返回值
res=obj(1,2,3,x=1,y=2)

插圖：惡搞圖55
09-07 元類

由上例得知，調(diào)用一個(gè)對(duì)象，就是觸發(fā)對(duì)象所在類中的__call__方法的執(zhí)行，如果把StanfordTeacher也當(dāng)做一個(gè)對(duì)象，那么在StanfordTeacher這個(gè)對(duì)象的類中也必然存在一個(gè)__call__方法

class Mymeta(type): #只有繼承了type類才能稱之為一個(gè)元類，否則就是一個(gè)普通的自定義類
    def __call__(self, *args, **kwargs):
        print(self) #
        print(args) #('lili', 18)
        print(kwargs) #{}
        return 123

class StanfordTeacher(object,metaclass=Mymeta):
    school='Stanford'

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

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

# 調(diào)用StanfordTeacher就是在調(diào)用StanfordTeacher類中的__call__方法
# 然后將StanfordTeacher傳給self,溢出的位置參數(shù)傳給*，溢出的關(guān)鍵字參數(shù)傳給**
# 調(diào)用StanfordTeacher的返回值就是調(diào)用__call__的返回值
t1=StanfordTeacher('lili',18)
print(t1) #123

插圖：惡搞圖56
09-07 元類

默認(rèn)地，調(diào)用t1=StanfordTeacher('lili',18)會(huì)做三件事

1、產(chǎn)生一個(gè)空對(duì)象obj

2、調(diào)用__init__方法初始化對(duì)象obj

3、返回初始化好的obj

對(duì)應(yīng)著，StanfordTeacher類中的__call__方法也應(yīng)該做這三件事

class Mymeta(type): #只有繼承了type類才能稱之為一個(gè)元類，否則就是一個(gè)普通的自定義類
    def __call__(self, *args, **kwargs): #self=
        #1、調(diào)用__new__產(chǎn)生一個(gè)空對(duì)象obj
        obj=self.__new__(self) # 此處的self是類OldoyTeacher，必須傳參，代表創(chuàng)建一個(gè)StanfordTeacher的對(duì)象obj

        #2、調(diào)用__init__初始化空對(duì)象obj
        self.__init__(obj,*args,**kwargs)

        #3、返回初始化好的對(duì)象obj
        return obj

class StanfordTeacher(object,metaclass=Mymeta):
    school='Stanford'

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

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

t1=StanfordTeacher('lili',18)
print(t1.__dict__) #{'name': 'lili', 'age': 18}

插圖：惡搞圖57
09-07 元類

上例的__call__相當(dāng)于一個(gè)模板，我們可以在該基礎(chǔ)上改寫__call__的邏輯從而控制調(diào)用StanfordTeacher的過程，比如將StanfordTeacher的對(duì)象的所有屬性都變成私有的

class Mymeta(type): #只有繼承了type類才能稱之為一個(gè)元類，否則就是一個(gè)普通的自定義類
    def __call__(self, *args, **kwargs): #self=
        #1、調(diào)用__new__產(chǎn)生一個(gè)空對(duì)象obj
        obj=self.__new__(self) # 此處的self是類StanfordTeacher，必須傳參，代表創(chuàng)建一個(gè)StanfordTeacher的對(duì)象obj

        #2、調(diào)用__init__初始化空對(duì)象obj
        self.__init__(obj,*args,**kwargs)

        # 在初始化之后，obj.__dict__里就有值了
        obj.__dict__={'_%s__%s' %(self.__name__,k):v for k,v in obj.__dict__.items()}
        #3、返回初始化好的對(duì)象obj
        return obj

class StanfordTeacher(object,metaclass=Mymeta):
    school='Stanford'

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

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

t1=StanfordTeacher('lili',18)
print(t1.__dict__) #{'_StanfordTeacher__name': 'lili', '_StanfordTeacher__age': 18}

上例中涉及到查找屬性的問題，比如self.__new__，請(qǐng)看下一小節(jié)

插圖：惡搞圖58
09-07 元類

五 再看屬性查找

結(jié)合python繼承的實(shí)現(xiàn)原理+元類重新看屬性的查找應(yīng)該是什么樣子呢？？？

插圖：惡搞圖59
09-07 元類

在學(xué)習(xí)完元類后，其實(shí)我們用class自定義的類也全都是對(duì)象（包括object類本身也是元類type的 一個(gè)實(shí)例，可以用type(object)查看），我們學(xué)習(xí)過繼承的實(shí)現(xiàn)原理，如果把類當(dāng)成對(duì)象去看，將下述繼承應(yīng)該說成是：對(duì)象StanfordTeacher繼承對(duì)象Foo，對(duì)象Foo繼承對(duì)象Bar，對(duì)象Bar繼承對(duì)象object

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

    def __call__(self, *args, **kwargs): #self=
        obj=self.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj

class Bar(object):
    n=333

class Foo(Bar):
    n=222

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

    school='Stanford'

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

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

print(StanfordTeacher.n) #自下而上依次注釋各個(gè)類中的n=xxx，然后重新運(yùn)行程序，發(fā)現(xiàn)n的查找順序?yàn)镾tanfordTeacher->Foo->Bar->object->Mymeta->type

插圖：惡搞圖51
09-07 元類

于是屬性查找應(yīng)該分成兩層，一層是對(duì)象層（基于c3算法的MRO）的查找，另外一個(gè)層則是類層（即元類層）的查找

插圖：01元類-繼承背景下的屬性查找
09-07 元類

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

插圖：惡搞圖60
09-07 元類

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

class Mymeta(type): 
    n=444

    def __call__(self, *args, **kwargs): #self=
        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 StanfordTeacher(Foo,metaclass=Mymeta):
    n=111

    school='Stanford'

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

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

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

StanfordTeacher('lili',18) #觸發(fā)StanfordTeacher的類中的__call__方法的執(zhí)行，進(jìn)而執(zhí)行self.__new__開始查找

總結(jié)，Mymeta下的__call__里的self.__new__在StanfordTeacher、Foo、Bar里都沒有找到__new__的情況下，會(huì)去找object里的__new__，而object下默認(rèn)就有一個(gè)__new__，所以即便是之前的類均未實(shí)現(xiàn)__new__,也一定會(huì)在object中找到一個(gè)，根本不會(huì)、也根本沒必要再去找元類Mymeta->type中查找__new__

插圖：惡搞圖61，惡搞圖62
09-07 元類

09-07 元類

我們?cè)谠惖腳_call__中也可以用object.__new__(self)去造對(duì)象

插圖：02元類-繼承背景下的屬性查找
09-07 元類

但我們還是推薦在__call__中使用self.__new__(self)去創(chuàng)造空對(duì)象，因?yàn)檫@種方式會(huì)檢索三個(gè)類StanfordTeacher->Foo->Bar,而object.new則是直接跨過了他們?nèi)齻€(gè)

最后說明一點(diǎn)

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

    def __new__(cls, *args, **kwargs):
        obj=type.__new__(cls,*args,**kwargs) # 必須按照這種傳值方式
        print(obj.__dict__)
        # return obj # 只有在返回值是type的對(duì)象時(shí)，才會(huì)觸發(fā)下面的__init__
        return 123

    def __init__(self,class_name,class_bases,class_dic):
        print('run。。。')

class StanfordTeacher(object,metaclass=Mymeta): #StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})
    n=111

    school='Stanford'

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

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

print(type(Mymeta)) #
# 產(chǎn)生類StanfordTeacher的過程就是在調(diào)用Mymeta，而Mymeta也是type類的一個(gè)對(duì)象，那么Mymeta之所以可以調(diào)用，一定是在元類type中有一個(gè)__call__方法
# 該方法中同樣需要做至少三件事：
# class type:
#     def __call__(self, *args, **kwargs): #self=
#         obj=self.__new__(self,*args,**kwargs) # 產(chǎn)生Mymeta的一個(gè)對(duì)象
#         self.__init__(obj,*args,**kwargs) 
#         return obj

插圖：惡搞圖63

09-07 元類

六 作業(yè)

插圖：惡搞圖64
09-07 元類

1、在元類中控制把自定義類的數(shù)據(jù)屬性都變成大寫

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': ,
 '__dict__': ,                                         
 '__weakref__': ,
 '__doc__': None}
'''

2、在元類中控制自定義的類無需__init__方法

? 1.元類幫其完成創(chuàng)建對(duì)象，以及初始化操作；

2.要求實(shí)例化時(shí)傳參必須為關(guān)鍵字形式，否則拋出異常TypeError: must use keyword argument

3.key作為用戶自定義類產(chǎn)生對(duì)象的屬性，且所有屬性變成大寫

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) #創(chuàng)建對(duì)象，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='lili',age=18,sex='male')
print(p.__dict__)

插圖：惡搞圖65
09-07 元類

3、在元類中控制自定義的類產(chǎn)生的對(duì)象相關(guān)的屬性全部為隱藏屬性

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

    def __call__(self, *args, **kwargs):
        #控制Foo的調(diào)用過程，即Foo對(duì)象的產(chǎn)生過程
        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('lili',18,'male')
print(obj.__dict__)

4、基于元類實(shí)現(xiàn)單例模式

插圖：惡搞圖66
09-07 元類

#步驟五：基于元類實(shí)現(xiàn)單例模式
# 單例：即單個(gè)實(shí)例，指的是同一個(gè)類實(shí)例化多次的結(jié)果指向同一個(gè)對(duì)象，用于節(jié)省內(nèi)存空間
# 如果我們從配置文件中讀取配置來進(jìn)行實(shí)例化，在配置相同的情況下，就沒必要重復(fù)產(chǎn)生對(duì)象浪費(fèi)內(nèi)存了
#settings.py文件內(nèi)容如下
HOST='1.1.1.1'
PORT=3306

#方式一:定義一個(gè)類方法實(shí)現(xiàn)單例模式
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

#方式二：定制元類實(shí)現(xiàn)單例模式
import settings

class Mymeta(type):
    def __init__(self,name,bases,dic): #定義類Mysql時(shí)就觸發(fā)
        # 事先先從配置文件中取配置來造一個(gè)Mysql的實(shí)例出來
        self.__instance = object.__new__(self)  # 產(chǎn)生對(duì)象
        self.__init__(self.__instance, settings.HOST, settings.PORT)  # 初始化對(duì)象
        # 上述兩步可以合成下面一步
        # self.__instance=super().__call__(*args,**kwargs)
        super().__init__(name,bases,dic)

    def __call__(self, *args, **kwargs): #Mysql(...)時(shí)觸發(fā)
        if args or kwargs: # args或kwargs內(nèi)有值
            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() # 沒有傳值則默認(rèn)從配置文件中讀配置來實(shí)例化，所有的實(shí)例應(yīng)該指向一個(gè)內(nèi)存地址
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3)
obj4=Mysql('1.1.1.4',3307)

#方式三:定義一個(gè)裝飾器實(shí)現(xiàn)單例模式
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

插圖：惡搞圖67
09-07 元類


網(wǎng)站題目：09-07元類
網(wǎng)站網(wǎng)址：http://weahome.cn/article/jjdjis.html

其他資訊

在線咨詢

微信咨詢

電話咨詢

028-86922220（工作日）

18980820575（7×24）

提交需求

返回頂部