巧用闭包和立即执行函数，实现函数只执行一次

本文将探讨一些实用的方法，帮助您轻松实现函数只执行一次的功能。我们首先从闭包和立即执行函数的基本概念开始，然后逐步深入探索具体实现方式。无论您是初次涉足编程领域的新手，还是经验丰富的开发人员，本文都将为您提供有益的参考。

1. 闭包和立即执行函数

闭包是一种非常强大的技术，它允许我们在函数内部定义另一个函数。立即执行函数 (IIFE) 是一种特殊的闭包，它会在定义时立即执行。闭包可以用来实现许多有趣的效果，其中一种就是函数只执行一次。

def make_counter():
    count = 0

    def counter():
        nonlocal count
        count += 1
        return count

    return counter

counter = make_counter()
print(counter())  # 1
print(counter())  # 2

在这个例子中，我们定义了一个名为 make_counter 的函数，该函数返回一个名为 counter 的内部函数。counter 函数每次调用时都会将 count 变量加一，并返回其值。当我们调用 make_counter() 时，它会创建一个闭包，该闭包包含 count 变量和 counter 函数。然后，我们把这个闭包赋值给 counter 变量。

当我们第一次调用 counter 时，它会将 count 变量的值加一，并返回其值。当我们第二次调用 counter 时，它会再次将 count 变量的值加一，并返回其值。但是，由于 count 变量是存储在闭包中的，因此它不会被重置。这就是为什么 counter 函数每次调用时都会返回一个递增的值。

2. 惰性求值

惰性求值是一种延迟计算的策略。在使用惰性求值时，只有在需要时才会计算值。这可以用来实现函数只执行一次。

def make_counter():
    def counter():
        return _counter()

    def _counter():
        count = 0
        while True:
            yield count
            count += 1

    return counter

counter = make_counter()
print(next(counter))  # 0
print(next(counter))  # 1

在这个例子中，我们定义了一个名为 make_counter 的函数，该函数返回一个名为 counter 的内部函数。counter 函数使用生成器来实现惰性求值。当我们第一次调用 counter 时，它会创建一个生成器对象。当我们调用 next 方法时，生成器对象会计算并返回下一个值。

由于生成器对象是惰性求值的，因此 count 变量的值只有在我们调用 next 方法时才会计算。这就是为什么 counter 函数每次调用时都会返回一个递增的值。

3. Memoization

Memoization 是一种优化技术，它可以用来减少函数调用的次数。Memoization 的基本思想是将函数的输入和输出存储在一个字典中。当函数再次被调用时，它会首先检查字典中是否有相应的输入。如果有，它就会直接返回存储的输出。如果没有，它就会计算输出并将其存储在字典中。

def memoize(func):
    cache = {}

    def wrapper(*args, **kwargs):
        key = str(args) + str(kwargs)
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]

    return wrapper

@memoize
def fibonacci(n):
    if n < 2:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))  # 55

在这个例子中，我们定义了一个名为 memoize 的装饰器，该装饰器可以用来对函数进行记忆化。当我们使用 @memoize 装饰 fibonacci 函数时，它会在 fibonacci 函数的前面添加一个名为 wrapper 的内部函数。wrapper 函数会将 fibonacci 函数的输入和输出存储在一个字典中。当 fibonacci 函数再次被调用时，wrapper 函数会首先检查字典中是否有相应的输入。如果有，它就会直接返回存储的输出。如果没有，它就会计算输出并将其存储在字典中。

4. 单例模式

单例模式是一种设计模式，它可以确保一个类只被实例化一次。单例模式通常用于实现全局对象。

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance

singleton = Singleton()
print(singleton)  # <__main__.Singleton object at 0x106b87e50>

在这个例子中，我们定义了一个名为 Singleton 的类，该类实现了单例模式。Singleton 类有一个名为 _instance 的类属性，该属性存储类的实例。当我们第一次调用 Singleton 类时，它会创建一个新的实例并将其存储在 _instance 属性中。当我们再次调用 Singleton 类时，它会直接返回 _instance 属性中的实例。

5. 委托

委托是一种设计模式，它可以将一个对象的某些功能委托给另一个对象。委托可以用来实现函数只执行一次。

class Counter:
    def __init__(self):
        self.count = 0

    def increment(self):
        self.count += 1

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance

    def get_counter(self):
        if not hasattr(self, "_counter"):
            self._counter = Counter()
        return self._counter

singleton = Singleton()
counter = singleton.get_counter()
counter.increment()
print(counter.count)  # 1

在这个例子中，我们定义了一个名为 Counter 的类，该类实现了一个简单的计数器。我们还定义了一个名为 Singleton 的类，该类实现了单例模式。Singleton 类有一个名为 get_counter 的方法，该方法返回一个 Counter 类的实例。

当我们第一次调用 get_counter 方法时，它会创建一个新的 Counter 类的实例并将其存储在 _counter 属性中。当我们再次调用 get_counter 方法时，它会直接返回 _counter 属性中的实例。

6. 事件处理

事件处理是一种编程技术，它允许我们对事件做出响应。事件处理可以用来实现函数只执行一次。

import tkinter as tk

class Counter:
    def __init__(self):
        self.count = 0

    def increment(self):
        self.count += 1

class App:
    def __init__(self):
        self.root = tk.Tk()
        self.button = tk.Button(self.root, text="Click me")
        self.button.configure(command=self.on_click)

        self.counter = Counter()

    def on_click(self):
        self.counter.increment()
        print(self.counter.count)  # 1

app = App()
app.root.mainloop()

在这个例子中，我们定义了一个名为 Counter 的类，该类实现了一个简单的计数器。我们还定义了一个名为 App 的类，该类实现了事件处理。App 类有一个名为 on_click 的方法，该方法在按钮被点击时被调用。

当按钮被点击时，on_click 方法会将 Counter 类的实例的 count 属性加一，并将其值打印到控制台。由于事件处理是一种惰性求值的形式，因此 on_click 方法只有在按钮被点击时才会被调用。

7. 锁

锁是一种并发编程的工具，它可以用来防止多个线程同时访问共享资源。锁可以用来实现函数只执行一次。

import threading

class Counter:
    def __init__(self):
        self.