Module 1 - Python, Programming and Development Environment
Understand how programs translate requirements into repeatable instructions, where Python fits among modern languages, and how the interpreter, source files and packages work together. Learners install a supported Python 3 release, configure an editor such as Visual Studio Code or PyCharm where available, use the interactive shell, run scripts from a terminal and organise a clean project folder. The module also introduces virtual environments, command-line navigation, common setup errors and a simple troubleshooting process. Practice begins with short programs that accept input, perform calculations and display useful output. The objective is not to memorise commands but to become comfortable creating, running and correcting Python code independently.
Module 2 - Syntax, Variables, Data Types and Expressions
Build a clear foundation in Python syntax, indentation, identifiers, comments, variables and expressions. Learners work with integers, floating-point values, booleans, strings and the special None value, then practise conversions, comparison, arithmetic and logical operators. Exercises demonstrate how Python evaluates expressions and why data type awareness matters when processing user input, calculations and files. The module introduces readable naming, small focused statements and the habit of checking assumptions with print output or the debugger. By the end, learners can write simple programs without copying line by line and can explain what each value represents in the problem being solved.
Module 3 - Conditions, Loops and Program Flow
Use if, elif and else to make decisions and for and while loops to repeat work safely. Learners practise range, membership tests, nested conditions, loop control with break and continue, and common patterns such as validation, counting, accumulation and searching. The module emphasises choosing clear conditions, avoiding infinite loops and breaking a large problem into small steps before coding. Practical activities include menu-driven programs, eligibility checks, number games, data filters and repeated input handling. Learners also compare loop-based and direct built-in approaches so they understand both the underlying logic and the concise Python style used in professional code.
Module 4 - Strings and Text Processing
Work confidently with text through indexing, slicing, immutability, string methods, formatting and regular-expression awareness. Learners clean inconsistent input, search and replace text, split and join fields, validate simple patterns and create readable output using f-strings. Exercises include username validation, word-frequency summaries, log-line parsing and formatting reports. The module discusses Unicode, encodings and why text files sometimes display incorrectly across systems. Learners are encouraged to use standard-library tools before adding external packages and to avoid fragile chains of replacements when a structured parser is more appropriate.
Module 5 - Lists, Tuples, Sets and Dictionaries
Learn how Python collections represent sequences, unique values and key-value records. Learners create, update, search, sort and combine lists; use tuples for fixed records; use sets for uniqueness and membership; and use dictionaries for structured lookup. They practise nested data, copying versus shared references, common mutability mistakes and selecting the right collection for a task. Activities include inventory records, student scores, contact books, duplicate removal and grouped summaries. The goal is to move beyond syntax and understand how data structure choices affect clarity, performance and maintainability.
Module 6 - Functions, Scope and Reusable Problem Solving
Design reusable functions with clear names, parameters, return values and focused responsibilities. Learners explore positional and keyword arguments, default values, variable-length arguments, local and global scope, docstrings and function annotations. The module explains the difference between printing and returning, how to test functions with representative inputs, and why long functions are difficult to debug. Practical work refactors earlier programs into smaller units and introduces pure-function thinking where useful. Learners leave with a repeatable method for decomposing requirements into functions that can be reused across scripts, APIs and applications.
Module 7 - Comprehensions, Iterators and Generators
Use list, set and dictionary comprehensions to express transformations and filters without sacrificing readability. Learners then examine the iterator protocol, enumerate, zip, sorted keys, generator expressions and yield-based generators. The module connects lazy iteration to memory-efficient file and data processing while warning against overly complex one-line code. Exercises compare an explicit loop, a comprehension and a generator so learners can choose the clearest solution. These concepts prepare students for pandas workflows, web responses and large-file processing later in the course.
Module 8 - Modules, Packages, pip and Virtual Environments
Organise code across modules and packages, import safely and understand how Python locates dependencies. Learners create and activate virtual environments, install packages with pip, record dependencies and separate project code from third-party libraries. The module covers import styles, the __name__ guard, basic package layout, environment variables and the difference between a library and an application. Practical tasks turn a single-file program into a maintainable multi-module project. Learners also discuss dependency updates and why production projects should not rely on an unrecorded global environment.
Module 9 - Exceptions, Debugging and Defensive Programming
Handle expected failures with try, except, else and finally, raise meaningful exceptions and avoid silently hiding errors. Learners use tracebacks, breakpoints, step-through debugging, logging and small reproduction cases to find defects. The module distinguishes user input errors, network failures, data problems and programmer bugs, and explains when recovery is appropriate. Practical exercises debug flawed programs, validate inputs and improve error messages. The goal is to develop calm, evidence-based troubleshooting rather than random code changes.
Module 10 - Files, pathlib, CSV, JSON and Data Exchange
Read and write text files safely using context managers and pathlib, then work with CSV and JSON data through standard-library modules. Learners consider file paths, encodings, newline behaviour, missing files, malformed records and validation before processing. Exercises include converting files, generating reports, merging records and building a small command-line data tool. The module introduces serialisation limits and the importance of not storing secrets or unsafe objects casually. These skills support automation, analytics and backend development.
Module 11 - Object-Oriented Programming and Data Classes
Understand classes, objects, attributes, methods, constructors, encapsulation and composition through practical domain models. Learners build small classes for orders, accounts or tasks, use properties where appropriate and compare inheritance with composition. Data classes are introduced for concise record-like objects, along with equality, representation and default-value considerations. The module does not force every problem into classes; learners practise deciding when functions and dictionaries are sufficient and when an object model improves clarity.
Module 12 - Type Hints, PEP 8 and Clean Python Code
Improve maintainability with type hints, readable naming, consistent formatting, docstrings and small modules. Learners use annotations for functions and common collections, understand that type hints support tools but do not replace runtime validation, and review code against practical PEP 8 principles. The module introduces formatter, linter and static-analysis awareness without tying the course to one vendor. Exercises include reviewing a messy script, extracting functions, clarifying names, removing duplication and documenting assumptions. Clean code is treated as communication between developers, not an aesthetic competition.
Module 13 - Testing with unittest and pytest
Write repeatable tests for functions and application behaviour. Learners practise test arrangement, assertions, boundary cases, exceptions, fixtures, parametrisation and mocking awareness. Both the standard unittest framework and pytest-style workflows are introduced according to the active lab environment. The module explains the testing pyramid, why a high test count does not guarantee quality, and how tests support refactoring. A small project receives a test suite and automated checks so learners can show more than manual screenshots in their portfolio.
Module 14 - SQL, Relational Databases and Python Connectivity
Learn how Python applications store and retrieve structured data using SQLite for local practice and a relational database such as MySQL or PostgreSQL where available. Learners create tables, define keys, write SELECT, INSERT, UPDATE and DELETE queries, use joins and transactions, and execute parameterised statements from Python. The module warns against string-concatenated SQL and introduces connection management, schema design and migrations at a foundation level. A practical mini-application persists users, tasks or orders and generates reports.
Module 15 - HTTP, REST APIs and Working with External Services
Understand requests, responses, methods, status codes, headers, query parameters, JSON payloads and authentication concepts. Learners call approved public or mock APIs, handle timeouts and errors, validate returned data and avoid exposing API keys. The module introduces REST design principles from both the consumer and provider perspective. Exercises include a command-line API client, data synchronisation and an integration that transforms external data into a useful report. Rate limits, terms of service and privacy are included as practical engineering constraints.
Module 16 - Web Applications with Flask
Build a small server-rendered or API-oriented web application with Flask, depending on the active syllabus. Learners create routes, templates, forms, configuration and database integration, then add validation and error handling. The module explains development versus production servers, application structure, environment configuration and basic security considerations. A guided project may be a task manager, feedback system or inventory application. Flask is used to demonstrate web fundamentals clearly rather than to imply that one framework fits every production system.
Module 17 - API Development with FastAPI and Pydantic
Create typed API endpoints with request and response models, validation and automatically generated OpenAPI documentation. Learners practise path and query parameters, status codes, dependency concepts, error responses and asynchronous-function awareness. Pydantic models demonstrate how type annotations and runtime validation work together. The project includes input validation, database access or an in-memory repository, tests and an API README. Security topics such as authentication are introduced carefully and implemented only in controlled examples.
Module 18 - Django Framework Awareness and Structured Web Projects
Explore Django as a batteries-included framework for larger structured applications. Learners review projects and apps, URL routing, models, migrations, the admin interface, templates and authentication concepts. The depth of implementation should match the approved course duration; Django may be a guided module rather than a full specialisation. The goal is to help learners compare Flask, FastAPI and Django based on project requirements and to understand how Python web applications are organised beyond a single file.
Module 19 - Automation, Scripting and Command-Line Tools
Automate repetitive tasks involving files, folders, spreadsheets, reports, APIs and system commands in a safe, reviewable way. Learners use argparse or an approved CLI library, logging, configuration files, scheduled-task awareness and dry-run patterns. Projects may rename and organise files, generate reports, validate data or call an API. The module stresses backups, permission checks and idempotent design so automation does not damage data when run twice. Learners document usage and limitations for non-developer users.
Module 20 - Responsible Web Data Collection and Browser Automation Awareness
Learn the difference between accessing an API, parsing permitted public HTML and automating a browser. Learners practise HTML parsing in a controlled lab, respect robots guidance, terms, rate limits, privacy and copyright, and avoid bypassing authentication or technical controls. Requests and Beautiful Soup may be used for approved examples, with Selenium or Playwright awareness where applicable. The learning outcome is responsible data collection and robust parsing, not indiscriminate scraping.
Module 21 - NumPy, pandas and Data Analysis Foundations
Introduce numerical arrays and tabular analysis for learners who want to use Python in analytics, data science or automation. Topics include NumPy arrays, vectorised operations, pandas Series and DataFrames, filtering, grouping, joins, missing values and simple charts with Matplotlib. Learners analyse a small dataset and produce a concise report with reproducible transformations. This module is a foundation; advanced statistics, machine learning and business intelligence require deeper specialised study.
Module 22 - Concurrency, Async Programming and Performance Awareness
Understand the difference between sequential work, threading, multiprocessing and asynchronous I/O at a conceptual and practical level. Learners use timing, profiling awareness and simple async examples to see why concurrency choices depend on the workload. The module covers blocking operations, task coordination, cancellation and error handling without promising advanced distributed-systems mastery. Performance optimisation begins with measurement, clear algorithms and appropriate data structures rather than premature micro-optimisation.
Module 23 - Security, Secrets and Production Readiness
Apply secure-development habits across scripts, APIs and web applications. Learners avoid hard-coded credentials, use environment variables, validate inputs, parameterise database queries, handle uploaded files carefully and keep dependencies updated. The module introduces password-hashing concepts, authentication versus authorisation, CORS awareness, logging privacy and secure error messages. It also explains why student projects should use test data and why copying security code without understanding it is risky.
Module 24 - Git, GitHub, Deployment and Capstone Delivery
Use Git for meaningful commits, branches, pull-request awareness and recovery from common mistakes. Learners prepare a README, dependency file, environment template, tests and deployment configuration for a capstone project. Deployment may use an approved cloud or platform service, Docker awareness and a simple CI check, subject to current lab resources. The final review evaluates problem definition, code quality, functionality, testing, documentation, security basics, demonstration and honest limitations. Learners finish with a portfolio-ready repository rather than only a certificate file.
