Browse Chunks

Showing 5201-5250 of 7392 chunks

with ThreadPoolExecutor() as executor: futures =

Submits multiple callable tasks to a managed pool of reusable threads, collecting Future objects that represent each pending computation. Addresses the overhead and error-prone complexity of manually creating, starting, and joining individual threads for parallel I/O-bound work. Reached for when you need to run many independent tasks concurrently without blocking the main thread on each one sequentially.

with ThreadPoolExecutor(max_workers=num_workers) as executor: futures = [executor.submit(func, arg) for arg in iterable]

executor.submit(task_func, *args, **kwargs).add_done_callback

CAT_5

Submits a callable to an Executor for asynchronous execution and registers a callback to be invoked when the resulting Future completes.

executor.submit(task_func, *args, **kwargs).add_done_callback(callback)

concurrent.futures.wait

CAT_5

Waits for a set of Future objects to complete, optionally with a timeout and a condition for when to return (e.g., when the first future completes). Returns two sets: done and not_done futures.

concurrent.futures.wait(futures, timeout=timeout, return_when=return_when)

[result for result in executor.map(task_func, iterable, chunksize=100)]

CAT_5

Applies a function to each item in an iterable in parallel using an executor, collecting results into a list with a chunk size of 100 for batching.

[result for result in executor.map(task_func, iterable, chunksize=100)]

with ThreadPoolExecutor(initializer=init_worker, initargs=(shared,)) as executor:

CAT_5

Creates a ThreadPoolExecutor where each worker thread is initialized with a shared object via the init_worker function before processing any tasks.

with ThreadPoolExecutor(initializer=<callable>, initargs=(<args>,)) as <executor>:

@my_decorator def greet(): return 'Hello'

CAT_6

Applies a decorator to modify or extend the behavior of the greet function.

@<decorator_name> def <function_name>(<parameters>): <body>

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

CAT_6

A parameterized decorator that executes the decorated function a specified number of times, useful for repeating side‑effects or retry‑like behavior without writing explicit loops.

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

@staticmethod\ndef utility():\n return 42

CAT_6

A static utility method that returns the constant integer 42, often used as a placeholder or example value.

@staticmethod\ndef <method_name>():\n return <literal>

@classmethod\\ndef create(cls):\\n return cls()

CAT_6

Defines a class method named create that returns a new instance of the class, serving as an alternative constructor.

@classmethod\n\ndef create(cls):\n return cls()

@classmethod def from_dict(cls, data): return cls(**data)

CAT_6

Creates a new instance of a class by unpacking a dictionary's key-value pairs as keyword arguments into the class constructor. Solves the problem of manually mapping dictionary fields to constructor parameters when deserializing data. Reached for whenever you receive a flat dictionary (e.g., from JSON parsing) and need to instantiate a matching object.

@classmethod\ndef from_dict(cls, data):\n return cls(**data)

@property def getter_name(self): return self.attribute

CAT_6

The @property decorator converts a zero-argument method into a computed attribute, accessible without parentheses like a plain attribute. It solves the problem of breaking the public API when evolving a simple attribute into a computed or validated one. You reach for it when callers must access a derived or validated value using attribute syntax rather than an explicit method call.

@property def getter_name(self): return self.attribute

@retry(tries=3, delay=1) def risky_op(): pass

CAT_6

Automatically retries a function call a specified number of times with a fixed delay between attempts when it raises an exception. Addresses transient failures in network or I/O operations where a single attempt is insufficient. Reached for whenever calling external services or resources that may intermittently fail.

@retry(tries=max_attempts, delay=wait_seconds) def function_name(): body

@cache(maxsize=128) def fib(n): return n if n<2 else fib(n-1)fib(n-2)

CAT_6

The @lru_cache decorator from functools memoizes a pure function's return values in a bounded LRU cache, eliminating redundant recomputation for repeated calls with identical arguments. It addresses the exponential time blowup of naive recursive algorithms by trading memory for speed. You reach for it whenever a deterministic function is invoked repeatedly with overlapping inputs, most commonly in recursive divide-and-conquer or dynamic-programming solutions.

@lru_cache(maxsize=maxsize) def func(arg): return ...

@validate(min=0, max=100) def process_value(x): return x

CAT_6

Applies a range-validation decorator to a function, ensuring the argument falls within [min, max] before the function body executes. Addresses the pain point of unchecked numeric inputs propagating invalid data through a pipeline. Reached for whenever a function acts as a gateway for bounded numeric data and must reject out-of-range values early.

@validate(min=min_value, max=max_value) def function_name(parameter): return parameter

@authenticate(role='admin') def admin_only(): return 'secret'

CAT_6

Applies a parameterized decorator to a function to enforce role-based access control before the function body executes. Eliminates the need to manually check permissions inside each handler, which scatters authorization logic and invites omission bugs. Reached for whenever a route or operation must be restricted to users holding a specific role.

@authenticate(role=role) def function_name(): ...

@rate_limit(calls=5, period=10) def api_call(): pass

CAT_6

Applies a rate limiter to a function, allowing at most N calls within a given time period. This prevents excessive calls to APIs or resources and helps avoid HTTP 429 errors.

@rate_limit(calls=limit, period=seconds) def func(): pass

@timeout(seconds=3) def slow_task(): pass

CAT_6

Applies a timeout decorator that limits the decorated function's execution to the specified number of seconds, raising a timeout exception if exceeded.

@timeout(seconds=seconds) def function_name(): function_body