Higher‑order function / decorator

Encapsulate repetitive execution of a function call in a reusable declarative form.

You need to call the same function multiple times in a row (e.g., polling, retry attempts, stress testing); you want to avoid duplicating a for‑loop at each call site.

Found in test utilities, automation scripts, game loops, and any Python codebase that uses decorators for cross‑cutting concerns.

def repeat(;): def decorator(;): def wrapper(*args, **kwargs): for _ in range(;): ;(*args, **kwargs) return wrapper return decorator

def repeat(;): def decorator(;): def wrapper(*args, **kwargs): for _ in range(;): ;(*args, **kwargs) return wrapper return decorator

times: integer specifying repetitions; func: the callable to be executed

• @repeat(N) above functions with side effects such as logging
• API calls
• or state updates

• Writing an explicit for loop
• using functools.partial to bind arguments
• a custom retry decorator that catches exceptions

Omitting the return wrapper (so the decorated function returns None); misplacing the loop inside the decorator instead of the wrapper; using mutable defaults for times

@retry (executes until success or max attempts) – repeats only on failure; @timeout – limits execution duration; @cache – stores results to avoid recomputation

Coming from Java: expecting @ syntax similar to annotations; forgetting that Python decorators are just functions that return functions

• decorator_pattern

Only the return value of the final iteration is accessible; earlier results are discarded. If you need to collect results, modify the wrapper to accumulate them. Side effects will occur times times.

Makes repetitive execution explicit, reduces boilerplate, and clarifies intent at the call site.

Think of a mantra: repeat the action N times.

Only the return value of the final iteration is returned; earlier results are discarded unless accumulated.

Can be extended to a retry decorator with exponential backoff or a caching decorator.