python类属性、实例属性、类方法、实例方法、静态方法区别

1. 类属性和实例属性

名称	对象类型	类的实例	类
类属性	不可变对象	可以访问，但不能修改。若修改，只是为该实例创建一个名字与该类属性相同的实例属性而已。	可以访问，可以修改。
类属性	可变对象	可以访问，可以一定程度修改。	可以访问，可以修改。
实例属性	不可变对象	可以访问，可以修改。	不可以访问，不可以修改。
实例属性	可变对象	可以访问，可以修改。	不可以访问，不可以修改。

举个例子，代码如下：

class Test(object):
    _num = 10 # 不可变对象
    _array = [1, 2, 3] # 可变对象

    def __init__(self, num, array):
        self.num = num
        self.array = array

    

if __name__ == '__main__':
    my_num = 20
    my_array = [4, 5, 6]
    t1 = Test(my_num, my_array)

    print('t1之前的_num:{}, {}'.format(t1._num, id(t1._num))) # 实例访问不可变类属性
    print('t1之前的_array:{}, {}'.format(t1._array, id(t1._array))) # 实例访问可变类属性
    print('Test之前的_array:{}, {}'.format(Test._array, id(Test._array))) # 类访问可变类属性
    print('t1之前的__dict__是:', t1.__dict__)
    t1._num = 11 # 实例修改不可变类属性
    t1._array.append(4) # 实例修改可变类属性，地址不变
    t1._array = [11, 22, 33] # 实例修改可变类属性，地址改变
    print('t1之后的_num:{}, {}'.format(t1._num, id(t1._num)))
    print('t1之后的_array:{}, {}'.format(t1._array, id(t1._array)))
    print('Test之后的_array:{}, {}'.format(Test._array, id(Test._array)))
    print('t1之后的__dict__是:', t1.__dict__)
	
	print(Test.num) # 类访问实例属性

输出结果如下：

# 输出结果
t1之前的_num: 10, 1850030480
t1之前的_array: [1, 2, 3], 11486632
Test之前的_array: [1, 2, 3], 11486632
t1之前的__dict__是: {'num': 20, 'array': [4, 5, 6]}

t1之后的_num: 11, 1850030496
t1之后的_array: [11, 22, 33], 12614712
Test之前的_array: [1, 2, 3, 4], 11486632
t1之后的__dict__是: {'num': 20, 'array': [4, 5, 6], '_num': 11, '_array': [11, 22, 33]}

Traceback (most recent call last):
  File ".\类方法和实例方法.py", line 46, in <module>
    print(Test.num)
AttributeError: type object 'Test' has no attribute 'num'

从输出结果，类的实例修改类属性。

• 实例修改类属性时，若不修改类属性的地址，是可以对类属性进行修改的。
• 实例修改类属性时，若修改类属性的地址，则实际上是为该实例创建了与类属性名字相同的实例属性。

类不可访问/修改实例属性。

2. 类方法、实例方法和静态方法

名称	类的实例	类
类方法	可以调用	可以调用
实例方法	可以调用	不能调用
静态方法	可以调用	可以调用

举个例子，代码如下：

#@author: sjl
class Test(object):
    _num = 10 # 不可变对象
    _array = [1, 2, 3] # 可变对象

    def __init__(self, num, array):
        self.num = num
        self.array = array

    def my_instance(self):
        print('这是一个实例方法')

    @classmethod
    def my_class(cls):
        print('这是一个类方法')
    
    @staticmethod
    def my_static():
        print('这是一个静态方法')


if __name__ == '__main__':
    my_num = 20
    my_array = [4, 5, 6]
    t1 = Test(my_num, my_array)

    try:
        t1.my_instance()
    except Exception as e:
        print('实例不能调用实例方法')
    try:
        t1.my_class()
    except Exception as e:
        print('实例不能调用类方法')
    try:
        t1.my_static()
    except Exception as e:
        print('实例不能调用静态方法')

    try:
        Test.my_instance()
    except Exception as e:
        print('类不能调用实例方法')
    try:
        Test.my_class()
    except Exception as e:
        print('类不能调用类方法')
    try:
        Test.my_static()
    except Exception as e:
        print('类不能调用静态方法')

输出如下：

这是一个实例方法
这是一个类方法
这是一个静态方法

类不能调用实例方法
这是一个类方法
这是一个静态方法

2.1 实例方法

对实例进行操作，与实例本身有关。

2.2 类方法

对类进行的操作，与类本身有关。

2.3 静态方法

静态方法是类中的函数，不需要实例和类。静态方法主要是用来存放逻辑性的代码，逻辑上属于类，但是和类本身没有关系，也就是说在静态方法中，不会涉及到类中的属性和方法的操作。可以理解为，静态方法是个独立的、单纯的函数，它仅仅托管于某个类的名称空间中，便于使用和维护。来自 Python 实例方法、类方法、静态方法的区别与作用

调用静态方法可以使用self.mystaticmethod()和cls.mystaticmethod()。

因此需要注意的是，在静态方法中绝对不能出现self和cls（在静态方法中不能使用实例和类的任何东西），除非你在这个方法内部将这两个变量进行定义了)，否则会报错。理论上，静态方法之间是不能调用，如果静态方法A需要调用静态方法B，那么其实静态方法A应该定义成一个实例方法或类方法。

3. 总结

实例操作类属性，当类属性是可变对象时，可以修改。但是这个修改是有条件的，就是不能改变该类属性的地址，也就是说在实例对该可变对象的类属性修改前后，id(该类属性)必须是不变的。否则，则会创建一个名字等同于该类属性名的实例属性。

类不可访问/修改实例属性， 不可调用/修改实例方法。

以下来自 类方法与实例方法的区别

• 静态方法在程序开始时生成内存，实例方法在程序运行中生成内存，所以静态方法可以直接调用。
• 实例方法要先成生实例，通过实例调用方法，静态速度很快，但是多了会占内存。
• 静态内存是连续的，因为是在程序开始时就生成了，而实例申请的是离散的空间，所以当然没有静态方法快，而且静态内存是有限制的，太多了程序会启动不了。
• 类方法常驻内存，实例方法不是，所以类方法效率高但占内存。
• 类方法在堆上分配内存，实例方法在堆栈上。
• 实例方法需要先创建实例才可以调用，比较麻烦，类方法不用，比较简单。
• 每个实例对象都有自身的实例方法，互相独立，不共享一个。其调用方式只能是对象名.方法名。

4. 参考文献

[1] Python 实例方法、类方法、静态方法的区别与作用
[2] 类方法与实例方法的区别
[3] “NameError: global name ‘self’ is not defined”