🔥Course Curriculum

Advance Python Programming

Programming· Advanced· Ages 15–17· 40 Hours

Course At a Glance

Program Outcomes

By the end of this course, students will be able to:

1
Design and implement structured Python applications using advanced programming concepts and object-oriented principles.
2
Apply data structures and algorithmic thinking to analyse and solve complex computational problems efficiently.
3
Develop real-world software projects that demonstrate independent coding ability, modular design, and professional programming practices.

Module 1

Advanced Object-Oriented Programming (OOP)

Students deepen their understanding of OOP principles including classes, constructors, inheritance, encapsulation, polymorphism, and abstraction. Emphasis is placed on designing modular, scalable programs using OOP best practices. Culminates in a Student Management System.

Approx. 10 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Concepts / Syntax
1.1	Classes & Objects: Deep Dive	Review class syntax and object creation. Go deeper: understand how __init__, instance attributes, and class attributes differ. Explore how methods access instance data via self. Trace object creation and memory in code.	Build: 'Student Class' — define a Student class with name, age, grade attributes and methods like introduce(), is_passing(), and get_gpa(). Create 5 student objects and call all methods.	`class, __init__, self, instance vs class attr`
1.2	Special (Dunder) Methods	Explore Python's special methods (__str__, __repr__, __len__, __eq__, __lt__) to make custom objects behave like built-in types. Understand operator overloading and why these methods matter for professional code.	Extend the Student class: add __str__ for readable printing, __eq__ to compare students by GPA, __lt__ to enable sorting. Print a sorted list of Student objects.	`__str__, __repr__, __eq__, __lt__, __len__`
1.3	Encapsulation & Properties	Apply encapsulation to protect data using private attributes (name mangling with __). Use @property decorators to create controlled getters and setters that validate data before storing it.	Refactor: Update the Student class so grade is private (__grade). Add a @property getter and a setter that raises ValueError if grade is outside 0–100. Test with valid and invalid values.	`__attr, @property, @setter, ValueError`
1.4	Inheritance	Create child classes that inherit attributes and methods from a parent class. Override parent methods to specialise behaviour. Use super() to call the parent constructor and extend it without duplicating code.	Build: Class hierarchy — Person (parent) → Student and Teacher (children). Student adds enrol() and get_grades(); Teacher adds assign_grade() and list_students(). Demonstrate polymorphic behaviour.	`class Child(Parent), super().__init__(), override`
1.5	Polymorphism & Abstraction	Use polymorphism to call the same method on different object types and get different behaviour. Introduce abstract base classes using the abc module. Understand interface design: define what a class must do without saying how.	Build: 'Shape Calculator' — abstract base class Shape with abstract method area(). Concrete classes: Circle, Rectangle, Triangle each implement area(). Loop over a list of mixed shapes and print their areas.	`from abc import ABC, abstractmethod, @abstractmethod`
1.6	OOP Design & Class Relationships	Understand composition (has-a) vs. inheritance (is-a). Design multi-class programs where objects contain other objects. Introduce UML-style class diagrams as a planning tool before coding.	Design Session: Sketch a class diagram for a School system (School → Classroom → Student). Then implement it: School has a list of Classrooms, each Classroom has a list of Students. Methods: enrol_student(), get_class_average().	`Composition, has-a, list of objects`
1.7	Student Management System — Part 1	Begin building a multi-class Student Management System. Define the full class hierarchy (Person, Student, Teacher, Course). Implement core methods for each class. Set up the main() menu structure.	Build Sprint: Student Management System skeleton — all classes defined with full attributes and methods. Menu runs and displays options. add_student() and list_students() fully functional.	`Full OOP: classes, inheritance, composition`
1.8	Student Management System — Part 2	Complete the Student Management System: add search, update, and delete functionality. Integrate input validation (try-except). Display formatted reports using __str__ methods. Conduct peer review and refine.	Project Completion: Search student by name, update grade, remove student, print class report with averages. Peer code review: Is the OOP design clean? Are responsibilities well separated?	`Full Module 1 — OOP best practices`

Module 2

Data Structures and Algorithmic Thinking

Students implement sorting and searching algorithms, explore abstract data types (stacks and queues), master recursion, and write efficient Pythonic code using comprehensions and functional tools. Introduces Big-O complexity at a conceptual level.

