Advanced Python

Build a function factory that captures configuration in a closure.

Use callables as strategy arguments to build a reusable higher-order operation.

Create a decorator that accepts arbitrary function signatures and preserves metadata.

Implement a parameterized decorator and verify its execution order when stacked with another decorator.

Implement type-specific behavior with functools.singledispatch.

Implement a custom iterator using the iterator protocol.

Convert an eager sequence transformation into a lazy generator function.

Delegate part of a generator pipeline with yield from.

Construct a lazy data-processing pipeline with itertools.

Debug exhaustion and one-pass behavior in iterator-based code.

Model an immutable value object with dataclasses.

Control attribute access and validation with properties.

Implement a reusable validating descriptor.

Make a custom object behave like a Python sequence through special methods.

Replace unnecessary inheritance with composition and dependency injection.

Trace method lookup in multiple inheritance using the method resolution order.

Implement cooperative inheritance with super().

Annotate nested collections, optional values, and callable parameters precisely.

Implement a type-safe generic function with TypeVar.

Define a structural interface with typing.Protocol.

Narrow union types through runtime checks.

Use a static type checker to diagnose and correct incompatible types.

Design a custom exception hierarchy for a small library.

Preserve failure context through explicit exception chaining.

Implement deterministic resource cleanup with a class-based context manager.

Create a generator-based context manager with contextlib.contextmanager.

Configure module-level logging with appropriate names and severity levels.

Write isolated behavioral tests with pytest.

Cover input boundaries using parametrized tests.

Share controlled test setup through fixtures.

Replace an external dependency with a mock at the correct import boundary.

Express an invariant as a property-based test with Hypothesis.

Use branch coverage results to identify an untested behavior.

Select threads, processes, or asyncio for a workload based on its blocking and CPU characteristics.

Run independent blocking I/O operations with ThreadPoolExecutor.

Reproduce and eliminate a shared-state race condition with a lock.

Run CPU-bound tasks with ProcessPoolExecutor.

Refactor an I/O workflow to use async-compatible operations without blocking the event loop.

Schedule and collect independent coroutines concurrently as asyncio tasks.

Apply timeouts and cancellation without leaking tasks.

Construct a repeatable microbenchmark with timeit.

Locate runtime bottlenecks with cProfile.

Measure allocation behavior with tracemalloc.

Add bounded memoization with functools.lru_cache.

Optimize a measured bottleneck while preserving behavior with regression tests.

Organize importable code with a src-based package layout.

Declare project metadata and dependency groups in pyproject.toml.

Expose a package operation through an argparse command-line interface.

Build a wheel and verify it in a clean virtual environment.

Configure automated formatting, linting, typing, and testing checks for a Python project.