工厂模式和策略模式有什么区别？

1. 目的不同:

工厂模式 (Factory Pattern): 主要用于创建对象。它提供了一种创建对象的接口，但将具体的对象实例化延迟到子类中进行。工厂模式的核心目的是解耦对象的创建和使用，让客户端代码无需关心具体对象的创建细节。
策略模式 (Strategy Pattern): 主要用于封装算法或策略。它定义了一系列算法，并将每个算法封装到独立的策略类中，使得算法可以独立于使用它的客户端代码而变化。策略模式的核心目的是使算法选择在运行时可变，提高代码的灵活性和可维护性。

2. 解决的问题不同:

工厂模式: 解决的是对象创建的复杂性问题。当对象的创建逻辑复杂，或者需要根据不同的条件创建不同的对象时，可以使用工厂模式将创建逻辑封装起来，客户端只需要通过工厂来获取对象，无需了解具体的创建过程。
策略模式: 解决的是算法或策略的多样性问题。当一个类需要根据不同的场景或条件选择不同的算法或策略时，可以使用策略模式将这些算法或策略封装起来，客户端可以根据需要动态地选择不同的策略。

3. 关注点不同:

工厂模式: 关注的是如何创建对象，重点在于对象的创建过程。
策略模式: 关注的是如何选择算法，重点在于算法的封装和切换。

4. 客户端的角色不同:

工厂模式: 客户端只需要请求工厂创建某种类型的对象，具体创建哪个对象由工厂决定。
策略模式: 客户端需要选择使用哪个策略，并将其注入到Context对象中。

简单来说:

工厂模式 就像一个 “对象工厂”，你告诉工厂你需要什么类型的 “产品”，工厂负责生产出来，你不用管生产过程。
策略模式 就像一个 “算法工具箱”，里面有很多不同的 “工具”（算法），你可以根据不同的 “任务” 选择合适的 “工具” 来使用。

1. 工厂模式 (Factory Pattern)

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 Duck(Animal):
    def speak(self):
        return "Quack!"

# 工厂类
class AnimalFactory:
    def create_animal(self, animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        elif animal_type == "duck":
            return Duck()
        else:
            return None

# 客户端代码
factory = AnimalFactory()

dog = factory.create_animal("dog")
print(f"Dog says: {dog.speak()}") # 输出: Dog says: Woof!

cat = factory.create_animal("cat")
print(f"Cat says: {cat.speak()}") # 输出: Cat says: Meow!

duck = factory.create_animal("duck")
print(f"Duck says: {duck.speak()}") # 输出: Duck says: Quack!

2. 策略模式 (Strategy Pattern)

from abc import ABC, abstractmethod

# 抽象策略接口
class SortingStrategy(ABC):
    @abstractmethod
    def sort(self, data):
        pass

# 具体策略类
class BubbleSortStrategy(SortingStrategy):
    def sort(self, data):
        print("Using Bubble Sort")
        # 冒泡排序算法 (简化示例)
        return sorted(data)

class QuickSortStrategy(SortingStrategy):
    def sort(self, data):
        print("Using Quick Sort")
        # 快速排序算法 (简化示例 - 使用 Python 内置排序)
        return sorted(data)

# 环境类 (Context)
class Sorter:
    def __init__(self, strategy: SortingStrategy):
        self._strategy = strategy

    def sort_data(self, data):
        return self._strategy.sort(data)

# 客户端代码
data = [5, 2, 8, 1, 9]

# 使用冒泡排序策略
bubble_sorter = Sorter(BubbleSortStrategy())
sorted_data_bubble = bubble_sorter.sort_data(data)
print(f"Sorted data (Bubble Sort): {sorted_data_bubble}")
# 输出: Using Bubble Sort
#      Sorted data (Bubble Sort): [1, 2, 5, 8, 9]

# 使用快速排序策略
quick_sorter = Sorter(QuickSortStrategy())
sorted_data_quick = quick_sorter.sort_data(data)
print(f"Sorted data (Quick Sort): {sorted_data_quick}")
# 输出: Using Quick Sort
#      Sorted data (Quick Sort): [1, 2, 5, 8, 9]

工厂模式 侧重于创建不同类型的对象，代码示例中 AnimalFactory 负责创建 Dog, Cat, Duck 对象。
策略模式 侧重于选择不同的算法或策略，代码示例中 Sorter 可以选择 BubbleSortStrategy 或 QuickSortStrategy 来排序数据。