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


参考网址：https://zhuanlan.zhihu.com/p/21101992

在 Python 中，实例方法（instance method），类方法（class method）与静态方法（static method）经常容易混淆。本文通过代码例子来说明它们的区别。



实例方法

Python 的实例方法用得最多，也最常见。我们先来看 Python 的实例方法。



class Kls(object):
    def __init__(self, data):
        self.data = data

    def printd(self):
        print(self.data)


ik1 = Kls('leo')
ik2 = Kls('lee')

ik1.printd()
ik2.printd()

输出：


  
leo 

  lee


上述例子中，printd为一个实例方法。实例方法第一个参数为self，当使用ik1.printd()调用实例方法时，实例ik1会传递给self参数，这样self参数就可以引用当前正在调用实例方法的实例。利用实例方法的这个特性，上述代码正确输出了两个实例的成员数据。



类方法

Python 的类方法采用装饰器@classmethod来定义，我们直接看例子。



class Kls(object):
    num_inst = 0

    def __init__(self):
        Kls.num_inst = Kls.num_inst + 1

    @classmethod
    def get_no_of_instance(cls):
        return cls.num_inst


ik1 = Kls()
ik2 = Kls()

print ik1.get_no_of_instance()
print Kls.get_no_of_instance()

输出：


  
2 

  2


在上述例子中，我们需要统计类Kls实例的个数，因此定义了一个类变量num_inst来存放实例个数。通过装饰器@classmethod的使用，方法get_no_of_instance被定义成一个类方法。在调用类方法时，Python 会将类（class Kls）传递给cls，这样在get_no_of_instance内部就可以引用类变量num_inst。 

由于在调用类方法时，只需要将类型本身传递给类方法，因此，既可以通过类也可以通过实例来调用类方法。



静态方法

在开发中，我们常常需要定义一些方法，这些方法跟类有关，但在实现时并不需要引用类或者实例，例如，设置环境变量，修改另一个类的变量，等。这个时候，我们可以使用静态方法。 

Python 使用装饰器@staticmethod来定义一个静态方法。



IND = 'ON'


class Kls(object):
    def __init__(self, data):
        self.data = data

    @staticmethod
    def checkind():
        return IND == 'ON'

    def do_reset(self):
        if self.checkind():
            print('Reset done for: %s' % self.data)

    def set_db(self):
        if self.checkind():
            print('DB connection made for: %s' % self.data)


ik1 = Kls(24)
ik1.do_reset()
ik1.set_db()

输出：


  
Reset done for: 24 

  DB connection made for: 24


在代码中，我们定义了一个全局变量IND，由于IND跟类Kls相关，所以我们将方法checkind放置在类Kls中定义。方法checkind只需检查IND的值，而不需要引用类或者实例，因此，我们将方法checkind定义为静态方法。 

对于静态方法，Python 并不需要传递类或者实例，因此，既可以使用类也可以使用实例来调用静态方法。



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

我们用代码说明实例方法，类方法，静态方法的区别。注意下述代码中方法foo，class_foo，static_foo的定义以及使用。



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


ik = Kls()

# 实例方法
ik.foo(1)
print(ik.foo)
print('==========================================')

# 类方法
ik.class_foo(1)
Kls.class_foo(1)
print(ik.class_foo)
print('==========================================')

# 静态方法
ik.static_foo(1)
Kls.static_foo('hi')
print(ik.static_foo)

输出：



executing foo(<__main__.Kls object at 0x0551E190>,1)
<bound method Kls.foo of <__main__.Kls object at 0x0551E190>>
==========================================
executing class_foo(<class '__main__.Kls'>,1)
executing class_foo(<class '__main__.Kls'>,1)
<bound method type.class_foo of <class '__main__.Kls'>>
==========================================
executing static_foo(1)
executing static_foo(hi)
<function static_foo at 0x055238B0>

对于实例方法，调用时会把实例ik作为第一个参数传递给self参数。因此，调用ik.foo(1)时输出了实例ik的地址。

对于类方法，调用时会把类Kls作为第一个参数传递给cls参数。因此，调用ik.class_foo(1)时输出了Kls类型信息。 

前面提到，可以通过类也可以通过实例来调用类方法，在上述代码中，我们再一次进行了验证。

对于静态方法，调用时并不需要传递类或者实例。其实，静态方法很像我们在类外定义的函数，只不过静态方法可以通过类或者实例来调用而已。

值得注意的是，在上述例子中，foo只是个函数，但当调用ik.foo的时候我们得到的是一个已经跟实例ik绑定的函数。调用foo时需要两个参数，但调用ik.foo时只需要一个参数。foo跟ik进行了绑定，因此，当我们打印ik.foo时，会看到以下输出:



<bound method Kls.foo of <__main__.Kls object at 0x0551E190>>

当调用ik.class_foo时，由于class_foo是类方法，因此，class_foo跟Kls进行了绑定（而不是跟ik绑定）。当我们打印ik.class_foo时，输出：



<bound method type.class_foo of <class '__main__.Kls'>>

当调用ik.static_foo时，静态方法并不会与类或者实例绑定，因此，打印ik.static_foo（或者Kls.static_foo）时输出：



<function static_foo at 0x055238B0>

概括来说，是否与类或者实例进行绑定，这就是实例方法，类方法，静态方法的区别。



参考资料

https://www.pythoncentral.io/difference-between-staticmethod-and-classmethod-in-python/
https://taizilongxu.gitbooks.io/stackoverflow-about-python/content/14/README.html
https://kuanghy.github.io/2015/12/19/python-variable
https://stackoverflow.com/questions/136097/what-is-the-difference-between-staticmethod-and-classmethod-in-python

类方法： 又叫做静态方法 


对象方法： 又叫实例方法，非静态方法 


