七、多态的魔力：什么是多态，鸭子类型在Python中的体现，抽象基类与接口设计

多态这个词，听起来挺唬人的。说白了就是一句话：同一个操作，作用于不同的对象，会产生不同的结果。我刚开始学面向对象时，总觉得多态是个很高深的概念。后来写多了才发现，它其实就是让代码更灵活、更通用的一个手段。

你想想看，如果没有多态，我们写代码就得针对每种类型写一套逻辑。有了多态，一套代码就能处理多种类型。这就是它的魔力所在。

7.1 什么是多态

多态（Polymorphism）这个词来自希腊语，意思是"多种形态"。在编程中，它指的是同一个接口，可以有不同的实现方式。

举个例子：

class Dog:
    def speak(self):
        return "汪汪汪"

class Cat:
    def speak(self):
        return "喵喵喵"

class Duck:
    def speak(self):
        return "嘎嘎嘎"

# 多态的体现
def animal_sound(animal):
    print(animal.speak())

# 传入不同的对象，得到不同的结果
animal_sound(Dog())   # 汪汪汪
animal_sound(Cat())   # 喵喵喵
animal_sound(Duck())  # 嘎嘎嘎

看到了吗？animal_sound 这个函数根本不关心你传进来的是什么类型。它只要求你有一个 speak 方法。这就是多态的核心思想：关注行为，而不是类型。

7.2 鸭子类型：Python 的多态哲学

Python 的多态，和 Java、C++ 那种传统多态不太一样。Python 用的是"鸭子类型"（Duck Typing）。

这个概念来自一句谚语："如果它走起来像鸭子，叫起来像鸭子，那它就是鸭子。"

在 Python 中，我们不关心对象是什么类型，只关心它有没有我们需要的方法或属性。我在项目中遇到过好几次这样的场景：

class Duck:
    def quack(self):
        print("鸭子叫：嘎嘎嘎")

class Person:
    def quack(self):
        print("人模仿鸭子叫：嘎嘎嘎")

def make_it_quack(thing):
    thing.quack()

# 不管是鸭子还是人，只要能 quack 就行
make_it_quack(Duck())    # 鸭子叫：嘎嘎嘎
make_it_quack(Person())  # 人模仿鸭子叫：嘎嘎嘎

这就是鸭子类型的魅力。你不需要继承同一个父类，不需要实现同一个接口。只要行为一致，就能被当作同一类对象使用。

7.3 鸭子类型的实际应用

鸭子类型在 Python 标准库中随处可见。比如 len() 函数：

# 只要实现了 __len__ 方法，就能用 len()
class MyCollection:
    def __len__(self):
        return 42

print(len(MyCollection()))  # 42
print(len([1, 2, 3]))       # 3
print(len("hello"))         # 5

再比如迭代器协议：

class MyRange:
    def __init__(self, n):
        self.n = n
        self.i = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.i < self.n:
            val = self.i
            self.i += 1
            return val
        else:
            raise StopIteration

# 只要实现了 __iter__ 和 __next__，就能用 for 循环
for x in MyRange(5):
    print(x)  # 0 1 2 3 4

为什么会这样？因为 Python 的 for 循环根本不关心你是什么类型。它只检查你有没有 __iter__ 和 __next__ 方法。这就是鸭子类型在语言层面的体现。

7.4 抽象基类：给鸭子类型加上规范

鸭子类型虽然灵活，但也有缺点。比如，你没法强制要求某个类必须实现某些方法。这时候，抽象基类（Abstract Base Class，简称 ABC）就派上用场了。

抽象基类的作用是：定义一组必须实现的方法，子类如果不实现，实例化时会报错。

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass
    
    @abstractmethod
    def move(self):
        pass

class Dog(Animal):
    def speak(self):
        return "汪汪汪"
    
    def move(self):
        return "跑起来了"

# 如果只实现 speak，不实现 move，实例化时会报错
# class Cat(Animal):
#     def speak(self):
#         return "喵喵喵"
# 
# cat = Cat()  # TypeError: Can't instantiate abstract class Cat with abstract method move

7.5 接口设计：抽象基类的正确用法

抽象基类在 Python 中，其实扮演了"接口"的角色。但 Python 没有 Java 那种专门的 interface 关键字，所以用 ABC 来实现接口设计。

我个人的习惯是：

1. 定义抽象基类时，只放核心方法。比如一个"可打印"的接口，只需要 print_info 方法。
2. 抽象方法不要太多。3-5 个就够了，太多会让子类实现起来很痛苦。
3. 可以用默认实现。不是所有方法都必须抽象，有些方法可以提供默认行为。

from abc import ABC, abstractmethod

class DataExporter(ABC):
    @abstractmethod
    def export(self, data):
        """导出数据，子类必须实现"""
        pass
    
    def validate(self, data):
        """数据验证，提供默认实现"""
        if not data:
            raise ValueError("数据不能为空")
        return True

class CSVExporter(DataExporter):
    def export(self, data):
        self.validate(data)
        print(f"导出为 CSV 格式：{data}")

class JSONExporter(DataExporter):
    def export(self, data):
        self.validate(data)
        print(f"导出为 JSON 格式：{data}")

你看，validate 方法提供了默认实现，子类可以直接用。而 export 方法必须自己实现。这样既保证了灵活性，又强制了规范。

7.6 鸭子类型 vs 抽象基类：什么时候用哪个？

这个问题我经常被问到。我的建议是：

场景	推荐方式	原因
小型项目、脚本	鸭子类型	灵活、快速，不需要太多约束
大型项目、框架	抽象基类	规范、可维护，团队协作时更清晰
库/API 设计	抽象基类	给使用者明确的接口规范
内部实现、临时代码	鸭子类型	减少代码量，提高开发效率

说白了，鸭子类型是 Python 的"默认模式"，抽象基类是"加强模式"。你可以在同一个项目中混合使用它们。

7.7 知识体系总览

下面这张图，帮你理清本章的核心逻辑：

7.8 总结

多态是面向对象编程中非常实用的特性。在 Python 中，它主要通过鸭子类型和抽象基类两种方式实现。

• 鸭子类型：灵活、自由，适合快速开发和脚本编写。你不需要继承任何东西，只要行为一致就行。
• 抽象基类：规范、严谨，适合大型项目和框架设计。它强制子类实现某些方法，保证接口的一致性。

嗯，这里要注意一点：不要为了用抽象基类而用抽象基类。如果你的代码只有两三个人用，鸭子类型完全够用。只有当你需要给很多人提供接口，或者团队协作需要明确规范时，才考虑抽象基类。

我在项目中见过不少过度设计的例子。有人把所有类都继承自抽象基类，结果代码变得又臭又长。记住：简单才是王道。能用鸭子类型解决的问题，就不要引入抽象基类。

---

公众号:蓝海资料掘金营，微信deep3321