python類的三種方法

一、先看語法，python 類語法中有三種方法，實例方法，靜態方法，類方法。

ps.python中self，cls的區別

普通實例方法，第一個參數需要是self，它表示一個具體的實例本身。
如果用了staticmethod，那么就可以無視這個self，而將這個方法當成一個普通的函數使用。
而對於classmethod，它的第一個參數不是self，是cls，它表示這個類本身。

# coding:utf-8
class Foo(object):
    """類三種方法語法形式"""
 
    def instance_method(self):
        print("是類{}的實例方法，只能被實例對象調用".format(Foo))
 
    @staticmethod
    def static_method():
        print("是靜態方法")
 
    @classmethod
    def class_method(cls):
        print("是類方法")
 
foo = Foo()
foo.instance_method()
foo.static_method()
foo.class_method()
print('----------------')
Foo.static_method()
Foo.class_method()

運行結果如下

是類<class '__main__.Foo'>的實例方法，只能被實例對象調用
是靜態方法
是類方法
----------------
是靜態方法
是類方法

說明：

實例方法只能被實例對象調用，靜態方法(由@staticmethod裝飾的方法)、類方法(由@classmethod裝飾的方法)，可以被類或類的實例對象調用。

實例方法，第一個參數必須要默認傳實例對象，一般習慣用self。
靜態方法，參數沒有要求。

類方法，第一個參數必須要默認傳類，一般習慣用cls。

二、靜態方法、類方法使用區別或者說使用場景

1、類方法用在模擬java定義多個構造函數的情況。

 由於python類中只能有一個初始化方法，不能按照不同的情況初始化類。

參考django https://docs.djangoproject.com/en/1.9/ref/models/instances/ 請看下面的代碼。

# coding:utf-8
class Book(object):
 
    def __init__(self, title):
        self.title = title
 
    @classmethod
    def class_method_create(cls, title):
        book = cls(title=title)
        return book
 
    @staticmethod
    def static_method_create(title):
        book= Book(title)
        return book
 
book1 = Book("use instance_method_create book instance")
book2 = Book.class_method_create("use class_method_create book instance")
book3 = Book.static_method_create("use static_method_create book instance")
print(book1.title)
print(book2.title)
print(book3.title)

結果：

use instance_method_create book instance
use class_method_create book instance
use static_method_create book instance

Process finished with exit code 0

特別說明，靜態方法也可以實現上面功能，當靜態方法每次都要寫上類的名字，不方便。

2、類中靜態方法方法調用靜態方法和類方法調用靜態方法例子。

下面的代碼，靜態方法調用另一個靜態方法，如果改用類方法調用靜態方法，可以讓cls代替類，

讓代碼看起來精簡一些。也防止類名修改了，不用在類定義中修改原來的類名。

# coding:utf-8
class Foo(object):
    X = 1
    Y = 2
 
    @staticmethod
    def averag(*mixes):
        return sum(mixes) / len(mixes)
 
    @staticmethod
    def static_method():  # 在靜態方法中調用靜態方法
        print "在靜態方法中調用靜態方法"
        return Foo.averag(Foo.X, Foo.Y)
 
    @classmethod
    def class_method(cls):  # 在類方法中使用靜態方法
        print "在類方法中使用靜態方法"
        return cls.averag(cls.X, cls.Y)
 
foo = Foo()
print(foo.static_method())
print(foo.class_method())

結果：

在靜態方法中調用靜態方法
1
在類方法中使用靜態方法
1

3、繼承類中的區別 

從下面代碼可以看出，如果子類繼承父類的方法，子類覆蓋了父類的靜態方法，
子類的實例繼承了父類的static_method靜態方法，調用該方法，還是調用的父類的方法和類屬性。

子類的實例繼承了父類的class_method類方法，調用該方法，調用的是子類的方法和子類的類屬性。

# coding:utf-8
class Foo(object):
    X = 1
    Y = 14
 
    @staticmethod
    def averag(*mixes):  # "父類中的靜態方法"
        return sum(mixes) / len(mixes)
 
    @staticmethod
    def static_method():  # "父類中的靜態方法"
        print "父類中的靜態方法"
        return Foo.averag(Foo.X, Foo.Y)
 
    @classmethod
    def class_method(cls):  # 父類中的類方法
        print "父類中的類方法"
        return cls.averag(cls.X, cls.Y)
 
 
class Son(Foo):
    X = 3
    Y = 5
 
    @staticmethod
    def averag(*mixes):  # "子類中重載了父類的靜態方法"
        print "子類中重載了父類的靜態方法"
        print "666 ",mixes
        return sum(mixes) / 3
 
p = Son()
print "result of p.averag(1,5)"
print (p.averag(1,5))
print "result of p.static_method()"
print(p.static_method())
print "result of p.class_method()"
print(p.class_method())

結果如下：

result of p.averag(1,5)
子類中重載了父類的靜態方法
666  (1, 5)
2
result of p.static_method()
父類中的靜態方法
7
result of p.class_method()
父類中的類方法
子類中重載了父類的靜態方法
666  (3, 5)
2

Process finished with exit code 0