🤠Closures

A closure is a function object that has access to variables in its enclosing lexical scope, even when the function is called outside that scope. In simpler terms, a closure is a function that remembers the values of the variables that were present in the enclosing scope at the time of its creation.

Closures are used in many programming languages, including Python, to implement various programming patterns. One of the most common uses of closures is to create function factories or generators.

A closure is created when a nested function references a value from its enclosing function's scope. The nested function can access and modify the values of the enclosing function's variables, even after the enclosing function has returned.

Closures are useful in situations where you want to create a function that maintains a state across multiple calls. For example, you might use a closure to create a counter function that counts the number of times it has been called, or a memoization function that remembers the results of expensive function calls to avoid recalculating them.

In Python, closures are created using nested functions. The nested function can access and modify the values of the enclosing function's variables using the nonlocal keyword. When the enclosing function returns, the closure function retains a reference to the values of the enclosing function's variables.

Creating Closures in Python

In Python, closures can be created using nested functions. Here are two common ways to create closures:

1. Using Nested Functions:

A closure is created when an inner function references a value from an outer function's scope. Here's an example of a closure that adds a given value to a number:

def adder(x):
    def inner(y):
        return x + y
    return inner

add_5 = adder(5)
print(add_5(10))  # Output: 15

In this example, the adder() function returns the inner() function, which takes a parameter y and adds it to the value of x. The add_5 variable is assigned the closure returned by adder(5), which means it remembers the value of x as 5. When add_5(10) is called, it adds 10 to 5 and returns 15.

1. Using Function Decorators:

Function decorators are a powerful feature in Python that allow you to modify the behavior of a function. A function decorator is a function that takes another function as input and returns a new function as output. Here's an example of a closure that uses a function decorator:

def adder(x):
    def decorator(func):
        def inner(y):
            return func(x + y)
        return inner
    return decorator

@adder(5)
def multiply_by_two(x):
    return x * 2

print(multiply_by_two(10))  # Output: 30

In this example, the adder() function returns a decorator function that takes another function (multiply_by_two) as input and returns a new function (inner) as output. The inner() function takes a parameter y, adds it to the value of x, and passes the result to the original function (multiply_by_two). The @adder(5) syntax applies the closure returned by adder(5) to the multiply_by_two function, so when multiply_by_two(10) is called, it first adds 5 to 10 (to get 15) and then multiplies it by 2 to get 30.

Examples of Closures

Here are some examples of closures in Python:

1. Counter:

A closure can be used to create a counter function that counts the number of times it has been called. Here's an example:

def counter():
    count = 0
    def inner():
        nonlocal count
        count += 1
        print("Count:", count)
    return inner

c = counter()
c()  # Output: Count: 1
c()  # Output: Count: 2
c()  # Output: Count: 3

In this example, the counter() function returns a closure that remembers the value of count as 0. Every time the closure is called, it increments the value of count by 1 and prints the current value of count.

1. Average:

A closure can also be used to create a function that calculates the average of a series of numbers. Here's an example:

def average():
    numbers = []
    def inner(num):
        numbers.append(num)
        avg = sum(numbers) / len(numbers)
        print("Average:", avg)
    return inner

a = average()
a(10)  # Output: Average: 10.0
a(20)  # Output: Average: 15.0
a(30)  # Output: Average: 20.0

In this example, the average() function returns a closure that remembers the list of numbers in the numbers variable. Every time the closure is called with a new number, it adds the number to the list, calculates the average of the numbers in the list, and prints the current average.

1. Memoization:

A closure can also be used to implement memoization, which is a technique that stores the results of expensive function calls and returns the cached result when the same inputs occur again. Here's an example:

def memoize(func):
    cache = {}
    def inner(n):
        if n not in cache:
            cache[n] = func(n)
        return cache[n]
    return inner

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

print(fibonacci(10))  # Output: 55

In this example, the memoize() function is a closure that takes a function func as input and returns a new function inner as output. The inner() function checks whether the result of func(n) has already been computed and cached in the cache dictionary. If it has, inner() returns the cached result; otherwise, it calls func(n), caches the result, and returns it. The @memoize syntax applies the memoization closure to the fibonacci() function, which calculates the nth Fibonacci number recursively. The first time fibonacci(10) is called, it computes the value using the recursive algorithm and caches the results of all the previous function calls. The second time fibonacci(10) is called, it simply returns the cached value without recomputing it, resulting in faster execution time.

Using Closures with Decorators

Using closures with decorators allows you to modify the behavior of a function by adding additional functionality before or after its execution. Here's an explanation of how to use closures with decorators:

Introduction to Decorators:

Decorators are functions that take another function as input and extend its functionality without modifying its source code. They are denoted by the @ symbol followed by the decorator function name placed above the function definition. Decorators provide a concise and flexible way to enhance the behavior of functions.

Creating Decorators with Closures:

Closures can be used to create decorators by defining an inner function within the decorator function. The inner function acts as the closure and can access the original function's arguments and return value. Here's an example:

def decorator(func):
    def inner(*args, **kwargs):
        # Additional functionality before the original function
        print("Decorating...")
        
        # Call the original function
        result = func(*args, **kwargs)
        
        # Additional functionality after the original function
        print("Finished decorating!")
        
        # Return the result of the original function
        return result
    
    # Return the closure
    return inner

In this example, the decorator() function takes another function (func) as input and returns the closure inner(). The inner() function performs additional operations before and after calling the original function (func). It uses the *args and **kwargs syntax to accept any number of positional and keyword arguments that the original function may have. Finally, the closure returns the result of the original function.

Examples of Decorators with Closures:

Let's see a practical example of using closures with decorators to measure the execution time of a function:

import time

def measure_time(func):
    def inner(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        execution_time = end_time - start_time
        print(f"Execution time: {execution_time} seconds")
        return result
    return inner

@measure_time
def some_function():
    # Function code here
    time.sleep(2)  # Simulate some time-consuming task

some_function()  # Output: Execution time: 2.0003676414489746 seconds

In this example, the measure_time() decorator measures the execution time of the decorated function. The inner() closure is responsible for starting the timer before calling the original function (func), ending the timer after the function finishes, calculating the execution time, and printing it. The @measure_time syntax applies the decorator to the some_function() function, and when some_function() is called, it prints the execution time.

Decorators with closures provide a powerful mechanism to add reusable and customizable behavior to functions without modifying their original code. They can be used for various purposes such as logging, timing, input validation, and more.

Advantages and Disadvantages of Closures

Advantages of Closures:

1. Encapsulation: Closures allow you to encapsulate data and functionality within a function, making it private and inaccessible from outside the function. This provides better data protection and security.

2. Code Reusability: Closures are a powerful tool for creating reusable code. You can create a closure once and use it multiple times across your codebase without duplicating code.

3. Stateful Functions: Closures enable you to create functions that have memory of previous calls, which makes them useful for stateful applications such as web servers and GUI applications.

4. Decorators: Closures provide a powerful mechanism for creating decorators, which allow you to modify the behavior of functions without modifying their source code.

Disadvantages of Closures:

1. Memory Management: Closures hold a reference to their enclosing scope, which means that any variables or objects referenced in the closure are not garbage collected until the closure is no longer referenced. This can cause memory leaks and increased memory usage.

2. Complexity: Closures can be complex and difficult to understand, especially for novice programmers. Nested functions and nonlocal variables can be confusing and require careful attention to detail.

3. Performance Overhead: Closures can have a performance overhead, especially if they are used extensively in a codebase. The extra function calls and variable lookups can slow down the execution of the code.