詳解Python中魔法方法的使用

Posted on by

python中的魔法方法是一些可以讓你對類添加“魔法”的特殊方法,它們經常是兩個下劃線包圍來命名的

Python的魔法方法，也稱為dunder(雙下劃線)方法。大多數的時候，我們將它們用於簡單的事情，例如構造函數(__init__)、字符串表示(__str__， __repr__)或算術運算符(__add__/__mul__)。其實還有許多你可能沒有聽說過的但是卻很好用的方法，在這篇文章中，我們將整理這些魔法方法!

迭代器的大小

我們都知道__len__方法，可以用它在容器類上實現len()函數。但是，如果您想獲取實現迭代器的類對象的長度怎麼辦?

it = iter(range(100))
 print(it.__length_hint__())
 # 100
 next(it)
 print(it.__length_hint__())
 # 99
 
 a = [1, 2, 3, 4, 5]
 it = iter(a)
 print(it.__length_hint__())
 # 5
 next(it)
 print(it.__length_hint__())
 # 4
 a.append(6)
 print(it.__length_hint__())
 # 5

你所需要做的就是實現__length_hint__方法，這個方法是迭代器上的內置方法(不是生成器)，正如你上面看到的那樣，並且還支持動態長度更改。但是，正如他的名字那樣，這隻是一個提示（hint），並不能保證完全準確:對於列表迭代器，可以得到準確的結果，但是對於其他迭代器則不確定。但是即使它不準確，它也可以幫我們獲得需要的信息，正如PEP 424中解釋的那樣

length_hint must return an integer (else a TypeError is raised) or NotImplemented, and is not required to be accurate. It may return a value that is either larger or smaller than the actual size of the container. A return value of NotImplemented indicates that there is no finite length estimate. It may not return a negative value (else a ValueError is raised).

元編程

大部分很少看到的神奇方法都與元編程有關，雖然元編程可能不是我們每天都需要使用的東西，但有一些方便的技巧可以使用它。

一個這樣的技巧是使用__init_subclass__作為擴展基類功能的快捷方式，而不必處理元類:

class Pet:
     def __init_subclass__(cls, /, default_breed, **kwargs):
         super().__init_subclass__(**kwargs)
         cls.default_breed = default_breed
 
 class Dog(Pet, default_name="German Shepherd"):
     pass

上面的代碼我們向基類添加關鍵字參數，該參數可以在定義子類時設置。在實際用例中可能會在想要處理提供的參數而不僅僅是賦值給屬性的情況下使用此方法。

看起來非常晦澀並且很少會用到，但其實你可能已經遇到過很多次瞭，因為它一般都是在構建API時使用的，例如在SQLAlchemy或Flask Views中都使用到瞭。

另一個元類的神奇方法是__call__。這個方法允許自定義調用類實例時發生的事情:

class CallableClass:
     def __call__(self, *args, **kwargs):
         print("I was called!")
 
 instance = CallableClass()
 
 instance()
 # I was called!

可以用它來創建一個不能被調用的類:

class NoInstances(type):
     def __call__(cls, *args, **kwargs):
         raise TypeError("Can't create instance of this class")
 
 class SomeClass(metaclass=NoInstances):
     @staticmethod
     def func(x):
         print('A static method')
 
 instance = SomeClass()
 # TypeError: Can't create instance of this class

對於隻有靜態方法的類，不需要創建類的實例就用到瞭這個方法。

另一個類似的場景是單例模式——一個類最多隻能有一個實例:

class Singleton(type):
     def __init__(cls, *args, **kwargs):
         cls.__instance = None
         super().__init__(*args, **kwargs)
 
     def __call__(cls, *args, **kwargs):
         if cls.__instance is None:
             cls.__instance = super().__call__(*args, **kwargs)
             return cls.__instance
         else:
             return cls.__instance
 
 class Logger(metaclass=Singleton):
     def __init__(self):
         print("Creating global Logger instance")

Singleton類擁有一個私有__instance——如果沒有，它會被創建並賦值，如果它已經存在，它隻會被返回。

假設有一個類，你想創建它的一個實例而不調用__init__。__new__ 方法可以幫助解決這個問題:

class Document:
     def __init__(self, text):
         self.text = text
 
 bare_document = Document.__new__(Document)
 print(bare_document.text)
 # AttributeError: 'Document' object has no attribute 'text'
 
 setattr(bare_document, "text", "Text of the document")

在某些情況下，我們可能需要繞過創建實例的通常過程，上面的代碼演示瞭如何做到這一點。我們不調用Document(…)，而是調用Document.__new__(Document)，它創建一個裸實例，而不調用__init__。因此，實例的屬性(在本例中為text)沒有初始化，所欲我們需要額外使用setattr函數賦值(它也是一個魔法的方法__setattr__)。

為什麼要這麼做呢。因為我們可能會想要替代構造函數，比如:

class Document:
     def __init__(self, text):
         self.text = text
     
     @classmethod
     def from_file(cls, file):  # Alternative constructor
         d = cls.__new__(cls)
         # Do stuff...
         return d

這裡定義from_file方法，它作為構造函數，首先使用__new__創建實例，然後在不調用__init__的情況下配置它。

