[[386004]]

在Python語言中有如下3種方法：

• 成員方法
• 類方法(classmethod)
• 靜態方法(staticmethod)

可能很多同學不清楚這3種方法，尤其是后兩類方法到底有什么不同。為此，本文將對這3種方法做一次敲骨瀝髓的深度剖析。

先說一下這3種方法的差異，了解差異后，就自然了解他們的區別了。

這3種方法有如下3點差異：

• 方法定義
• 調用方式
• 方法歸屬

1. 方法定義

這3種方法在定義上有如下2點不同。

(1)是否使用裝飾器

成員方法不需要使用任何裝飾器，直接使用def關鍵字定義方法即可，代碼如下：

def method(self, a, b, c): 
    pass 

類方法必須使用@classmethod裝飾器修飾，代碼如下：

@classmethod 
def method(cls, a, b, c): 
    pass 

靜態方法必須使用@staticmethod裝飾器修飾，代碼如下：

@staticmethod 
def method(a, b, c): 
    pass 

(2)參數不同

成員方法與類方法，除正常的方法參數外，都必須多加一個參數，這個參數必須是方法的第1個參數。參數可以是任意名，但通常成員方法的第1個參數名是self，類方法的第1個參數名是cls。而靜態方法不需要加額外的參數。見前面代碼中的method方法。

self和cls分別表示類實例和類本身，這一點在后面會詳細介紹。

下面看一個完整定義這3種方法的代碼：

class MyClass(object): 
    # 成員方法    
    def foo(self, x): 
        print("executing foo(%s, %s)" % (self, x)) 
    # 類方法 
    @classmethod 
    def class_foo(cls, x): 
        print("executing class_foo(%s, %s)" % (cls, x)) 
    # 靜態方法  
    @staticmethod 
    def static_foo(x): 
        print("executing static_foo(%s)" % x) 

2. 調用方式

(1)調用成員方法

成員方法只能通過類實例調用，代碼如下：

my = MyClass() 
 
my.foo(20) 

在定義成員方法時，第一個參數是表示類實例的self，這個參數并不需要在調用時顯式指定，而是由Python運行時自動處理。對于上面的調用代碼，Python運行時會自動將表示MyClass實例的my傳入foo方法。所以my就是foo方法中第一個參數self的值。通過self，在方法內部可以引用MyClass實例的其他成員。

執行這段代碼，會輸出如下內容。很明顯，self是一個對象，首地址是0x7f7f1003df70

executing foo(<__main__.MyClass object at 0x7f7f1003df70>, 20) 

(2)調用類方法

類方法可以通過類實例調用，也可以直接通過類本身調用，代碼如下：

my = MyClass() 
# 通過類實例調用 
my.class_foo(20) 
# 通過類本身調用 
MyClass.class_foo(20) 

執行這段代碼，會輸出如下內容：

executing class_foo(<class '__main__.MyClass'>, 20) 
executing class_foo(<class '__main__.MyClass'>, 20) 

很明顯，class_foo方法的cls參數不再是類的實例(因為沒有對象地址)，而是MyClass類本身。所以不管使用哪一種方式調用類方法，傳入class_foo方法第1個參數的值都是類本身。所以通過類方法，可以獲取類的靜態資源，與直接引用MyClass是一樣的。

(3)調用靜態方法

調用靜態方法與調用類方法一樣，都可以通過類實例或類本身調用，從這一點看不出來哪一個是類方法，哪一個是靜態方法，代碼如下：

my = MyClass() 
MyClass.static_foo(20) 
my.static_foo('hello') 

執行這段代碼，會輸出如下內容：

executing static_foo(20) 
executing static_foo(hello) 

由于在定義靜態方法時并沒有指定任何額外的參數，所以靜態方法并沒有與類或類實例綁定，當然，在靜態方法中，仍然可以通過MyClass引用類中的靜態成員。

3. 方法歸屬

方法歸屬是這3種方法的重要區別，可以分別將這3種方法作為屬性輸出，看看是什么結果。

my = MyClass()) 
# 輸出成員方法 
print(my.foo) 
# 輸出類方法 
print(my.class_foo) 
# 輸出靜態方法 
print(my.static_foo) 

執行這段代碼，會輸出如下內容：

<bound method MyClass.foo of <__main__.MyClass object at 0x7f7f1003df70>> 
<bound method MyClass.class_foo of <class '__main__.MyClass'>> 
<function MyClass.static_foo at 0x7f7f1003ad30> 

從輸出結果可以看到，成員方法綁定到了類實例中(該方法屬于類實例)，類方法與類本身綁定，而靜態方法就是一個獨立的對象(因為有對象首地址)，不屬于任何類或實例。

從以上3個方法我們已經可以得出classmethod方法與staticmethod的區別，下面總結一下：

4. 總結

(1)共同點

classmethod方法與staticmethod方法的共同點只有一個，就是調用時，既可以使用類實例，也可以直接用類本身調用。所以從調用上，根本分不出是類方法，還是靜態方法。

(2)差異

類方法顧名思義，是與類綁定的，相當于下面的調用方式：

def process(cls, x): 
    print(cls,x) 
MyClass.process = process 
# 調用process方法時直接傳入了MyClass 
MyClass.process(MyClass, 20) 

只是類方法在調用時自動傳入了MyClass，而上面的代碼是顯式傳入MyClass的，但最終效果是完全一樣的。

而靜態方法其實就是一個寄居蟹，完全不屬于它的宿主。只是寄居在類中。換句話說，直接將靜態方法從類中移出來作為獨立的函數，完全不需要修改一行代碼就可以直接運行。因為靜態方法不會訪問類中的任何成員，當然，可能訪問類的靜態成員，但也是使用類本身(如MyClass)，這種訪問方式，獨立的函數同樣可以。

其實Python提供靜態方法倒不是非常必要，不過Java就很有必要了。由于Python支持獨立的函數形式，所以不使用靜態方法，也可以使用獨立的函數。通常獨立的函數可以全局訪問(在一個模塊訪問另外一個模塊中的函數)。而Java是純面向對象語言，并不支持獨立函數。所以為了實現這種全局調用的效果，Java類提供了靜態方法，可以通過MyClass.process(...)的形式在其他類訪問MyClass中的process方法。

不過Python中的靜態方法到是有一個作用，就是分組。如果模塊中有大量的獨立函數，而且這些獨立函數的功能可能完全不同，就顯得比較亂，所以通常的做法是將這些獨立函數作為Python類的靜態方法，將同一類型的獨立函數放到一個類中，這樣就會讓整個代碼結構顯得更有調理。就像將文件存放在硬盤上一樣，如果將所有的文件都放在一個目錄中，找文件會很費勁。所以需要將同一類文件放到特定的目錄中，這樣看起來目錄結構更清晰。所以靜態方法與Python類，就相當于文件與目錄的關系，主要就是起到分類的作用。

(3)使用場景

如果只是描述類的一般的動作，而且類的不同實例，動作的表現可能還不同，那么就用成員方法，例如，move(移動)、fly(飛)、getAge(如不同Person類的實例，可能年齡是不同的)等。

類方法與靜態方法大多數時候可以互換，但如果想讓方法保持獨立，應該使用靜態方法，因為靜態方法不需要多余的參數接收類或類實例。

本文轉載自微信公眾號「極客起源」，可以通過以下二維碼關注。轉載本文請聯系極客起源公眾號。