對python中元類的理解

来源:https://www.cnblogs.com/xxpythonxx/archive/2020/01/07/12163908.html
-Advertisement-
Play Games

1. 類也是對象 在大多數編程語言中，類就是一組用來描述如何生成一個對象的代碼段。在Python中這一點仍然成立： 但是，Python中的類還遠不止如此。類同樣也是一種對象。是的，沒錯，就是對象。只要你使用關鍵字class，Python解釋器在執行的時候就會創建一個對象。 下麵的代碼段： 將在記憶體中 ...


1. 類也是對象

在大多數編程語言中，類就是一組用來描述如何生成一個對象的代碼段。在Python中這一點仍然成立：

>>> class ObjectCreator(object):
…       pass
…
>>> my_object = ObjectCreator()
>>> print my_object
<__main__.ObjectCreator object at 0x8974f2c>

但是，Python中的類還遠不止如此。類同樣也是一種對象。是的，沒錯，就是對象。只要你使用關鍵字class，Python解釋器在執行的時候就會創建一個對象。

下麵的代碼段：

>>> class ObjectCreator(object):
…       pass
…

將在記憶體中創建一個對象，名字就是ObjectCreator。這個對象（類對象ObjectCreator）擁有創建對象（實例對象）的能力。但是，它的本質仍然是一個對象，於是乎你可以對它做如下的操作：

  • 你可以將它賦值給一個變數
  • 你可以拷貝它
  • 你可以為它增加屬性
  • 你可以將它作為函數參數進行傳遞

下麵是示例：

>>> print ObjectCreator     # 你可以列印一個類，因為它其實也是一個對象
<class '__main__.ObjectCreator'>
>>> def echo(o):
…       print o
…
>>> echo(ObjectCreator)                 # 你可以將類做為參數傳給函數
<class '__main__.ObjectCreator'>
>>> print hasattr(ObjectCreator, 'new_attribute')
Fasle
>>> ObjectCreator.new_attribute = 'foo' #  你可以為類增加屬性
>>> print hasattr(ObjectCreator, 'new_attribute')
True
>>> print ObjectCreator.new_attribute
foo
>>> ObjectCreatorMirror = ObjectCreator # 你可以將類賦值給一個變數
>>> print ObjectCreatorMirror()
<__main__.ObjectCreator object at 0x8997b4c>

2. 動態地創建類

因為類也是對象，你可以在運行時動態的創建它們，就像其他任何對象一樣。首先，你可以在函數中創建類，使用class關鍵字即可。

>>> def choose_class(name):
…       if name == 'foo':
…           class Foo(object):
…               pass
…           return Foo     # 返回的是類，不是類的實例
…       else:
…           class Bar(object):
…               pass
…           return Bar
…
>>> MyClass = choose_class('foo')
>>> print MyClass              # 函數返回的是類，不是類的實例
<class '__main__'.Foo>
>>> print MyClass()            # 你可以通過這個類創建類實例，也就是對象
<__main__.Foo object at 0x89c6d4c>

但這還不夠動態，因為你仍然需要自己編寫整個類的代碼。由於類也是對象，所以它們必須是通過什麼東西來生成的才對。當你使用class關鍵字時，Python解釋器自動創建這個對象。但就和Python中的大多數事情一樣，Python仍然提供給你手動處理的方法。

還記得內建函數type嗎？這個古老但強大的函數能夠讓你知道一個對象的類型是什麼，就像這樣：

>>> print type(1) #數值的類型
<type 'int'>
>>> print type("1") #字元串的類型
<type 'str'>
>>> print type(ObjectCreator()) #實例對象的類型
<class '__main__.ObjectCreator'>
>>> print type(ObjectCreator) #類的類型
<type 'type'>

仔細觀察上面的運行結果，發現使用type對ObjectCreator查看類型是，答案為type， 是不是有些驚訝。。。看下麵

3. 使用type創建類

type還有一種完全不同的功能，動態的創建類。

type可以接受一個類的描述作為參數，然後返回一個類。（要知道，根據傳入參數的不同，同一個函數擁有兩種完全不同的用法是一件很傻的事情，但這在Python中是為了保持向後相容性）

type可以像這樣工作：

type(類名, 由父類名稱組成的元組（針對繼承的情況，可以為空），包含屬性的字典（名稱和值）)

比如下麵的代碼：

In [2]: class Test: #定義了一個Test類
   ...:     pass
   ...:
In [3]: Test() #創建了一個Test類的實例對象
Out[3]: <__main__.Test at 0x10d3f8438>

可以手動像這樣創建：

Test2 = type("Test2",(),{}) #定了一個Test2類
In [5]: Test2() #創建了一個Test2類的實例對象
Out[5]: <__main__.Test2 at 0x10d406b38>

