08. 面向对象编程（二）

本文介绍: 上一篇文章中，我们介绍了面向对象编程的类和实例，以及三大基本特性。今天我们继续来了解面向对象编程的其他知识。

1、前言

5.2、字符串表示运算符 str() 的重载

5.3、索引运算符 [] 的重载

6、小结

1、前言

上一篇文章中，我们介绍了面向对象编程的类和实例，以及三大基本特性。今天我们继续来了解面向对象编程的其他知识。

2、多重继承

多重继承是面向对象编程中的一个概念，它允许一个类同时继承自多个父类。这使得子类可以继承多个父类的属性和方法。在Python中，多重继承是支持的，但需要小心使用，因为它可能引起一些设计上的复杂性和潜在的问题。

多重继承的场景：举个例子，我们现在可能会拥有多种角色，比如程序员（Programmer）以及老父亲（Father）。那么Python中我们可能定义两个类：

# 老父亲类
class Father:
    pass

# 程序员类
class Programmer:
    pass

同时，两个不同的类拥有一个相同的方法（eat）和各自不同的方法：老父亲拥有泡奶粉的方法，程序员需要加班改bug的方法。代码示例：

# 老父亲类
class Father:

    # 老父亲需要泡奶粉的动作
    def soak_milk(self):
        print("我是一位老父亲，加班到家后要给娃泡奶粉")

    # 老父亲也要吃饭
    def eat(self):
        print("老父亲要吃饭，吃面条")


# 程序员类
class Programmer:

    # 程序员要加班改bug
    def fix_bug(self):
        print("我是一位程序猿，需要加班改bug")

    # 程序员也要吃饭
    def eat(self):
        print("程序员要吃饭，吃快餐")

最后，我同时拥有这两个角色，那么创建一个我的类，继承了Father和Programmer，之后创建出来的实例就同时拥有了老父亲泡奶粉的能力，以及程序员加班改bug的能力。完整示例代码：

# 创建一个我的类，多重继承Father和Programmer
class Me(Father, Programmer):
    pass

# 创建一个我的实例
me = Me()
# 我要吃饭
me.eat()
# 老父亲泡奶粉
me.soak_milk()
# 程序员改bug
me.fix_bug()

执行结果：

从上述代码中可以看出，多重继承的语法为class 类名(父类1, 父类2…)。如果继承的多个父类中有相同的方法，那么最先执行最左继承的父类。什么？你问我怎么知道的？我猜的！！！来看我猜的对不对，Python提供了一个特殊的方法__mro__来查看类的方法解析顺序。

在多重继承中，Python 使用 C3 线性化算法来确定方法的调用顺序，这被称为方法解析顺序（Method Resolution Order，简称MRO）。MRO 定义了从多个父类中继承方法时的顺序，它是基于 C3 算法生成的线性列表。

查看结果：

先解析Me类，之后是Father，再Programmer。诚不欺客，没骗人吧！

2.1、潜在的问题

尽管多重继承提供了一定的灵活性，但也容易导致一些设计上的复杂性和潜在的问题，例如：

菱形继承问题：当一个子类继承自两个有共同父类的类时，可能会出现方法冲突的问题。Python 的 MRO 算法通常能够解决这个问题，但在复杂的继承结构中，需要小心设计以避免混淆。
代码可读性：多重继承可能导致代码可读性降低，因为需要追踪多个父类的方法和属性。
耦合性：过度使用多重继承可能导致类之间的高度耦合，降低了代码的灵活性和可维护性。

3、@Property

@property 是 Python 中用于将方法转换为只读属性的装饰器。通过使用 @property 装饰器，你可以定义一个方法，使之在调用时表现得像一个属性一样。这有助于隐藏类的内部实现细节，提高代码的可读性。正如上一篇中提到受保护成员的访问控制时，除了使用公开方法访问外，还可以此装饰器进行访问。

class Girl:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self._weight = 90   # 女孩子的体重当然是秘密了

    def get_weight(self):
        return self._weight

girl = Girl("小花", 20)
# 访问方式1
print(f"{girl.name}今年{girl.age}岁，体重{girl._weight}公斤")
# 访问方式2
print(f"{girl.name}今年{girl.age}岁，体重{girl.get_weight()}公斤")

上面代码是前面介绍到的访问方式，除了这两个以外，还可以使用@Property。代码改造一下：

