🐍Course Curriculum

Python Fundamentals

Programming· Beginner· Ages 11–13· 20 Hours

Course At a Glance

Program Outcomes

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

1
Write and execute basic Python programs using correct syntax.
2
Apply programming concepts such as variables, conditions, loops, and functions.
3
Develop simple interactive applications and demonstrate logical problem-solving skills.

Module 1

Introduction to Python & Basic Syntax

Students are introduced to text-based programming using Python. They write and run simple programs, learn core syntax, use variables, and work with arithmetic and comparison operators.

Approx. 5 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Concepts / Syntax
1.1	Welcome to Python	Introduction to text-based programming and why Python is popular. Students learn how computers process instructions. They set up the coding environment (IDLE or an online IDE like Replit) and run their very first program.	First Program: Write and run 'Hello, World!' and 'Hello, [Your Name]!' — modify the output and observe results.	`print()`
1.2	Print & Strings	Understand what a string is and how to use the print() function to display text. Practice printing multiple lines, combining text with commas, and using escape characters like \n.	Build: 'My Profile Card' — print a neatly formatted personal card with name, age, hobby, and favourite subject using multiple print() statements.	`print(), str, \n, \t`
1.3	Variables & Data Types	Learn what variables are and how to store information in them. Explore the three core data types: strings (str), integers (int), and floats (float). Use type() to identify data types.	Guided Exercise: Declare variables for name, age, height, and favourite number. Print them using f-strings.	`str, int, float, type()`
1.4	Arithmetic Operators	Perform calculations using +, -, , /, //, %, and *. Understand integer division vs. float division. Apply BODMAS/PEMDAS rules in Python expressions.	Build: 'Quick Maths Calculator' — a program that calculates area of a rectangle, perimeter, and simple percentage given hardcoded values.	`+, -, , /, //, %, *`
1.5	User Input	Use input() to collect data from the user at runtime. Understand that input() always returns a string and learn to convert types using int() and float().	Build: 'Personal Greeter' — asks the user for their name and age, then prints a personalised greeting and tells them what year they were born.	`input(), int(), float()`
1.6	Comparison & Logical Operators	Use comparison operators (==, !=, <, >, <=, >=) and logical operators (and, or, not) to write expressions that evaluate to True or False. Understand boolean values.	Exercises: Predict the output of 10 comparison expressions, then write 5 of your own. Introduce the concept of conditions as a bridge to Module 2.	`==, !=, <, >, and, or, not, bool`

Module 2

Conditional Statements and Loops

Students control program flow using if/elif/else and repeat tasks with for and while loops. They build interactive programs including a number guessing game.

Approx. 5 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Concepts / Syntax
2.1	If Statements	Write conditional code using if to execute a block only when a condition is True. Practice indentation rules — Python's way of defining code blocks. Trace through code manually before running it.	Build: 'Age Checker' — user enters their age; program prints whether they are old enough to join a club (age >= 10).	`if, :, indentation`
2.2	If-Else & If-Elif-Else	Extend conditionals with else (two outcomes) and elif (multiple outcomes). Build a grading system and a season classifier using chained conditions.	Build: 'Grade Calculator' — user enters a score (0–100); program prints a grade letter (A/B/C/D/F) and a message using if-elif-else.	`if, elif, else`
2.3	Nested Conditions	Write if statements inside other if statements to handle layered decisions. Understand when nesting is appropriate vs. using elif. Practise tracing nested logic.	Build: 'Theme Park Ticket Price' — checks age AND height to determine ticket type (child/adult/senior) and whether the ride is allowed.	`nested if, and, or`
2.4	For Loops	Iterate over a sequence using for loops. Use range() to generate number sequences. Understand loop variables and how loops count. Print patterns and sum numbers.	Exercises: Print numbers 1–10, print even numbers, sum all numbers from 1 to 100. Mini-Build: 'Times Table Generator' — prints the full times table for a number the user enters.	`for, in, range()`
2.5	While Loops	Use while loops for repetition when the number of iterations is unknown. Understand the risk of infinite loops and how to use break and continue. Compare for vs. while.	Build: 'Number Guessing Game v1' — computer picks a fixed number; player keeps guessing until correct. Prints 'Too high', 'Too low', or 'Correct!'.	`while, break, continue`
2.6	Loops + Conditions Combined	Combine loops and conditionals to build interactive programs with validation logic. Use a while loop to keep asking for valid input until the user enters the correct format.	Build: 'Number Guessing Game v2' — adds random number generation with randint(), a guess counter, and a congratulations message showing how many attempts it took.	`random.randint(), while, if-elif-else`

Module 3

Functions

Students learn to define and call functions, use parameters and return values, and organise code efficiently into reusable, readable blocks.

