Telling the computer what to do

You write price = 20, and from then on the name price refers to the number 20. Later you can write price = 25 and the name refers to something else. Nothing is permanent.

There are four kinds of information you meet immediately. Whole numbers, called integers — 3, 100, -7. Numbers with a decimal point, called floats — 3.5, 0.001. Text, called strings, always written inside quotes — "hello". And true-or-false values, called booleans — written True and False, capitalised.

The important mental shift: a variable does not contain the value, it refers to it. This sounds like hair-splitting now. It becomes the single most important idea in the whole roadmap when you reach linked lists and trees from week 15 onwards, because those are built entirely out of things referring to other things.

print("hello") puts hello on the screen. That is your main window into what your program is doing, and for the next few weeks it is also your main debugging tool — when something is wrong, print the value and look at it.

name = input("What is your name? ") shows the question, waits for typing, and stores whatever came back in name. One trap catches everyone: input() always gives you text, even when the person typed a number. If you need the number 5 rather than the text "5", you have to convert it with int().

f-strings are the tidy way to mix values into text. You write f"Hello {name}" and Python drops the value of name into the sentence. The f before the opening quote is what switches this on. Without it you get the literal characters {name}, which is a confusing first bug to hit.

Arithmetic is what you expect: + - * / for add, subtract, multiply and divide. Two are less obvious and both matter enormously later. Double slash divides and throws away the remainder, so 7 // 2 is 3. And percent gives you only the remainder, so 7 % 2 is 1.

That percent operator looks like a novelty and is not. It is how you test whether a number is even, how clock arithmetic works, and — in week 17 — how a hash table decides which storage slot to put something in. It shows up constantly.

Comparisons give back True or False: double equals for “is equal to”, exclamation-equals for “is not equal to”, and the usual less-than and greater-than signs for ordering. Note the double equals. A single equals assigns a value; a double equals asks a question. Mixing them up is the most common beginner typo in any language.

Logical operators join conditions: and needs both sides true, or needs at least one, not flips true to false. In Python these are written as those English words, not as symbols.

The shape is: if age >= 18: followed by an indented block of steps. If the condition is false those steps are skipped entirely, as though they were not written.

elif lets you chain more questions, and Python checks them top to bottom, stopping at the first one that is true. else is the fallback with no condition attached. You can have as many elif branches as you like, and at most one else.

The most useful habit to build here is thinking about which branch runs when nothing matches. Beginners write the happy path and forget the else, so the program silently does nothing when something unexpected happens. That silence is much harder to debug than a crash would have been.

for item in things: runs the indented block once per item, with item referring to a different one each time. for i in range(5): runs it five times with i counting 0, 1, 2, 3, 4. Note that it starts at 0 and stops before 5 — that is deliberate, and it matches how positions in a list are numbered.

while condition: keeps going as long as the condition is true. It checks before each pass, so if the condition is already false, the block never runs at all. The risk with while is the infinite loop: if nothing inside ever makes the condition false, your program hangs forever. Press Ctrl+C in the terminal to stop it.

break exits the loop immediately, abandoning the rest of it. continue skips the rest of this one pass and jumps to the next. Both are useful, and both make code harder to follow if you scatter them, so use them only where they genuinely simplify things.

Choosing between the two: use for when you know the collection or the number of repeats up front. Use while when you are waiting for something to become true and do not know how long that will take.

Most languages use curly brackets to mark where a block starts and ends. Python uses indentation instead — normally four spaces. Lines indented to the same depth belong to the same block.

This means a line indented one level too far quietly becomes part of the loop above it and runs many times instead of once. That is not a crash, it is wrong behaviour, which is harder to spot.

Let your editor handle it. VS Code indents automatically after a colon. Do not mix tabs and spaces — Python will refuse to run the file, and the error message is not especially clear about why.

Every beginner loses an hour to this exactly once. Knowing in advance that indentation is meaningful is most of the cure.