Python Core (Beginner to Advanced)
Master the Python language end-to-end through projects: fundamentals, idiomatic and functional Python, object-oriented design, packaging and environments, the standard library, and concurrency, perfo…
Master the Python language end-to-end through projects: fundamentals, idiomatic and functional Python, object-oriented design, packaging and environments, the standard library, and concurrency, performance, and testing. The language foundation every Python role assumes — and the base the AI/ML, Web, and Data-Automation tracks build on.
6 phases · 48 projects · v1.1.0
Target roles: Python Developer, Software Engineer, Backend Engineer (Python), ML/Data Engineer (foundation)
Stack: Python 3.12, pytest, typing, venv, Poetry
PHASE 1 · 9 projects
Language Fundamentals
Read and write clean, correct Python: types, collections, control flow, functions, and exceptions.
01 · featured
Unit Converter CLI
Build an interactive command-line unit converter to learn Python's core types, type conversion, functions, conditionals, loops, and exception handling.
Python 3.12 · input/print · functions · exceptions
02
String Toolkit
Build a small library of text utilities (slugify, word count, title-case, reverse, palindrome check) to master Python strings, slicing, methods, and f-string formatting.
Python 3.12 · str methods · slicing · f-strings
03
Number Guessing Game
Build a guess-the-number game with hints, attempt limits, and replay to master numbers, the random module, comparison operators, and while loops.
Python 3.12 · random · while loops · int/float
04
To-Do List (Lists & Tuples)
Build an in-memory to-do manager with add/list/complete/remove to master Python lists, tuples, indexing, iteration, and mutation vs immutability.
Python 3.12 · list · tuple · enumerate
05
Contact Book (Dicts & Sets)
Build a searchable contact book to master dictionaries (key/value lookup), sets (uniqueness and membership), and why hashing makes them fast.
Python 3.12 · dict · set · hashing
06
Data Cleaning with Comprehensions
Clean a messy list of records using list, dict, and set comprehensions, learning when a comprehension improves clarity and when it hurts it.
Python 3.12 · comprehensions · list/dict/set
07
Control Flow Patterns
Implement classic exercises (FizzBuzz, a multiplication table, a simple text menu with match/case, and prime detection) to master conditionals, loops, and structural pattern matching.
Python 3.12 · match/case · for/while · boolean logic
08
Functions Deep Dive
Build a small statistics toolkit to master function parameters, default arguments, *args/**kwargs, multiple return values, scope, and the mutable-default-argument trap.
Python 3.12 · functions · *args/**kwargs · scope
09
Errors & Input Validation
Build a reusable validation layer with custom exceptions to master try/except/else/finally, exception hierarchy, raising and chaining, and the EAFP vs LBYL styles.
Python 3.12 · exceptions · custom errors · EAFP
PHASE 2 · 8 projects
Idiomatic & Functional Python
Write Python the way Python developers do: comprehensions, generators, decorators, typing, and the functional toolkit.
01
Unpacking, Starred Targets & zip
Build a CSV row transformer to master tuple/dict unpacking, starred assignment, zip, enumerate, and dict merging — the idioms that make Python code concise.
Python 3.12 · unpacking · zip · enumerate
02
Iterators & Generators
Build a lazy log-file reader and number streams using the iterator protocol and generator functions with yield, learning lazy evaluation and memory efficiency.
Python 3.12 · generators · yield · iterator protocol
03
Decorators
Build timing, caching, and retry decorators to learn how functions wrap other functions, why functools.wraps matters, and how decorators with arguments work.
Python 3.12 · decorators · functools.wraps · closures
04
Closures & Higher-Order Functions
Build configurable function factories and pipelines to master closures, functions as values, higher-order functions, and lambda — the foundation under decorators and callbacks.
Python 3.12 · closures · higher-order functions · lambda
05
Functional Toolkit: map, filter, reduce, partial
Process data with map, filter, functools.reduce, functools.partial, and the operator module — and learn when these beat a comprehension and when they don't.
Python 3.12 · functools · operator · map/filter/reduce
06
itertools Recipes
Solve real problems with itertools (chain, islice, groupby, count, cycle, combinations, permutations, accumulate) to learn efficient, lazy iteration patterns.
Python 3.12 · itertools · generators
07
Type Hints & Static Checking with mypy
Add complete type hints to a small module and verify them with mypy: built-in generics, Optional/Union, type aliases, Protocols, and Generics.
Python 3.12 · typing · mypy
08
Dataclasses, Enums & NamedTuples
Model structured records with dataclasses (mutable, frozen, with defaults and methods), Enums for fixed choices, and NamedTuple for lightweight immutable records.
Python 3.12 · dataclasses · enum · typing.NamedTuple
PHASE 3 · 8 projects
Object-Oriented Python & Design
Model problems with classes done well — inheritance, dunder methods, properties, ABCs, and Pythonic design.
01
Classes & Instances
Model a bank account with classes to learn __init__, instance vs class attributes, methods, and the role of self.
Python 3.12 · classes · self · attributes
02
Dunder Methods (Operator Overloading)
Build a Vector and a Money class implementing __repr__/__str__, __eq__/__hash__, __add__, comparison, and __len__ to learn how Python's data model makes objects behave like built-ins.
Python 3.12 · dunder methods · data model
03
Inheritance, super() & the MRO
Model a shape hierarchy to learn inheritance, method overriding, super(), and how Python resolves methods across multiple base classes (the MRO).
Python 3.12 · inheritance · super · MRO
04
Properties & Encapsulation
Use @property, setters, and computed attributes to enforce invariants and expose a clean interface, learning Python's convention-based encapsulation.
Python 3.12 · @property · encapsulation
05
Abstract Base Classes & Interfaces
Define a payment-processor interface with abc.ABC and @abstractmethod so subclasses are forced to implement required methods, learning interface-based design.
Python 3.12 · abc · interfaces
06
Composition over Inheritance
Model a Car built from an Engine, Wheels, and a Logger to learn composition, delegation, and dependency injection — and when they beat inheritance.
Python 3.12 · composition · delegation · dependency injection
07
Class Methods & Static Methods
Add alternative constructors and utility methods to a Date/Color class to learn @classmethod, @staticmethod, and how they differ from instance methods.
Python 3.12 · @classmethod · @staticmethod
08
Pythonic Design Patterns
Implement Strategy, Factory, and a Pythonic Singleton/registry, learning how Python's first-class functions and modules simplify classic OO patterns.
Python 3.12 · design patterns · first-class functions
PHASE 4 · 7 projects
Modules, Packaging & Environments
Turn scripts into installable, reproducible, distributable packages.
01
Modules & the Import System
Split a script into multiple modules and learn how Python's import system works: import vs from-import, absolute vs relative imports, __name__, and how sys.path resolves modules.
Python 3.12 · modules · imports
02
Packages & Project Structure
Organize modules into an installable package with a src layout, __init__.py, and a clean public API, learning how real Python projects are structured.
Python 3.12 · packages · __init__.py · src layout
03
Virtual Environments & pip
Create isolated environments with venv, install and pin dependencies with pip and requirements.txt, and learn why isolation and reproducibility matter.
Python 3.12 · venv · pip · requirements.txt
04
pyproject.toml & Building a Package
Write a pyproject.toml, build a wheel and sdist, and install your package locally (editable) — the modern, standardized way to package Python.
Python 3.12 · pyproject.toml · build · hatchling
05
Publishing to PyPI (TestPyPI)
Publish your package to TestPyPI with twine, then install it back with pip — the full release loop, practiced safely on the test index.
Python 3.12 · twine · TestPyPI · build
06
Dependency Management & Lockfiles
Use a modern tool (uv or Poetry) to resolve, lock, and reproduce dependencies, learning version constraints, lockfiles, and how dependency resolution handles conflicts.
Python 3.12 · uv · Poetry · lockfiles
07
CLI Entry Points
Turn your package into an installable command-line tool using project.scripts entry points and argparse, so users can run it by name after pip install.
Python 3.12 · entry points · argparse
PHASE 5 · 7 projects
Standard Library & I/O
Get real work done with the batteries Python includes: files, data formats, dates, regex, logging, and processes.
01
Files & pathlib
Build a file-organizing tool using pathlib to read, write, move, and inspect files and directories the modern way, learning paths, encodings, and safe I/O.
Python 3.12 · pathlib · file I/O
02
Context Managers
Write custom context managers with both __enter__/__exit__ and contextlib.contextmanager (a timer, a temporary-directory, a DB-like transaction) to master guaranteed setup/teardown.
Python 3.12 · context managers · contextlib
03
JSON & CSV Data Formats
Read, write, and convert between JSON and CSV with the standard library, handling nested data, types, and the quirks of each format.
Python 3.12 · json · csv
04
Dates, Times & Time Zones
Build a small scheduling/age calculator to master datetime, timedelta, parsing/formatting, and the critical difference between naive and timezone-aware datetimes.
Python 3.12 · datetime · zoneinfo
05
Regular Expressions
Build a log/text extractor with the re module: patterns, groups, named groups, substitution, and compiled patterns, learning when regex is the right tool and when it isn't.
Python 3.12 · re
06
Logging Done Right
Replace print debugging with the logging module: levels, loggers, handlers, formatters, and writing to console and file with structured output.
Python 3.12 · logging
07
Subprocess & OS Interaction
Run external commands with subprocess and interact with the environment via os/shutil, learning safe argument passing, capturing output, exit codes, and avoiding shell-injection.
Python 3.12 · subprocess · os · shutil
PHASE 6 · 9 projects
Concurrency, Performance & Testing
Make Python fast, concurrent, and trustworthy — and prove it with tests.
01
Threading & the GIL
Speed up I/O-bound work with threads and learn why the GIL means threads help I/O but not CPU-bound code, plus thread safety with locks.
Python 3.12 · threading · GIL
02
Multiprocessing
Use multiprocessing to parallelize CPU-bound work across cores, learning processes vs threads, Pool/map, and the cost of inter-process communication.
Python 3.12 · multiprocessing
03
Asyncio Basics
Learn async/await, coroutines, and the event loop by building an async program, understanding how single-threaded concurrency handles many I/O operations.
Python 3.12 · asyncio · async/await
04
Async Concurrency Patterns
Build a concurrent async fetcher with tasks, gather, timeouts, semaphores for rate-limiting, and error handling — the patterns real async code uses.
Python 3.12 · asyncio · httpx
05
concurrent.futures
Use ThreadPoolExecutor and ProcessPoolExecutor for a unified, high-level pool API, learning futures, executor.map, as_completed, and choosing the right pool.
Python 3.12 · concurrent.futures
06
Profiling & Optimization
Measure performance with timeit and cProfile, find the real bottleneck, and optimize it with data-driven changes (better algorithms/data structures, caching), avoiding premature optimization.
Python 3.12 · timeit · cProfile
07
pytest Basics
Write your first automated test suite with pytest: test functions, plain assert, testing for exceptions, and structuring tests so they run from one command.
Python 3.12 · pytest
08
Fixtures & Parametrization
Use pytest fixtures for reusable setup/teardown and parametrize to run one test across many inputs, keeping tests DRY and thorough.
Python 3.12 · pytest · fixtures
09
Mocking & Coverage
Isolate external dependencies with unittest.mock (patch, Mock, monkeypatch) and measure test thoroughness with coverage, learning to test code that talks to networks, time, or files.
Python 3.12 · unittest.mock · pytest · coverage
Next step
Request Python Core (Beginner to Advanced)
An advisor reviews the fit and confirms terms in writing. A request is not an acceptance and nothing is charged until you agree.