python入门（8）面向对象 ：类、对象、属性与方法

1. 面向对象思想

当我们谈论Python的面向对象思想时，主要指的是Python中的类和对象的概念以及与之相关的特性和原则。面向对象编程（Object-Oriented Programming，简称OOP）是一种常用的编程范式，它将程序中的数据和操作数据的方法组织在一起，形成对象，通过对象之间的交互来实现程序的功能。

在Python中，面向对象编程主要围绕以下几个核心概念展开：

（1）类（Class）：类是面向对象编程的基础，它是一种自定义的数据类型，用于描述对象的属性和行为。类定义了对象的结构和行为的模板，可以创建多个具有相同结构和行为的对象。

（2）对象（Object）：对象是类的实例化，是类的具体实体。每个对象都具有特定的属性和行为，可以通过访问对象的属性和调用对象的方法来操作对象。

（3）属性（Attribute）：属性是对象的数据，用于描述对象的特征和状态。属性可以是变量或数据成员，每个对象可以有不同的属性值。

（4）方法（Method）：方法是类中定义的函数，用于描述对象的行为和操作。方法可以访问和操作对象的属性，并可以通过参数接受输入，执行相应的逻辑。

（5）封装（Encapsulation）：封装是将数据和操作数据的方法封装在一个类中，对外部隐藏对象的内部实现细节，只暴露必要的接口供其他对象使用。

（6）继承（Inheritance）：继承是一种机制，允许创建一个新类（子类）继承现有类（父类）的属性和方法。子类可以扩展或修改继承自父类的功能，实现代码的重用和扩展。

（7）多态（Polymorphism）：多态是指对象在不同的上下文中表现出不同的行为。同一个方法名可以在不同的类中有不同的实现，对象可以根据上下文选择适当的方法来执行。

通过面向对象编程，可以将程序的逻辑分解为多个独立的对象，并通过对象之间的交互来实现复杂的功能。面向对象编程提供了更灵活、可扩展和易维护的代码结构，使代码更具可读性和可重用性。

下面是一个简单的示例，演示了Python中类和对象的基本用法：

# 定义一个Person类
class Person:
    # 构造方法
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 实例方法
    def greet(self):
        print(f"Hello, my name is {self.name}. I'm {self.age} years old.")

# 创建Person对象
person = Person("Alice", 25)

接下来，我们可以使用已经创建的对象进行属性访问和方法调用：

# 访问对象属性
print(person.name)  # 输出：Alice
print(person.age)  # 输出：25

# 调用对象方法
person.greet()  # 输出：Hello, my name is Alice. I'm 25 years old.

在上面的示例中，我们定义了一个Person类，它具有name和age两个属性，并且有一个greet方法用于打招呼。通过创建Person对象并访问对象的属性和调用方法，我们可以实现对对象的操作和交互。

此外，面向对象编程还涉及到其他概念和特性，如类的继承、方法的重写、类的多态等。这些概念可以让我们更好地组织和管理代码，提高代码的可维护性和可扩展性。

请注意，面向对象编程是一种编程范式，它并不是唯一的编程方式，而是根据实际需求选择合适的编程范式。在Python中，除了面向对象编程，还可以使用函数式编程、过程式编程等不同的编程范式来解决问题。

2. 面向对象中的类

在Python中，类是面向对象编程的核心概念之一。通过类，我们可以创建对象，定义对象的属性和方法，并对对象进行操作和交互。

类的定义通过关键字class进行，具体语法如下：

class ClassName:
    # 类的属性和方法定义
    pass

在类的定义中，可以包含类的属性和方法。属性是类的数据成员，用于存储对象的状态信息；方法是类的函数成员，用于定义对象的行为和操作。

下面是一个示例，展示了一个简单的Person类的定义：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name}. I'm {self.age} years old.")

在上面的示例中，Person类有两个属性：name和age，并且有一个greet方法用于打招呼。__init__方法是一个特殊的方法，用于在创建对象时进行初始化操作。

通过类，我们可以创建对象并访问对象的属性和调用方法：

person = Person("Alice", 25)
print(person.name)  # 输出：Alice
print(person.age)  # 输出：25
person.greet()  # 输出：Hello, my name is Alice. I'm 25 years old.

