python 静态方法，类方法，实例方法的区别

实例方法：

顾名思义就是给实例使用的方法。
　　就是我们使用最普遍的在类内部定义的方法。

实例方法第一个参数为 self。self表示当前调用此方法的实例，相当于其他语言中的this。

实例方法可以调用实例属性，也可以调用类属性。类属性的调用有两种格式：self.类属性 ， 类名.类属性。两种都是一样的。但是不要使用self来调用类属性！类属性是给类使用的，一定要用类名去调用。

实例方法必须通过实例来调用

实例属性：以self.属性 格式的属性都为实例属性。实例方法是属于实例的，每个实例都有单独的实例属性。
　　类属性：在类内部方法的外部定义的属性，不以self.属性的格式的属性。类属性是属于类的。所有当前类的 实例 都共享 类 的类属性。
　　类属性 相当于java中的 static 属性。

class Foo(object):
    class_property = '类属性'

    def __init__(self):
        self.instance_property = '实例属性'

    def say(self):
        print '实例方法'
        print '调用实例属性---',self.instance_property
        #两种是一样的，但是切记：类属性要用类名去调用
        #print '调用类属性---',self.class_property
        print '调用类属性---',Foo.class_property

if __name__ == '__main__':
    my_foo = Foo()
    my_foo.say()     #必须通过实例来调用

类方法：

顾名思义，类方法就是给类使用的方法。
　　类方式用 @classmethod装饰器修饰。用@classmethod装饰器修饰的方法都是类方法。
　　类方法第一个参数为cls，cls表示当前类。
　　类方法可以调用类属性，但是不能调用实例属性，也不能调用实例方法。
　　类方法有两种调用方式：
　　　　类名.类方法
　　　　实例.类方法。
　　　两种是一样的。但是 切记 类方法是给类使用的 不要使用实例去调用类方法。一定要用类名去调用。
　　类方法相当于 Java中的 static方法。

class Foo(object):
    class_property = '类属性'

    def __init__(self):
        self.instance_property = '实例属性'

    def say(self):
        print '实例方法'
        print '调用实例属性---',self.instance_property
        print '调用类属性---',Foo.class_property

    @classmethod
    def class_say(cls):
        print '类方法'
        #无法调用实例属性，会报错
        #print '调用实例属性',cls.instance_property
        #无法调用实例方法，会报错
        #cls.say()
        print '调用类属性',cls.class_property

if __name__ == '__main__':
    Foo.class_say()

    #这样调用也可以，但是千万不要这样做
    # my_foo = Foo()
    # my_foo.class_say()
    

静态方法：

静态方法是一种普通函数，位于类定义内部。
　　静态方法以@staticmethod装饰器修饰。以@staticmethod修饰的方法都是静态方法。
　　静态方法无法调用实例属性，实例方法。
　　静态方法内部必须使用 类名.类实例，类名.类方法 这样的格式才能调用类属性与类方法，否则无法调用。
　　静态方法与类方法一样 都是属于类。
　　静态方法有两种调用方式：
　　　　类名.静态方法
　　　　实例.静态方法
　　　两种是一样的。但是 切记 静态方法是给类使用的 不要使用实例去调用静态方法。一定要用类名去调用。

class Foo(object):
    class_property = '类属性'

    def __init__(self):
        self.instance_property = '实例属性'

    def say(self):
        print '实例方法'
        print '调用实例属性---',self.instance_property
        print '调用类属性---',Foo.class_property

    @classmethod
    def class_say(cls):
        print '类方法'
        print '调用类属性',cls.class_property

    @staticmethod
    def static_say():
        print '静态方法'
        #必须以类名.类方法或实例,才能调用类方法或者类属性，否则不能调用
        print '调用类属性',Foo.class_property
        print '调用类方法',Foo.class_say()

if __name__ == '__main__':
    Foo.static_say()

    #这样调用也可以，但是千万不要这样做
    # my_foo = Foo()
    # my_foo.static_say()

