Python中的工厂模式和LazyFunction()函数

工厂模式（Factory Pattern）是一种常见的设计模式，用于创建对象的过程中，将对象的创建逻辑封装在一个单独的工厂类中，并通过该工厂类来实例化对象。这种模式可以解耦对象的创建和使用，提高代码的灵活性和可维护性。

在Python中，可以使用工厂模式来实现对象的创建。下面是一个简单的例子：

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class AnimalFactory:
    def create_animal(self, animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError("Invalid animal type!")

# 使用工厂创建对象
factory = AnimalFactory()
dog = factory.create_animal("dog")
cat = factory.create_animal("cat")

print(dog.speak())  # 输出 "Woof!"
print(cat.speak())  # 输出 "Meow!"

在这个例子中，我们定义了一个基类Animal和两个子类Dog和Cat。AnimalFactory是一个工厂类，它有一个create_animal方法，根据传入的参数创建相应的对象。

通过这种方式，我们可以动态地选择创建Dog对象还是Cat对象，而无需在使用方进行对象的实例化。

另外，在Python中，还有一种延迟执行（Lazy Evaluation）的函数，可以在需要时才执行，可以通过装饰器functools.lru_cache来实现。下面是一个使用functools.lru_cache的例子：

import functools

@functools.lru_cache()
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 输出 55

在这个例子中，我们定义了一个递归函数fibonacci，用于计算斐波那契数列的第n个数。通过@functools.lru_cache()装饰器修饰该函数，可以将其结果缓存起来，在下次调用时直接返回缓存的结果，避免重复计算。

在调用fibonacci(10)时，会计算斐波那契数列的前10个数，并将结果缓存起来。如果下次再调用fibonacci(10)，则会直接返回缓存的结果，不再执行递归计算。

这种延迟执行的函数在处理递归、重复计算等问题上非常有用，可以提高程序的性能和效率。