Pythonoid PRO

An if statement lets a program do something only in certain situations, instead of doing the same thing every time.

• Comparison operators: >, <, >=, <=, ==, !=
• True and False as real values
• The if statement
• elif for additional cases
• else as the catch-all
• Why the order of conditions changes the result

A for loop runs the same instruction several times, so a child writes one line instead of twenty.

• The for loop
• range(n) — counting from zero
• Why range(n) never reaches n
• Using the loop variable inside the loop
• Building a running total across passes
• Loops and if statements together

A while loop repeats for as long as something stays true, which makes it the right tool when you do not know in advance how many times to go round.

• The while loop
• Conditions that change over time
• Why a loop can run forever, and how to spot it
• break — leaving a loop immediately
• continue — skipping one pass only
• Choosing between for and while

A list holds several values under one name, in order, so a program can work with a whole collection instead of one thing at a time.

• Creating a list
• Indexing from zero
• Slicing with [start:end]
• append() — adding an item
• remove() — taking an item out
• What copying a list actually does
• Looping over a list

input() is the one command that genuinely pauses a program and waits for the player to type something back.

• Asking a question with input()
• input() always returns text, never a number
• Converting text to a number with int()
• The TypeError from forgetting to convert
• Comparing a converted number correctly

A dictionary is a stat sheet — a value looked up by its name, not by its position in a list.

• Creating a dictionary and looking up a value by key
• The difference between key-based and position-based lookup
• Updating a key's value
• Adding a brand new key
• The KeyError from a missing key, and .get() with a default
• Looping over a list of dictionaries

A function lets you name a piece of code once and run it again as many times as you like.

• Defining a function with def
• Calling a function, and calling it more than once
• Parameters that customise what a function does
• return hands a value back — it does not display it
• A function call finishes and your code continues afterward
• Choosing whether a function should print or return

A Python error message already tells you what went wrong — this topic teaches how to actually read it.

• Reading a traceback's last line first
• Recognising IndexError, KeyError, TypeError, ValueError, ZeroDivisionError by name
• Syntax errors vs. runtime errors vs. logic errors
• Why a logic error produces no error message at all
• A five-step debugging procedure: read, expect, observe, change one thing, rerun

The same handful of loop shapes shows up again and again in real programs — this topic gives them names.

• The max-tracking and min-tracking patterns
• The counter pattern, and how it differs from an accumulator
• Search-with-a-flag, and finding a value's position
• Why binary search needs a sorted list, and roughly how much faster it is
• Selection sort, as a way to see how sorting actually works
• Testing a pattern against an empty list, a single item, and identical values

The same information can be stored several genuinely different ways — this topic is about choosing which one fits the question you'll actually ask.

• The same data as two parallel lists, a list of dicts, and a dict of lists
• Looping over nested data, including a loop inside a loop
• Updating a value that lives one level deep
• Sets for removing duplicates and checking membership
• Why a set's order isn't guaranteed, and when to use sorted()
• Choosing the right structure for the question being asked

A name never changes what code does — only whether a human reading it later can tell what it's for.

• Why a variable's name never affects what a program computes
• Magic numbers, and the real inconsistency bug they cause
• Named constants as the fix — one value, one place it's defined
• Spotting exact duplication vs. structural duplication
• Extracting a repeated shape into a function with a parameter
• Refactoring: changing how code looks without changing what it does

Extra, harder puzzles for kids who want more — never required, never a prerequisite for anything else. Two flavors run across every topic: fixing a broken piece of code with no crash to point at, and solving something the obvious way before finding the shorter, better way to write the same thing.