Python面向对象，类属性，实例属性，类方法，实例方法，静态方法的区别及用法详解

一. 前言

• 在Python的面向对象编程中，类属性和实例属性是两个不同的概念，它们在作用域和使用方式上有所区别。
• 在Python中的面向对象编程中有三种方法：实例方法、类方法和静态方法，它们之间的差异主要体现在参数传递和调用方式上。

二. 面向对象 - 类属性和实例属性

1. 区别

在 Python 中，类属性和实例属性的区别在于它们的作用域不同。

• 类属性是属于类对象的属性，它的值对于类的所有实例来说是相同的，类属性可以通过类名或实例名访问。
• 实例属性是属于实例对象的属性，每个实例都可以有自己的属性值。实例属性只能通过实例名访问。

2. 示例代码

class MyClass:
    class_attr = "I am a class attribute"

    def __init__(self, ins_attr):
        self.ins_attr = ins_attr


if __name__ == '__main__':
    obj1 = MyClass("I am an instance attribute of obj1")
    obj2 = MyClass("I am an instance attribute of obj2")

    print(obj1.class_attr)  # 输出 "I am a class attribute"
    print(obj2.class_attr)  # 输出 "I am a class attribute"

    print(obj1.ins_attr)  # 输出 "I am an instance attribute of obj1"
    print(obj2.ins_attr)  # 输出 "I am an instance attribute of obj2"

    obj1.class_attr = "I am a new update class attribute of obj1"
    print(obj1.class_attr)  # 输出 "I am a new update class attribute of obj1"
    print(obj2.class_attr)  # 输出 "I am a class attribute"

    MyClass.class_attr = "I am a new MyClass attribute"
    print(obj1.class_attr)  # 输出 "I am a new update class attribute of obj1"
    print(obj2.class_attr)  # 输出 "I am a new MyClass attribute"
    print(MyClass.class_attr)  # 输出 "I am a new MyClass attribute"

上面的代码中，我们定义了一个 MyClass 类，其中有一个类属性 class_attr 和一个实例属性 name。在实例化 obj1 和 obj2 之后，我们分别访问了它们的实例属性和类属性，然后我们修改了类属性的值，并且分别访问了两个实例的类属性值，最后打印了每个实例的属性值。

运行结果如下

从以上运行结果可以看到，

• 当我们根据使用实例对象修改类属性时，该实例对象的类属性会改变，但只会作用于自身（修改的实例对象），不会影响其他实例的属性值。
• 当我们通过类直接修改类属性时，类属性会发生改变，并且生效作用于其他的实例对象，其他的实例对象访问结果会变成类修改类属性后的结果，而实例对象修改过后的类属性却没有受到影响，它的类属性的值是它（实例对象）修改过后的值。

3. 总结

• 类属性是一个类的全局变量，所有实例对象共享一个值，可以通过类名或实例对象访问，此外需要注意不同的修改方式可能会影响类属性的最终输出结果。
• 实例属性属于实例对象私有的属性，每个实例对象都有自己的值，只能通过实例对象访问。

在实际开发中，需要根据实际情况选择类属性和实例属性的使用

2. 常用的类属性，方法装饰方式及用法

1. @property

将一个方法转换成属性，可以像访问属性一样访问。

class MyClass:
    def __init__(self, value):
        self._x = value
    
    @property
    def x(self):
        return self._x
    
c = MyClass(5)
print(c.x)  # 输出5

2. @classmethod

将一个方法声明为类方法，用类名调用。

class MyClass:
    x = 0
    
    @classmethod
    def classmethod(cls):
        cls.x += 1
        return cls.x
    
print(MyClass.classmethod())  # 输出1
print(MyClass.classmethod())  # 输出2

3. @staticmethod

将一个方法声明为静态方法，可以不需要实例化对象就能够调用。

class MyClass:
    @staticmethod
    def staticmethod():
        return "This is a static method."
    
print(MyClass.staticmethod())  # 输出"This is a static method."

4. @get.setter

用于设置属性值的方法，必须定义在@property方法下面。

class MyClass:
    def __init__(self, value):
        self._x = value
    
    @property
    def x(self):
        return self._x
    
    @x.setter
    def x(self, value):
        self._x = value * 2
    
c = MyClass(5)
print(c.x)  # 输出5
c.x = 10
print(c.x)  # 输出20

5. @get.deleter

用于删除属性的方法，必须定义在@property方法下面。

class MyClass:
    def __init__(self, value):
        self._x = value
    
    @property
    def x(self):
        return self._x
    
    @x.deleter
    def x(self):
        del self._x
    
c = MyClass(5)
print(c.x)  # 输出5
del c.x
# print(c.x)  # AttributeError: 'MyClass' object has no attribute '_x'

6. @cached_property

缓存属性，只计算一次，后续访问直接返回缓存值。

from cached_property import cached_property

class MyClass:
    @cached_property
    def x(self):
        print("Calculating x.")
        return 5
    
c = MyClass()
print(c.x)  # 输出Calculating x. 5
print(c.x)  # 输出5

