Python超詳細講解元類的使用

更新時間：2022年06月28日 10:19:18 作者：henry_rhy

在Python里一切都是對象（object），基本數據類型，如數字，字符串，函數都是對象。對象可以由類（class）進行創(chuàng)建。那么既然一切都是對象，那么類是對象嗎？是的，類也是對象，那么又是誰創(chuàng)造了類呢？答案也很簡單，也是類，一個能創(chuàng)作類的類，稱之為(type)元類

類的定義

對象是通過類創(chuàng)建的，如下面的代碼：

# object 為頂層基類
class Work(object):
    a = 100
Mywork = Work()   # 實例化
print(Mywork )   # Mywork 是 Work 所創(chuàng)建的一個對象  <__main__.Work object at 0x101eb4630>
print(type(Mywork))    # <class '__main__.Work'>
print(type(Work))    # 類型為元類 <class 'type'>

解析：

可以看見對象 Mywork 是類 Work 創(chuàng)建的實例。然但是可以看到Work的類型時由一個叫 type 的類創(chuàng)建的實例。即 Mywork —》 Work —》 type 創(chuàng)建

上面的例子中對象是動態(tài)創(chuàng)建的，類則是通過關鍵字 class 聲明定義的

那么class關鍵字背后的玄機是什么呢？

實際上，class Work(object) 這樣的代碼，等價于 Work = type(‘Work’, (objects, ), {“a”:100})
即類 type 通過實例化創(chuàng)建了它的對象 Work，而這個 Work 恰恰是一個類，這樣能創(chuàng)建類的類，就是 Python 的元類。而在python中內置的元類叫：type

一、什么是元類

用來創(chuàng)建類的類，叫做元類
類是元類創(chuàng)建出來的對象
函數type實際上是一個元類，type就是Python在背后用來創(chuàng)建所有類的元類

二、注意區(qū)分元類和繼承的基類

type是元類，所有的類都是通過type所創(chuàng)建出來的
object頂層的基類，所有類的繼承頂層父類都是object

三、type 元類的使用

可以看到type是小寫，一般情況下都會認為它是一個函數，通過查看源代碼去看下如下定義的：

class type(object):
"""
type(object_or_name, bases, dict)
type(object) -> the object's type
type(name, bases, dict) -> a new type
"""
	# 實例化
	def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__
	     """
	     type(object_or_name, bases, dict)
	     type(object) -> the object's type
	     type(name, bases, dict) -> a new type
	     # (copied from class doc)
	     """
	     pass
	# 創(chuàng)建類    
	@staticmethod     # known case of __new__
    def __new__(*args, **kwargs):   # real signature unknown
        """ 
        Create and return a new object.  See help(type) for accurate signature. 
        （創(chuàng)建并返回一個新對象）
        """
        pass

type的用法一：獲取數據時那種類型： type(object) -> the object’s type

a = 100
b = "100"
c = [11,22,33]
print(type(a))    # ======》 <class 'int'>
print(type(b))    # ======》 <class 'str'>
print(type(c))    # ======》 <class 'list'>

type的用法二：創(chuàng)建類：type(object_or_name, bases, dict)

1.在查看源碼的時候，可以看到在初始化時，init__方法接受三個參數，type 在實例化的過程，也會重新創(chuàng)建一個新的類，而創(chuàng)建類的代碼來自__new 方法，它的參數與 __init__方法是一樣的。

2.當調用 type 進行實例化的時候，會先自動調用 new 方法，再調用__init__方法，最終會實例化一個對象，這個對象是一個類。

1. 元類 type 的 init 方法有3個參數：

1.name：類名（字符串類型）
2.bases：繼承的父類（元祖類型）
3.dict：屬性和方法組成的字典（字典類型）

具體例子：

# 通過 class 定義類
class Myclass(object):
    a = 100
    b = 200
# 通過type創(chuàng)建的類(動態(tài)創(chuàng)建類)
Myclass1 = type("Myclass1",(object,),{"a":"100","b":"200"})
print(Myclass)
print(Myclass1)

如果需要定義實例方法和類屬性怎么辦呢?，將方法和屬性以字典的形式傳進去

def work(self):
    print("這是實例方法——————work————————")
# 定義類屬性值
def init_method(self, aa, bb, cc):
    self.aa = aa
    self.bb = bb
    self.cc = cc
# 通過type創(chuàng)建的類(動態(tài)創(chuàng)建類)
Myclass2 = type("Myclass2",(object,),{"a":"100","b":"200","work":work,"work_1":work_1,"__init__":init_method})
m = Myclass2(11,22,33)
m.work()
print(m.aa, m.bb, m.cc)

四、自定義元類的使用

既然元類可以創(chuàng)建類，那也可以自定義元類，自定義直接繼承類 type ，在自定義元類的步驟：

1.定義一個類繼承type

2.重寫new方法

具體例子：

# 定義一個類繼承type
class Mytest(type):
	# 重寫new方法
    def __new__(cls, type_name, bases, atter, *args, **kwargs):
        new_cls = super().__new__(cls,type_name, bases, atter)         
        return new_cls      # 返回新的類
M2 = Mytest("M2",(Mytest,),{"atter":100})
print(M2)     # =====》  <class '__main__.M2'>

使用class創(chuàng)建類的時候指定自定義的元類

1.不去指定時，默認創(chuàng)建都是type類

2.指定自定義的元類去創(chuàng)建類：metaclass = 指定的元類

class Myclass(type):
    """自定義的元類"""
    def __new__(cls, type_name, bases, attrs, *args, **kwargs):
        new_cls = super().__new__(cls, type_name, bases, attrs)
        print("這個是Myclass:", type_name, bases, attrs, )
        return new_cls
# 通過metaclass=xxxx   繼承自定義元類
class Inherited_class(metaclass=Myclass):
    a = 100
    b = 200
print(type(Inherited_class))  # ======》 <class '__main__.Myclass'>