[Python基础课程]31_接口

在编程中，接口（Interface） 是一种纯粹的协议或契约。它只定义一个类"能做什么"（即方法签名），而不定义"怎么做"（即方法实现）。

如果说抽象类是一张"带有一部分说明的蓝图"，那么接口就是一份清单：它列出了所有必须具备的功能，谁想声明自己属于这一类，谁就必须实现清单上的所有条目。

在 Python 中，"接口" (interface) 的概念与在 Java 或 C# 等语言中有所不同。Python 并没有像这些语言那样内置的、强制性的 interface 关键字。Python 更倾向于鸭子类型 (Duck Typing) 的哲学，即"如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子"。

尽管如此，我们仍然可以通过多种方式在 Python 中实现接口的概念，但我们可以通过鸭子类型、抽象基类、协议来实现和接口一样的效果。

java 复制代码

public interface Vehicle {
    
    // 接口中定义的方法默认是 public 和 abstract 的，因此这两个关键字通常可以省略
    void startEngine();
    
    // 接口中的方法也默认是 public
    void stopEngine();
}

鸭子类型

这是 Python 中实现接口最自然和最常用的方式。你不需要显式地声明一个类实现某个接口，只要这个类提供了接口所需的方法，那么它就可以被当作实现了这个接口。

优点： 简洁，符合 Python 的哲学。

缺点： 缺乏编译时检查（Python 是动态类型语言），错误可能在运行时才暴露。

下面是使用鸭子类型的一个例子：

python 复制代码

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

class Duck:
    def speak(self):
        return "Quack!"

def make_noise(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()
duck = Duck()

make_noise(dog)  # 输出: Woof!
make_noise(cat)  # 输出: Meow!
make_noise(duck) # 输出: Quack!

# 如果传入一个没有 speak 方法的对象，会在运行时出错
class Rock:
    pass

rock = Rock()
# make_noise(rock) # 会引发 AttributeError: 'Rock' object has no attribute 'speak'

在这个例子中，Dog、Cat 和 Duck 类都提供了 speak 方法，所以它们都可以被 make_noise 函数"看作"实现了"会说话"的接口。

抽象基类

Python 提供了 abc（Abstract Base Classes - ABCs）模块来定义抽象基类。抽象基类可以定义抽象方法，子类必须实现这些抽象方法才能被实例化。这提供了一种更正式的方式来定义接口，并且可以在一定程度上提供类型检查。

优点：

强制实现： 子类必须实现抽象方法，否则无法实例化。
类型检查： 可以使用 isinstance() 和 issubclass() 进行类型检查。
明确意图： 清晰地表达了类的设计意图，即它是一个接口。

缺点： 仍然是运行时检查，而不是编译时检查。

python 复制代码

from abc import ABC, abstractmethod

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

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def make_noise(animal: Animal):
    print(animal.speak())

# 不能直接实例化抽象基类
# animal = Animal() # 会引发 TypeError: Can't instantiate abstract class Animal with abstract method speak

if __name__ == '__main__':
    make_noise(Dog())
    make_noise(Cat())

# 如果子类没有实现抽象方法，会报错
class Bird(Animal):
    pass

# bird = Bird() # 会引发 TypeError: Can't instantiate abstract class Bird with abstract method speak

print(isinstance(dog, Animal)) # 输出: True
print(issubclass(Dog, Animal)) # 输出: True

在这个例子中，Animal 是一个抽象基类，定义了 speak 抽象方法。Dog 和 Cat 继承了这个抽象基类，就必须实现 speak 方法才能被实例化。

make_noise 方法指定了输入的参数的类型必须是 Animal 类或其子类，这就要求输入的参数都要实现 Animal 中的抽象方法，达到了类似接口的规范作用。

协议

Python 3.8 引入了 typing.Protocol，这是一种更明确、更类型化的方式来定义接口。它允许你在不强制继承的情况下，通过类型提示来定义期望的行为。

优点：

类型提示： 结合类型检查工具（如 MyPy），可以在开发阶段捕获类型错误。
非继承关系： 不需要强制继承关系，任何符合协议的对象都可以被视为实现了该协议。
更精确的接口定义： 可以定义更复杂的接口，包括属性和方法。

缺点： 需要使用外部类型检查工具才能发挥最大作用。

python 复制代码

from typing import Protocol


class Speaker(Protocol):
    def speak(self) -> str:
        # ... 表示这是一个抽象方法，不需要具体实现
        ...


class Dog:
    def speak(self) -> str:
        return "Woof!"


class Cat:
    def speak(self) -> str:
        return "Meow!"


class Car:
    def drive(self) -> str:
        return "Vroom!"


def make_animal_noise(animal: Speaker):
    print(animal.speak())


dog_instance = Dog()
cat_instance = Cat()
car_instance = Car()

# 输出: Woof!
make_animal_noise(dog_instance)
# 输出: Meow!
make_animal_noise(cat_instance)

# 使用 MyPy 检查会发现错误，因为 Car 不符合 Speaker 协议
# make_animal_noise(car_instance) # MyPy 会报错: Argument "car_instance" to "make_animal_noise" has incompatible type "Car"; expected "Speaker"

在这个例子中，Speaker 是一个协议，定义了 speak 方法。Dog 和 Cat 都符合 Speaker 协议，即使它们没有直接继承 Speaker。make_animal_noise 函数通过类型提示 animal: Speaker 明确表示它期望一个符合 Speaker 协议的对象。

如何使用 MyPy 检查代码？参考如下步骤：

shell 复制代码

pip install mypy
python -m mypy test.py