Course Content
Module 1 – Getting Started with Python
introduced the fundamentals of Python, giving beginners a clear understanding of how the language works and how to start writing simple programs. Python was highlighted as a beginner-friendly language with simple syntax, making it easy to read and write code.
0/7
Module 2 – Introduction to Python Programming
In this Introduction to Python module, learners explore Python’s clear, readable syntax and powerful features. Beginning with installation and a simple “Hello, World!” script, you will progress through variables, control flow and functions using step-by-step examples. By the end, you will be equipped to write your own Python programmes, automate routine tasks and tap into an extensive library ecosystem for real-world projects.
0/7
Basic Command for Command prompt, PowerShell, Zsh(macOS)
0/1
Module 3 – Variables, Data Types and Basic Operations
In the Variables, Data Types and Basic Operations in Python module, learners explore how to store and manage data using variables, master fundamental types such as integers, floats, strings and booleans, and perform arithmetic, comparison and logical operations step by step. Clear explanations, real world examples and hands on exercises guide you through writing and debugging code. By the end of this module, you will be ready to build dynamic Python programs and automate everyday tasks.
0/6
Module 4 – Control Flow – Conditions and Loops
Control flow structures determine the order in which your program’s code executes. With conditional statements, you can make decisions and execute certain code blocks only when specific conditions are met. Loops allow you to repeat actions efficiently without writing redundant code. In this module, we will explore fundamental control flow concepts in Python in a step-by-step manner, similar to Microsoft’s learning curriculum. By the end, you’ll understand how to use if, elif, and else statements (including nested conditions) for decision-making, how truthy and falsy values work in Boolean logic, how to construct for loops (using range() and iterating over collections), how to use while loops along with loop control statements (break and continue), and how to leverage list comprehensions and generator expressions for concise looping. Finally, we’ll apply these concepts in a practical exercise to build an interactive decision-making system. Each section below includes explanations, code examples, and mini-exercises to reinforce the concepts, all formatted for clarity and easy follow-along.
0/8
Day 1 Summary
We covered Modules 1, 2 & Module 3 (Lesson 1 & 2)
0/1
Module 5 – Functions and Code Organisation
Imagine you need to clean up a messy data set or send a personalised email to each customer. Instead of writing the same steps over and over, you can create a function and call it whenever you need. In this lesson on Functions and Code Organisation, you will learn how to define functions, pass and return information, document your work and group related code into modules for easy reuse and maintenance.
0/10
Day 2 Summary
Summary for Day 21 Aug 2025
0/1
Day 3 Summary
Summary of Day 28 Aug 2025
0/1
Module 7 – Working with Files and Folders
In this lesson, we will learn how to manipulate files and directories using Python. We’ll explore common file operations using the os module, and see how the pathlib module provides an object-oriented way to handle file paths. We’ll also use the glob module for pattern-based file searches and learn file I/O operations for text, CSV, and binary files. Additionally, we’ll introduce the calendar and time modules to work with dates and timestamps. Finally, an interactive lab will tie everything together by automating a folder backup and cleanup task. Follow the step-by-step sections below for each subtopic, try out the code examples, and explore the guided lab at the end.
0/9
Module 8 – Error Handling and Debugging Techniques
In this lesson, we will learn how to handle errors in Python programs and how to debug code effectively. Errors are inevitable, but knowing how to manage them ensures our programs don't crash unexpectedly. We will cover the difference between syntax errors and exceptions, how to use try, except, else, and finally blocks to catch and handle exceptions, and how to raise your own exceptions (including creating custom exception classes). We’ll also explore debugging strategies: using simple print statements or the logging module to trace your program’s execution, and using Python’s interactive debugger pdb to step through code. By following best practices for error handling and debugging, you can write resilient, maintainable code. Throughout this lesson, try the examples and exercises to practice these techniques.
0/9
Day 4 Summary
0/1
Module 9 – Automating Excel and PDFs with Python
In this lesson, you will learn how to automate common communication and reporting tasks using Python. We will cover sending notifications via email, messaging platforms, and SMS, as well as manipulating Excel spreadsheets and PDF files programmatically. Each section below includes step-by-step explanations, code examples, and interactive exercises to reinforce your understanding. By the end of this lesson, you’ll be able to send emails with attachments, integrate with Slack/Microsoft Teams, send SMS alerts, and automate Excel/PDF workflows.
0/9
Day 5 Summary
0/1
Mini Project: Build your own Automation Tool
The project incorporates two common automation tasks – Contact Management and Student Tasks Tracking
0/2
Day 6 Summary
0/1
Introduction to Python Programming (Copy 1)

Build a CLI Script to Bulk-Rename or Categorize Files

Objectives

By completing this lab, you will:

  • Build a complete command-line tool using Python (or your preferred language).

  • Apply loops, conditionals, and input validation.

  • Use file operations (rename/move).

  • Handle edge cases, errors, and add logging.

  • Practice real-world problem solving with automation.

