Beginner Python is not "I have written a for loop before." It is being able to read a short piece of code and say, correctly, what it does when it runs — including the small number of places where Python is quietly different from what the syntax suggests. That is a real, useful, employable level, and it stops well before most job postings mean when they say "Python required".
What "Beginner" Actually Covers
At beginner level you can read and write straight-line code: variables, the core types (int, float, str, bool, list, dict), if/elif/else branching, for and while loops, and functions with positional parameters and a return value. You can use basic string methods and list operations — append, index, slicing with a single start:stop — and you can write a try/except block around code that might raise an obvious error.
You also understand that Python blocks are defined by indentation rather than braces, and that mixing tabs and spaces in the same file is not a style choice but a real error the interpreter will refuse to run.
That is a genuine floor, and it covers a large share of scripting and automation work. It also looks, from the outside, indistinguishable from having only skimmed a tutorial — which is why naming the specific things you can do reads as more credible than the bare word "Python" on its own.
Where It Breaks
The first wall most beginners hit is the assumption that Python always does the obvious thing. Most of the time it does — until a handful of specific, well-known cases where it does not, and none of them raise an error to warn you.
- A default argument that is a list or dict, which is created once and shared across every call that does not supply its own
- `is` used where `==` was meant, which happens to work on small cached integers and short strings and then silently breaks on anything else
- `5 / 2` producing `2.5` where a beginner coming from another language expected `2`
- A `for` loop that mutates the list it is iterating over, which skips elements because the iterator position and the list length move against each other
- An `except:` with no exception type, which catches everything including typos and keyboard interrupts, and hides the real error instead of handling it
None of these require advanced knowledge to avoid. They require knowing that Python has a small, specific list of places where reading the code and predicting its output are different tasks — which is exactly what beginner-level testing is checking for.
What to Put on a CV at This Level
"Basic Python: variables, control flow, functions, core data types, list/dict basics, try/except" is accurate and it is enough for a real share of scripting, data-entry-adjacent and junior QA roles that never ask for a decorator or a generator.
What would overstate it: "Python" with nothing after it, or naming things you have only read about — decorators, generators, OOP — without having written one. Those get tested directly in the first working week, not the interview.
The Next Rung
Two things separate beginner from intermediate: comprehensions (a list/dict comprehension instead of a manual loop that appends), and a genuine understanding of what a variable actually holds — a value, or a reference to a shared, mutable object. The mutable-default-argument bug above is the first hint of the second idea; intermediate work is where it stops being a trap and starts being a tool you use on purpose.
The Python Test scores syntax/types, functions/scope, data structures and errors/OOP separately across 30 questions in about six minutes, which is a faster way to see which of those is the actual gap than guessing from a tutorial.
Why This Gap Shows Up Fast Once Code Is Reused
A beginner-level script tends to survive exactly as long as it is run once and thrown away. The moment it becomes a function called from more than one place — a shared default argument reused across calls, a list mutated by a caller who did not expect that — the gaps stop being private and start being someone else's bug report, usually filed after the code has already shipped.
That is the honest reason this tier is worth taking seriously rather than rushing past it. Someone who has genuinely internalised the handful of gotchas above has removed most of what makes small Python scripts unreliable once they get reused. Everything the next tier adds builds on that foundation being solid.