class Girl:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self._weight = 90  # 女孩子的体重当然是秘密了

    def get_weight(self):
        return self._weight


    # @Property注解装饰的，是被视为只读的属性
    @property
    def weight(self):
        return self._weight


girl = Girl("小花", 20)
print(f"{girl.name}今年{girl.age}岁，体重{girl.weight}公斤")

也是可以访问的，当我们调用girl.weight时，实际上并不是直接访问属性，而是调用get_weight()方法。使用@Property只是简化了get_weight()的调用方式。

但是值得注意的是@Property注释的属性会被视为只读属性，如果此时你试图修改它，那么Python解释器会给你抛出异常，告诉你他没有setter方法。

当然，如果我们已添加了@Property后，还可以使用“@属性名称.setter”方式来定义属性的setter方法。

class Girl:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self._weight = 90

    def get_weight(self):
        return self._weight


    # @Property注解装饰的，是被视为只读的属性
    @property
    def weight(self):
        return self._weight

    # 添加   @属性名称.setter   表示给该属性添加了setter方法，该setter方法允许你修改该变量的值
    @weight.setter
    def weight(self, val):
        self._weight = val


girl = Girl("小花", 20)
print(f"{girl.name}今年{girl.age}岁，体重{girl.weight}公斤")
girl.weight = 200
print(f"{girl.name}今年{girl.age}岁，体重{girl.weight}公斤")

这时候，我们运行程序就不会报错了：

4、@staticmethod

@staticmethod 是 Python 中用于定义静态方法的装饰器。静态方法是类中的方法，与类的实例无关，因此它不会访问或修改实例的状态。静态方法通常用于执行与类相关的操作，而不需要访问实例的属性。

class MyClass:
    @staticmethod
    def static_method_with_decorator():
        return "I am a static method with decorator"

    def static_method_without_decorator():
        return "I am a static method without decorator"

# 通过类名调用带有装饰器的静态方法
result1 = MyClass.static_method_with_decorator()
print(result1)  # 输出: I am a static method with decorator

# 通过类名调用没有装饰器的静态方法（不推荐）
result2 = MyClass.static_method_without_decorator()
print(result2)  # 输出: I am a static method without decorator

运行结果：

但是你会发现，其实加不加@staticmethod都允许用类名来访问静态方法，那么既然如此为什么要加上这个注解呢？其实，在 Python 中，加不加 @staticmethod 装饰器影响的是对方法的理解和类的设计风格。从功能上来说，不加 @staticmethod 也可以正常工作，因为 Python 允许通过类名直接调用类的方法。

然而，使用 @staticmethod 装饰器有一些优点：

清晰性：@staticmethod 装饰器明确地表明某个方法是静态方法，提高了代码的可读性。读者可以立即看到这个方法是与类相关但与实例无关的。
一致性：在类中使用 @staticmethod 保持了方法定义的一致性，使得在查看类的方法时更容易识别哪些方法是静态的。
IDE支持：使用 @staticmethod 可以让一些集成开发环境（IDE）更好地支持代码提示和文档生成。

5、运算符重载

运算符重载是指在类中定义特殊方法，使得该类的实例对象可以支持一些内建运算符（如+、-、*等）的操作。通过重载运算符，我们可以定义自定义的行为，使得类对象可以与运算符一样被操作。

在Python中，运算符重载是通过特殊方法来实现的，这些方法以双下划线开头和结尾，例如 __add__、__sub__、__mul__等。以下是一些常用的运算符重载方法。

5.1、加法运算符 + 的重载

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if isinstance(other, Point):
            return Point(self.x + other.x, self.y + other.y)
        else:
            raise TypeError("Unsupported operand type")

p1 = Point(1, 2)
p2 = Point(3, 4)
result = p1 + p2
print(result.x, result.y)  # 输出: 4 6

5.2、字符串表示运算符 str() 的重载

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"Point({self.x}, {self.y})"

p = Point(1, 2)
print(str(p))  # 输出: Point(1, 2)

5.3、索引运算符 [] 的重载

class Vector:
    def __init__(self, values):
        self.values = values

    def __getitem__(self, index):
        return self.values[index]

v = Vector([1, 2, 3, 4, 5])
print(v[2])  # 输出: 3

运算符重载为类提供了更自然和直观的使用方式，使得类的实例对象可以像内建类型一样参与各种操作。然而，需要小心不要滥用运算符重载，以避免使代码变得难以理解和维护。