Py python
A complete quiz-based curriculum covering Python from first principles to expert-level, production-grade knowledge. Python's simplicity hides a lot of nuance — this track is built around the surprises that trip up even experienced developers.
Part 1 — Foundations
6 topicsIntroduction & Setup
CPython vs. other implementations and version differences (2 vs 3) shape everything downstream.
Variables & Data Types
Dynamic typing, object identity, and small-int caching produce classic is-vs-== gotchas.
Operators & Expressions
Chained comparisons, // vs /, and operator overloading via dunder methods are frequent traps.
Control Flow
for...else, walrus operator, and truthy/falsy rules for custom objects surprise newcomers.
Functions
Mutable default arguments are Python's most famous footgun.
Strings & Text
Immutability, encoding pitfalls, and f-string evaluation order matter in real code.
Part 2 — Core Data Structures
5 topicsLists & Tuples
Shallow copies, list aliasing, and tuple immutability-of-reference-not-contents are daily bugs.
Dictionaries & Sets
Hashability rules and insertion-order guarantees (3.7+) affect correctness and performance.
Comprehensions & Generators
Lazy evaluation and comprehension scoping are common sources of subtle bugs.
Functional Programming
map/filter/reduce, lambda limitations, and functools are idiomatic in data-heavy code.
Closures & Decorators
Late-binding closures in loops and decorator argument order are classic interview gotchas.
Part 3 — OOP & Design
4 topicsClasses & Objects
Class vs. instance attributes and mutable class-level defaults cause shared-state bugs.
Inheritance & Polymorphism
Method Resolution Order (MRO) and super() in multiple inheritance are frequently misunderstood.
Magic Methods & Protocols
__eq__/__hash__ consistency and operator dunders define how objects behave idiomatically.
Properties & Descriptors
The descriptor protocol underlies @property, ORMs, and much of Python's "magic."
Part 4 — Robustness & I/O
5 topicsError Handling
Bare except, exception chaining, and finally-with-return interactions cause silent bugs.
Modules & Packages
Circular imports and __init__.py semantics are frequent real-world stumbling blocks.
File I/O & Serialization
Context managers, encoding defaults, and pickle security risks matter in production.
Iterators & Context Managers
The iterator protocol and __enter__/__exit__ exception suppression are easy to misuse.
Type Hints & Typing
Optional, generics, and runtime-vs-static-only enforcement are widely misunderstood.
Part 5 — Concurrency & Meta
3 topicsConcurrency: Threading & Multiprocessing
The GIL means threads don't parallelize CPU-bound work — a top source of design mistakes.
Async/Await
Blocking calls inside async def silently kill concurrency without raising an error.
Metaprogramming
Metaclasses, __init_subclass__, and dynamic attribute access power frameworks like Django.
Part 6 — Professional & Expert
5 topicsTesting
Fixture scope, mocking pitfalls, and parametrization determine test suite trustworthiness.
Packaging & Virtual Environments
Dependency resolution and pyproject.toml conventions are essential for shipping real projects.
Performance & Optimization
Profiling before optimizing, and knowing where CPython is slow, prevents wasted effort.
Security
eval/pickle risks and injection vectors are the most common Python vulnerabilities.
Exercises & Projects (Capstone)
A mixed-review capstone spanning generators, decorators, OOP, and concurrency.