为什么要存在类方法？
　　比如：我们需要进行数据库操作，创建数据库连接只需要进行一次即可，不需要每次都创建数据库连接。
　　类方法中的类实例只会初始化一次，以后每次调用均是同一个类属性，并不会再次初始化。只要调用一次以后，不管在任何模块中调用都不会在初始化。

class Foo(object):
    class_property = None

    @classmethod
    def class_say(cls):
        print '类方法'
        print '类属性--',cls.class_property
        print '类属性 id ',id(cls.class_property)
        if cls.class_property == None:
            cls.class_property = time.time()
        print '****调用类属性',cls.class_property
        print '****调用雷属性 id ',id(cls.class_property)

    @staticmethod
    def static_say():
        print '静态方法'
        #必须以类名.类方法或实例,才能调用类方法或者类属性，否则不能调用
        print '****调用类属性',Foo.class_property
        print '****调用类方法',Foo.class_say()

if __name__ == '__main__':
    Foo.class_say()
    print '-------'
    Foo.class_say()
    print '-------'

    print '实例'
    foo = Foo2()
    foo2 = Foo2()

    foo.say()
    foo2.say()

运行结果如下：

image.png

我们可以看到 类属性只进行了一次初始化，以后的调用均是同一个类实例。
实例属性则是，每建立一个实例就会初始化一次，除非你只要一个实例，在单个模块中这样可以，但是在多个模块中这是不可能的。
我们看一个多个模块中的情况：

#coding=utf-8
#test2.py
import time

class Foo(object):
    class_property = None

    @classmethod
    def class_say(cls):
        print '类方法'
        print '类属性--',cls.class_property
        print '类属性 id ',id(cls.class_property)
        if cls.class_property == None:
            cls.class_property = time.time()
        print '****调用类属性',cls.class_property
        print '****调用雷属性 id ',id(cls.class_property)

class Foo2(object):
    def __init__(self):
        self.instanlce_property = None

    def say(self):
        print '实例方法'
        print '调用实例属性 --',self.instanlce_property
        print '实例属性 id',id(self.instanlce_property)
        if self.instanlce_property == None:
            self.instanlce_property = time.time()
        print '****调用实例属性  --', self.instanlce_property
        print '****实例属性   id', id(self.instanlce_property)

#coding=utf-8
#test4.py
import test2

def test4_class_foo():
    print '类属性 test4模块'
    foo = test2.Foo
    foo.class_say()

def test4_instance_foo():
    print '实例 test4模块'
    foo2 = test2.Foo2()
    foo2.say()

coding=utf-8
#test3.py
import test2
import test4

def test3_class_foo():
    print '类属性 test3模块'
    foo = test2.Foo
    foo.class_say()

def test3_instanlce_foo():
    print '实例属性 test3模块'
    foo2 = test2.Foo2()
    foo2.say()

if __name__ == '__main__':
    test3_class_foo()
    test4.test4_class_foo()
    print '实例-----------'
    test3_instanlce_foo()
    test4.test4_instance_foo()

运行结果如下：

image.png

可以清楚的看到 不同模块之间 类属性只初始化一次，实例属性则是，每建立一个实例就会初始化一次。除非你只要一个实例，在单个模块中这样可以，但是在多个模块中这是不可能的

静态方法与类方法的用途是一样的，没什么区别。
但是为什么要存在静态方法呢？

为了更加面向对象设计（oop）

首先，静态方法就是一普通函数
　　其次，静态方法是与类无关的。也就是说 静态方法实现的功能可以是与所存在的类所实现的功能没有任何关系。类方法的功能，则是与类所实现的功能相关联的。打个比方就是 ：类方法相当于类的亲儿子，静态方法就相当于收养的流浪猫。
　　oop的思想是 一切以类为基础。
　　为了更加oop，所有说就把普通函数塞进来类里面，这就是静态方。