python 类的类方法、实例方法和静态方法

一、python 类语法中有三种方法，实例方法，静态方法，类方法。

1、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('*'*20)
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

说明：静态方法也可以实现上面功能，当静态方法每次都要写上类的名字，不方便。

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)
 
print(Foo.static_method())
print(Foo.class_method())

在静态方法中调用静态方法
1.5
在类方法中使用静态方法
1.5

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():  # "父类中的静态方法"
        print("父类中的静态方法")
        return Foo.averag(Foo.X, Foo.Y)
 
    @classmethod
    def class_method(cls):  # 父类中的类方法
        print("父类中的类方法")
        print(cls.X, cls.Y)
        return cls.averag(cls.X, cls.Y)
 
 
class Son(Foo):
    X = 3 
    Y = 5 
 
    @staticmethod
    def averag(*mixes):  # "子类中重载了父类的静态方法"
        print("子类中重载了父类的静态方法")
        return sum(mixes) / 3 
 
print("result of p.averag(1,5)")
print(Son.averag(1,5))
print("result of p.static_method()")
print(Son.static_method())
print("result of p.class_method()")
print(Son.class_method())

result of p.averag(1,5)
子类中重载了父类的静态方法
2.0
result of p.static_method()
父类中的静态方法
1.5
result of p.class_method()
父类中的类方法
3 5
子类中重载了父类的静态方法
2.6666666666666665