Advanced Python is not a longer function. It is a decorator that survives introspection, a generator used exactly once because that is the only way it can be used, and a class hierarchy where `super()` follows a real, specific search order rather than the straight line a diagram suggests. The skill being tested here is what happens when your code is called by something other than you.
What "Advanced" Actually Covers
Writing decorators — functions that wrap other functions to add behaviour — and knowing to apply `functools.wraps` so the wrapped function keeps its real name and docstring instead of silently becoming the wrapper. Writing generators with `yield` for lazy, memory-efficient iteration instead of building a full list up front.
Custom dunder methods: `__eq__` and `__hash__` together (never one without deliberately deciding about the other), `__repr__` for a debuggable string representation, `__len__` and `__getitem__` to make a custom class behave like a built-in container. Inheritance across more than one parent class, understanding what `super()` actually resolves to rather than assuming "the direct parent". The full context-manager protocol (`__enter__`/`__exit__`), not just using `with` on something already built.
What Still Breaks
- Defining `__eq__` without `__hash__`, silently making instances unusable as dict keys or set members
- Iterating an exhausted generator a second time and getting nothing, with no exception to explain why
- A decorator without `functools.wraps` that quietly breaks introspection, documentation tools, and some test-discovery mechanisms
- A `super()` call in a multiple-inheritance hierarchy resolving to a class the author did not expect, because the search order is not a simple parent chain
- A custom `__repr__` that is expensive to compute, silently slowing down debugging sessions and logging because it runs every time the object is printed or inspected
The theme repeats: advanced Python tools solve a real problem — lazy iteration, custom equality, flexible inheritance — and each one introduces a smaller, specific way to get it subtly wrong, none of which raise an error at the point where the mistake was actually made.
What to Put on a CV at This Level
"Advanced Python: decorators, generators, custom dunder methods, multiple inheritance/MRO, context managers" is accurate and it will get tested specifically — expect a question about what a decorator does to a function's identity, not a request to define what a decorator is.
What would overstate it: "Python expert" on the strength of writing one decorator. Expert level, covered next, is about the language's concurrency model and memory behaviour — a different, harder question than syntax mastery.
The Next Rung
Expert Python moves past single-threaded correctness into the CPython execution model itself: the GIL and what it actually does and does not prevent, the difference between threading, multiprocessing and asyncio for concurrent work, and descriptors — the mechanism that `property`, `staticmethod` and `classmethod` are all built on top of.
The Python Test scores errors/OOP as its own category across 30 code-reading questions, which is where most advanced-level candidates lose points — not on writing a decorator from scratch, but on predicting what one does to code that already exists. Pair it with the Java Test if the role also expects statically-typed OOP fluency alongside Python's more dynamic version of the same ideas.
The Real Signal Employers Are Screening For
A job ad that specifically says "advanced Python" or "strong OOP" is usually not asking whether you can name more dunder methods than an intermediate candidate — it is asking whether code you write today will still behave correctly when a colleague imports it, subclasses it, or calls it in a loop six months from now. That is a narrower, more testable question than raw feature knowledge.
It is also where interview screens diverge most from CV claims, because "advanced" is an easy word to write and a specific thing to actually demonstrate. A scenario question — what does this decorated function's `__name__` print, what happens if you iterate this generator twice — is a much harder thing to bluff than reciting a list of features.