在类的定义中，还可以使用其他特殊方法，如__str__用于定义对象的字符串表示、__eq__用于定义对象的相等性比较等。这些特殊方法可以增强类的功能和行为。

除了定义属性和方法，类还可以进行继承，通过继承可以创建子类，子类可以继承父类的属性和方法，并且可以添加自己的属性和方法。继承可以实现代码的重用和扩展。

总结起来，类是面向对象编程的基本构建块，通过定义类，我们可以创建对象并对其进行操作。类可以包含属性和方法，通过继承可以实现代码的重用和扩展。

3. 面向对象中的对象

3.1 对象的创建

在Python面向对象编程中，对象的创建包括以下几个步骤：

1. 定义类：首先需要定义一个类，类是对象的模板，用于描述对象的属性和方法。

2. 实例化对象：通过类来创建对象的过程称为实例化。在实例化时，会调用类的构造方法（__init__方法）来进行对象的初始化。

3. 分配内存空间：在实例化时，系统会自动为对象分配内存空间。

4. 初始化属性：通过构造方法，在对象中初始化属性的值。可以在构造方法中接收参数，并将其赋值给对象的属性。

5. 返回对象引用：对象创建完成后，会返回对象的引用，可以将其保存在变量中，以便后续使用。

下面是一个简单的示例，展示了对象的创建过程：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 25)

在上面的示例中，通过Person类创建了一个名为person的对象。在实例化时，会自动调用Person类的构造方法__init__，并传入参数"Alice"和25。构造方法将这些参数赋值给对象的属性name和age。

通过对象引用person，我们可以访问和操作对象的属性：

print(person.name)  # 输出：Alice
print(person.age)  # 输出：25

通过上述流程，我们可以创建多个对象，每个对象都拥有自己的属性和方法。对象的创建过程允许我们根据类的定义来构造具体的实例，并在实例化时进行个性化的初始化操作。

4. 属性和方法

在Python的面向对象编程中，类可以定义属性和方法，用于描述对象的特征和行为。

4.1 属性

属性是类中定义的变量，用于存储对象的状态或特征。在类的内部，可以通过self关键字来引用对象的属性。在类的外部，可以通过对象来访问属性。

类的属性可以分为两种类型：实例属性和类属性。

1. 实例属性：实例属性属于特定对象的属性，每个对象都有自己的实例属性副本。它们在类的实例化过程中被初始化，并通过 self 参数来访问和操作。实例属性通常在类的构造方法（__init__）中定义。

2. 类属性：类属性属于整个类的属性，所有类的实例共享相同的类属性。它们在类的定义中直接声明，并通过类名或实例访问。

下面是一个示例，演示了类中属性的使用：

class Car:
    wheels = 4  # 类属性

    def __init__(self, make, model):
        self.make = make  # 实例属性
        self.model = model

    def start_engine(self):
        print("The engine is started.")

# 创建 Car 类的实例
car1 = Car("Toyota", "Camry")
car2 = Car("Honda", "Accord")

# 访问实例属性
print(car1.make)  # Output: Toyota
print(car2.model)  # Output: Accord

# 访问类属性
print(Car.wheels)  # Output: 4

4.2 方法

方法是类中定义的函数，用于描述对象的行为和操作。在类中定义的方法可以访问对象的属性，并可以通过self关键字引用当前对象。

类的方法是定义在类中的函数，用于执行特定的操作。类的方法可以分为以下几种类型：

1. 实例方法：实例方法与特定对象相关联，可以访问和操作对象的实例属性。实例方法的第一个参数通常是 self，表示当前对象实例。

2. 静态方法：静态方法与类相关联，不与特定对象绑定。它们在类的定义中使用 @staticmethod 装饰器来声明，并可以通过类名或实例访问。静态方法不能访问实例属性，通常用于执行与类相关的操作。

3. 类方法：类方法与类相关联，可以访问和操作类属性。它们在类的定义中使用 @classmethod 装饰器来声明，并以类作为第一个参数，通常命名为 cls。

下面是一个示例，演示了类中属性和方法的使用：

class Car:
    wheels = 4  # 类属性

    def __init__(self, make, model):
        self.make = make  # 实例属性
        self.model = model

    def start_engine(self):
        print("The engine is started.")

    @staticmethod
    def honk():
        print("Honk!")

    @classmethod
    def get_wheels(cls):
        return cls.wheels

