在Python面向对象编程中，属性和方法是类及其对象的重要组成部分。如果说封装、继承和多态是面向对象编程中的思想，那么类的属性和方法就是骨架，因为有属性和方法，面向对象编程才变的有血有肉。

属性

属性是类或对象所拥有的数据，它用于描述对象的特征和状态。属性可以是实例属性（对象特有的属性）或类属性（属于类本身的属性）。可以使用点运算符来访问和修改属性的值。

实例属性

实例属性（Instance Attribute）是属于对象实例的属性。每个对象实例都有自己的一组实例属性，这些属性的值可以在对象的生命周期内不断变化。

假设我们要定义一个名为"Car"的类，表示一个车的信息，有一个brand（品牌）。我们可以使用实例属性来表示这些信息。

class Car:
    def __init__(self, brand):
        self.brand = brand

在上面的代码中，我们定义了一个"Car"类，有一个实例属性：brand。在类的构造函数__init__中，我们使用self关键字来引用当前实例对象，并使用点运算符给实例属性赋值。
现在，我们可以创建一个"Car"对象，并访问其实例属性：

car1 = Car("Toyota")
print(car1.brand)  # 输出：Toyota

在上面的代码中，我们创建了一个名为"car1"的"Car"对象，并访问了其实例属性brand，输出结果"Toyota"。
可以注意到，每个实例对象都有自己独立的一组实例属性，并且可以根据具体对象的需求来进行不同的赋值。例如，我们可以创建另一个"Car"对象，给其brand属性赋予不同的值：

car2 = Car("Tesla")
print(car2.brand)  # 输出：Tesla

在上面的代码中，我们创建了一个名为"car2"的"Car"对象，并访问了其实例属性brand，输出结果"Tesla"。
通过实例属性，我们可以通过对象实例来描述其具体的特征和状态。每个实例对象具有相互独立且可以随时修改的实例属性，这使得面向对象编程更加灵活和可扩展。

类属性

类属性（Class Attribute）是属于类的属性，它是所有该类的实例所共享的属性。类属性与任何一个实例对象无关，通常用于定义类的共享数据。

假设我们要定义一个名为"Car"的类，表示汽车的信息，有一个品牌属性和一个数量属性。我们可以使用类属性来表示这些信息。

class Car:
    brand = "Toyota"
    count = 0

    def __init__(self, model):
        self.model = model
        Car.count += 1

在上面的代码中，我们定义了一个"Car"类，有两个类属性：brand和count。在类的构造函数__init__中，我们使用self关键字来引用当前实例对象，并使用点运算符给实例属性model赋值。同时，每次创建一个新的Car对象时，我们都会将count类属性的值加1，以统计Car对象的数量。
现在，我们可以创建几个"Car"对象，并访问其类属性和实例属性：

car1 = Car("Corolla")
car2 = Car("Rav4")

print(Car.brand)  # 输出：Toyota
print(Car.count)  # 输出：2

print(car1.model)  # 输出：Corolla
print(car2.model)  # 输出：Rav4

print(car1.brand)  # 输出：Toyota
print(car2.brand)  # 输出：Toyota

在上面的代码中，我们创建了两个"Car"对象"car1"和"car2"。我们首先使用类名访问类属性brand和count，输出结果分别为"Toyota"（所有"Car"对象的共享品牌属性）和2（创建的"Car"对象数量）。
然后，我们通过对象名访问实例属性model，输出结果分别为"Corolla"和"Rav4"。可以注意到，每个对象实例都有自己独立的实例属性model。最后，我们通过对象名访问类属性brand，输出结果均为"Toyota"。这是因为类属性是所有该类的实例所共享的，所以每个对象实例都可以访问和修改类属性。
通过类属性，我们可以在类层面上定义和管理共享的数据。所有该类的实例都可以通过类名来访问和修改类属性，这使得数据的共享和统一管理更加方便。

方法

方法是类中定义的函数，它与类进行绑定。方法可以访问和操作类的属性，并可被类的实例调用。方法分为实例方法、类方法和静态方法。

实例方法

实例方法（Instance Method）是定义在类中的方法，是绑定到对象实例的，实例方法可以在方法内部访问实例属性，用于操作对象实例的行为，并且可以使用self关键字来引用调用该方法的对象实例。
假设我们仍然以"Car"类为例，除了原有的实例属性之外，我们多一个速度相关的属性，并对外显示当前的速度。这个方法属于实例级别的，表示特定对象实例的行为，我们可以使用实例方法来实现。

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
        self.speed = 0

    def accelerate(self, increment):
        self.speed += increment

    def decelerate(self, decrement):
        if self.speed >= decrement:
            self.speed -= decrement
        else:
            self.speed = 0

    def show_speed(self):
        print("Current speed:", self.speed, "km/h")

