摘要：Python 以其 “duck typing” 哲学而闻名，这是一种多态性形式，其中对象的类型或类不如它定义的方法重要。当您在不知道对象类型的情况下使用对象的方法时，只要该对象支持方法调用，Python 就会运行它。这通常被总结为“如果它看起来像一只鸭子，嘎嘎

多态性是面向对象编程 （OOP） 中的一个核心概念，是指单个接口支持多种类型实体的能力，或者不同对象以唯一方式响应同一方法调用的能力。

在 Python 中，多态性是其设计中固有的，允许灵活和动态地使用对象。让我们分解一下概述的多态性的主要特性，以及它们如何在 Python 中应用。

Python 以其 “duck typing” 哲学而闻名，这是一种多态性形式，其中对象的类型或类不如它定义的方法重要。当您在不知道对象类型的情况下使用对象的方法时，只要该对象支持方法调用，Python 就会运行它。这通常被总结为“如果它看起来像一只鸭子，嘎嘎叫声像一只鸭子，那它一定是一只鸭子。

Python 中多态性的一个典型示例是 + 运算符，它可以在两个整数之间执行加法或连接两个字符串，具体取决于操作数类型。这是 Python 的一个内置功能，展示了它的灵活性和动态类型。

类方法的多态性是 Python 中的一个有效工具，在数据科学领域特别有价值。它允许创建灵活、可扩展且可维护的代码，这些代码可以通过统一的接口处理各种数据类型和处理策略。通过利用多态性，数据科学家可以将他们的代码库设计得更加抽象和通用，从而促进跨各种数据科学任务的更轻松的实验和迭代。

在许多编程语言中，方法重载是指拥有多个名称相同但参数不同的方法的能力。这通常用于为方法提供不同的实现，具体取决于传递的参数的数量和类型。但是，由于其性质和处理函数定义的方式，Python 处理此概念的方式不同。

在 Python 中，方法是在类中定义的，它们的行为不会根据传递的参数的数量或类型而改变。如果在同一范围内定义多个名称相同但参数不同的方法，则最后一个定义将覆盖前面的定义。这是因为 Python 不支持 Java 或 C++ 等静态类型语言中的传统方法重载。相反，Python 依靠其动态类型和其他功能来实现类似的功能。下面是一个演示此演示的简单示例：

在 Java 或 C++ 等语言中，您可以通过改变它们接受的参数的数量或类型来创建重载方法。例如，你可以有一个名为 calculate_area 的方法，它的工作方式不同，具体取决于你传入的是矩形还是圆的尺寸。

但是，如前所述，Python 采用了不同的方法。 它不直接支持静态类型语言中的传统方法重载。相反，Python 允许您使用默认值、可变长度参数列表或关键字参数定义具有灵活数量参数的单个方法。这种动态行为更符合 Python 的简单性和灵活性理念。

以下是 Python 如何在不显式方法重载的情况下实现类似功能：

可以定义函数参数的默认值。如果未提供参数，则使用默认值。例如：

Python 中的关键字参数通过显式指定每个参数对应的参数来增强函数调用的可读性和清晰度。与顺序很重要的位置参数不同，关键字参数允许您以任何顺序将值传递给函数，只要您使用参数名称即可。此功能对于采用多个参数的函数特别有用，使您的代码更易于理解，并且不易因参数顺序不正确而出现错误。

下面是一个演示关键字参数工作原理的简单示例：

在此示例中，使用 name 、age 和 email 的关键字参数调用 create_user 函数。参数的顺序无关紧要，因为每个参数都已明确命名。这不仅可以提高可读性，还可以防止因以错误的顺序传递参数而引起的错误。

关键字参数是 Python 中的一项强大功能，有助于使代码更清晰、更易于维护。它们允许函数调用方按名称指定参数，这可以使复杂的函数调用更易于读取和写入。通过使用关键字参数，您可以使 Python 程序更直观，并且不易出现与参数顺序相关的错误。

在 Python 中，您可以在单个函数调用中混合位置参数和关键字参数。但是，位置参数必须位于任何关键字参数之前。下面是一个示例：

在 set_profile 调用中，“Alice” 和 28 是位置参数，而 country=“Canada” 是关键字参数。这种混合允许灵活的函数调用，同时仍确保每个参数表示的含义清晰。

在 Python 中， *args 和 **kwargs 是允许函数接受可变数量的参数的机制。*args 用于将可变数量的剩余位置参数舀入一个元组，而 **kwargs 将剩余的关键字参数收集到字典中。此功能对于创建灵活的动态函数非常有用，这些函数可以处理不同数量的输入，而无需事先定义确切的参数数量。