Approx. 10 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Concepts / Syntax
2.1	Algorithm Thinking & Big-O Basics	Introduce algorithmic thinking: breaking a problem into clear, ordered steps. Define time complexity informally — why does algorithm choice matter? Introduce Big-O notation at a conceptual level: O(1), O(n), O(n²). Compare two solutions to the same problem.	Analysis Exercise: Given three functions that find the maximum in a list, predict which is fastest, measure with time.time(), and discuss why. Write pseudocode for two everyday algorithms.	`import time, time.time(), pseudocode, O(n)`
2.2	Linear & Binary Search	Implement linear search (O(n)) and binary search (O(log n)). Understand the precondition for binary search (sorted data). Trace through both algorithms step-by-step. Measure performance difference on large lists.	Build & Compare: Implement linear_search(lst, target) and binary_search(lst, target). Test on a list of 10,000 numbers. Time both and display results. Discuss when each is preferable.	`while, mid = (lo+hi)//2, time complexity comparison`
2.3	Bubble Sort & Selection Sort	Implement two elementary sorting algorithms: Bubble Sort (O(n²)) and Selection Sort (O(n²)). Trace through both with a small list on paper before coding. Count comparisons and swaps to understand efficiency.	Build & Visualise: Implement both algorithms. Add a print-each-pass option so students can watch the list change at each iteration. Count total swaps for a random list of 10 numbers.	`nested for loops, swap a,b = b,a, pass counter`
2.4	Insertion Sort & Merge Sort	Implement Insertion Sort (O(n²) worst, O(n) best) and introduce Merge Sort as a divide-and-conquer algorithm (O(n log n)). Understand recursion as a tool for divide-and-conquer. Trace the merge step carefully.	Build: Implement insertion_sort() iteratively and merge_sort() recursively. Test on the same 20-element random list. Compare step counts. Discuss when merge sort's overhead is worth it.	`recursion, def merge_sort(lst), divide and conquer`
2.5	Stacks & Queues	Introduce abstract data types: Stack (LIFO) and Queue (FIFO). Implement both using Python lists. Understand real-world use cases: undo history (stack), print queue (queue). Use collections.deque for efficient queue operations.	Build: 'Undo System' using a stack — user performs actions (add, delete, modify) and can undo the last action. 'Task Scheduler' using a queue — add tasks and process them in FIFO order.	`append(), pop(), deque, popleft(), LIFO, FIFO`
2.6	Recursion	Understand recursion: a function that calls itself. Identify base cases and recursive cases. Trace recursive calls using a call stack diagram. Implement classic recursive solutions and compare to iterative equivalents.	Build: recursive factorial(n), fibonacci(n), and countdown(n). Then implement a recursive binary search. Discuss stack overflow risk and when iteration is preferable.	`def f(n): if base: return; else: f(n-1)`
2.7	List Comprehensions & Generators	Write concise list transformations using list comprehensions with optional conditions. Understand generator expressions for memory-efficient iteration. Use map(), filter(), and sorted() with lambda functions for functional-style programming.	Refactor Sprint: Rewrite 5 for-loop solutions using list comprehensions. Build a prime number generator using a generator expression. Use sorted() with a lambda to sort a list of Student objects by GPA.	`[x for x in lst if cond], lambda, map(), filter()`
2.8	Algorithm Challenge & Optimisation	Apply sorting, searching, recursion, and comprehensions together to solve multi-step problems. Analyse solutions for efficiency and refactor. Practice thinking about which data structure and algorithm best fits a given problem.	Challenge Lab: Solve 3 timed algorithm problems (e.g. find duplicates in O(n), sort a list of dictionaries by value, implement a frequency counter). Discuss and compare solutions as a class. Peer code review.	`Full Module 2 — algorithmic thinking`

Module 3

File Handling, APIs, and External Libraries

Students manage structured data through TXT, CSV, and JSON file operations. They install and use external libraries, interact with public APIs using the requests module, apply regular expressions, and build a complete data pipeline project.

