Memory Optimization — HIGH

• 3.1 Intern Repeated Strings to Save Memory — HIGH (reduces duplicate string storage)
• 3.2 Use slots for Memory-Efficient Classes — HIGH (20-50% memory reduction per instance)
• 3.3 Use array.array for Homogeneous Numeric Data — HIGH (4-8× memory reduction for numbers)
• 3.4 Use Generators for Large Sequences — HIGH (100-1000× memory reduction)
• 3.5 Use weakref for Caches to Prevent Memory Leaks — HIGH (prevents unbounded cache growth)

Concurrency & Parallelism — HIGH

• 4.1 Use asyncio for I/O-Bound Concurrency — HIGH (300% throughput improvement for I/O)
• 4.2 Use multiprocessing for CPU-Bound Parallelism — HIGH (4-8× speedup on multi-core systems)
• 4.3 Use Queue for Thread-Safe Communication — HIGH (prevents race conditions)
• 4.4 Use TaskGroup for Structured Concurrency — HIGH (prevents resource leaks on failure)
• 4.5 Use ThreadPoolExecutor for Blocking Calls in Async — HIGH (prevents event loop blocking)

Loop & Iteration — MEDIUM

• 5.1 Hoist Loop-Invariant Computations — MEDIUM (avoids N× redundant work)
• 5.2 Use any() and all() for Boolean Aggregation — MEDIUM (O(n) to O(1) best case)
• 5.3 Use dict.items() for Key-Value Iteration — MEDIUM (single lookup vs double lookup)
• 5.4 Use enumerate() for Index-Value Iteration — MEDIUM (cleaner code, avoids index errors)
• 5.5 Use itertools for Efficient Iteration Patterns — MEDIUM (2-3× faster iteration patterns)
• 5.6 Use List Comprehensions Over Explicit Loops — MEDIUM (2-3× faster iteration)

String Operations — MEDIUM

• 6.1 Use f-strings for Simple String Formatting — MEDIUM (20-30% faster than .format())
• 6.2 Use join() for Multiple String Concatenation — MEDIUM (4× faster for 5+ strings)
• 6.3 Use str.startswith() with Tuple for Multiple Prefixes — MEDIUM (single call vs multiple comparisons)
• 6.4 Use str.translate() for Character-Level Replacements — MEDIUM (10× faster than chained replace())

Function & Call Overhead — LOW-MEDIUM

• 7.1 Reduce Function Calls in Tight Loops — LOW-MEDIUM (100ms savings per 1M iterations)
• 7.2 Use functools.partial for Pre-Filled Arguments — LOW-MEDIUM (50% faster debugging via introspection)
• 7.3 Use Keyword-Only Arguments for API Clarity — LOW-MEDIUM (prevents positional argument errors)
• 7.4 Use lru_cache for Expensive Function Memoization — LOW-MEDIUM (avoids repeated computation)

Python Idioms & Micro — LOW

• 8.1 Leverage Zero-Cost Exception Handling — LOW (zero overhead in happy path (Python 3.11+))
• 8.2 Prefer Local Variables Over Global Lookups — LOW (faster name resolution)
• 8.3 Use dataclass for Data-Holding Classes — LOW (reduces boilerplate by 80%)
• 8.4 Use Lazy Imports for Faster Startup — LOW (10-15% faster startup)
• 8.5 Use match Statement for Structural Pattern Matching — LOW (reduces branch complexity)
• 8.6 Use Walrus Operator for Assignment in Expressions — LOW (eliminates redundant computations)