*args 允许函数采用任意数量的位置参数。以下是如何使用它：

在此示例中，sum_numbers接受任意数量的参数，无论传递多少个参数，都可以将它们相加。

**kwargs 允许函数接受任意数量的关键字参数。下面是一个示例：

在此示例中，greet 函数可以接受任意数量的关键字参数。它会查找特定键 （greeting 和 name） 来自定义其响应，如果未提供，则提供默认值。

kwargs.get（'greeting'， 'Hello'） 接受 “greeting” 关键字参数或默认值 “Hello”。

您可以在同一个函数中组合 *args 和 **kwargs 来处理位置变量和关键字变量参数：

在此示例中，create_profile 接受必需的 name 和 email 参数、任意数量的技能作为位置参数，以及作为关键字参数的其他详细信息。这允许高度灵活的功能，可以适应各种输入，同时保持清晰简洁的界面。

*args 和 **kwargs 是 Python 中的强大功能，它们为函数定义提供了灵活性，允许它们处理可变数量的位置和关键字参数。这在函数将接收的参数的确切数量未知或可能变化的情况下特别有用，从而使您的代码更具动态性且更易于维护。

Python 中的方法重载可以通过各种技术实现，其中一种技术包括使用多重分派装饰器。这种方法允许根据接收到的参数类型执行不同的方法，使其成为处理方法重载的动态且有效的方法。

多重调度是一种技术，其中要调用的函数或方法由传递给它的参数的运行时类型（更具体地说，参数的数量及其类型）确定。在原生支持它的编程语言（例如 Julia）中，这是一个强大的概念。

在 Python 中，multipledispatch 包可用于实现多重分派。此包允许您定义具有多个实现的泛型函数，并根据运行时传递的参数类型选择合适的函数。

首先，您需要安装 multipledispatch 软件包：

然后，您可以使用它来实现基于参数类型的方法重载，如下所示：

虽然 Python 不直接支持方法重载，但 multipledispatch 包提供了一种强大而有效的方法，可以通过多次分派实现类似的功能。这种方法不仅增强了代码的可读性和可维护性，而且还在处理不同类型的参数时提供了更大的灵活性，使其成为希望在其应用程序中实现方法重载的 Python 开发人员的宝贵工具。

考虑这样一个场景：我们定义了一个函数，该函数接受两个对象并调用它们的 speak 方法。由于多态性，不同类型的对象可以传递给此函数，只要它们具有 speak 方法即可。

在此示例中，animal_sound 函数可以对传递给它的任何对象调用 speak 方法，从而通过鸭子键入演示多态性。该函数不需要提前知道对象的类型，只需要它可以执行预期的操作（方法调用）。

Python 中具有类方法继承的多态性允许不同的类具有具有相同名称但具有不同实现的方法。多态性的这一方面在为数据科学项目设计灵活且可扩展的代码时特别有用，其中数据处理、分析或可视化等操作在不同类型的数据中可能有很大差异，但可以通过通用接口调用。

在数据科学上下文中，多态性支持为不同的数据处理类创建一致的接口。每个类都可以有自己的方法实现，例如 process_data、analyze 或 visualize，并根据它处理的特定数据类型进行定制。这种方法简化了代码并增强了其可读性和可维护性，使数据科学家能够跨不同的数据类型和处理技术使用统一的调用约定。

让我们考虑数据科学项目中的一个场景，我们需要处理不同类型的数据：数值数据和文本数据。我们将定义一个名为 DataProcessor 的基类，并使用 process_data 方法。然后，我们将创建两个子类 NumericDataProcessor 和 TextDataProcessor，每个子类都重写 process_data 方法以适当地处理各自的数据类型。

步骤 1：定义基类

这个 Base Class 建立了一个带有子类的 Contract，强制执行 process_data 方法的实现。

在此示例中：

请记住从 abc 模块导入 ABC 和 abstractmethod 来定义抽象基类。@abstractmethod 装饰器确保 DataProcessor 的任何子类都必须为 process_data 提供实现

有关@abstractmethod的 comPlate 解释，请参见下文。

第 2 步：使用多态性实现子类

每个子类都提供自己的 process_data 实现，并根据它处理的特定数据类型进行定制。

第 3 步：在数据科学工作流中利用多态性

在此示例中，process_all 函数不需要知道它正在处理的数据类型。它依赖于多态性，根据传递给它的对象调用适当的 process_data 方法。这种方法展示了多态性在数据科学项目中创建灵活且可扩展的数据处理管道的强大功能。