Approx. 10 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Concepts / Syntax
3.1	Advanced File Handling: TXT & CSV	Review reading/writing text files. Introduce the csv module for structured data: read rows into lists of dictionaries with csv.DictReader, write rows with csv.DictWriter. Handle headers, delimiters, and quoting automatically.	Build: 'Student CSV Manager' — read a students.csv file into a list of dicts, display a formatted table, add a new student, and write the updated list back to the CSV.	`import csv, DictReader, DictWriter, fieldnames`
3.2	JSON: Reading, Writing & Parsing	Understand JSON as a data interchange format. Use the json module to parse JSON strings and files into Python dicts/lists (json.load, json.loads) and serialise Python objects to JSON (json.dump, json.dumps). Handle nested JSON structures.	Build: 'Settings Manager' — store and load application configuration from a config.json file. Let users update settings via a menu. Save changes back to the JSON file with proper formatting.	`import json, json.load(), json.dump(), json.dumps()`
3.3	External Libraries & pip	Understand Python's package ecosystem. Install libraries using pip. Explore the datetime module (dates, times, timedeltas) and the random module (shuffle, choices, sample) in depth. Understand how to read library documentation.	Build: 'Event Scheduler' — uses datetime to let users schedule events, calculate days until an event, and sort events by date. Uses random to assign a random motivational quote on startup.	`pip install, import datetime, timedelta, random.choice()`
3.4	Introduction to APIs	Understand what an API is and how HTTP requests work (GET, response codes, JSON responses). Use the requests library to make API calls. Parse JSON responses and extract specific fields. Handle connection errors with try-except.	Guided Build: 'Weather App' — fetch current weather for a user-entered city using the Open-Meteo API (free, no key required). Display temperature, wind speed, and weather description.	`import requests, requests.get(), .json(), status_code`
3.5	API Data Processing & Storage	Fetch data from an API, process and filter it, then save results to a CSV or JSON file for later use. Build a complete fetch-process-store pipeline. Add error handling for network failures and unexpected response structures.	Build: 'Trivia Quiz App' — fetches 10 questions from the Open Trivia DB API, shuffles answers with random, runs the quiz, scores the user, and saves results (name, score, date) to a results.json file.	`API pipeline: fetch → parse → process → save`
3.6	Data Analysis with Python	Compute statistics from datasets without external libraries: mean, median, mode, range, frequency counts using dictionaries. Process a CSV dataset and generate a text-based summary report. Introduce the concept of data pipelines.	Build: 'Dataset Analyser' — reads a CSV of student scores, computes mean, median, highest, lowest, and grade distribution. Outputs a formatted summary report and saves it to report.txt.	`sorted(), sum(), len(), dict frequency counter`
3.7	Regular Expressions	Introduce the re module for pattern matching in strings. Use re.match(), re.search(), re.findall(), and re.sub(). Write patterns to validate email addresses, phone numbers, and extract structured data from text files.	Build: 'Data Validator' — validate user-entered email, phone number, and postcode using regex patterns. Extract all email addresses from a sample text file and save them to a list.	`import re, re.match(), re.findall(), r'pattern'`
3.8	Module 3 Integration Project	Combine file handling, external libraries, and APIs in a single cohesive program. Students choose a dataset (API or CSV), process it, analyse it, and produce a structured output file — a mini data pipeline from start to finish.	Project: 'Data Pipeline' — fetch or load data, clean and process it, compute summary statistics, and save a formatted report to both a .txt and .json file. All file and API operations wrapped in try-except.	`Full Module 3 — file + API + libraries`

Module 4

Final Capstone Project

Students integrate all learned concepts to design and develop a complete software project demonstrating structured programming, OOP design, data management, API or file integration, error handling, and clear documentation.

