Every concept we teach, clearly explained

Show text and results on the screen with print().

A name that holds a value, so you can use it and change it later.

Package steps under a name so you can reuse them with one call.

Repeat code many times without retyping, using a loop variable that changes each pass.

Run different code depending on whether something is true.

Compare values with ==, !=, <, >, <=, >= to get True or False.

Do arithmetic with +, -, *, /, //, %, and **.

Borrow tools other people wrote, starting with the ones Python ships with.

Feed values into a function to change what it does.

An ordered collection you can grow, index, and loop over.

Look up values by a key instead of a position — key to value pairs.

Build text with values dropped inside using f-strings.

Start a variable before a loop, then change it a little on every trip: totals, counts, and best-so-far.

Send an answer back out of a function with return.

Combine true/false tests with and, or, not.

Get one item from a list by its position (starting at 0).

Change a list: append, remove, pop, insert, and more.

The kinds of values code uses: numbers, text (strings), and booleans.

Read Python's error messages and fix bugs methodically.

Transform text: upper, lower, strip, split, replace, and more.

Generate a sequence of numbers to loop over: range(start, stop, step).

Make things unpredictable with random numbers and choices.

A loop inside a loop — rows and columns, grids, every pair.

Repeat as long as a condition stays true.

Read what the user types with input().

Find any spot with two numbers: x is how far across, y is how far down.

Extra math: sqrt, sin/cos, pi, floor/ceil.

Blueprints (classes) that create objects bundling data and behavior.

An object's data (attributes) and its actions (methods).

Colors by name, and the three numbers (red, green, blue) inside every one.

Build a list in one readable line from a loop.

Where a variable lives — local vs global — and why it matters.

Loop over items and their index at once.

Fixed, unchangeable sequences — great for coordinates and pairs.

Catch errors so your program recovers instead of crashing.

Painting shapes with one command each: circles, boxes, ovals, rings, hearts.

Build a scene back to front, in sections, so every part lands where it should.

The 400-by-400 sheet every painting lives on, and how to fill it.

Write a recipe for a piece once, like a ladybug or a building, then paint it anywhere.

Let the computer pick spots, sizes, and colors so no two pieces match.

Let loops, recipes, and randomness make art that's different every Run.

Movement is a small change every frame: speed, falling, bouncing, and gravity.

The numbers that make it a game: points going up, lives going down.

Lists of game pieces that grow and shrink: a wall of bricks, a wave of rocks, a stream of gates.

React to keys: held down for steering, pressed once for a jump or a zap.

One variable that says which part of the game is happening: title, playing, paused, or over.

Tell when two game pieces touch, and decide what happens next.

Count frames to make something happen on a beat, or last a while and then stop.

The heartbeat of every game: play(), then draw(), about 60 times a second.

The things in your game, like a basket, a ball, or a brick, that know where they are and how to draw themselves.

Small utility classes that style an element right in its class list.

Extra information on an element: class, id, href, alt, and more.

The live page a script can search and change: find an element, then update it.

How styling works: color, size, and the box of space around every element.

Make a page respond: listen for a click or a key press, then run a function.

Reusable building blocks, like a navbar, a card, or a footer, composed into pages.

The elements that structure a web page: headings, paragraphs, sections, links.

Keep content in an array of objects and let a loop turn each one into markup.

Lay elements out in rows and columns at once, with items that can span several.

Line elements up in a row or column, and decide how the space between them is shared.

One page that fits a phone and a monitor: mobile first, then breakpoints.

Collect what a visitor types: labels, inputs, dropdowns, and a button that submits.

Ask another computer for data with fetch, wait for the answer, and put it on the page.

The molecules that store and carry genetic instructions.

How DNA becomes RNA becomes protein — a pipeline.

Three-letter chunks of genetic code, each naming one amino acid.

The building blocks proteins are made of.

Measuring and comparing biological sequences with code.

The full codon to amino-acid mapping, with start and stop.

The same gene across different species.

What price/volume data looks like and how to read it in code.

Turning indicators into buy/hold/sell decisions — conceptually.

Testing a strategy on past data to study it — educational, not advice.

Position sizing, drawdown, and why risk matters — not advice.

Smoothing noisy data by averaging a sliding window.

Turning any input into a fixed-size fingerprint that changes if the input does.

How a network agrees on the next block.

Blocks that each carry the previous block's hash, forming a chain.

Concepts behind decentralized finance — conceptual, not advice.

Public/private keys that prove ownership and sign actions.

Signed transfers recorded on the chain.

A tamper-evident chain of data blocks shared across a network.

Programs that run on a blockchain under fixed rules.

Why weaknesses exist and how defenders think about them.

The doors and languages services use to talk (HTTP, TCP, ports).

How data travels between machines — packets, addresses, routes.

Thinking like a defender: assume nothing, verify everything.

Authorization, disclosure, and doing security work responsibly.