Python 3 入门与进阶(十):面向对象编程(下)——继承、多态与高级特性

大家好，我是煜道。

今天我们一起来学习 面向对象编程（下）——继承、多态与高级特性。

引言

继承是面向对象编程的核心特征之一，它允许我们创建类的层次结构，实现代码复用和逻辑扩展。多态则使得不同类的对象可以以统一的方式进行处理，提高了代码的灵活性和可扩展性。

Python作为一门多范式语言，在面向对象方面提供了丰富的支持，包括单继承、多继承、抽象基类以及Mixin模式等高级特性。

本文将深入探讨Python面向对象的高级特性，包括继承的实现、MRO（方法解析顺序）、super()函数的使用、多态的实现、抽象基类以及Mixin模式。通过本文的学习，我们将能够设计复杂的类层次结构，并灵活运用面向对象的高级技巧。

01 继承的基本概念

1.1 什么是继承

继承允许我们创建新类（子类）来继承已有类（父类或基类）的属性和方法：

classAnimal:def__init__(self, name):        self.name = namedefspeak(self):passclassDog(Animal):defspeak(self):returnf"{self.name} says Woof!"classCat(Animal):defspeak(self):returnf"{self.name} says Meow!"dog = Dog("Buddy")cat = Cat("Whiskers")print(dog.speak())  # Buddy says Woof!print(cat.speak())  # Whiskers says Meow!

1.2 继承的实现

classPerson:def__init__(self, name, age):        self.name = name        self.age = agedefintroduce(self):returnf"I'm {self.name}, {self.age} years old"classStudent(Person):def__init__(self, name, age, student_id):# 调用父类构造函数        super().__init__(name, age)        self.student_id = student_iddefintroduce(self):        base_intro = super().introduce()returnf"{base_intro}, student ID: {self.student_id}"student = Student("Alice", 20, "S12345")print(student.introduce())# I'm Alice, 20 years old, student ID: S12345

1.3 isinstance与issubclass

classAnimal:passclassDog(Animal):passclassCat(Animal):passdog = Dog()# isinstance检查对象是否是某类的实例print(isinstance(dog, Dog))    # Trueprint(isinstance(dog, Animal)) # True（继承关系）# issubclass检查类是否是另一类的子类print(issubclass(Dog, Animal))  # Trueprint(issubclass(Dog, Cat))     # False

02 方法重写与super()

2.1 方法重写

子类可以重写父类的方法：

classShape:defarea(self):return0classRectangle(Shape):def__init__(self, width, height):        self.width = width        self.height = heightdefarea(self):return self.width * self.heightr = Rectangle(5, 3)print(r.area())  # 15（重写后的方法）

2.2 super()函数

super()用于调用父类的方法：

classParent:def__init__(self):        print("Parent __init__")        self.value = 100defmethod(self):        print("Parent method")classChild(Parent):def__init__(self):        super().__init__()  # 调用父类__init__        print("Child __init__")        self.value = 200# 重写defmethod(self):        super().method()  # 调用父类方法        print("Child method")child = Child()# 输出：# Parent __init__# Child __init__child.method()# 输出：# Parent method# Child method

2.3 super()的原理

super()实际上返回的是代理对象，它负责按照MRO顺序查找方法：

classA:defprocess(self):        print("A process")classB(A):defprocess(self):        print("B process")        super().process()classC(A):defprocess(self):        print("C process")        super().process()classD(B, C):defprocess(self):        print("D process")        super().process()d = D()d.process()# 输出：# D process# B process# C process# A process

03 多重继承与MRO

3.1 多重继承

Python支持一个类继承多个父类：

classFlyable:deffly(self):returnf"{self.name} is flying"classSwimmable:defswim(self):returnf"{self.name} is swimming"classDuck(Flyable, Swimmable):def__init__(self, name):        self.name = nameduck = Duck("Donald")print(duck.fly())    # Donald is flyingprint(duck.swim())   # Donald is swimming

3.2 方法解析顺序（MRO）

当存在多重继承时，Python使用C3线性化算法确定方法查找顺序：

classA:defmethod(self):        print("A")classB(A):defmethod(self):        print("B")classC(A):defmethod(self):        print("C")classD(B, C):passd = D()d.method()  # 输出B# 查看MROprint(D.mro())# [<class '__main__.D'>, <class '__main__.B'>,#  <class '__main__.C'>, <class '__main__.A'>,#  <class 'object'>]

3.3 菱形继承问题

# 菱形继承示例classBase:def__init__(self):        print("Base __init__")classA(Base):def__init__(self):        super().__init__()        print("A __init__")classB(Base):def__init__(self):        super().__init__()        print("B __init__")classC(A, B):def__init__(self):        super().__init__()  # 只调用一次Base        print("C __init__")c = C()# 输出：# Base __init__# B __init__# A __init__# C __init__

04 多态

4.1 什么是多态

多态意味着"多种形式"——不同的类可以以相同的方式响应相同的消息（方法调用）。

classAnimal:defspeak(self):passclassDog(Animal):defspeak(self):return"Woof!"classCat(Animal):defspeak(self):return"Meow!"classCow(Animal):defspeak(self):return"Moo!"# 多态：相同的调用，不同的结果defmake_speak(animal):    print(animal.speak())animals = [Dog(), Cat(), Cow()]for animal in animals:    make_speak(animal)# Woof!# Meow!# Moo!

