Every concept we teach, clearly explained

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

Named boxes that hold a value you can use and change later.

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

Bring in code others wrote — including our own packages.

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

Run different code depending on whether something is true.

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

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

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

Feed values into a function to change what it does.

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

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

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

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

Send an answer back out of a function with return.

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

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

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

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

Build text with values dropped inside using f-strings.

Repeat as long as a condition stays true.

Make things unpredictable with random numbers and choices.

Colors are three numbers: red, green, blue (0-255 each).

Read Python's error messages and fix bugs methodically.

Locate things on a grid with x (across) and y (down).

Read what the user types with input().

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

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

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.

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

Fixed, unchangeable sequences — great for coordinates and pairs.

Catch errors so your program recovers instead of crashing.

The drawing surface your art lives on.

Stamping shapes — stars, flowers — onto the canvas.

Reusing shape helpers you import instead of redrawing them.

Arranging art with balance — thirds, center, edges.

Let loops and randomness create art that's different every run.

Use random numbers for variety in position, size, and color.

React to key presses to move and act.

The things in your game — ship, enemies — that own their look and moves.

The heartbeat of every game: update, draw, repeat — each frame.

Tell when two things touch — and do something about it.

Movement is many small position changes, one per frame.

Spawning groups of enemies with loops and lists.

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

Tracking what's happening: playing, paused, or game over.

Utility classes for styling straight in your markup.

Extra info on tags: id, class, href, alt, and more.

The tags that structure a web page.

The live tree of your page that code can read and change.

Layouts that adapt from phone to desktop.

Reusable building blocks you compose into pages.

Styling: colors, spacing, fonts, and layout.

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.