Approx. 5 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Concepts / Syntax
3.1	Introduction to Functions	Understand why functions are useful: reusability, organisation, and readability. Define a simple function with def, call it, and observe how Python executes it. Understand the difference between defining and calling.	Build: Convert 3 repeated code blocks (greet, draw a line, print a header) into named functions and call them multiple times.	`def, (), :`
3.2	Parameters & Arguments	Pass information into functions using parameters. Understand positional arguments and how data flows into a function. Write functions that behave differently based on the input they receive.	Build: 'Custom Greeter Function' — greet(name, age) prints a personalised message. 'Area Calculator' — area_of_rectangle(width, height) returns the area.	`def func(param), arguments`
3.3	Return Values	Use return to send a value back from a function. Understand the difference between printing inside a function vs. returning a value. Store return values in variables.	Build: 'Mini Math Library' — functions for add(), subtract(), multiply(), divide() that return results. Call them and use results in further calculations.	`return, storing return value`
3.4	Default Parameters & Multiple Returns	Set default values for parameters so functions work even without all arguments. Return multiple values from a function using tuples. Unpack returned values into separate variables.	Build: 'Temperature Converter' — convert_temp(value, unit='C') converts Celsius to Fahrenheit or vice versa. Returns both the result and the output unit.	`def f(x=default), return a, b`
3.5	Scope: Local vs. Global	Understand variable scope — where a variable 'lives' in a program. Distinguish between local variables (inside a function) and global variables (outside). Avoid common scope bugs.	Debugging Session: Trace and fix 3 programs with scope errors. Then refactor a messy script into clean functions with proper scope.	`local, global, scope`
3.6	Functions in Action	Combine everything from Module 3: functions with parameters, return values, and proper scope to build a small modular program. Reinforce the principle: one function = one job.	Build: 'BMI Calculator' — separate functions for get_input(), calculate_bmi(weight, height), classify_bmi(bmi), and print_result(name, bmi, category). Fully function-driven.	`Full Module 3 syntax`

Module 4

Mini Project

Students apply all previously learned concepts — variables, conditions, loops, and functions — to plan, build, test, and present a complete interactive Python program.

Approx. 5 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Concepts / Syntax
4.1	Project Planning	Students choose a mini-project from three options (Quiz App, Simple Calculator, or Mad Libs Story Generator) or propose their own. They plan the program: what it does, what inputs it needs, what it outputs, and which concepts it will use.	Planning Workshop: Complete a Project Plan Sheet — program name, description, list of functions needed, sample inputs/outputs, and a pseudocode outline.	`Pseudocode, planning`
4.2	Project Build — Part 1	Students begin coding their chosen project. Focus on getting the core logic working: input collection, main processing logic, and basic output. Teacher provides guided checkpoints.	Build Session: Complete the input and core logic sections of the project. Run and test with sample data.	`Variables, input(), if-elif-else`
4.3	Project Build — Part 2	Students continue building: add functions to organise their code, implement loops for repeated interactions (e.g. quiz questions, retry options), and refine the user experience.	Build Session: Refactor code into functions. Add a loop so the program can be replayed. Add formatted output with print() and f-strings.	`def, for/while, return, f-strings`
4.4	Testing & Debugging	Introduce systematic testing: run the program with valid inputs, invalid inputs, and edge cases. Read and interpret error messages (SyntaxError, TypeError, NameError). Fix bugs using print() as a debugging tool.	Debug Lab: Intentionally broken versions of three programs — students find and fix all errors. Then test their own project with at least 5 different inputs.	`SyntaxError, TypeError, print() debugging`
4.5	Polish & Final Testing	Add finishing touches: descriptive welcome messages, clear prompts, input validation (while loop to re-ask on bad input), and a clean exit message. Peer-review session.	Peer Review: Students swap projects, run them, and complete a feedback form (What worked well? One suggestion for improvement?).	`while validation loop, try/except (intro)`
4.6	Project Presentation Day	Students present their completed project to the class. Each student demonstrates the program running, explains one concept they found challenging and how they solved it, and shares what they would add next.	Final Demo: 2-minute live demo + 1-minute reflection. Classmates ask one question each. Teacher provides written feedback.	`Full course`

Teaching Notes & Tips

Pacing Guidance

Each lesson is designed for a 45–60 minute session. Modules 1–3 contain 6 lessons each; Module 4 is project-based. Allow extra time for Lesson 4.4 (debugging) as students often need more support.

Differentiation

Faster learners can extend activities by adding error handling (try/except), lists, or file I/O. Slower learners should focus on core tasks. Pair programming is recommended for debugging sessions.

Assessment

Assess each module via the activity/project. Criteria: Does the program run without errors? Are the target concepts used correctly? Is the code readable (meaningful variable names, comments)?

Tools & Environment

Recommended: Replit (replit.com) — free, browser-based, no installation needed. Alternatively, Python 3 + IDLE (desktop). Ensure Python 3.8+ is used for f-string support.

Enroll Your Child Now