访问一个对象方法，必须建立在有一个对象的前提的基础上 

访问类方法，不需要对象的存在，直接就访问

步骤 1 : 类方法

类方法： 又叫做静态方法

对象方法： 又叫实例方法，非静态方法

访问一个对象方法，必须建立在有一个对象的前提的基础上

访问类方法，不需要对象的存在，直接就访问

package charactor;
 
public class Hero {
    public String name;
    protected float hp;
 
    //实例方法,对象方法，非静态方法
    //必须有对象才能够调用
    public void die(){
        hp = 0;
    }
     
    //类方法，静态方法
    //通过类就可以直接调用
    public static void battleWin(){
        System.out.println("battle win");
    }
     
    public static void main(String[] args) {
           Hero garen =  new Hero();
           garen.name = "盖伦";
           //必须有一个对象才能调用
           garen.die();
            
           Hero teemo =  new Hero();
           teemo.name = "提莫";
            
           //无需对象，直接通过类调用
           Hero.battleWin();
         
    }
}

步骤 2 : 调用类方法

和访问类属性一样，调用类方法也有两种方式

1. 对象.类方法

garen.battleWin();

2. 类.类方法

Hero.battleWin();

这两种方式都可以调用类方法，但是建议使用第二种 类.类方法 的方式进行，这样更符合语义上的理解。

并且在很多时候，并没有实例，比如在前面练习的时候用到的随机数的获取办法

Math.random()

random()就是一个类方法，直接通过类Math进行调用，并没有一个Math的实例存在。

步骤 3 : 什么时候设计对象方法，什么时候设计类方法

如果在某一个方法里，调用了对象属性，比如

public String getName(){
    return name;
}

name属性是对象属性，只有存在一个具体对象的时候，name才有意义。 如果方法里访问了对象属性，那么这个方法，就必须设计为对象方法


如果一个方法，没有调用任何对象属性，那么就可以考虑设计为类方法，比如

public static void printGameDuration(){
    System.out.println("已经玩了10分50秒");
}

printGameDuration 打印当前玩了多长时间了，不和某一个具体的英雄关联起来，所有的英雄都是一样的。 这样的方法，更带有功能性色彩

步骤 4 : 练习-类方法

在一个类方法中，直接调用一个对象方法，

比如在battleWin中调用die()

能否直接调用？ 为什么？

Objective-C里面既有实例方法也类方法。类方法(Class Method) 有时被称为工厂方法(Factory Method)或者方便方法(Convenience method)。工厂方法的称谓明显和一般意义上的工厂方法不同，从本质上来说，类方法可以独立于对象而执行，所以在其他的语言里面类方法有的时候被称为静态方法。

注意点一：类方法

1，类方法可以调用类方法。

2，类方法不可以调用实例方法，但是类方法可以通过创建对象来访问实例方法。

3，类方法不可以使用实例变量。类方法可以使用self，因为self不是实例变量。

4，类方法作为消息，可以被发送到类或者对象里面去（实际上，就是可以通过类或者对象调用类方法的意思

注意点二：类方法和实例方法

1:实例方法是— 类开头是+ 实例方法是用实例对象访问，类方法的对象是类而不是实例，通常创建对象或者工具类。

在实例方法里，根据继承原理发送消息给self和super其实都是发送给self

在类方法里面self是其他的类的类方法，在类方法中给self发送消息只能发类方法self是类super也是

什么时候用类方法，要创建一个实例时候获取一个共享实例，或者获取关于类的一些共有信息

2:类方法(class method)和实例方法(instance method)。类方法被限定在类范围内，不能被类的实例调用（即脱离实例运行）。alloc就是一种类方法。实例方法    限定在对象实例的范围内（即实例化之前不能运行）。init就是一种实例方法，被alloc方法返回的对象实例调用。

instance method  以减号 “-” 开头

class method  以加号 “+” 开头，相当于static方法
 1 #import <Foundation/Foundation.h>
 2 /*
 3  对象方法
 4  1> 减号 - 开头
 5  2> 只能由对象来调用
 6  3> 对象方法中能访问当前对象的成员变量（实例变量）
 7  
 8  类方法
 9  1> 加号 + 开头
10  2> 只能由类（名）来调用
11  3> 类方法中不能访问成员变量（实例变量）
12  
13  
14  类方法的好处和使用场合
15  1> 不依赖于对象，执行效率高
16  2> 能用类方法，尽量用类方法
17  3> 场合：当方法内部不需要使用到成员变量时，就可以改为类方法
18  
19  可以允许类方法和对象方法同名
20  */
21 
22 
23 @interface Person : NSObject
24 {
25     int age;
26 }
27 
28 // 类方法都是以+开头
29 + (void)printClassName;
30 
31 - (void)test;
32 + (void)test;
33 
34 @end
35 
36 @implementation Person
37 
38 + (void)printClassName
39 {
40     // error：instance variable 'age' accessed in class method
41     // 实例变量age不能在类方法中访问
42     //NSLog(@"这个类叫做Person-%d", age);
43 }
44 
45 - (void)test
46 {
47     NSLog(@"111-%d", age);
48     
49     //[Person test];
50 }
51 
52 + (void)test
53 {
54     // 会引发死循环
55     //[Person test];
56     
57     NSLog(@"333");
58     
59     // 会引发死循环
60 //    /[Person test];
61 }
62 
63 @end
64 
65 int main()
66 {
67     //[Person printClassName];
68     
69     [Person test];
70     
71     //Person *p = [Person new];
72     //[p test];
73     
74     /*
75      -[Person printClassName]: unrecognized selector sent to instance 0x7fa520c0b370
76      */
77     // 系统会认为现在调用的printClassName是个对象方法
78     //[p printClassName];
79     
80     return 0;
81 }

转载博客园 iOS_bowen.