Section 5 of 9

Python Roadmap: Beginner → Expert

Six-stage Python path optimized for a TypeScript developer, with projects and free resources.

Context for you: coming from TypeScript, Python’s learning curve is mostly idiom, not concepts. You already know closures, async, typing, modules. Stages 1–2 can compress to ~3 weeks; the real work is stages 4–6.

Stage 1 — Core Syntax & Semantics (1–2 weeks for a TS dev)

Topics: variables/dynamic typing, list/tuple/dict/set, slicing, comprehensions, functions (*args/**kwargs, default-arg gotcha), f-strings, truthiness, None, exceptions (try/except/else/finally), file I/O, venv + pip. TS→Python mapping: interface → TypedDict/dataclass/pydantic; === → == (and is for identity); map/filter → comprehensions; npm → pip + venv (or uv/poetry). Projects: CLI expense tracker (JSON persistence); log-file parser that summarizes an Nginx/Express access log. Free resources: Official Python Tutorial (docs.python.org/3/tutorial); “Automate the Boring Stuff with Python” (free online, automatetheboringstuff.com); Corey Schafer “Python Tutorials” playlist (YouTube).

Stage 2 — Idiomatic Python & Standard Library (2–3 weeks)

Topics: iterators/generators (yield), itertools, functools (lru_cache, partial), decorators, context managers (with, contextlib), pathlib, collections (Counter, defaultdict, deque), dataclasses, type hints + mypy, enum, walrus operator, structural pattern matching (match). Projects: rewrite Stage-1 projects idiomatically; build a decorator-based retry/timing utility; typed config loader with dataclasses + mypy --strict. Free resources: Corey Schafer decorator/generator videos; official typing docs; CS50P (Harvard’s “CS50’s Introduction to Programming with Python,” free on YouTube/edX) for structured reinforcement.

Stage 3 — OOP, Testing, Tooling (2–3 weeks)

Topics: classes, dunder methods, properties, ABCs vs Protocol (structural typing — closest to TS interfaces), inheritance vs composition; pytest (fixtures, parametrize, monkeypatch), coverage; ruff (lint+format), uv or poetry for dependency management; project layout (src/ layout, pyproject.toml). Projects: library-management or bank-account domain model with 80%+ pytest coverage; publish a tiny package to TestPyPI. Free resources: pytest official docs; Corey Schafer OOP playlist; “Automate the Boring Stuff” later chapters.

Stage 4 — Backend Python (3–4 weeks — leverage your Node/Express experience)

Topics: asyncio (event loop — you know this mental model from Node), async/await, httpx; FastAPI (routing, Pydantic v2 validation, dependency injection, JWT auth — direct RBAC skill transfer), SQLAlchemy 2.0 + Alembic migrations, background tasks, Docker for Python apps. Projects: re-implement one of your Express+MySQL APIs (from resume) in FastAPI + MySQL/Postgres with JWT/RBAC + pytest; containerize it. Free resources: FastAPI official tutorial (fastapi.tiangolo.com — exceptionally good); SQLAlchemy 2.0 docs; testdriven.io free articles.

Stage 5 — Data & Numerical Python (3–4 weeks; prerequisite for AI work)

Topics: NumPy (arrays, broadcasting, vectorization), pandas (DataFrames, groupby, joins, time series), matplotlib/seaborn basics, Jupyter notebooks, reading CSV/Parquet/SQL sources. Projects: exploratory analysis of a Kaggle dataset (e.g., IPL matches or NYC taxi); ETL script: MySQL → pandas → cleaned Parquet + summary charts. Free resources: “Python for Data Analysis” author Wes McKinney’s free online edition (wesmckinney.com/book); Kaggle Learn micro-courses (Pandas, Data Visualization — free with exercises); Corey Schafer pandas playlist.

Stage 6 — Expert / Specialization (ongoing)

Topics: performance profiling (cProfile, timeit), concurrency trade-offs (threads vs processes vs asyncio; GIL — being removed in free-threaded 3.13+ builds, still default-on in 2026), C-extensions awareness (why NumPy is fast), packaging, design patterns in Python, metaclasses/descriptors (read-only knowledge), and the on-ramp to AI: openai/anthropic SDKs, LangChain/LlamaIndex basics (bridges to Task 8 roadmaps). Projects: async web scraper with rate limiting; small LLM-powered CLI tool using an API SDK; contribute one PR to an open-source Python repo. Free resources: “Fluent Python” concepts via talks by Luciano Ramalho on YouTube [UNVERIFIED — book itself is paid]; Real Python free articles; Anthropic/OpenAI cookbook repos on GitHub (free).

Total realistic timeline for you: 3–4 months part-time to Stage 5; Stage 6 is continuous.

Python is the English of the programming world — simple to read, spoken everywhere, and the default language of AI. If your career plan involves AI at all, Python is non-negotiable, the way English is non-negotiable for international business.

The journey, in cooking-school terms:

Stage 1 — Learn the kitchen basics. Chopping, boiling, following a recipe. In Python: writing simple instructions, storing information in lists, reading files. You build: a small personal expense tracker.
Stage 2 — Cook like a local. Anyone can boil pasta; Italians do it properly. Python has “proper” ways to write things that mark you as fluent. You build: cleaner versions of your first tools.
Stage 3 — Kitchen discipline. Professional kitchens label everything and taste-test constantly. In code this means organizing projects and writing automatic tests that catch mistakes before customers do.
Stage 4 — Run a restaurant. Build real web services — the behind-the-scenes machinery when an app logs you in or fetches your data. (The user already does this in another language; here it’s just new equipment, same restaurant.)
Stage 5 — Become the market analyst. Python’s superpower: digesting huge spreadsheets of data in seconds — sales records, user behavior — and turning them into charts and answers. This is the doorway to AI work.
Stage 6 — Master chef. Speed-tuning, teaching others, and connecting Python to AI models — the skills the market pays a premium for.

Best free teachers: Harvard’s CS50P course (free, on YouTube), the book “Automate the Boring Stuff with Python” (free to read online), and Corey Schafer’s YouTube channel. Total time for an experienced developer: about 3–4 months of evenings. For a true beginner: closer to 6–9 months.

Diagrams

TS → Python skill transfer

Node.js / TypeScript	Python equivalent
Node event loop	`asyncio`
Express	FastAPI
npm / `package.json`	`uv` / `pyproject.toml`
TS `interface`	`Protocol` / `pydantic`
Jest	`pytest`
ESLint + Prettier	`ruff`

~60% of your Node.js mental model transfers directly.