# 创建 Car 类的实例
car1 = Car("Toyota", "Camry")
car2 = Car("Honda", "Accord")

# 调用实例方法
car1.start_engine()  # Output: The engine is started.

# 调用静态方法
Car.honk()  # Output: Honk!

# 调用类方法
print(Car.get_wheels())  # Output: 4

除了普通方法，还有一些特殊的方法被称为魔术方法（Magic Methods），用于重载对象的特定行为。例如，__init__方法是在创建对象时自动调用的构造方法。魔术方法以双下划线开头和结尾，用于执行特定的操作。

总结来说，属性用于存储对象的状态，而方法用于定义对象的行为和操作。通过定义属性和方法，我们可以将相关的数据和逻辑封装到类中，实现面向对象编程的思想。

4.3 _ _init_ _方法

在Python的面向对象编程中，__init__方法是一个特殊的方法，用于在创建对象时进行初始化操作。它是在对象实例化时自动调用的构造方法。

__init__方法的主要作用是对对象的属性进行初始化赋值。通过在__init__方法中定义属性，并将其赋予特定的初始值，我们可以确保在对象创建时，它的属性已经被正确地初始化。

下面是一个示例，展示了__init__方法的使用：

class Person:
    def __init__(self, name, age):
        self.name = name  # 初始化名为name的属性
        self.age = age  # 初始化名为age的属性

person = Person("Alice", 25)
print(person.name)  # 输出：Alice
print(person.age)  # 输出：25

在上述示例中，我们定义了一个名为Person的类，其中的__init__方法接收两个参数：name和age。在方法内部，我们使用self.name = name和self.age = age语句，将传入的参数赋值给对象的属性。这样，在创建Person对象时，我们可以直接传入姓名和年龄，并将其作为对象的初始属性值。

需要注意的是，__init__方法中的第一个参数通常是self，它代表当前对象实例。在方法内部，我们可以使用self来引用对象的属性和方法。在调用类的其他方法时，不需要显式传递self参数，Python会自动将当前对象作为第一个参数传递给方法。

总结来说，__init__方法是类中的一个特殊方法，用于在对象实例化时进行属性的初始化赋值。通过在__init__方法中定义属性并进行赋值，我们可以确保在创建对象时，其属性已经被正确地初始化。

4.4 _ _init_ _ 底层实现

__init__方法是在Python中的特殊方法之一，它由解释器在对象实例化时自动调用。__init__方法的底层实现主要包括以下步骤：

1. 创建一个新的空对象。在调用类的构造方法时，解释器会创建一个新的空对象，该对象是该类的实例。

2. 将新对象的类型设置为类。解释器会将新创建的对象的类型设置为类本身，以便对象能够访问类中定义的属性和方法。

3. 分配内存空间。解释器会为新对象分配内存空间，以便存储对象的属性和方法。

4. 调用__init__方法。一旦对象的内存空间分配完毕，解释器会自动调用对象所属类中定义的__init__方法。这样，我们就有机会在该方法中进行对象属性的初始化操作。

5. 初始化属性。在__init__方法中，我们可以通过使用self来引用当前对象，并将属性赋值给对象。这些属性将存储在对象的内存空间中，以供后续的方法调用和访问。

6. 返回对象。完成属性初始化后，__init__方法执行完毕，解释器会返回新创建的对象作为类的实例。

需要注意的是，__init__方法是可选的，也就是说并不是所有的类都需要定义该方法。如果在类中没有定义__init__方法，Python会使用默认的空的__init__方法。但是，如果我们需要在对象实例化时进行属性的初始化操作，就需要显式地定义__init__方法。

总结来说，__init__方法的底层实现包括创建空对象、分配内存空间、设置对象类型、调用__init__方法、属性初始化和返回对象等步骤。这样，我们可以在__init__方法中进行对象属性的初始化赋值，确保对象在创建时已经具有正确的属性值。

4.5 静态方法

静态方法是与类相关联的方法，但不需要访问类的实例或类的任何属性。它们是类的一部分，但在调用时与类的实例无关。静态方法在类的命名空间中定义，并使用@staticmethod装饰器标记。

以下示例代码演示了在Python中如何使用静态方法（@staticmethod）定义类的静态方法。

class MathUtils:
    @staticmethod
    def add(x, y):
        return x + y

