Explain Core Python Runtime and Language Concepts

Scenario Overview

In high-volume backend and trading environments, a subtle misunderstanding of Python runtime semantics can cause silent data corruption, memory exhaustion, or severe concurrency bottlenecks. Analyze the four production scenarios below and explain their runtime mechanics, potential failure modes, and production-grade fixes.

Part 1: Mutability and Reference Semantics

Consider the following function designed to append timestamped metrics to an in-memory batch:

def record_metric(name: str, value: float, tags: list = []):
    tags.append(f"metric:{name}")
    return {"name": name, "value": value, "tags": tags}

• Explain what happens across multiple invocations when tags is omitted.
• Describe how Python resolves default argument expressions at import/definition time versus call time.
• Provide the idiomatic fix and explain why is None is preferred over truthiness checks.

Part 2: Memory Efficiency with Generators

A service reads a 10 GB tick data CSV file to filter and emit valid records:

def parse_ticks(filepath: str):
    with open(filepath, "r") as f:
        lines = [line.strip() for line in f]
    return [line.split(",") for line in lines if not line.startswith("#")]

• Explain the memory profile of this function and why it crashes in constrained container environments.
• Refactor this code into an iterative generator pipeline using yield.
• Detail what happens to an unexhausted generator when a consumer raises an unhandled exception or terminates early.

Part 3: Concurrency and the GIL

You must process two workloads:

1. A CPU-bound task: Computing cryptographic hashes over 1,000,000 records.
2. An I/O-bound task: Polling 50 external HTTP price endpoints.

• Explain how CPython's Global Interpreter Lock (GIL) dictates your choice between threading.Thread, multiprocessing.Process, and asyncio for both tasks.
• Explain how Python threads achieve cooperative multitasking despite the GIL.

Part 4: Context Managers and Resource Safety

Explain the protocol underlying with statements (__enter__ and __exit__).

• What are the arguments passed to __exit__ when an exception occurs inside the with block?
• How does __exit__ indicate whether an exception should be suppressed or propagated?
• Explain when using the @contextlib.contextmanager decorator is appropriate versus writing an explicit class.