Python 鸭子类型、猴子补丁、白鹅类型

最新推荐文章于 2024-09-15 22:31:42 发布

测试有道

最新推荐文章于 2024-09-15 22:31:42 发布

阅读量956

点赞数 23

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/lIujunXHU/article/details/141192467

版权

Python 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

1、鸭子类型

1.1、鸭子类型说明

定义：在 Python 中，鸭子类型意味着只要对象实现了所需的方法和属性，它就可以被用作所需的类型，而不必显式地继承或实现某个接口。这种灵活性允许我们创建更加动态的代码。

它认为“如果它走路像鸭子、游泳像鸭子、叫声像鸭子，那么它就是鸭子。”在 Python 中，这意味着对象的行为（方法和属性）比其实际类型更重要。

示例：

假设我们有一个函数 make_it_fly，它要求传入的对象有一个 fly 方法。无论对象的实际类型是什么，只要它有 fly 方法，就可以传入该函数。

class Bird:
    def fly(self):
        print("Bird is flying")

class Airplane:
    def fly(self):
        print("Airplane is flying")

class Car:
    def drive(self):
        print("Car is driving")

def make_it_fly(flyable):
    flyable.fly()

# 创建对象
bird = Bird()
airplane = Airplane()
car = Car()

# 调用函数
make_it_fly(bird)      # 输出: Bird is flying
make_it_fly(airplane)  # 输出: Airplane is flying

# make_it_fly(car)  # 会引发错误，因为 Car 类没有 fly 方法

在这个例子中，make_it_fly 函数只关心传入对象是否有 fly 方法，而不关心对象的具体类型。这就是鸭子类型的特征：只要对象的行为符合要求，它就可以被使用。

1.2、多态说明

定义：多态是指同一种操作作用于不同类型的对象上，能够表现出不同的行为。在面向对象编程中，多态通常通过继承和重写方法来实现。

示例：

我们创建一个基类 Shape，并让两个子类 Circle 和 Rectangle 继承自它。每个子类实现自己的 area 方法。即使调用 area 方法的对象的具体类型不同，结果会不同，这是多态的体现。

class Shape:
    def area(self):
        raise NotImplementedError("Subclasses must implement this method")

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

def print_area(shape):
    print("Area:", shape.area())

# 创建对象
circle = Circle(5)
rectangle = Rectangle(4, 6)

# 调用函数
print_area(circle)      # 输出: Area: 78.5
print_area(rectangle)  # 输出: Area: 24

在这个例子中，print_area 函数接受 Shape 类型的对象，但它可以处理任何继承自 Shape 的子类对象。每个子类实现了不同的 area 方法，体现了多态的特性：同一个方法名称 area 在不同的对象上有不同的实现。

1.3、二者对比

鸭子类型：侧重于对象是否具有所需的方法或属性，不关心对象的实际类型。例如，make_it_fly 函数只关心对象是否有 fly 方法。
多态：侧重于不同对象类型可以通过相同的接口（方法）表现出不同的行为。例如，print_area 函数可以处理不同形状的对象，通过不同的 area 实现展示不同的结果。
两者之间有交集，但鸭子类型强调的是接口的适配性，而多态则强调通过统一接口处理不同对象的能力。

2、猴子补丁

定义：Python中的猴子补丁（Monkey Patching）是一种动态修改代码运行时行为的技术，它允许开发者在不修改源代码的情况下（在内存中发挥作用，不会修改源码），通过替换或修改对象（如模块、类或函数）的属性和方法，来改变程序的行为。

作用：

动态修复bug：在程序运行时，如果发现某个模块或类的行为不符合预期，可以使用猴子补丁来快速修复bug，而无需停止程序、修改源代码并重新部署。
动态增加功能：在不修改现有代码的情况下，为模块或类添加新的功能或行为，以满足新的需求。
临时解决方案：当第三方库中存在错误或缺失的功能，而开发者无法直接修改其源代码时，可以使用猴子补丁作为临时解决方案。

优势：

灵活性高：猴子补丁允许在运行时动态修改代码行为，提供了极高的灵活性。
避免依赖升级：在依赖关系复杂或版本冲突的情况下，使用猴子补丁可以避免升级依赖或等待上游修复的漫长周期。

劣势：

可维护性差：猴子补丁可能会破坏代码的封装性和可维护性，使得其他开发者难以理解和维护代码。
潜在风险高：不当的猴子补丁可能会导致程序行为不可预测，增加调试和排错的难度。
版本控制问题：猴子补丁的代码可能不会很好地与版本控制系统集成，因为它们通常是在运行时应用的。

示例：

假设我们有一个名为math_utils.py的模块，里面定义了一个计算平方根的函数sqrt：

# math_utils.py  
import math  
  
def sqrt(number):  
    return math.sqrt(number)

现在，我们想在运行时修改sqrt函数的行为，使其能够处理负数输入并返回绝对值的平方根。我们可以使用猴子补丁来实现这一点（在主入口函数中）：

# main.py  
import math_utils  
import math  
  
def positive_sqrt(number):  
    return math.sqrt(abs(number))  
  
# 使用猴子补丁替换math_utils模块中的sqrt函数  
math_utils.sqrt = positive_sqrt  
  
# 测试修改后的sqrt函数  
print(math_utils.sqrt(-4))  # 输出: 2.0

在这个示例中，我们通过直接替换math_utils模块中的sqrt函数引用，实现了对其行为的动态修改。这样，在不修改math_utils.py源代码的情况下，我们就改变了sqrt函数的行为。

总的来说，猴子补丁是Python中一个强大但需谨慎使用的工具。在享受其带来的灵活性和快速响应能力的同时，开发者也需要注意其可能带来的可维护性和稳定性问题。

3、白鹅类型

定义：Python中的白鹅类型（Goose Typing）是一种与鸭子类型（Duck Typing）相对应的编程风格，它主要关注于使用抽象基类（Abstract Base Classes, ABCs）来明确声明接口。

白鹅类型的特点：

明确接口定义：白鹅类型通过抽象基类明确声明了接口，这些接口包括了一系列必须实现的方法。子类在继承抽象基类时，必须实现这些抽象方法，以满足接口定义。
抽象基类检查：抽象基类会在运行时检查子类是否实现了所有必需的接口方法。如果子类没有实现所有抽象方法，尝试实例化该子类将会导致错误。
注册机制：即使没有直接继承抽象基类，也可以通过注册机制将一个类声明为抽象基类的虚拟子类。这允许类在不改变其继承结构的情况下，获得抽象基类提供的某些功能或特性。
灵活性：与鸭子类型相比，白鹅类型提供了更多的灵活性和控制。通过明确接口定义，白鹅类型能够确保类型安全，并减少运行时错误。

示例：

import abc
class Animal(abc.ABC): # 定义抽象类
    @abc.abstractmethod  # 定义抽象类方法，子类必须实现该方法
    def run(self):
        pass

class Cat(Animal):
    def run(self):
        print("{} is running".format(__class__.__name__))

class Dog(Animal):
    def run(self):
        print("{} is running".format(__class__.__name__))

animal = [Cat(), Dog()]
for a in animal:
    a.run()

Python中的白鹅类型是一种通过抽象基类明确声明接口的编程风格。它提供了比鸭子类型更多的类型安全和灵活性，通过接口定义和抽象基类检查来确保子类实现了必要的方法。这种类型在构建框架和库时特别有用，因为它允许开发者定义清晰的接口，并确保其他开发者在实现这些接口时遵循相同的规范。