Python是一种动态类型的语言，如何使它不必使用抽象类/继承？

如何解决Python是一种动态类型的语言，如何使它不必使用抽象类/继承？

我已经在python中查找了设计模式，并在某些文章中看到了以下句子：

“我们在不使用继承的情况下实现了Abstract Factory，主要是因为Python是一种动态类型的语言，因此不需要抽象类。”

代码示例：

class Dog:
    """One of the objects to be returned"""

    def speak(self):
        return "Woof!"

    def __str__(self):
        return "Dog"


class DogFactory:
    """Concrete Factory"""

    def get_pet(self):
        """Returns a Dog object"""
        return Dog()

    def get_food(self):
        """Returns a Dog Food object"""
        return "Dog Food!"


class PetStore:
    """ PetStore houses our Abstract Factory """

    def __init__(self,pet_factory=None):
        """ pet_factory is our Abstract Factory """

        self._pet_factory = pet_factory


    def show_pet(self):
        """ Utility method to display the details of the objects retured by the DogFactory """

        pet = self._pet_factory.get_pet()
        pet_food = self._pet_factory.get_food()

        print("Our pet is '{}'!".format(pet))
        print("Our pet says hello by '{}'".format(pet.speak()))
        print("Its food is '{}'!".format(pet_food))


#Create a Concrete Factory
factory = DogFactory()

#Create a pet store housing our Abstract Factory
shop = PetStore(factory)

#Invoke the utility method to show the details of our pet
shop.show_pet()

我理解了我提供的示例，但是我没有得到这个陈述，并且我已经看到许多其他示例使用继承和抽象类在python中实现设计模式（例如：本例中的抽象工厂），例如几乎所有其他语言都可以使用，例如java。

我真的很希望对声明进行解释，并使用代码示例对这两种方法（有和没有抽象类/接口/继承）有何区别。

编辑：

问题：具体来说，我想通过说明代码示例（摘要）如何理解动态类型如何使生活变得轻松，并补偿上述代码示例中对继承/接口的使用。工厂）的外观，就像是否使用继承/接口来实现与给定示例相同的功能。

谢谢。

解决方法

如果必须用静态类型的语言编写此代码，则他们可能会编写一个名为PetFactory的基类，它具有两个功能，get_pet和get_food。

但是在动态类型语言中，函数（在这种情况下为PetStore(...)）并不关心其参数是什么类型。相反，它使用“鸭子打字”

该术语来源于这样的说法：“如果它走路像鸭子，嘎嘎叫鸭子，那它一定是鸭子。” （还有其他变化）。

鸭子类型是与动态类型相关的概念，其中对象的类型或类不如其定义的方法重要。使用鸭子类型时，根本不会检查类型。相反，您要检查是否存在给定的方法或属性。*

与动态类型语言的许多方面一样，它为您提供了更大的自由度，但使事情变得井井有条。您不需要从特定的类继承或定义接口，但是它也使出错和增加运行时错误变得更加容易。

,

这里的关键是“ PetFactory”。在上面的代码中，“ PetFactory”没有技术意义。但是从概念上讲，实际上是一个“接口”，我将其称为“ PetFactory”。 “ PetFactory”必须具有功能get_pet和get_food。

如果要编写一个新的“ PetFactory”，无论他们是否在脑海中起了名字，他们都必须确定该接口及其要求。

它没有真实名称的事实使它更难辨认它甚至存在，也很难缠住它（当“接口”只是您正在使用的许多事物之一时，这一点就变得尤为重要）

但是除此之外，要确定“ PetFactory”的要求，必须跟踪多个功能。在这种情况下，它并不难，但是有了更多功能，它很快就会变得复杂。

相反，人们可以使用继承并按照以下方式进行操作：

class PetFactory():
    def get_pet(self):
        """returns a pet"""
        pass

    def get_food(self):
        """returns a string defining the pet's food"""
        pass

class DogFactory(PetFactory):

    def get_pet(self):
        """Returns a Dog object"""
        return Dog()

    def get_food(self):
        """Returns a Dog Food object"""
        return "Dog Food!"

从技术角度来看，添加此类实际上并没有任何作用。但是从概念上讲，“ PetFactory”的存在现在很明显，其要求很明确，并且具有技术名称。

---

通过PEP 3119的实现，python现在还具有形式抽象基类。使用这些代码，新代码将如下所示：

from abc import ABC,abstractmethod

class PetFactory(ABC):

    @abstractmethod
    def get_pet(self):
        """returns a pet"""
        pass

    @abstractmethod
    def get_food(self):
        """returns a string defining the pet's food"""
        pass

class DogFactory(PetFactory):

    def get_pet(self):
        """Returns a Dog object"""
        return Dog()

    def get_food(self):
        """Returns a Dog Food object"""
        return "Dog Food!"

这样做的好处是，它清楚地标记了PetFactory类的用途，并强制任何子类在实例化所有抽象方法之前将其实现。它还允许进行类型检查：isinstance(PetFactory)。