在上面的代码中，我们定义了一个"Car"类，有三个实例属性：brand（品牌）、model（型号）和speed（速度）。另外，我们定义了三个实例方法：accelerate（加速）、decelerate（减速）和show_speed（显示速度）。
在方法内部，我们使用self关键字引用当前实例对象的属性，通过对speed属性的增减操作实现加速和减速的功能。show_speed方法用于在终端中显示当前汽车的速度信息。
现在，我们可以创建一个"Car"对象，并调用其实例方法：

car1 = Car("Toyota", "Corolla")
car1.accelerate(40)
car1.show_speed()  # 输出：Current speed: 40 km/h

car1.decelerate(20)
car1.show_speed()  # 输出：Current speed: 20 km/h

在上面的代码中，我们创建了一个名为"car1"的"Car"对象，并先后调用其accelerate和decelerate方法。然后，通过调用show_speed方法打印出了当前汽车的速度信息。

通过实例方法，我们可以为对象实例定义具体的行为。每个实例对象都可以调用实例方法，并且每次调用时，方法内部都可以根据对象实例的具体属性值来进行不同的操作。这使得我们可以方便地操控和控制对象行为，实现更加灵活和可定制的功能。在汽车示例中，我们通过实例方法实现了汽车的加速、减速和显示速度等功能。

类方法

类方法（Class Method）是绑定到类本身的方法，类方法由装饰器@classmethod标记，可以在方法内部访问和修改类属性。
类方法是定义在类中的方法，使用classmethod装饰器修饰，它与实例方法不同的是，类方法是针对整个类进行操作，不依赖于具体的实例对象。下面通过一个示例来详细说明类方法的概念和使用。

class Car:
    total_cars = 0

    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
        Car.total_cars += 1

    @classmethod
    def get_total_cars(cls):
        return cls.total_cars

在上面的代码中，我们定义了一个"Car"类，有两个实例属性：brand（品牌）和model（型号），以及一个类属性total_cars（总车辆数）。另外，我们使用classmethod装饰器修饰了get_total_cars方法，将其定义为类方法。
在get_total_cars方法内部，我们通过cls关键字引用当前类对象，从而可以访问到类属性total_cars。
现在，我们可以创建多个"Car"对象，并调用类方法：

car1 = Car("Toyota", "Corolla")
car2 = Car("Honda", "Civic")
car3 = Car("Ford", "Mustang")

print(Car.get_total_cars())  # 输出：3

在上面的代码中，我们创建了三个不同的"Car"对象，并通过调用类方法get_total_cars来获取当前已创建的汽车对象数目。输出结果为3，表示目前已经创建了3个Car对象。
需要注意的是，类方法可以通过类名直接调用，不需要创建对象实例。而且，无论是通过类名调用还是通过对象实例调用类方法，它们都能够访问和操作类级别的属性和方法。
类方法经常用于处理类级别的操作，例如计数器、类属性的访问和修改等。在汽车示例中，我们使用类方法get_total_cars来获取当前已创建的汽车对象数目，因为总车辆数是整个类共享的。

静态方法

静态方法是定义在类中的方法，静态方法是类中独立于对象实例和类的方法，由装饰器@staticmethod标记，与实例方法和类方法不同的是，静态方法不需要访问实例属性或类属性，它是一种独立于实例和类的方法。

class Car:
    def __init__(self, brand, model, distance, time):
        self.brand = brand
        self.model = model
        self.distance = distance
        self.time = time

    @staticmethod
    def calculate_average_speed(distance, time):
        return distance / time

    def get_info(self):
        print(f"Brand: {self.brand}")
        print(f"Model: {self.model}")
        print(f"Distance: {self.distance} km")
        print(f"Time: {self.time} hours")
        print(f"Average Speed: {self.calculate_average_speed(self.distance, self.time)} km/h")

car = Car("Toyota", "Corolla", 400, 5)
car.get_info()

在上面的代码中，我们定义了一个"Car"类，构造函数接收品牌、型号、行驶距离和所需时间这四个参数。然后，我们使用静态方法calculate_average_speed计算平均速度，即行驶距离除以所需时间。在get_info方法中，我们打印了汽车的品牌、型号、行驶距离、所需时间和平均速度（通过调用静态方法）。

运行上述代码，将得到如下输出：

Brand: Toyota
Model: Corolla
Distance: 400 km
Time: 5 hours
Average Speed: 80.0 km/h

从输出结果中可以看到，我们成功获取了汽车的信息并计算了平均速度。通过使用静态方法，我们将计算平均速度的逻辑封装在类中，使代码更加清晰和可维护。同时，静态方法可以直接通过类名调用，无需先创建汽车对象实例。
需要注意的是，静态方法可以在类中被所有实例共享，也可以被类自身直接调用。静态方法在不需要访问实例属性或类属性的情况下，提供了一种方便的方式来执行类相关的操作。

更多精彩内容，请关注同名公众：一点sir（alittle-sir）