print(MathUtils.add(2, 3))  # Output: 5

在上述示例中，MathUtils类定义了一个静态方法add，该方法接受两个参数 x 和 y，并返回它们的和。由于该方法是静态方法，我们可以直接通过类名调用它，而不需要创建类的实例。

在主程序中，我们使用MathUtils.add(2, 3)调用了静态方法add，传递参数2和3。执行结果为5，即两个参数的和。

静态方法适用于那些不依赖于实例状态，仅依赖于传入参数的操作。它们可以用于实现通用的功能或实用函数，与特定实例无关。

请注意，静态方法不能访问类的实例属性或调用其他实例方法，因为它们不与特定实例关联。它们主要用于实现独立于实例的逻辑。

4.6 类方法

类方法是与类相关联的方法，它可以访问类的属性，并且可以通过类名直接调用，而不需要实例化类。类方法在类的命名空间中定义，并使用@classmethod装饰器标记。

下列示例代码演示了在Python中如何使用类方法（@classmethod）创建类的方法。

class Circle:
    pi = 3.14

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

    @classmethod
    def from_diameter(cls, diameter):
        return cls(diameter / 2)

circle = Circle.from_diameter(10)
print(circle.radius)  # Output: 5

在上述示例中，Circle类定义了一个类方法from_diameter，用于根据给定直径创建一个圆对象。该类方法接受一个参数diameter，并使用它来计算半径，并通过cls(diameter / 2)创建一个新的Circle对象。在这里，cls表示类本身，可以在类方法内部使用它来引用类。

在主程序中，我们使用Circle.from_diameter(10)调用了类方法from_diameter，传递参数10作为直径。该类方法内部使用直径计算出半径，并通过cls(diameter / 2)创建了一个新的Circle对象。最终，我们打印出该对象的半径，输出结果为5。

类方法常用于创建替代构造函数或提供便捷的对象创建方式。它们可以在不直接实例化类的情况下创建对象，并提供更多的灵活性和可读性。

请注意，类方法的第一个参数约定为cls，表示类本身。通过这个参数，我们可以在类方法内部引用类的属性或调用其他类方法。与实例方法不同，类方法不会自动传递实例作为第一个参数。

4.7 执行的优先级

在 Python 的类中，类属性、实例属性、静态方法和类方法有不同的优先级和执行顺序。

4.7.1 优先级：

实例属性的优先级最高，如果在实例中存在与类属性同名的实例属性，则会屏蔽掉类属性，优先使用实例属性。

类属性的优先级次之，在实例中没有同名的实例属性时，会使用类属性作为默认值。

静态方法和类方法不受属性优先级的影响，它们可以访问和操作类属性，但不会被类属性覆盖。

4.7.2 执行顺序：

静态方法和类方法可以在没有实例的情况下直接通过类名调用，不需要先创建实例。

实例方法需要通过实例调用，会隐式地将实例作为第一个参数传递给方法。

当通过实例调用方法时，如果方法名既在实例中定义为实例方法，又在类中定义为类方法或静态方法，则实例方法优先被调用。

当通过类名调用方法时，如果方法名既在类中定义为类方法，又在类中定义为静态方法，则类方法优先被调用。

下面是一个示例，演示了优先级和执行顺序的影响：

class MyClass:
    x = "class attribute"

    def __init__(self):
        self.x = "instance attribute"

    def print_x(self):
        print(self.x)

    @staticmethod
    def static_method():
        print("Static method")

    @classmethod
    def class_method(cls):
        print("Class method")


# 创建实例
obj = MyClass()

# 实例属性优先于类属性
print(obj.x)  # Output: instance attribute

# 实例方法优先于类方法和静态方法
obj.print_x()  # Output: instance attribute

# 类属性被类方法和静态方法访问
MyClass.static_method()  # Output: Static method
MyClass.class_method()  # Output: Class method

# 类属性被类名访问
print(MyClass.x)  # Output: class attribute

# 静态方法和类方法可以通过类名调用
MyClass.static_method()  # Output: Static method
MyClass.class_method()  # Output: Class method

在上述示例中，我们创建了一个类 MyClass，其中包含了类属性 x，实例属性 x，实例方法 print_x()，静态方法 static_method() 和类方法 class_method()。通过创建实例和调用方法，我们可以观察到不同属性和方法的优先级和执行顺序。