了解 Liskov 替换原则 （LSP） 对于设计健壮、可维护的面向对象的软件至关重要。它是面向对象设计的五项 SOLID 原则之一，旨在使软件更易于理解、灵活和可维护。在本文中，我们将探讨 LSP 如何应用于 Python，特别关注继承中的类方法多态性。我们将从定义 LSP 开始，然后通过示例深入研究它在 Python 中的应用。

里斯科夫替换原则（最初由 Barbara Liskov 在 1987 年提出）指出

超类的对象应该可以被子类的对象替换，而不会影响程序的正确性。

简单来说，子类应该在不改变其行为的情况下扩展基类。此原则确保类及其派生类是可互换的，而不会修改程序的预期结果。

Python 是一种动态类型语言，不强制执行类型检查。这使得遵守 LSP 更像是一种设计选择，而不是语言强制要求。但是，在 Python 中遵循 LSP 对于构建可扩展且可维护的面向对象系统至关重要，尤其是在处理类继承和多态性时。

如前所述，Polymorphism 允许方法根据调用它们的对象执行不同的操作。这与继承密切相关，其中子类从基类继承方法和属性，但也可以覆盖或扩展它们。

为了遵守 Liskov 替换原则，子类不仅应该继承自基类，而且还应该确保它们可以互换使用而不会破坏功能。让我们用一个涉及类方法多态性的例子来说明这一点。

假设我们有一个基类 Bird，其方法 fly 为。然后，我们创建一个继承自 Bird 的子类 Penguin。由于企鹅不会飞，我们可能会想重写 Penguin 中的 fly 方法以抛出异常或不执行任何操作。

这种设计违反了 Liskov 替换原则，因为我们不能用 Penguin 对象替换 Bird 对象并期望 fly 方法能够正确运行。在 base 方法中我们有一个 print，在 subclass 方法中我们有一个错误。这两种方法的输出不一致。

更好的方法是重构我们的设计，使其符合 LSP。我们可以引入一个更通用的类 Animal，并让 Bird 和 Penguin 继承自 Animal。然后，只向那些实际可以飞行的类添加 fly 方法。

在这个设计中，FlyingAnimal 是 Animal 的一个子类，它引入了 fly 方法。Bird 和 Penguin 都是 Animal 的子类，但只有 Bird 继承自 FlyingAnimal。这遵循 LSP，因为我们并不期望所有动物（或 Animal 的子类）都能飞行。

里斯科夫替换原则 （LSP） 不仅控制子类方法的行为和输出，还扩展到方法签名本身，包括参数的数量和类型。一个常见的误解是，覆盖子类中的方法可以自由地更改参数的数量。但是，这样做可能会违反 LSP，从而导致细微的错误和代码脆弱性。让我们通过示例来探索这个概念，并以最佳实践结束。

考虑一个类层次结构，其中基类定义了一个方法，该方法需要一个参数，但子类方法需要两个参数。此修改可能会导致 LSP 冲突，因为子类不再无缝替代基类。

示例：具有两个参数的基类

具有附加参数的子类

乍一看，这似乎是一种通过为第三个参数提供默认值来扩展功能的聪明方法。但是，在 Calculator 类的用户希望 add 方法仅使用两个参数的情况下，它巧妙地违反了 LSP。当使用 AdvancedCalculator 实例代替 Calculator 实例时，这种设计可能会导致意外行为，尤其是在多态场景中。

为了遵守 LSP，子类方法应接受与其基类对应项相同的参数。如果需要扩展，请考虑使用不会更改方法的外部签名的替代方法。

具有 LSP 依从性的更正子类

在此更正版本中，AdvancedCalculator 仍覆盖 add 方法，但保留原始参数列表，确保它可以毫无问题地替代 Calculator。扩展功能是通过新方法 add_three 提供的，该方法不会干扰现有 add 方法的 LSP 合规性。

从 Liskov 替换原则得出的最终规则很明确：

如果您的类层次结构违反了 LSP，则继承可能不是适合您设计的工具。

此原则超越了方法行为，包括方法签名，确保子类在所有方面都可以真正替代其基类。

违反 LSP 可能会导致不可预测的代码行为和维护难题。作为最佳实践，请始终设计您的类层次结构，以确保子类的任何实例都可以代替其超类的实例，不仅在它的作用方面，而且在它的使用方式方面。如有疑问，请首选组合而不是继承（我们将在本系列的最后一篇文章中看到这意味着什么）或重构层次结构以更好地反映对象的实际关系和行为。

通过遵守 LSP 和其他 SOLID 原则，您可以确保代码库保持稳健、灵活和可维护，从而显著降低出现错误的可能性，并使未来的扩展更易于实施。

来源：自由坦荡的湖泊AI一点号