Python中的属性和实例方法、类方法、静态方法的用法和区别

类属性、实例属性

类属性

• 定义：类属性是直接在类中定义的属性。
• 类属性可以通过类或类的实例访问到。
• 类属性只能通过类对象来修改，无法通过实例对象修改。

class A(Object):
	count = 0

a = A()
a.count = 10
print('A, ', A.count)
print('a, ', a.count)

A, 0
a, 10

A.count = 100
print('A, ', A.count)
print('a, ', a.count)

A, 100
a, 100

实例属性

• 通过实例对象添加的属性属于实例属性
• 实例属性只能通过实例对象来访问和修改，类对象无法访问

class A():
    count = 0
    
    def __init__(self):
        self.name = 'stone'  # 实例属性

# print('A, ', A.name)   # 报错----类对象无法访问实例属性
print('a, ', a.name)

注意：

• 如果是公共的，所有实例都共享这个属性则使用类属性；
• 只有当前对象（实例）使用则使用实例属性；

实例方法、类方法、静态方法的用法和区别

本章节转自：https://blog.csdn.net/lihao21/article/details/79762681
Python 实例方法、类方法和静态方法

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


# 实例调用，自动将当前调用对象作为self传入
ik1.printd()
ik2.printd()

# 类调用，不会自动传入self，必须手动传入self
Kls.printd(ik1)
Kls.printd(ik2)

输出：

leo
lee
leo
lee

上述例子中，printd为一个实例方法。

实例方法第一个参数为self

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

实例方法可以通过实例和类进行调用

• 通过实例调用时，会自动将当前调用对象作为self传入；
• 通过类调用时，不会自动传入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):
    	print("这是一个类方法", cls)
        return cls.num_inst


ik1 = Kls()
ik2 = Kls()

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

输出：

这是一个类方法 <class '__main__.Kls'>
2
这是一个类方法 <class '__main__.Kls'>
2

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

类方法第一个参数为cls，会被自动传入，cls就是当前的类对象

由于在调用类方法时，只需要将类型本身传递给类方法，因此，

类方法既可以通过类调用，也可以通过实例来调用，两者没有区别。

静态方法

在开发中，我们常常需要定义一些方法，这些方法跟类有关，

但在实现时并不需要引用类或者实例。

例如，设置环境变量，修改另一个类的变量，等。这个时候，我们可以使用静态方法。

静态方法，基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数。

静态方法一般都是工具方法，和当前类无关。

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>

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

（2）对于类方法，调用时会把类Kls作为第一个参数传递给cls参数。因此，调用ik.class_foo(1)时输出了Kls类型信息。
前面提到，可以通过类也可以通过实例来调用类方法，在上述代码中，我们再一次进行了验证。

（3）对于静态方法，调用时并不需要传递类或者实例。

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

值得注意的是，在上述例子中，

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

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

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

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

3、当调用ik.static_foo时，

静态方法并不会与类或者实例绑定，

因此，打印ik.static_foo（或者Kls.static_foo）时输出：

<function static_foo at 0x055238B0>

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

参考资料

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