我們使用"Test2"作為類名，並且也可以把它當做一個變數來作為類的引用。類和變數是不同的，這裡沒有任何理由把事情弄的複雜。即type函數中第1個實參，也可以叫做其他的名字，這個名字表示類的名字

In [23]: MyDogClass = type('MyDog', (), {})

In [24]: print MyDogClass
<class '__main__.MyDog'>

使用help來測試這2個類

In [10]: help(Test) #用help查看Test類

Help on class Test in module __main__:

class Test(builtins.object)
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)
In [8]: help(Test2) #用help查看Test2類

Help on class Test2 in module __main__:

class Test2(builtins.object)
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)

4. 使用type創建帶有屬性的類

type 接受一個字典來為類定義屬性，因此

>>> Foo = type('Foo', (), {'bar':True})

可以翻譯為：

>>> class Foo(object):
…       bar = True

並且可以將Foo當成一個普通的類一樣使用：

>>> print Foo
<class '__main__.Foo'>
>>> print Foo.bar
True
>>> f = Foo()
>>> print f
<__main__.Foo object at 0x8a9b84c>
>>> print f.bar
True

當然，你可以向這個類繼承，所以，如下的代碼：

>>> class FooChild(Foo):
…       pass

就可以寫成：

>>> FooChild = type('FooChild', (Foo,),{})
>>> print FooChild
<class '__main__.FooChild'>
>>> print FooChild.bar   # bar屬性是由Foo繼承而來
True

註意：

type的第2個參數，元組中是父類的名字，而不是字元串
添加的屬性是類屬性，並不是實例屬性

5. 使用type創建帶有方法的類

最終你會希望為你的類增加方法。只需要定義一個有著恰當簽名的函數並將其作為屬性賦值就可以了。

添加實例方法

In [46]: def echo_bar(self): #定義了一個普通的函數
    ...:     print(self.bar)
    ...:

In [47]: FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar}) #讓FooChild類中的echo_bar屬性，指向了上面定義的函數

In [48]: hasattr(Foo, 'echo_bar') #判斷Foo類中，是否有echo_bar這個屬性
Out[48]: False

In [49]:

In [49]: hasattr(FooChild, 'echo_bar') #判斷FooChild類中，是否有echo_bar這個屬性
Out[49]: True

In [50]: my_foo = FooChild()

In [51]: my_foo.echo_bar()
True

添加靜態方法

In [36]: @staticmethod
    ...: def testStatic():
    ...:     print("static method ....")
    ...:

In [37]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar, "testStatic":
    ...: testStatic})

In [38]: fooclid = Foochild()

In [39]: fooclid.testStatic
Out[39]: <function __main__.testStatic>

In [40]: fooclid.testStatic()
static method ....

In [41]: fooclid.echo_bar()
True

添加類方法

In [42]: @classmethod
    ...: def testClass(cls):
    ...:     print(cls.bar)
    ...:

In [43]:

In [43]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar, "testStatic":
    ...: testStatic, "testClass":testClass})

In [44]:

In [44]: fooclid = Foochild()

In [45]: fooclid.testClass()
True

你可以看到，在Python中，類也是對象，你可以動態的創建類。這就是當你使用關鍵字class時Python在幕後做的事情，而這就是通過元類來實現的。

6. 到底什麼是元類（終於到主題了）

元類就是用來創建類的“東西”。你創建類就是為了創建類的實例對象，不是嗎？但是我們已經學習到了Python中的類也是對象。

元類就是用來創建這些類（對象）的，元類就是類的類，你可以這樣理解為：

MyClass = MetaClass() #使用元類創建出一個對象，這個對象稱為“類”
MyObject = MyClass() #使用“類”來創建出實例對象

你已經看到了type可以讓你像這樣做：

MyClass = type('MyClass', (), {})

這是因為函數type實際上是一個元類。type就是Python在背後用來創建所有類的元類。現在你想知道那為什麼type會全部採用小寫形式而不是Type呢？

好吧，我猜這是為了和str保持一致性，str是用來創建字元串對象的類，而int是用來創建整數對象的類。type就是創建類對象的類。你可以通過檢查__class__屬性來看到這一點。Python中所有的東西，註意，我是指所有的東西——都是對象。這包括整數、字元串、函數以及類。它們全部都是對象，而且它們都是從一個類創建而來，這個類就是type。

>>> age = 35
>>> age.__class__
<type 'int'>
>>> name = 'bob'
>>> name.__class__
<type 'str'>
>>> def foo(): pass
>>>foo.__class__
<type 'function'>
>>> class Bar(object): pass
>>> b = Bar()
>>> b.__class__
<class '__main__.Bar'>

