Python Course

Lesson 1 • Variables and Built-in Data Types

Introduces variables, type assignment, and Python's primitive types. Understanding types is prerequisite for all data manipulation ahead.

Lesson 2 • Operators and Expressions

Explains arithmetic, comparison, logical, and assignment operators. Operator fluency enables writing meaningful computational expressions.

Lesson 3 • Input, Output, and Basic Debugging

Covers print formatting, user input, and reading error messages. These skills make scripts interactive and errors diagnosable.

Lesson 4 • Core Syntax and Code Structure

Teaches indentation rules, comments, and statement structure. Correct syntax habits prevent errors throughout the entire course.

Lesson 1 • For Loops and Iteration

Covers iterating over sequences and using range. For loops enable repetitive processing of collections introduced in later chapters.

Lesson 2 • While Loops and Loop Control

Explains condition-driven loops and break, continue, and pass. These tools handle indefinite repetition and early exit scenarios.

Lesson 3 • Exception Handling Basics

Covers try, except, else, and finally blocks for error management. Robust control flow requires handling unexpected runtime conditions gracefully.

Lesson 4 • Comprehensions and Functional Iteration

Introduces list comprehensions and map/filter patterns. Concise iteration syntax improves readability and performance in data tasks.

Lesson 1 • Choosing and Nesting Data Structures

Guides selection among structures and building nested composites. Correct structure choice directly impacts code clarity and runtime efficiency.

Lesson 2 • Dictionaries: Keys, Values, and Methods

Covers dict creation, access patterns, and iteration methods. Dictionaries are the backbone of structured data and configuration handling.

Lesson 3 • Tuples and Immutable Sequences

Explains tuple creation, unpacking, and immutability benefits. Tuples enforce data integrity where mutation would cause bugs.

Lesson 4 • Sets and Membership Operations

Teaches set creation, deduplication, and set algebra. Sets provide O(1) membership testing critical for performance-sensitive code.

Lesson 1 • Defining and Calling Functions

Teaches def syntax, parameters, and return values. Functions are the primary unit of reuse for all subsequent modules.

Lesson 2 • Scope, Namespaces, and Closures

Explains local, enclosing, global, and built-in scope rules. Scope mastery prevents subtle bugs in larger programs.

Lesson 3 • Docstrings and Function Documentation

Teaches docstring conventions and introspection tools. Well-documented functions are essential for team collaboration and API design.

Lesson 4 • Lambda Functions and Higher-Order Functions

Introduces anonymous functions and functions as first-class objects. These patterns underpin functional programming and callback-based APIs.

Lesson 1 • Classes, Objects, and Attributes

Introduces class definition, instantiation, and instance attributes. Classes organise related data and behaviour into reusable blueprints.

Lesson 2 • Dunder Methods and Operator Overloading

Covers __str__, __repr__, __eq__, __len__, and arithmetic dunders. Custom dunder methods make objects behave naturally with Python syntax.

Lesson 3 • Methods: Instance, Class, and Static

Covers the three method types and their appropriate use cases. Choosing the right method type clarifies intent and reduces coupling.

Lesson 4 • Encapsulation and Properties

Explains private naming conventions, getters, setters, and @property. Encapsulation protects internal state and enforces valid data access.

Lesson 1 • Logging with the logging Module

Explains log levels, handlers, formatters, and logger hierarchy. Structured logging replaces print debugging in production-grade applications.

Lesson 2 • Path Manipulation and Directory Operations

Covers pathlib for path construction, traversal, and file system queries. Portable path handling prevents OS-specific bugs in cross-platform code.

Lesson 3 • Advanced Exception Handling Patterns

Covers custom exception classes, exception chaining, and context suppression. Structured error handling makes library APIs predictable and debuggable.

Lesson 4 • Working with Binary and Structured Files

Teaches binary file access and structured formats like pickle. Binary I/O is required for images, serialized objects, and custom protocols.

Lesson 1 • Managing Dependencies with pip

Explains pip install, requirements files, and dependency pinning. Proper dependency management ensures reproducible project environments.

Lesson 2 • Working with JSON and CSV Data

Covers reading and writing JSON and CSV using standard library tools. These formats are ubiquitous in data exchange and configuration files.

Lesson 3 • Creating and Importing Modules

Teaches module creation, import syntax, and namespace management. Modular code is easier to test, maintain, and share across projects.

Lesson 4 • Building and Distributing Packages

Covers package directory structure, __init__.py, and relative imports. Packages enable large codebases to be organized and distributed cleanly.

Lesson 1 • Debugging with pdb and IDE Tools

Explains breakpoints, step execution, and variable inspection. Systematic debugging reduces time spent diagnosing complex runtime failures.

Lesson 2 • Unit Testing with pytest

Teaches test function structure, assertions, and test discovery. Automated tests catch regressions and document expected behavior permanently.

Lesson 3 • Code Coverage and Refactoring Techniques

Teaches coverage measurement and safe code refactoring strategies. High coverage and clean structure reduce defect rates in long-lived codebases.

Lesson 4 • Code Quality with Linters and Formatters

Covers flake8, pylint, and black for style enforcement. Consistent formatting and linting reduce review friction in collaborative projects.