Intermediate Python is the level most real scripts and small tools actually run on: comprehensions instead of manual append loops, f-strings, basic classes, and *args/**kwargs. It is genuinely productive — and it is also where Python's shared, mutable state starts to matter, because the code you write now gets called by other code, not just run top to bottom once.
What "Intermediate" Actually Covers
The centrepiece is comprehensions — list, dict and set comprehensions used instead of a manual loop with `.append()` — plus f-strings for formatting, `*args`/`**kwargs` for flexible function signatures, and slicing beyond a single start:stop, including a step. You can write a basic class with `__init__` and instance methods, use a `with` statement to manage a file or resource, and sort a list of objects using a `key=` function instead of writing a custom comparison.
You also understand — not just as a rule you memorised, but as something you can predict — that assigning a list or dict to a new variable name does not copy it, and that passing one into a function lets that function mutate the caller's original.
Where It Breaks
- A list comprehension or lambda built inside a loop that captures the loop variable itself, not its value at each iteration — every closure reads the final value
- A shallow copy that looks independent and is not, because the nested lists or dicts inside it are still the same shared objects
- A function that mutates a list argument in place, silently changing the caller's data because nobody copied it first
- Modifying a list while iterating over it with a `for` loop — items get skipped because the loop's position and the list's length move against each other as items are removed
- Comparing a value that arrived as a string (from user input, a file, or an API) against an integer, where `"5" == 5` is false even though a person reading the code assumes they match
The pattern across all five is the same: intermediate Python code is correct as long as nothing shares state with anything else, and starts producing wrong answers — not errors — the moment two pieces of code touch the same mutable object without realising it.
What to Put on a CV at This Level
"Intermediate Python: comprehensions, f-strings, *args/**kwargs, basic OOP, context managers, sorting with key functions" is accurate and is what most job ads asking for "solid Python" actually want — the ability to build a working tool from scratch, not just modify one that already exists.
What would overstate it: claiming "advanced Python" on the strength of comprehensions alone. Advanced work is specifically about writing code that behaves correctly when other code calls into it in ways you did not design for — a distinct, testable claim covered next.
The Next Rung
Advanced Python is built around writing code that other code relies on: decorators that wrap a function without breaking its identity, generators that produce values lazily instead of building a whole list in memory, custom `__eq__`/`__repr__` methods, and inheritance that behaves predictably even with more than one parent class.
The Python Test scores functions/scope and errors/OOP as separate categories across its 30 questions, which is a fast way to see specifically whether closures or class mechanics are the actual gap holding an intermediate score back.
Why Intermediate Python Is Where Most Real Work Actually Sits
It is worth saying plainly: intermediate is not a consolation tier. A large share of data-wrangling scripts, small internal tools and automation code never touches a decorator or a metaclass, and does not need to — the comprehensions-and-classes toolkit here is a complete, employable skill on its own.
The honest reason to push further is not that intermediate is insufficient — it is that any code meant to be imported, called by other developers, or run unattended for a long time eventually meets an input or a caller its author did not anticipate. If that describes the work ahead, the advanced tier is worth the time. If it does not, intermediate Python done carefully is a genuinely complete skill.