Python Closures

1. What is a Closure

A closure is a function that remembers and has access to variables from its enclosing scope even after the outer function has finished execution.

def outer():
    message = "Hello"
    
    def inner():
        return message

    return inner

func = outer()
print(func())  # Output: Hello

The inner function retains access to message.

---

2. Basic Closure Structure

def multiplier(x):
    def multiply(y):
        return x * y
    return multiply

times2 = multiplier(2)
print(times2(5))  # Output: 10

Functions carry state without using global variables.

---

3. Closure Retaining State

def counter():
    count = 0

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

    return increment

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

Closure maintains persistent state across calls.

---

4. nonlocal in Closures

def power(base):
    exponent = 2

    def calculate():
        nonlocal exponent
        exponent += 1
        return base ** exponent

    return calculate

p = power(2)
print(p())
print(p())

nonlocal allows modification of enclosed variables.

---

5. Closure vs Global Variable

factor = 10

def using_global():
    return lambda x: x * factor

def using_closure():
    factor = 10
    return lambda x: x * factor

print(using_closure()(5))

Closures prevent unintended side-effects on global state.

---

6. Multiple Closures from Same Function

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

add5 = make_adder(5)
add10 = make_adder(10)

print(add5(3))    # 8
print(add10(3))   # 13

Each closure holds its own independent environment.

---

7. Inspecting Closure Variables

def outer():
    value = 42

    def inner():
        return value

    return inner

func = outer()
print(func.__closure__[0].cell_contents)  # 42

Shows internal structure of closure data.

---

8. Closures as Function Factories

def logger(prefix):
    def log(message):
        print(f"{prefix}: {message}")
    return log

info_logger = logger("INFO")
error_logger = logger("ERROR")

info_logger("System started")
error_logger("System failed")

Closures generate specialized functions dynamically.

---

9. Closure in Decorators (Foundation Pattern)

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before execution")
        return func(*args, **kwargs)
    return wrapper

Decorators rely on closures to extend function behaviour.

---

10. Real-World Closure Example (Configuration)

def threshold_checker(threshold):
    def check(value):
        return value > threshold
    return check

high_temp = threshold_checker(40)

print(high_temp(35))  # False
print(high_temp(45))  # True

Closures encapsulate configuration logic cleanly.

---