Python Problem Solvers
Think like a programmer: algorithms, recursion, data structures and classes.
An advanced Python course for confident young coders. Learn to plan and debug like a programmer, master searching and sorting, recursion, data structures and classes, then tackle competition-style challenges and a final project.
Ask about this course
About this course
Python Problem Solvers is for students who already write Python with functions, lists, strings, dictionaries and loops, and want to take on bigger, harder problems.
Across six modules, students learn to plan before they code with decomposition and pseudocode, trace programs by hand, and debug systematically with their own assert tests. They build the classic searching and sorting algorithms themselves, then use Python's sorted() with key= and compare approaches by counting steps. They meet recursion, choose the right data structure (2D lists, sets, tuples, stacks and queues) and design their own classes with __init__, methods and __str__.
The course finishes in a challenge lab: mixed competition-style problems with a calm, timed strategy, and a final project where each student solves a real problem they care about.
Every lesson is taught live and 1-to-1 by an instructor. Students practise with auto-graded Python problems that run in the browser, and submit three projects in My Projects for instructor feedback.
What your child will learn
- Break a problem into steps and plan it in pseudocode before coding
- Trace code by hand and debug systematically using assert tests
- Implement linear search, binary search, selection sort and bubble sort, and explain how their step counts compare
- Sort data by custom rules with sorted() and key=
- Write recursive functions with correct base and recursive cases, and know when a loop is better
- Choose between lists, dictionaries, sets, tuples, stacks and queues for a task
- Design classes with __init__, attributes, methods and __str__
- Solve unfamiliar, competition-style problems using a clear strategy and explain the solution
Course structure
- 1
Thinking like a programmer
Before the clever code comes the clever thinking. Break problems into steps with pseudocode, trace programs by hand like a detective, and catch bugs systematically with tests you write yourself.
3 lessons
- 2
Searching and sorting
Meet the classic algorithms: linear and binary search, selection and bubble sort, and Python's own sorted() with key=. Start counting steps to compare how fast different approaches are.
4 lessons
- 3
Recursion
Functions that call themselves. Learn the base case and recursive case, solve factorial, power and digit problems, check palindromes, walk nested lists — and learn when a plain loop is the better choice.
2 lessons
- 4
Data structures
Pick the right container for the job: 2D lists for grids and boards, sets for fast membership, tuples for fixed records, and stacks and queues (with lists and deque) for processing things in order.
4 lessons
- 5
Objects and classes
Design your own types. Write classes with __init__, attributes and methods, give them a friendly __str__, and model game entities and inventories — then build a class-based mini game or app.
2 lessons
- 6
Challenge lab
Put everything together: tackle mixed competition-style problems with a calm, timed strategy, then plan, build and present a final project that solves a real problem you care about.
2 lessons
Example projects
Algorithm visualiser in text
A program that prints every pass of a sorting or searching algorithm so you can watch it work.
Class-based mini game
A battle, pet or shop game built from classes that interact, with friendly __str__ output.
League table manager
Enter match results and print a table sorted by points, goal difference and name.
Maze solver
A grid maze where the program finds a route from start to finish using a stack or queue.