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()

例項方法只能被例項物件呼叫。
靜態方法(由@staticmethod裝飾的方法)、類方法(由@classmethod裝飾的方法)，可以被類或類的例項物件呼叫。
例項方法，第一個引數必須要預設傳例項物件，一般習慣用self。
靜態方法，引數沒有要求。
類方法，第一個引數必須要預設傳類，一般習慣用cls。
又例如：

class Room:
    tag = 1

    def __init__(self, name, owner, width, length, heigh):
        self.name = name
        self.owner = owner
        self.width = width
        self.length = length
        self.heigh = heigh

    @property
 

    def cal_area(self):
        return self.width * self.length

    def test(self):
        print('from test', self.name)

    @classmethod
    def tell_info(cls, x):
        print(cls)
        print('-->>', cls.tag, x)

    @staticmethod
    def wash_body(a, b, c):
        print('{}\n{}\n{}'
 
.format(a, b, c))


r = Room('廁所', 'alex', 100, 100, 100000)
print(r.name)
print(r.cal_area)
r.test()

Room.tell_info(10)
Room.test(r)
print('------')
r.tell_info(20)
print('--------')
Room.wash_body('alex', 'yuanhao', 'wupeiqi')
r.wash_body('alex', 'yuanhao', 'wupeiqi')
------------------------------------------------
輸出：

廁所
10000
from test 廁所
<class '__main__.Room'>
-->> 1 10
from test 廁所
------
<class '__main__.Room'>
-->> 1 20
--------
alex
yuanhao
wupeiqi
alex
yuanhao
wupeiqi

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

# coding:utf-8


class Book(object):

    def __init__(self, title):
        self.title = title

    @classmethod
    def create(cls, title):
        book = cls(title=title)
        return book

book1 = Book("python")
book2 = Book.create("python and django")
print(book1.title)
print(book2.title)

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

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():
        return Foo.averag(Foo.X, Foo.Y)

    @classmethod
    def class_method(cls):
        return cls.averag(cls.X, cls.Y)

foo = Foo()
print(foo.static_method())
print(foo.class_method())

3、繼承類中的區別
從下面程式碼可以看出，如果子類繼承父類的方法，子類覆蓋了父類的靜態方法，
子類的例項繼承了父類的static_method靜態方法，呼叫該方法，還是呼叫的父類的方法和類屬性。
子類的例項繼承了父類的class_method類方法，呼叫該方法，呼叫的是子類的方法和子類的類屬性。

# coding:utf-8


class Foo(object):
    X = 1
    Y = 2

    @staticmethod
    def averag(*mixes):
        return sum(mixes) / len(mixes)

    @staticmethod
    def static_method():
        return Foo.averag(Foo.X, Foo.Y)

    @classmethod
    def class_method(cls):
        return cls.averag(cls.X, cls.Y)


class Son(Foo):
    X = 3
    Y = 5

    @staticmethod
    def averag(*mixes):
        return sum(mixes) / 3

p = Son()
print(p.static_method())
print(p.class_method())
# 1.5
# 2.6666666666666665