下一個與元編程相關的神奇方法是__getattr__。當普通屬性訪問失敗時調用此方法。這可以用來將對缺失方法的訪問/調用委托給另一個類:

class String:
     def __init__(self, value):
         self._value = str(value)
 
     def custom_operation(self):
         pass
 
     def __getattr__(self, name):
         return getattr(self._value, name)
 
 s = String("some text")
 s.custom_operation()  # Calls String.custom_operation()
 print(s.split())  # Calls String.__getattr__("split") and delegates to str.split
 # ['some', 'text']
 
 print("some text" + "more text")
 # ... works
 print(s + "more text")
 # TypeError: unsupported operand type(s) for +: 'String' and 'str'

我們想為類添加一些額外的函數(如上面的custom_operation)定義string的自定義實現。但是我們並不想重新實現每一個字符串方法，比如split、join、capitalize等等。這裡我們就可以使用__getattr__來調用這些現有的字符串方法。

雖然這適用於普通方法，但請註意，在上面的示例中，魔法方法__add__（提供的連接等操作）沒有得到委托。所以，如果我們想讓它們也能正常工作，就必須重新實現它們。

自省(introspection)

最後一個與元編程相關的方法是__getattribute__。它一個看起來非常類似於前面的__getattr__，但是他們有一個細微的區別，__getattr__隻在屬性查找失敗時被調用，而__getattribute__是在嘗試屬性查找之前被調用。

所以可以使用__getattribute__來控制對屬性的訪問，或者你可以創建一個裝飾器來記錄每次訪問實例屬性的嘗試:

def logger(cls):
     original_getattribute = cls.__getattribute__
 
     def getattribute(self, name):
         print(f"Getting: '{name}'")
         return original_getattribute(self, name)
 
     cls.__getattribute__ = getattribute
     return cls
 
 @logger
 class SomeClass:
     def __init__(self, attr):
         self.attr = attr
 
     def func(self):
         ...
 
 instance = SomeClass("value")
 instance.attr
 # Getting: 'attr'
 instance.func()
 # Getting: 'func'

裝飾器函數logger 首先記錄它所裝飾的類的原始__getattribute__方法。然後將其替換為自定義方法，該方法在調用原始的__getattribute__方法之前記錄瞭被訪問屬性的名稱。

魔法屬性

到目前為止，我們隻討論瞭魔法方法，但在Python中也有相當多的魔法變量/屬性。其中一個是__all__:

# some_module/__init__.py
 __all__ = ["func", "some_var"]
 
 some_var = "data"
 some_other_var = "more data"
 
 def func():
     return "hello"
 
 # -----------
 
 from some_module import *
 
 print(some_var)
 # "data"
 print(func())
 # "hello"
 
 print(some_other_var)
 # Exception, "some_other_var" is not exported by the module

這個屬性可用於定義從模塊導出哪些變量和函數。我們創建瞭一個Python模塊…/some_module/單獨文件(__init__.py)。在這個文件中定義瞭2個變量和一個函數，隻導出其中的2個(func和some_var)。如果我們嘗試在其他Python程序中導入some_module的內容，我們隻能得到2個內容。

但是要註意，__all__變量隻影響上面所示的* import，我們仍然可以使用顯式的名稱導入函數和變量，比如import some_other_var from some_module。

另一個常見的雙下劃線變量(模塊屬性)是__file__。這個變量標識瞭訪問它的文件的路徑:

from pathlib import Path
 
 print(__file__)
 print(Path(__file__).resolve())
 # /home/.../directory/examples.py
 
 # Or the old way:
 import os
 print(os.path.dirname(os.path.abspath(__file__)))
 # /home/.../directory/

這樣我們就可以結合__all__和__file__，可以在一個文件夾中加載所有模塊:

# Directory structure:
 # .
 # |____some_dir
 #   |____module_three.py
 #   |____module_two.py
 #   |____module_one.py
 
 from pathlib import Path, PurePath
 modules = list(Path(__file__).parent.glob("*.py"))
 print([PurePath(f).stem for f in modules if f.is_file() and not f.name == "__init__.py"])
 # ['module_one', 'module_two', 'module_three']

最後一個我重要的屬性是的是__debug__。它可以用於調試，但更具體地說，它可以用於更好地控制斷言:

# example.py
 def func():
     if __debug__:
         print("debugging logs")
 
     # Do stuff...
 
 func()

如果我們使用

python example.py

正常運行這段代碼，我們將看到打印出“調試日志”，但是如果我們使用

python -O example.py

，優化標志(-O)將把__debug__設置為false並刪除調試消息。因此，如果在生產環境中使用-O運行代碼，就不必擔心調試過程中被遺忘的打印調用，因為它們都不會顯示。

創建自己魔法方法

我們可以創建自己的方法和屬性嗎?是的，你可以，但你不應該這麼做。

雙下劃線名稱是為Python語言的未來擴展保留的，不應該用於自己的代碼。如果你決定在你的代碼中使用這樣的名稱，那麼將來如果它們被添加到Python解釋器中，這就與你的代碼不兼容瞭。所以對於這些方法，我們隻要記住和使用就好瞭。

到此這篇關於詳解Python中魔法方法的使用的文章就介紹到這瞭,更多相關Python魔法方法內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：