7. @lazy_attribute

在第一次访问该属性时才进行计算，之后返回缓存值。

from lazy_object_proxy import Proxy

class MyClass:
    def __init__(self):
        self._my_property = Proxy(self.calculate_my_property)

    def calculate_my_property(self):
        print("Calculating my_property!")
        return 100

    @property
    def my_property(self):
        return self._my_property

my_class = MyClass()
print(my_class.my_property) # Output: Calculating my_property! 100
print(my_class.my_property) # Output: 100

8. @abstractmethod

@abstractmethod是Python语言中用于实现抽象方法的装饰器。当一个方法被@abstractmethod装饰时，它就成为了一个抽象方法，必须在子类中被实现，否则子类将无法实例化。

使用@abstractmethod装饰器可以将一个方法标记为抽象方法。抽象方法通常被声明在抽象类中，抽象类是一种不能被实例化的类，只能被继承。子类继承抽象类时必须实现它的抽象方法。

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius * self.radius

#s1 = Shape() # This will raise TypeError

r = Rectangle(5, 10)
print(r.area())

c = Circle(7)
print(c.area())

 

在上述示例中，我们定义了一个抽象类Shape，它包含一个抽象方法area()。我们还定义了两个子类Rectangle和Circle，它们都继承自Shape类，并实现了area()方法。在这个例子中，我们不能实例化Shape类，但可以实例化Rectangle和Circle类。每个实例都可以使用自己相应的area()方法计算面积。

二. 面向对象 - 类方法，静态方法，实例方法

1. 三者主要区别：

1. 类方法：

使用@classmethod装饰器进行修饰，第一个参数默认为cls，表示类本身。类方法是可以被类和类的实例对象调用的。在类方法中不能访问实例属性和实例方法，因为它不依赖任何实例对象，而是依赖类本身，通常用于创建类对象或者对类属性的操作。

2. 实例方法：

实例方法没有任何特殊的修饰器，第一个参数默认为self，表示实例本身。实例方法只能被实例对象调用，因为它依赖于实例对象。实例方法可以访问实例对象的属性和其他实例方法。

3. 静态方法：

使用@staticmethod装饰器进行修饰，它不需要表示自身对象的self和cls参数。静态方法是类的工具包，它与类和实例对象没有任何关系，通常用于工具函数或类的初始化操作。

2. 另外介绍类方法和实例方法两种类型区别：

• 类方法使用@classmethod装饰器修饰，而实例方法没有。
• 类方法的第一个参数是类对象(cls)，而实例方法的第一个参数是实例对象(self)。
• 类方法可以直接通过类名调用，而实例方法必须通过实例对象调用。
• 类方法对于所有实例都是一样的，而实例方法对于每个实例都可能会不同。
• 类方法通常用于创建、修改、查询类属性和类状态的操作，而实例方法通常用于操作实例属性和实例状态的操作。
• 类方法可以访问类属性，但不能访问实例属性。而实例方法可以访问实例属性和类属性。

在使用类方法和实例方法时，需要根据具体的业务需求来选择使用哪一种方法。

3. 示例代码说明解释

1. 实例方法：

在Python中，类中的所有函数默认都是实例方法，实例方法是将self作为第一个参数的方法，它可以通过实例化一个对象来调用，它可以访问实例中的数据，也可以修改实例中的数据，最常用的方法之一。

class MyClass:
    def my_instance_method(self, arg1, arg2):
        # 实例方法的代码
        pass

instance = MyClass()
instance.my_instance_method(arg1, arg2)

 

2. 类方法：

类方法是将cls作为第一个参数的方法，它可以通过类名或对象名来调用，也可以修改类变量，但是它不能访问实例变量，类方法使用@classmethod装饰器来定义。

示例代码

class MyClass:
    class_var = 0

    @classmethod
    def my_class_method(cls, arg1, arg2):
        # 类方法的代码
        cls.class_var += 1
        pass

MyClass.my_class_method(arg1, arg2)

 

3. 静态方法：

这种方法也是类成员方法，但它们不需要访问类或实例的上下文。静态方法可以像普通函数一样被调用，没有默认的参数。
静态方法不需要传递任何参数，它与类和实例无关，可以使用类名或对象名来调用，因此静态方法不能访问实例变量或类变量，静态方法使用@staticmethod装饰器来定义。

class MyClass:
    @staticmethod
    def my_static_method(arg1, arg2):
        # 静态方法的代码
        pass

MyClass.my_static_method(arg1, arg2)

 

三. 总结：

• 实例方法是最常用的方法类型，只能被实例调用，第一个参数是self；
• 类方法和静态方法都是类成员方法，可以通过类或实例调用；
• 类方法第一个参数是cls，表示当前类对象；
• 静态方法没有默认参数，类的上下文不会传递给它。

以上就是关于python中面向对象的属性，类方法，静态方法，实例方法的区别及用法详解，希望对你有所帮助，请不吝你的三连，谢谢！

 

2024-02-28 11:54:38【出处】：https://johnsonchen.blog.csdn.net/article/details/132459157

=======================================================================================