What are the basic uses of closures in Python?

What is a closure

A closure is a function that is defined inside another function and can access the function Variables in scope, even if the function has completed execution and been destroyed. In other words, a closure is a combination of a function and its environment.

Simply put, closure is a special form of function that can access variables inside the function from outside the function, but these variables will not be destroyed after the function is executed. Closures can be used in Python to create modular, reusable code.

Closures in Python

Functions in Python are first-class objects, that is, they can be passed, referenced, returned, and assigned like other objects. In Python, closures can be implemented through function nesting.

Here is a simple example that demonstrates how to create a closure:

def outer_function(x): 
    def inner_function(y): 
        return x + y 
    return inner_function 
    
closure = outer_function(10)
print(closure(5))

In this example, outer_function is a function that accepts one parameterx, and returns a function inner_function. inner_function is also a function that accepts a parameter y and returns the sum of x and y.

In the last line of code, we create a closure closure and pass the return value of outer_function(10) (that is, inner_function)Assign a value to it. Then we call the closure function, pass in the parameter 5, and print the return value 15. In this example, the value of x is 10 because the parameter we passed to outer_function is 10.

How to implement closures

There are two ways to implement closures in Python: function nesting and decorators.

Function Nesting

In Python, we can define a function, define another function inside this function, and then return this inner function. This inner function can access the variables of the outer function, which is a closure.

The nesting method is as shown in the simple example above and will not be described in detail here.

Decorator

Decorator is another way to implement closure in Python. A decorator is a function that accepts a function as an argument and returns a new function. The new function can add some new functions based on the original function without changing the code of the original function.

The following is a simple example that demonstrates how to use decorators to implement closures:

def my_decorator(func):
    def wrapper():
        print("Before the function is called.") 
        func() 
        print("After the function is called.") 
    return wrapper 
    
@my_decorator 
def say_hello():
    print("Hello!")
    say_hello()

In this example, we define a decorator function my_decorator, And apply it to function say_hello. The decorator function accepts a function as a parameter and returns a new function wrapper. The wrapper function adds some new functions based on the original function say_hello.

In the last line of code, we call the say_hello function and print out the following:

Before the function is called.
Hello!
After the function is called.

Through the decorator, we successfully implemented a closure.

Applications of closures

Closures have many application scenarios in Python. Here are a few common scenarios:

1. Delayed execution

Closures can be used to implement delayed execution, that is, calculations are only performed when the function is called. This can improve program performance, especially when evaluating complex expressions.

The following is an example that demonstrates how to use closures to implement delayed execution:

def delayed_sum(a, b):
    def sum(): 
        return a + b 
    return sum 
    
result = delayed_sum(1, 2) 
print(result()) # 3

In this example, we define a delayed_sum function that accepts two Parameters a and b, and returns a function sum. When we call the delayed_sum function, it does not calculate the sum of a and b, but returns a sum function. When we call the sum function, it will calculate the sum of a and b and return the result.

2. Caching results

Closures can be used to cache the results of functions, especially when calculating complex functions, which can greatly improve the performance of the program.

The following is an example that demonstrates how to use closures to implement cached results:

def memoize(func):
    cache = {} 
    
    def wrapper(*args):
        if args in cache: 
            return cache[args] 
        result = func(*args) 
        cache[args] = result 
        return result 
    return wrapper 
                                        
@memoize 
def fibonacci(n): 
    if n in (0, 1):
        return n 
    return fibonacci(n - 1) + fibonacci(n - 2) 
    
print(fibonacci(10)) # 55

In this example, we define a memoize decorator function that can Cache the result of the decorated function. In the fibonacci function, we use the memoize decorator to avoid repeated calculation of values ​​in the Fibonacci sequence. When we first call the fibonacci function, it calculates the values ​​of fibonacci(0) and fibonacci(1) and stores them in the cache . When we call the fibonacci function next time, it will first check whether the required value has been calculated in the cache. If so, it will directly return the result in the cache, otherwise it will be calculated again.

3. Implement functions similar to private variables

In Python, we cannot directly define private variables like Java and C. However, we can use closures to achieve functionality similar to private variables.

下面是一个例子，演示了如何使用闭包实现私有变量：

def counter():
    count = 0 
    def inner():
        nonlocal count 
        count += 1 
        return count 
    return inner 
   
c1 = counter() 
c2 = counter() 
print(c1()) # 1 
print(c1()) # 2 
print(c2()) # 1 
print(c2()) # 2

在这个例子中，我们定义了一个counter函数，它返回一个inner函数。inner函数可以访问count变量，而count变量是在counter函数中定义的。由于 Python 中没有直接定义私有变量的语法，我们使用了一个内部函数来访问外部函数中的变量。这样，我们就可以实现类似于私有变量的功能。

在调用c1和c2时，它们返回的inner函数中的count变量是不同的。这是因为每次调用counter函数时，它都会返回一个新的inner函数，每个inner函数都有自己的count变量。

闭包的优缺点

闭包有很多优点，例如：

• 可以避免使用全局变量，提高程序的可维护性；

• 可以实现类似于私有变量的功能，提高程序的安全性；

• 可以实现延迟执行和缓存结果，提高程序的性能。

但是，闭包也有一些缺点，例如：

• 可能会占用较多的内存空间，因为闭包会保留外部函数的状态；

• 可能会导致循环引用的问题，如果闭包中引用了外部函数的变量，而这些变量又引用了闭包中的变量，就会出现循环引用的问题。

小结

Python中的闭包是一种非常强大的编程技术，它可以帮助我们提高程序的可维护性、安全性和性能。通过闭包，我们可以避免使用全局变量、实现类似于私有变量的功能、实现延迟执行和缓存结果等。

要使用闭包，我们需要了解闭包的原理和使用方法。在Python中，可以使用嵌

套函数来实现闭包。在定义闭包时，需要注意外部函数和内部函数的作用域、变量的生命周期等问题，以避免出现意外的错误。

在实际编程中，可以使用闭包来实现许多有用的功能，例如缓存结果、实现状态机、实现装饰器等。对于有经验的Python程序员来说，闭包已经成为不可或缺的一部分。

在使用闭包时，需要注意以下几点：

• 尽量避免在闭包中修改外部函数的变量。如果需要修改变量，应该使用nonlocal关键字。

• 闭包中的变量是在函数定义时绑定的，而不是在函数调用时绑定的。因此，如果在闭包中引用了外部函数的变量，应该确保这些变量在闭包定义时是可用的。

• 闭包中引用的外部函数的变量会一直存在，直到闭包被销毁。因此，如果闭包中引用了外部函数的大量变量，可能会占用大量的内存空间。

The above is the detailed content of What are the basic uses of closures in Python?. For more information, please follow other related articles on the PHP Chinese website!