What you will learn

• 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.