AI-Augmented Python — Free Sample

1. An AI assistant generates: `def merge(a, b={}): b.update(a); return b`. The first call works correctly. The second call returns merged data from the first call too. What's happening?

Default mutable arguments are evaluated once at function definition; the same dict is reused across calls. Fix: use `def merge(a, b=None): b = {} if b is None else b; b.update(a); return b`. The dict.update method has a global side effect; switch to dict-comprehension. Python is passing b by reference; clone with b.copy() inside the function. AI generated buggy code; rewrite without default arguments at all.

2. AI suggests using `pandas.read_csv(url)` to ingest a 50GB compressed CSV from S3 into memory for processing. The instance has 64GB RAM. What's the highest-leverage critique?

Even with 64GB RAM, pandas decompresses + materializes the CSV in memory at multiples of file size; you'll likely OOM on a 50GB compressed file. Use chunked reads (`chunksize=N`), Polars (lazy execution), DuckDB (out-of-memory SQL), or process the file as a stream instead of loading all at once. The 64GB RAM is enough; pandas handles 50GB CSVs natively with no issues. Convert the CSV to Parquet first; that solves the memory problem. Add `low_memory=False` to read_csv; that's the recommended fix.

3. AI writes a list comprehension: `result = [process(x) for x in items if validate(x)]`. validate() is slow (DB call); items contains 10,000 entries with ~5% valid. What's worth refining?

validate() is called once per item (10,000 calls); process() runs only on valid items (~500 calls). Total ~10,500 calls, dominated by 10,000 validate() DB roundtrips. Either batch the validate calls (single query for the IDs you need to check), or denormalize the valid-status into the items so validate() becomes an in-memory check. List comprehensions are slow; rewrite with map/filter. Add multiprocessing.Pool to parallelize the validate() calls. Use a generator expression instead; that lazily evaluates.

4. AI generates a type hint: `def fetch_users(ids: list[int]) -> dict[int, User]:`. Your codebase targets Python 3.8 (per setup.py classifiers). What's the right call?

PEP 585 generic-builtins (list[int], dict[K,V] without typing.List/Dict) require Python 3.9+. On 3.8 this will SyntaxError at import time. Either use typing.List/Dict imports (compatible with 3.8) or add `from __future__ import annotations` (defers evaluation; works on 3.7+). The hints are fine; Python's type hints are evaluated lazily. Drop the type hints entirely; they don't affect runtime behavior. Switch to Pydantic models; that solves type-hint compatibility.

5. AI generates an async function: `async def gather_results(): return await asyncio.gather(*[fetch(u) for u in urls])`. urls has 1,000 entries against an external API with documented 50 req/s rate limit. What's worth knowing?

asyncio.gather fires all 1,000 coroutines concurrently — you'll exceed the 50 req/s limit immediately and get rate-limited. Use `asyncio.Semaphore(50)` around fetch, or wrap with a rate-limited pool (aiolimiter, or a hand-rolled token bucket). Verify the rate-limit policy first — burst-vs-sustained matters. Add try/except around the fetch; rate-limit errors will be handled. Replace asyncio.gather with asyncio.wait; that throttles automatically. Run the coroutines sequentially with a for-loop; safer than gather.

Your directional indicator

This 5-question sample gives a rough indication only. For a valid, verified Skills Passport credential, take the full 40-question assessment — it takes about 30 minutes.

Coming soon

Full assessment launching soon