4.2 鸭子类型

Python采用"鸭子类型"（Duck Typing）："如果它走起来像鸭子，叫起来像鸭子，那它就是鸭子。"

classDuck:deffly(self):return"Duck flying"classAirplane:deffly(self):return"Airplane flying"# 两者都可以传递给需要"能飞"的函数deftakeoff(obj):    print(obj.fly())duck = Duck()plane = Airplane()takeoff(duck)   # Duck flyingtakeoff(plane)  # Airplane flying

4.3 Protocol与结构子类型

Python 3.8+引入的Protocol实现了结构子类型：

from typing import ProtocolclassFlyable(Protocol):deffly(self) -> str:        ...classBird:deffly(self):return"Bird flying"classAirplane:deffly(self):return"Airplane flying"deftakeoff(obj: Flyable):    print(obj.fly())# Flyable是Protocol，只要对象有fly方法即可bird = Bird()plane = Airplane()takeoff(bird)    # Bird flyingtakeoff(plane)   # Airplane flying

05 抽象基类

5.1 抽象基类的定义

抽象基类（ABC）用于定义必须由子类实现的方法接口：

from abc import ABC, abstractmethodclassShape(ABC):    @abstractmethoddefarea(self):pass    @abstractmethoddefperimeter(self):passclassRectangle(Shape):def__init__(self, width, height):        self.width = width        self.height = heightdefarea(self):return self.width * self.heightdefperimeter(self):return2 * (self.width + self.height)# r = Shape()  # TypeError：不能实例化抽象类r = Rectangle(5, 3)print(r.area())      # 15print(r.perimeter()) # 16

5.2 使用抽象基类的好处

from abc import ABC, abstractmethodclassCacheBase(ABC):    @abstractmethoddefget(self, key):pass    @abstractmethoddefset(self, key, value):passclassRedisCache(CacheBase):defget(self, key):# 实现Redis获取逻辑passdefset(self, key, value):# 实现Redis设置逻辑pass# 如果忘记实现某个方法，会在创建实例时报错# cache = RedisCache()  # TypeError（如果方法未实现）

5.3 预定义抽象基类

from collections.abc import Sized, Iterable, ContainerclassMyList(Sized, Iterable, Container):def__init__(self, data):        self.data = datadef__len__(self):return len(self.data)def__iter__(self):return iter(self.data)def__contains__(self, item):return item in self.data# 检查是否实现某接口lst = MyList([1, 2, 3])print(isinstance(lst, Sized))     # Trueprint(isinstance(lst, Iterable))  # True

06 Mixin模式

6.1 什么是Mixin

Mixin是一种代码复用的设计模式，通过多重继承将功能"混入"到类中：

classJsonMixin:defto_json(self):import jsonreturn json.dumps(self.__dict__)classXmlMixin:defto_xml(self):# 简化的XML转换returnf"<{self.__class__.__name__}>{self.__dict__}</{self.__class__.__name__}>"classUser(JsonMixin, XmlMixin):def__init__(self, name, email):        self.name = name        self.email = emailuser = User("Alice", "alice@example.com")print(user.to_json())print(user.to_xml())

6.2 Mixin的特点

6.3 Mixin的实际应用

classJsonSerializer:defserialize(self):import jsonreturn json.dumps({            k: v for k, v in self.__dict__.items()ifnot k.startswith('_')        })classTimestampMixin:def__init__(self, *args, **kwargs):        super().__init__(*args, **kwargs)        self.created_at = self.updated_at = self._now()def_now(self):from datetime import datetimereturn datetime.now().isoformat()deftouch(self):        self.updated_at = self._now()classValidatedMixin:defvalidate(self):# 验证逻辑returnTrueclassUser(JsonSerializer, TimestampMixin, ValidatedMixin):def__init__(self, name, email):        self.name = name        self.email = email        super().__init__()user = User("Alice", "alice@example.com")print(user.serialize())print(user.created_at)

07 组合与继承

7.1 优先使用组合

"组合优于继承"是一条重要的设计原则：

# 继承方式classA:defmethod(self):        print("A method")classB(A):defother_method(self):        self.method()# 组合方式classA:defmethod(self):        print("A method")classB:def__init__(self):        self.a = A()defother_method(self):        self.a.method()

7.2 何时使用继承

• "是一个"（is-a）关系：Dog is an Animal。
• 需要使用父类的功能。
• 需要多态行为。

7.3 何时使用组合

• "有一个"（has-a）关系：Car has an Engine。
• 需要灵活组合功能。
• 避免多重继承的复杂性。

08 小结

本文深入探讨了Python面向对象的高级特性：

1. 继承：单继承与多继承，isinstance和issubclass。
2. 方法重写与super()：调用父类方法，MRO的作用。
3. 多重继承：C3线性化算法，菱形继承问题。
4. 多态：鸭子类型，Protocol。
5. 抽象基类：ABC，@abstractmethod。
6. Mixin模式：功能混入，组合优于继承。

面向对象编程是Python的重要范式，合理运用继承、组合和多态能够构建出灵活、可维护的代码结构。