Python

Master Python from scratch with our comprehensive, interactive curriculum — 120 lessons from Beginner to Advanced.

A complete free Python course from zero to advanced — variables, functions, loops, OOP, file handling and async — with interactive lessons and projects.

Part of the free Python course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

Start with Lesson 1 and build real skills step by step — at your own pace.

Lessons in this course

• Introduction to Python — Install Python, run your first script, and understand how Python works
• Variables and Data Types — Learn how to store text, numbers, and booleans in your programs
• Operators and Expressions — Arithmetic, comparison, and logical operators explained with examples
• Control Flow - If/Else — Make decisions in code with if, elif, and else statements
• Loops - For and While — Repeat actions automatically with for loops and while loops
• Functions — Write reusable blocks of code and pass data in and out with parameters
• *args & **kwargs — Accept any number of positional and keyword arguments in your functions
• Lambda Functions — Write small anonymous functions for sorting, mapping and filtering
• f-strings & String Formatting — Format strings cleanly with f-strings — the modern Python standard
• String Methods — split, join, strip, replace and the string methods you'll use daily
• Sets — Store unique values and do fast membership tests, unions and intersections
• Tuples — Immutable sequences, tuple unpacking, and when to use them over lists
• Comprehensions — Build lists, dicts and sets in one readable line
• enumerate & zip — Loop with an index, and loop over multiple iterables at once
• Checkpoint: Python Essentials — Review & combine the core concepts in a build challenge — then a quiz
• Regular Expressions (re) — Search, match and replace text patterns with the re module
• Dates & Times (datetime) — Work with dates, times, durations and formatting
• Working with JSON — Parse and create JSON with json.loads and json.dumps
• HTTP Requests & APIs — Call REST APIs and handle responses with the requests library
• Reading CSV & Excel Files — Read and write spreadsheet data with csv and openpyxl/pandas
• Web Scraping with BeautifulSoup — Extract data from web pages with requests and BeautifulSoup
• itertools — Iteration power tools — chain, groupby, combinations and more
• Modern File Paths with pathlib — Handle file paths cleanly with the modern pathlib module
• Checkpoint: A Real-World Script — Combine APIs, dates, regex and CSV into one real script — then a quiz
• Lists and Collections — Store and manipulate ordered sequences of data with Python lists
• Dictionaries — Work with key-value pairs to structure and look up real-world data
• File Handling — Read from and write to files — txt, csv, and more
• Exception Handling — Handle errors gracefully so your programs don't crash unexpectedly
• Modules and Packages — Organise code into reusable files and import the Python standard library
• Object-Oriented Programming — Model real-world concepts using classes, objects, and methods
• Inheritance and Polymorphism — Build class hierarchies and reuse code through inheritance
• Decorators & Advanced Features — Wrap functions to add behaviour without modifying their code
• Advanced Functions & Parameters Masterclass — args, kwargs, keyword-only args, and function signatures in depth
• Higher-Order Functions & Function Factories — Pass and return functions, build factories and pipelines
• Closures & Lexical Scope in Real Projects — Understand variable capture and build stateful function patterns
• Context Managers & the with Statement in Depth — Write custom context managers for resource and lifecycle control
• Generators & Iterators Mastery — Produce values lazily for memory-efficient data pipelines
• Advanced Async & Await Patterns — Write clean asynchronous code with async/await and coroutines
• AsyncIO: Event Loop, Tasks & Futures — Deep dive into the AsyncIO event loop, tasks, and concurrent I/O
• Concurrency in Python: Threads vs Processes — Understand the GIL and choose between threading and multiprocessing
• Parallelism with concurrent.futures — Run CPU-bound tasks in parallel with ProcessPoolExecutor
• Profiling & Optimising Python Performance — Find bottlenecks with cProfile, timeit, and memory profilers
• Memory Management & Garbage Collection Internals — How Python allocates, tracks, and frees memory under the hood
• Type Hints & Static Typing with mypy — Add type annotations and catch bugs before runtime with mypy
• Data Classes & Advanced Class Patterns — Reduce boilerplate with @dataclass and slots
• Magic Methods & the Python Data Model — Implement __repr__, __len__, __eq__, and more to integrate with Python
• Operator Overloading & Custom Behaviours — Make your objects work with +, -, *, and comparison operators
• Mixins, Multiple Inheritance & OOP Patterns — Compose behaviour with mixins and navigate multiple inheritance safely
• Design Patterns in Python (Singleton, Factory, Strategy) — Apply classic GoF patterns idiomatically in Python
• Module & Package Architecture for Large Codebases — Structure growing projects with namespaces, imports, and __init__.py
• Logging, Debugging & Error Handling at Scale — Add structured logging, use pdb, and handle errors in production
• Testing with pytest: Fixtures, Parametrisation & Mocks — Write reliable tests with pytest fixtures, parametrize, and unittest.mock
• Building Command-Line Tools with argparse & Typer — Build polished CLI tools with argument parsing and subcommands
• Virtual Environments & Dependency Management Best Practices — Isolate projects with venv and manage packages with pip and Poetry
• Packaging & Publishing Python Libraries to PyPI — Package your code and publish it so others can pip install it
• Working with Files, Streams & Large Datasets — Handle large files with streaming, chunking, and pathlib
• Advanced Collections, itertools & functools — Use Counter, defaultdict, chain, groupby, partial and more
• Functional Programming Techniques in Python — Write pure, composable code with map, filter, reduce, and comprehensions
• Metaprogramming & Introspection with inspect — Dynamically inspect, modify, and create classes and functions at runtime
• Building and Reusing Custom Decorator Libraries — Create your own decorator toolkit with functools.wraps and class decorators
• Using SQLite & ORMs (SQLAlchemy) in Python — Query databases with raw SQLite and the SQLAlchemy ORM
• REST API Clients & External Service Integrations — Call REST APIs with requests, handle auth, and parse JSON responses
• Automation & Scripting for DevOps and System Tasks — Automate file operations, shell commands, and scheduled tasks
• Integrating Python with Other Languages (C, Rust & more) — Call C extensions with ctypes and Cython, and interface with Rust
• Architecture Patterns for Python Apps (MVC, Clean Architecture) — Structure large Python applications with proven architectural patterns
• Slicing Lists & Strings — Extract sub-sequences with [start:stop:step], negative indices, and [::-1]
• Booleans & Truthiness — Truthy/falsy values, short-circuit and/or, and any()/all()
• None & NoneType — Use None correctly — is None vs ==, and the mutable-default-arg trap
• Conditional Expressions (Ternary) — Pick a value inline with a if cond else b, including in comprehensions
• The Walrus Operator (:=) — Assign inside expressions to simplify loops and comprehensions
• Structural Pattern Matching (match/case) — Match literals, sequences, mappings and classes with guards (3.10+)
• Unpacking & Star Expressions — Destructure with a, *rest = ... and splat args with * and **
• Sorting with sorted() & key — Order data with sorted/sort, reverse, and key functions (multi-key too)
• Checkpoint: Core Syntax — Combine slicing, unpacking, sorting and match/case — then a quiz
• functools: lru_cache, partial, reduce — Memoize with lru_cache, pre-fill args with partial, and fold with reduce
• Enums (the enum module) — Model fixed sets of named constants with Enum, auto(), and IntEnum
• namedtuple & NamedTuple — Lightweight immutable records with named fields and defaults
• Randomness with the random Module — randint, choice, shuffle and seeded reproducibility (and when to use secrets)
• Running Commands with subprocess — Run external programs with subprocess.run, capture output, and stay safe
• Hashing with hashlib — Compute SHA-256/HMAC digests, hash files, and understand salts vs encryption
• Testing with unittest — Write TestCase classes with asserts, setUp/tearDown, and assertRaises
• Advanced Type Hints (Generics, Protocol, TypedDict) — Generics with TypeVar, structural typing with Protocol, and TypedDict
• Checkpoint: The Standard Library — Combine enums, namedtuples, functools and hashlib in a build — then a quiz
• Dictionary Methods Deep Dive — get, setdefault, update, pop, items and dict comprehensions in depth
• Counter & defaultdict — Count and group data effortlessly with collections.Counter and defaultdict
• deque & Queues — O(1) appends and pops at both ends with collections.deque
• Heaps with heapq (Priority Queues) — Build priority queues and find top-k with the heapq module
• Binary Search with bisect — Search and insert into sorted lists in O(log n) with bisect
• Numbers: int, float, Decimal & Fraction — Exact money math with Decimal, exact ratios with Fraction, and float pitfalls
• Strings, Bytes & Unicode Encodings — str vs bytes, encode/decode, UTF-8, and fixing UnicodeDecodeError
• Iterators: __iter__ & __next__ — How the iterator protocol powers every for loop — write your own
• Checkpoint: Data Structures — Combine Counter, heapq, deque and bisect in a build — then a quiz
• Abstract Base Classes (abc) — Define and enforce interfaces with abc.ABC and @abstractmethod
• Properties & Descriptors — Computed, validated attributes with @property and the descriptor protocol
• __slots__ & Memory Optimization — Cut memory and speed up attribute access by dropping __dict__
• Scope: global, nonlocal & LEGB — Master name resolution and avoid the UnboundLocalError trap
• Custom Exceptions & Exception Chaining — Build exception hierarchies and chain causes with raise ... from
• Time Zones with zoneinfo — Aware datetimes, converting between zones, and storing UTC correctly
• Serialization with pickle — Save and load Python objects — and the critical security warning
• Config Files with configparser — Read and write INI configuration with sections, types, and defaults
• Checkpoint: OOP & Standard Library — Combine abc, properties, custom exceptions and config in a build — then a quiz
• Threading & the GIL — Run concurrent I/O with threads and understand why the GIL limits CPU work
• multiprocessing: True Parallelism — Use multiple processes to bypass the GIL for CPU-bound work
• Thread-Safe Queues (queue) — Coordinate producers and consumers safely with queue.Queue
• contextlib: contextmanager, suppress, ExitStack — Write your own with-statements and manage dynamic resources
• Temporary Files & Directories — Create auto-cleaning temp files and folders with the tempfile module
• Finding Files with glob & fnmatch — Match file paths with wildcards using glob and fnmatch
• High-Level File Operations (shutil) — Copy, move, archive and delete trees with the shutil module
• Network Programming with sockets — Build TCP clients and servers with Python's socket module
• Checkpoint: Concurrency & I/O — Combine threads, queues, temp files and sockets in a build — then a quiz
• The statistics Module — Compute mean, median, mode, stdev and quantiles from the standard library
• The operator Module — Use itemgetter, attrgetter and operator functions for fast, clean code
• Binary Data with struct — Pack and unpack C-style binary data and read file headers
• Text Wrapping & Formatting (textwrap) — Wrap, indent, dedent and shorten text cleanly with textwrap
• Benchmarking with timeit — Measure tiny code snippets accurately and compare approaches
• The warnings Module — Emit, filter and capture warnings — and turn them into errors
• Introspection with inspect — Examine signatures, source and members of live objects at runtime
• Weak References (weakref) — Reference objects without keeping them alive — caches and cycle-breaking
• Checkpoint: Stdlib Power Tools — Combine struct, statistics and textwrap in a build — then a quiz
• Final Project Ideas — Guided project ideas to put everything you've learned into practice
• Data Validation with Pydantic — Validate and parse data with typed BaseModel classes, field constraints and validators
• NumPy for Numerical Computing — The ndarray, vectorized math, broadcasting and fast aggregations over arrays
• Data Visualization with Matplotlib — Line, scatter, bar and histogram plots with the pyplot and object-oriented APIs
• Building APIs with FastAPI — Typed path operations, Pydantic models, dependency injection and auto Swagger docs
• Static Type Checking with mypy — Catch bugs before runtime with gradual typing, strict mode, generics and Protocols

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary