What are some examples of the factory pattern in Python?

What are some examples of the factory pattern in Python?

The factory pattern is a creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. Here are a few examples in Python:

1. Simple Factory: A method that returns an instance of a class based on provided parameters.
2. Factory Method: A method that defines an interface for creating an object, but lets subclasses alter the type of objects that will be created.
3. Abstract Factory: An interface for creating families of related or dependent objects without specifying their concrete classes.

Can you show me a code example of the factory method?

Sure! Here's a simple example of the factory method pattern in 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!"

class AnimalFactory:
    @staticmethod
    def create_animal(animal_type):
        if animal_type == 'dog':
            return Dog()
        elif animal_type == 'cat':
            return Cat()
        else:
            raise ValueError(f'Unknown animal type: {animal_type}')

# Usage
animal = AnimalFactory.create_animal('dog')
print(animal.speak())  # Output: Woof!

What about the abstract factory pattern?

Here's an example of the abstract factory pattern in Python:

from abc import ABC, abstractmethod

class Dog(ABC):
    @abstractmethod
    def bark(self):
        pass

class Cat(ABC):
    @abstractmethod
    def meow(self):
        pass

class DogFactory(ABC):
    @abstractmethod
    def create_dog(self):
        pass

class CatFactory(ABC):
    @abstractmethod
    def create_cat(self):
        pass

class ConcreteDog(Dog):
    def bark(self):
        return "Woof!"

class ConcreteCat(Cat):
    def meow(self):
        return "Meow!"

class ConcreteFactory(DogFactory, CatFactory):
    def create_dog(self):
        return ConcreteDog()

    def create_cat(self):
        return ConcreteCat()

# Usage
factory = ConcreteFactory()
my_dog = factory.create_dog()
my_cat = factory.create_cat()
print(my_dog.bark())  # Output: Woof!
print(my_cat.meow())  # Output: Meow!

Thanks! This is really helpful.