Python Decorators

def my_decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

def log_args(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with:")
        print(f"  args: {args}")
        print(f"  kwargs: {kwargs}")
        result = func(*args, **kwargs)
        print(f"  returned: {result}")
        return result
    return wrapper

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

print(add(5, 3))

from functools import wraps

# Without @wraps: the wrapper's own identity leaks out
def plain_decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

# With @wraps: the original function's metadata is copied over
def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@plain_decorator
def lost_identity():
    """This docstring disappears"""
    pass

@my_decorator
def complex_function():
    """This function does something complex"""
    pass

print(lost_identity.__name__)
print(lost_identity.__doc__)

print(complex_function.__name__)
print(complex_function.__doc__)

from functools import wraps

def repeat(times):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(times=3)
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

import time
from functools import wraps

# Timing decorator
def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # perf_counter is the right clock for measuring durations:
        # it is monotonic and higher resolution than time.time()
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} took {end - start:.2f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "Done"

print(slow_function())

# Memoization decorator
def memoize(func):
    cache = {}
    @wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

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

# Without the cache this recursion is exponential and would not finish;
# memoized, each n is computed exactly once.
print(fibonacci(50))

def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class Database:
    def __init__(self):
        print("Creating database connection")

db1 = Database()
db2 = Database()   # no second "Creating..." line: the instance is reused
print(db1 is db2)

class MyClass:
    def __init__(self, value):
        self._value = value

    @classmethod
    def from_string(cls, string):
        value = int(string)
        return cls(value)

    @staticmethod
    def static_method():
        return "Static method called"

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        if new_value < 0:
            raise ValueError("Must be positive")
        self._value = new_value

obj = MyClass(10)
print(obj.value)          # @property: reads like an attribute

obj.value = 20            # goes through the setter
print(obj.value)

# @classmethod: an alternative constructor
print(MyClass.from_string("42").value)

# @staticmethod: no self, no cls
print(MyClass.static_method())

# The setter validates, so this is rejected
try:
    obj.value = -5
except ValueError as e:
    print(f"ValueError: {e}")

from functools import wraps

def uppercase(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result.upper()
    return wrapper

def exclaim(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result + "!"
    return wrapper

@uppercase
@exclaim
def greet(name):
    return f"hello, {name}"

# exclaim runs first (it is closest to the function), then uppercase
print(greet("Alice"))