ডেকোরেটর এবং ক্লোজার (Decorators & Closures)

# Functions can be assigned to variables
def shout(text):
    return text.upper() + "!!!"

yell = shout  # No parentheses — we're passing the function itself
print(yell("hello"))

# Functions can be passed as arguments
def apply_twice(func, value):
    return func(func(value))

def add_exclamation(text):
    return text + "!"

result = apply_twice(add_exclamation, "wow")
print(result)  # wow + ! + ! 

# Functions can be stored in data structures
operations = {
    "double": lambda x: x * 2,
    "square": lambda x: x ** 2,
    "negate": lambda x: -x,
}

for name, func in operations.items():
    print(f"{name}(5) = {func(5)}")

HELLO!!!
wow!!
double(5) = 10
square(5) = 25
negate(5) = -5

# A function that creates customized functions
def make_multiplier(factor):
    def multiply(x):
        return x * factor  # 'factor' is remembered!
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))   # 10
print(triple(5))   # 15
print(double(100)) # 200

# The closure remembers 'factor' even though make_multiplier finished!
print()

# Practical closure: a counter
def make_counter(start=0):
    count = [start]  # Using a list so the inner function can modify it
    def increment():
        count[0] += 1
        return count[0]
    return increment

page_views = make_counter()
print(f"Visit 1: {page_views()}")
print(f"Visit 2: {page_views()}")
print(f"Visit 3: {page_views()}")

10
15
200

Visit 1: 1
Visit 2: 2
Visit 3: 3

import functools
import time

# A simple timer decorator
def timer(func):
    @functools.wraps(func)  # Preserves the original function's name/docstring
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)  # Call the original function
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_greeting(name):
    """Greet someone slowly."""
    time.sleep(0.1)  # Simulate slow work
    return f"Hello, {name}!"

# Using the decorated function
result = slow_greeting("Anika")
print(result)
print(f"Function name: {slow_greeting.__name__}")  # Thanks to @wraps
print(f"Docstring: {slow_greeting.__doc__}")

slow_greeting took 0.1003s
Hello, Anika!
Function name: slow_greeting
Docstring: Greet someone slowly.

import functools

# 1. Logging decorator
def log_call(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        args_str = ", ".join(map(repr, args))
        print(f"Calling {func.__name__}({args_str})")
        result = func(*args, **kwargs)
        print(f"  → returned {result!r}")
        return result
    return wrapper

# 2. Simple memoization (caching) decorator
def memoize(func):
    cache = {}
    @functools.wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

@log_call
def add(a, b):
    return a + b

add(3, 4)
print()

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

# Without memoize, fib(35) would take forever. With it: instant!
print(f"fib(10) = {fibonacci(10)}")
print(f"fib(35) = {fibonacci(35)}")

print()

# Python has a built-in version!
@functools.lru_cache(maxsize=128)
def factorial(n):
    return 1 if n <= 1 else n * factorial(n - 1)

print(f"20! = {factorial(20)}")

Calling add(3, 4)
  → returned 7

fib(10) = 55
fib(35) = 9227465

20! = 2432902008176640000

import functools

def repeat(n):
    """Decorator factory: repeat a function n times."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            result = None
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)  # repeat(3) returns the actual decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("World")

print()

# Stacking decorators — they apply bottom-up
def bold(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return f"<b>{func(*args, **kwargs)}</b>"
    return wrapper

def italic(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return f"<i>{func(*args, **kwargs)}</i>"
    return wrapper

@bold       # Applied second (outer)
@italic     # Applied first (inner)
def greet(name):
    return f"Hello, {name}"

print(greet("Anika"))  # bold(italic(greet))("Anika")

Hello, World!
Hello, World!
Hello, World!

<b><i>Hello, Anika</i></b>