Choose a Project Option

You have two options. Pick one, or do both for extra practice:

Option A: Bulk-Rename Files

A script that renames all files in a given directory using a naming scheme (e.g., add prefix, suffix, or sequential numbering).

Option B: Categorize Files

A script that moves files into subfolders based on file types (e.g., .jpg → Images, .pdf → Documents).

Step-by-Step Instructions

Step 1: Setup and Planning

 Create a Test Folder:

  • For Rename (Option A):
    Create a folder test_rename and add mixed files (e.g., file1.txt, image.png, doc.docx).

  • For Categorize (Option B):
    Create a folder test_sort and add mixed types (e.g., photo1.jpg, report.pdf, song.mp3).
    Ensure no subfolders exist yet.

 Tip: Work on copies of files, not originals, to avoid data loss during testing.

Step 2: Outline the Logic in Pseudocode

Bulk-Rename – Pseudocode

BEGIN
PROMPT for folder path and new filename prefix
SET count = 1
FOR EACH file in folder:
    IF file is a directory, CONTINUE
    CONSTRUCT new_name = prefix + "_" + count + original extension
    RENAME file to new_name
    PRINT success message
    INCREMENT count
END FOR
PRINT "Renaming complete."
END

Categorize – Pseudocode

BEGIN
PROMPT for folder path
DEFINE categories = {
    "Images": [".jpg", ".png", ".gif"],
    "Documents": [".pdf", ".docx", ".txt"],
    "Audio": [".mp3", ".wav"]
}
FOR EACH file in folder:
    IF file is a directory, CONTINUE
    SET ext = file extension (lowercased)
    FOR EACH category:
        IF ext is in category list:
            SET dest_folder = category
            BREAK
    IF no category matched:
        SET dest_folder = "Others"
    IF dest_folder does not exist:
        CREATE it
    MOVE file to dest_folder
    PRINT move message
END FOR
PRINT "Categorization complete."
END

Step 3: Plan Edge Cases

  •  Empty folders: Script should run without errors.

  •  Duplicate prefixes (rename): Avoid double-renaming.

  •  Filename collisions: Use numbering or unique naming.

  •  Categorize: Prevent re-moving already sorted files.

  •  Permissions issues: Catch and log exceptions.

  •  Skip folders (only operate on files).

Step 4: Implement the Script

 Example: Python Script for Bulk Rename (Option A)

import os

# Get user inputs
folder = input("Enter folder path to rename files in: ").strip()
prefix = input("Enter new filename prefix: ").strip()

# Validate input
if not os.path.isdir(folder):
    print("Error: Folder not found.")
    exit(1)

count = 1

# Loop through files
for filename in os.listdir(folder):
    file_path = os.path.join(folder, filename)
    if os.path.isdir(file_path):
        continue  # Skip folders

    name, ext = os.path.splitext(filename)
    new_name = f"{prefix}_{count}{ext}"
    new_path = os.path.join(folder, new_name)

    try:
        os.rename(file_path, new_path)
        print(f'Renamed "{filename}" to "{new_name}"')
        count += 1
    except Exception as e:
        print(f'ERROR renaming "{filename}": {e}')

print("Renaming complete.")

 For File Categorization (Option B), use:

  • os.makedirs(path, exist_ok=True) to create folders if missing.

  • shutil.move(src, dst) or os.rename() to move files.

  • Loop through categories and match file extensions.

Step 5: Testing

For Rename:

  •  Check all files got renamed.

  •  Confirm nothing was lost or skipped.

For Categorize:

  •  Confirm folders like “Images”, “Documents”, “Audio” were created.

  •  Check that files moved correctly.

Example Output – Categorize Script:

Created folder: Images
Moved photo1.jpg -> Images/photo1.jpg
Moved photo2.png -> Images/photo2.png

Created folder: Documents
Moved report.pdf -> Documents/report.pdf
Moved notes.txt  -> Documents/notes.txt

Created folder: Audio
Moved song.mp3   -> Audio/song.mp3

File categorization complete.

 Test Edge Cases:

  • Empty folder

  •  Subfolders present (should skip or handle)

  •  Already processed files (optional skip logic)

  •  Read-only or restricted files

  •  Large number of files

Step 6: Review and Optimize

Optional enhancements:

  • Add a mode selector: rename or categorize

  • Skip already renamed or sorted files

  • Add logging to a file (e.g., log.txt)

  • Add an undo option (if you track original names)

  • Add a dry-run mode to preview actions without making changes

Lab Summary

By the end of this lab, you will have:

 Identified a repetitive manual task
 Designed logic with pseudocode
 Used input handling, loops, and conditionals
 Performed file renaming or moving
 Tested and handled errors
 Built a working CLI script!