Python Course Curriculum — Learn Python Step by Step

Complete step-by-step learning path from Python Foundations to Advanced concepts and practical projects. Start with your first print() statement and finish with real, portfolio-ready Python projects.

Back to PyGym home

Level 1 — Python Foundations

Master core concepts: syntax, variables, data types, strings, collections, control flow, functions, and error handling.

Module 1: Getting Started with Python · Take the module quiz

Understand the Python execution model, print statement, comments, basic syntax, and indentation rules.

What is Python & Your First Program (10 min, beginner)
Comments & Syntax Rules (10 min, beginner)

Module 2: Variables and Data Types · Take the module quiz

Store and manipulate data using variables, primitive data types (int, float, str, bool, None), type conversion, and basic operators.

Variables and Primitive Types (12 min, beginner)

Module 3: Strings & String Operations · Take the module quiz

Master string indexing, slicing, methods (.upper(), .split(), .join(), .strip()), escape characters, and f-string formatting.

Indexing, Slicing & f-Strings (15 min, beginner)

Module 4: Collections (Lists, Tuples, Sets, Dicts) · Take the module quiz

Explore Python built-in collections: mutable lists, immutable tuples, unique sets, and key-value dictionaries.

Lists and Dictionaries (20 min, beginner)

Module 5: Control Flow & Loops · Take the module quiz

Control execution using if/elif/else conditions, comparison operators, for loops, while loops, break, and continue.

Conditionals and Loops (20 min, beginner)

Module 6: Functions & Scope · Take the module quiz

Define reusable functions, parameters, return statements, default arguments, *args, **kwargs, and variable scope.

Defining Functions and Arguments (20 min, beginner)

Module 7: Error & Exception Handling · Take the module quiz

Handle runtime errors gracefully using try, except, else, finally, raise, and custom exception classes.

Try, Except, and Finally (15 min, beginner)

Level 2 — Intermediate Python

Elevate your skills: modules, files, OOP (Classes, Objects, Inheritance), comprehensions, generators, decorators, and context managers.

Module 8: Modules & Packages · Take the module quiz

Organize code with import system, standard library modules (math, random, datetime, sys), and package structure.

Import System and Standard Library (15 min, intermediate)

Module 9: File Handling & Serialization · Take the module quiz

Read and write text files using context managers (with open()), JSON processing (json.dumps, json.loads), and CSV handling.

Context Managers & JSON Data (20 min, intermediate)

Module 10: Object-Oriented Programming (OOP) · Take the module quiz

Design software with classes, objects, constructors (__init__), self, instance vs class attributes, inheritance, encapsulation, and polymorphism.

Classes, Objects & Inheritance (25 min, intermediate)

Module 11: Pythonic Programming & Comprehensions · Take the module quiz

Write concise, elegant code with list/dict/set comprehensions, generator expressions, unpacking, enumerate(), zip(), and map()/filter().

List and Dictionary Comprehensions (15 min, intermediate)

Module 12: Iterators & Generators · Take the module quiz

Understand iterables, iter(), next(), generator functions with yield, lazy evaluation, and generator pipelines.

Generators and Yield (20 min, intermediate)

Module 13: Decorators · Take the module quiz

Master first-class functions, closures, function decorators with @syntax, wrapper functions, and decorator parameters.

Function Decorators (20 min, intermediate)

Module 14: Context Managers & with · Take the module quiz

Understand resource acquisition and release with the context manager protocol (__enter__, __exit__) and contextlib.

Custom Context Managers (20 min, intermediate)

Level 3 — Advanced Python

Master enterprise topics: Advanced OOP, Type Hints, Functional Programming, Async/Concurrency, Testing, Performance, and Python Internals.

Module 15: Advanced OOP & Dunder Methods · Take the module quiz

Explore dunder magic methods (__repr__, __str__, __getitem__, __len__, __call__), @property, dataclasses, and Abstract Base Classes (ABC).

Magic Methods and Dataclasses (25 min, advanced)

Module 16: Type Hints & Static Analysis · Take the module quiz

Annotate code with typing module (List, Dict, Optional, Union, Any, Callable, Protocol, TypedDict) for static type checking.

Type Annotations and Generics (20 min, advanced)

Module 17: Functional Programming Concepts · Take the module quiz

Explore pure functions, immutability, higher-order functions, functools (reduce, partial, lru_cache), and closures.

Higher-Order Functions & functools (20 min, advanced)

Module 18: Concurrency & Async IO · Take the module quiz

Understand asynchronous programming with asyncio (async/await, event loop, asyncio.gather), threading, and GIL concepts.

Async Coroutines and asyncio.gather (25 min, advanced)

Module 19: Testing & Quality Assurance · Take the module quiz

Write robust unit tests using unittest module, assertions, pytest concepts, fixtures, and mocking.

Unit Testing with unittest (20 min, advanced)

Module 20: Performance & Profiling · Take the module quiz

Optimize execution speed and memory using Big-O analysis, timeit module, generators over lists, and caching strategies.

Profiling & Memory Optimization (20 min, advanced)

Module 21: Python Internals & Execution Model · Take the module quiz

Understand CPython objects, reference counting, garbage collection, id(), is vs ==, namespaces, stack vs heap, and bytecode.

Memory Management & Identity (20 min, advanced)

Module 22: Professional Python Development · Take the module quiz

Set up production environments: virtualenv, pip, pyproject.toml, logging module, environment variables, code formatting, and linting.

Logging and Configuration (20 min, advanced)