Approx. 10 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Concepts / Syntax
4.1	Capstone Briefing & Project Selection	Students are presented with three capstone project tracks and may also propose their own. Each project must demonstrate OOP design, data structures, file handling or API use, error management, and a user-facing menu interface.	Selection & Ideation: Review project briefs for all three tracks. Select a project. Write a one-paragraph project description answering: What does it do? Who is it for? What concepts does it use?	`Project planning, scope definition`
4.2	Software Design & Architecture	Design the full software architecture before writing production code. Create a class diagram, define all modules (files), and map out the data flow. Write function and method stubs with docstrings. Plan the file/API data format.	Design Deliverable: Hand-drawn or digital class diagram, module map, and data flow diagram. Stub out all classes and functions. Run the skeleton — menus display, stubs return placeholder values.	`UML class diagram, stubs, docstrings, __main__`
4.3	Core Build Sprint — Part 1	Implement the primary data model: classes with full attributes and methods, core data structures, and the main menu loop. Aim for a working prototype by end of session — core features functional even if not polished.	Build Sprint: Complete all class implementations and the main menu. Core features (add, view, search) must work end-to-end with sample data. Progress check with teacher.	`OOP, data structures, menu loop`
4.4	Core Build Sprint — Part 2	Implement remaining features: file persistence (load on startup, save on exit), API integration if applicable, advanced data operations (sorting, filtering, searching). Ensure all major use cases are covered.	Build Sprint: Add file load/save, complete all menu options, integrate any API calls. Run through the full program from start to exit with no crashes. Fix all critical bugs identified.	`File I/O, API calls, sorting, error handling`
4.5	Error Handling & Input Validation	Audit the entire program for unhandled exceptions. Add try-except to all file operations, API calls, and type conversions. Implement robust input validation loops using reusable helper functions. Test every failure path deliberately.	Hardening Session: Work through a testing checklist — enter wrong data types, delete the data file mid-run, simulate a network error. Program must handle all gracefully.	`try-except-finally, custom Exception class, validation`
4.6	Code Quality & Documentation	Apply professional coding standards: consistent naming (PEP 8), meaningful comments, complete docstrings on all classes and functions, removal of dead code and debugging prints. Generate a README.txt explaining how to run the project.	Code Review Checklist: PEP 8 compliance, all functions documented, no magic numbers, meaningful variable names, README complete. Peer review swap — each student reviews one other project using the checklist.	`PEP 8, docstrings, README, code review`
4.7	Final Testing & Demo Preparation	Conduct a full end-to-end test pass covering all features, edge cases, and error paths. Prepare a 5-minute demonstration script. Create a brief slide or outline covering: project overview, architecture, key challenges, and one feature they are proud of.	Dress Rehearsal: Each student runs a timed 5-minute demo for the teacher. Receive specific feedback on what to clarify or improve for the final presentation.	`Full system test, demo preparation`
4.8	Capstone Presentation Day	Students deliver their final capstone presentation to the class. Presentations include a live program demo, explanation of the OOP design and data structures used, a challenge they solved and how, and what they would add given more time.	Final Presentation: 5-minute demo + 3-minute Q&A from peers and teacher. Assessed on: functionality, code quality, OOP design, error handling, and communication clarity.	`Full course — Advanced Python`

Teaching Notes & Tips

Pacing Guidance

Each module contains 8 lessons of approximately 50–60 minutes each, totalling ~40 hours. Module 1 (OOP) is foundational — do not rush Lessons 1.4–1.6. Module 4 lessons are extended project sessions; hold flexible checkpoints rather than strict timings.

Differentiation

Advanced students can explore: multiple inheritance, decorators, context managers, pandas for data analysis, Flask for web APIs, or SQLite for database persistence. Students needing support should focus on core OOP and avoid over-engineering their capstone.

Assessment Criteria

Module projects assessed on: (1) Functionality — does it work correctly? (2) OOP Design — proper class structure and relationships. (3) Code Quality — PEP 8, docstrings, meaningful names. (4) Error Handling — graceful failure on bad input. (5) Presentation — clarity of explanation.

Tools & Environment

Required: VS Code with Python + Pylance extensions, Python 3.10+. Students should be comfortable using the terminal. Module 3 requires pip access to install requests. API lessons use free, keyless APIs (Open-Meteo, Open Trivia DB) to avoid sign-up barriers.

Capstone Project Tracks

Track A — Library Management System: OOP-designed system to manage books, members, and loans with CSV persistence. Track B — Weather Dashboard: Fetches multi-city weather via API, stores history in JSON, displays trends. Track C — Personal Finance Tracker: OOP-driven expense/income manager with category analysis and file persistence. Track D — Student-proposed project (requires teacher approval and design sign-off by Lesson 4.2).

Prior Knowledge Expected

Students must be confident with: all Python syntax (variables, loops, conditions), defining and calling functions with parameters and return values, reading/writing text files, try-except error handling, and working with lists and dictionaries (Python Fundamentals Basic + Intermediate courses).

Enroll Your Child Now