現在，對於任何一個__class__的__class__屬性又是什麼呢？

>>> a.__class__.__class__
<type 'type'>
>>> age.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>

因此，元類就是創建類這種對象的東西。type就是Python的內建元類，當然了，你也可以創建自己的元類。

**7. __metaclass__屬性**

你可以在定義一個類的時候為其添加__metaclass__屬性。

class Foo(object):
    __metaclass__ = something…
    ...省略...

如果你這麼做了，Python就會用元類來創建類Foo。小心點，這裡面有些技巧。你首先寫下class Foo(object)，但是類Foo還沒有在記憶體中創建。Python會在類的定義中尋找__metaclass__屬性，如果找到了，Python就會用它來創建類Foo，如果沒有找到，就會用內建的type來創建這個類。把下麵這段話反覆讀幾次。當你寫如下代碼時 :

class Foo(Bar):
    pass

Python做瞭如下的操作：

Foo中有__metaclass__這個屬性嗎？如果是，Python會通過__metaclass__創建一個名字為Foo的類(對象)
如果Python沒有找到__metaclass__，它會繼續在Bar（父類）中尋找__metaclass__屬性，並嘗試做和前面同樣的操作。

如果Python在任何父類中都找不到__metaclass__，它就會在模塊層次中去尋找__metaclass__，並嘗試做同樣的操作。

如果還是找不到__metaclass__,Python就會用內置的type來創建這個類對象。

現在的問題就是，你可以在__metaclass__中放置些什麼代碼呢？答案就是：可以創建一個類的東西。那麼什麼可以用來創建一個類呢？type，或者任何使用到type或者子類化type的東東都可以。

8. 自定義元類

元類的主要目的就是為了當創建類時能夠自動地改變類。通常，你會為API做這樣的事情，你希望可以創建符合當前上下文的類。

假想一個很傻的例子，你決定在你的模塊里所有的類的屬性都應該是大寫形式。有好幾種方法可以辦到，但其中一種就是通過在模塊級別設定__metaclass__。採用這種方法，這個模塊中的所有類都會通過這個元類來創建，我們只需要告訴元類把所有的屬性都改成大寫形式就萬事大吉了。

幸運的是，__metaclass__實際上可以被任意調用，它並不需要是一個正式的類。所以，我們這裡就先以一個簡單的函數作為例子開始。

python2中

#-*- coding:utf-8 -*-
def upper_attr(future_class_name, future_class_parents, future_class_attr):

    #遍歷屬性字典，把不是__開頭的屬性名字變為大寫
    newAttr = {}
    for name,value in future_class_attr.items():
        if not name.startswith("__"):
            newAttr[name.upper()] = value

    #調用type來創建一個類
    return type(future_class_name, future_class_parents, newAttr)

class Foo(object):
    __metaclass__ = upper_attr #設置Foo類的元類為upper_attr
    bar = 'bip'

print(hasattr(Foo, 'bar'))
print(hasattr(Foo, 'BAR'))

f = Foo()
print(f.BAR)

python3中

#-*- coding:utf-8 -*-
def upper_attr(future_class_name, future_class_parents, future_class_attr):

    #遍歷屬性字典，把不是__開頭的屬性名字變為大寫
    newAttr = {}
    for name,value in future_class_attr.items():
        if not name.startswith("__"):
            newAttr[name.upper()] = value

    #調用type來創建一個類
    return type(future_class_name, future_class_parents, newAttr)

class Foo(object, metaclass=upper_attr):
    bar = 'bip'

print(hasattr(Foo, 'bar'))
print(hasattr(Foo, 'BAR'))

f = Foo()
print(f.BAR)

現在讓我們再做一次，這一次用一個真正的class來當做元類。

#coding=utf-8

class UpperAttrMetaClass(type):
    # __new__ 是在__init__之前被調用的特殊方法
    # __new__是用來創建對象並返回之的方法
    # 而__init__只是用來將傳入的參數初始化給對象
    # 你很少用到__new__，除非你希望能夠控制對象的創建
    # 這裡，創建的對象是類，我們希望能夠自定義它，所以我們這裡改寫__new__
    # 如果你希望的話，你也可以在__init__中做些事情
    # 還有一些高級的用法會涉及到改寫__call__特殊方法，但是我們這裡不用
    def __new__(cls, future_class_name, future_class_parents, future_class_attr):
        #遍歷屬性字典，把不是__開頭的屬性名字變為大寫
        newAttr = {}
        for name,value in future_class_attr.items():
            if not name.startswith("__"):
                newAttr[name.upper()] = value

        # 方法1：通過'type'來做類對象的創建
        # return type(future_class_name, future_class_parents, newAttr)

        # 方法2：復用type.__new__方法
        # 這就是基本的OOP編程，沒什麼魔法
        # return type.__new__(cls, future_class_name, future_class_parents, newAttr)

        # 方法3：使用super方法
        return super(UpperAttrMetaClass, cls).__new__(cls, future_class_name, future_class_parents, newAttr)

