Learn Python from the basics to production readiness: prerequisite skills & environment setup, history & background & why choose Python, core concepts & main architecture, syntax & program structure, advanced functions & functional tools, advanced data types & collections, exception handling & resource management, modularization, basic packaging & virtual environments, dependency management & reproducible environments, persistence & databases, I/O serialization & data formats, configuration secrets & environment management, basic networking & HTTP clients, web frameworks & API design, security best practices, concurrency & parallelism, performance tuning & profiling, type checking & contracting, testing at scale, packaging, distribution & PyPI, CI/CD, containerization & deployment, observability, monitoring & maintenance, up to migration, scaling teams & governance with a total of 23 episodes.
Before touching Python, you need to master basic programming logic, data structures, OOP concepts, and terminal usage. In this episode you also set up Python 3.12, a virtual environment, an editor, and tools such as black, isort, ruff, and mypy.

This episode traces Python's history from its creation by Guido van Rossum, the evolution of the 2.x releases toward 3.x, to the batteries included philosophy. You'll also learn to compare Python with other languages and understand the trade-offs of interpretation versus compilation.

This episode breaks down how Python works behind the scenes: CPython, bytecode, the interpreter loop, and the GIL. You'll also get to know alternative implementations such as PyPy, Jython, IronPython, and GraalPython, as well as Python project structure: modules, packages, the import system, and sys.path.

This episode dissects Python's core syntax: built-in data types, operators, control flow, functions, and comprehensions. You'll also learn naming best practices, modularization, and how to write docstrings correctly according to convention.

This episode deepens your Python functions: positional and keyword arguments, *args and **kwargs, and the mutable default trap. You'll also learn higher-order functions, lambda, the functools module for partial and lru_cache, and iterator utilities.

This episode deepens Python's collection data types: the collections module with deque, defaultdict, Counter, and namedtuple, plus the basics of typing for type annotations. You'll also learn memory and performance considerations when choosing data structures.

This episode covers Python error handling: try, except, else, and finally, plus creating custom exceptions. You'll also learn context managers with the with keyword and the contextlib module for building your own context managers.

This episode takes you from scripts to a structured project: creating a package, writing a minimal setup.cfg or pyproject.toml, using pip install -e for development, and running the proper virtual environment workflow.

This episode covers how to keep dependencies under control: comparing requirements.txt and pyproject.toml, tools like Poetry and Flit, lockfiles with pip-tools, pipx for CLI tools, and virtualenv best practices for reproducible environments.

This episode connects your project to databases: SQLAlchemy Core and ORM, schema migrations with Alembic, an overview of drivers for Redis and MongoDB, and connection pooling and transaction patterns that are safe for production applications.