#python2的用法
class Foo(object):
    __metaclass__ = UpperAttrMetaClass
    bar = 'bip'

# python3的用法
# class Foo(object, metaclass = UpperAttrMetaClass):
#     bar = 'bip'

print(hasattr(Foo, 'bar'))
# 輸出: False
print(hasattr(Foo, 'BAR'))
# 輸出:True

f = Foo()
print(f.BAR)
# 輸出:'bip'

就是這樣，除此之外，關於元類真的沒有別的可說的了。但就元類本身而言，它們其實是很簡單的：

  • 攔截類的創建
  • 修改類
  • 返回修改之後的類
  • 究竟為什麼要使用元類？

現在回到我們的大主題上來，究竟是為什麼你會去使用這樣一種容易出錯且晦澀的特性？好吧，一般來說，你根本就用不上它：

“元類就是深度的魔法，99%的用戶應該根本不必為此操心。如果你想搞清楚究竟是否需要用到元類，那麼你就不需要它。那些實際用到元類的人都非常清楚地知道他們需要做什麼，而且根本不需要解釋為什麼要用元類。” —— Python界的領袖 Tim Peters


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 2020，我該何去何從
    有人說，我的人生會一帆風順，今天突然感覺到，是啊，我挺安分的。 1 大學畢業，面試拿到一個Offer就停止求職了。公司是一家國企，剛進來感覺用的技術挺新的，不像銀行等公司還在用老舊的技術，自己也沒心思去學那些，反而對比較新的技術更有興趣。一開始還想著，公司還是比較新鮮有活力的，可以待一待，但是慢慢的 ...
  • 入門訓練 序列求和
    問題描述 求1+2+3+...+n的值。 輸入格式 輸入包括一個整數n。 輸出格式 輸出一行，包括一個整數，表示1+2+3+...+n的值。 樣例輸入 4 樣例輸出 10 樣例輸入 100 說明：有一些試題會給出多組樣例輸入輸出以幫助你更好的做題。 一般在提交之前所有這些樣例都需要測試通過才行，但這 ...
  • Java比較器介面Comparable和Comparator
    一、為什麼會使用比較 在Java中經常會涉及到對象數組的排序問題，那麼就涉及到對象之間的比較問題， 說明：Java中的對象，正常情況下，只能進行比較：== 或 != 。不能使用 > 或 < 的 但是在開發場景中，我們需要對多個對象進行排序，言外之意，就需要比較對象的大小。 如何實現？使用兩個介面中的 ...
  • 關於分散式系統中雷同集群技術及原理，你知道多少？
    寫在前面 在當今信息爆炸的時代，單台電腦已經無法負載日益增長的業務發展，雖然也有性能強大的超級電腦，但是這種高端機不僅費用高昂，也不靈活，一般的企業是負擔不起的，而且也損失不起，那麼將一群廉價的普通電腦組合起來，讓它們協同工作就像一臺超級電腦一樣地對外提供服務，就成了順其自然的設想，但是這又 ...
  • java百貨中心供應鏈管理系統 源碼
    開發環境: Windows操作系統開發工具：MyEclipse/Eclipse + JDK+ Tomcat + MySQL 資料庫百貨中心供應鏈管理系統主要用於實現了企業管理數據統計等。本系統結構如下：（1）管理界面： 登錄模塊：實現管理員登錄功能； 合作公司管理模塊：實現合作公司信息的增加、修改、 ...
  • java中LinkedList源碼分析
    ArrayList是動態數組，其實本質就是對數組的操作。那麼LinkedList實現原理和ArrayList是完全不一樣的。現在就來分析一下ArrayList和LinkeList的優劣吧LinkedList是一個雙向鏈表，每個元素都是一個Node對象,這個node對象裡面有三個成員： E item; ...
  • Python屬性和內建屬性
    屬性property 1. 私有屬性添加getter和setter方法 2. 使用property升級getter和setter方法 運行結果: 3. 使用property取代getter和setter方法 @property成為屬性函數，可以對屬性賦值時做必要的檢查，並保證代碼的清晰短小，主要有2 ...
  • Python模塊進階、標準庫、擴展庫
    模塊進階 Python有一套很有用的標準庫(standard library)。標準庫會隨著Python解釋器，一起安裝在你的電腦中的。 它是Python的一個組成部分。這些標準庫是Python為你準備好的利器，可以讓編程事半功倍。 用標準庫 hashlib 應用實例 用於註冊、登錄.... 運行結 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類