Numbers, Strings and Operators

Numbers combine with arithmetic operators, most of which look exactly as you would expect: + add, - subtract, * multiply, / divide. Three more are worth knowing because they solve real problems:

wall = 240        # wall length in cm
tile = 18         # tile size in cm

print(wall / tile)   # 13.333333333333334  -- exact division, a float
print(wall // tile)  # 13    -- floor division: whole tiles that fit
print(wall % tile)   # 6     -- modulo: the leftover cm at the end
print(2 ** 10)       # 1024  -- power: 2 to the 10th

/ always gives a float, even when it divides evenly (10 / 2 is 5.0). // is floor division - it divides and throws away the remainder, perfect for 'how many whole tiles fit along this wall'. % is modulo - the remainder left over - which answers 'how much offcut is at the end' and, later, powers every-nth-item patterns. ** is exponent, for powers.

Order of operations follows normal maths: * and / happen before + and -, and parentheses force the order you want. This matters:

print(2 + 3 * 4)      # 14, not 20 -- multiply first
print((2 + 3) * 4)    # 20 -- parentheses first

When a calculation has more than two steps, add parentheses even where they are technically optional - they make your intent obvious and prevent a whole class of quiet arithmetic bugs.

Two everyday points finish the picture. First, integers and floats mix freely: 10 * 1.08 gives the float 10.8, because the moment a float enters the sum the result becomes a float - which is usually what you want for measurements and money. Second, the self-updating shorthand from the last lesson applies here too, and you will lean on it hard: total += price adds price onto total in place, subtotal *= 1.18 bumps a figure up by a tax rate, and so on. These +=, -=, *= operators are just tidy ways of writing total = total + price, and they read cleanly when a value accumulates. Keep parentheses around anything you would pause to check by hand, prefer floats wherever fractions are possible, and Python behaves as a completely reliable calculator.

Text is a string, and strings have their own operators. + between two strings concatenates them - joins them end to end - and * repeats one:

first = "Master"
last = "Bedroom"
name = first + " " + last   # "Master Bedroom" -- note the space string
rule = "-" * 20             # "--------------------" a divider line

Gluing strings with + gets clumsy fast, especially when you mix in numbers - and you cannot + a string and a number directly at all. The modern, far cleaner way to build text is the f-string: put the letter f before the opening quote, and then drop any expression inside {curly braces} right in the text. Python evaluates what is in the braces and slots the result in:

room = "Kitchen"
area = 12.5
print(f"The {room} is {area} square metres.")
# The Kitchen is 12.5 square metres.

rate = 1450
print(f"Tiling cost: {area * rate:.0f} rupees")
# Tiling cost: 18125 rupees

That second example shows two things f-strings do beautifully: you can put a whole calculation inside the braces, and you can format the result with a colon code - :.0f means 'show as a float with zero decimal places', :.2f means two, and :, adds thousands separators. F-strings are how you turn raw numbers into sentences and reports a human can read, and you will reach for them in almost every script you write.

When a piece of text runs long or needs to span several lines - a multi-line note, a little report block - wrap it in triple quotes, """like this""", and it keeps every line break you type:

report = f"""Room: {room}
Area: {area} sqm
Status: ready to tile"""
print(report)

Triple-quoted strings are handy for anything with structure, and you will see them again as the standard way to document what a function does in Module 3. For now, note the two tools: single-line f-strings for slotting values into a sentence, and triple quotes when the text itself has shape.

Strings come with a toolkit of built-in actions called methods. You call a method by writing the string (or its variable), a dot, the method name, and parentheses - text.method(). They are how you clean and reshape the messy text that arrives from files, spreadsheets and people:

raw = "  Oak Flooring  "
print(raw.strip())        # "Oak Flooring" -- trims outer spaces
print(raw.strip().upper())# "OAK FLOORING"
print(raw.strip().lower())# "oak flooring"
print("bedroom".replace("bed", "bath"))  # "bathroom"
print("A-101,A-102,A-103".split(","))    # ['A-101', 'A-102', 'A-103']

strip() removes surrounding whitespace - invaluable, because data from spreadsheets is full of stray spaces that break comparisons. upper() and lower() change case, which is the standard trick for comparing text reliably (more in the next section). replace() swaps one piece of text for another. split() breaks a string into a list at a separator - here turning a comma-separated line into separate drawing numbers, a first taste of the list you meet in Module 2.

Notice you can chain methods - raw.strip().upper() strips first, then uppercases the result - because each method hands back a new string for the next to act on. Two more you will use often: "48".isdigit() asks whether a string is all digits (handy before converting user input), and len("oak") reports a string's length (here 3). Another everyday check is the in keyword, which tests whether one piece of text appears inside another: "oak" in "oak flooring" is True. That is exactly how you filter for, say, every finish description mentioning 'timber'. Between these, an f-string, and the cleaning methods above, you have most of day-to-day text wrangling covered. You do not memorise the list; you learn that the toolkit exists and look up the exact name when you need it - your editor will even suggest the methods when you type a dot after a string.

To make decisions, code has to ask questions, and the answer to a question is a bool - True or False. Comparison operators produce those answers:

area = 18
print(area > 15)     # True   -- greater than
print(area < 10)     # False  -- less than
print(area >= 18)    # True   -- greater than or equal
print(area == 18)    # True   -- equal? (two equals signs!)
print(area != 20)    # True   -- not equal

The operators are >, <, >=, <=, == and !=. Every one of them evaluates to True or False, which is exactly what the if statements of Module 2 need to decide what to do. The single most common beginner bug lives here: `=` assigns a value, but `==` asks whether two values are equal. Writing if area = 18 is an error; you mean if area == 18. One equals sets, two equals ask - burn that in now and save yourself hours later.

Comparisons work on strings too, alphabetically, and this is where case bites you:

print("oak" == "Oak")            # False -- capital O differs!
print("oak" == "Oak".lower())   # True  -- normalise case first

Because "oak" and "Oak" are literally different text to a computer, comparing text you did not type yourself almost always means lowercasing both sides first with .lower(). That single habit prevents a mountain of 'but they look the same!' confusion when you start filtering real data.

Comparisons rarely travel alone. Real decisions combine them - area over 15 **and** it is a wet area - and Python spells those joins with the plain English words and, or and not. You will meet them properly in Module 2 alongside if, but the idea is intuitive already: area > 15 and is_wet_area is True only when both parts are true, or needs just one, and not flips a True to False. There is even a neat shorthand Python allows that other languages do not - 10 < area < 20 reads exactly as the maths does and asks whether area sits between the two. Every one of these still boils down to producing a single True or False, which is all a decision needs.

Text and numbers are different types, and Python will not silently guess between them. "12" is text; 12 is a number; "12" + 3 is an error, not 15. This trips up every beginner, because the difference is invisible on screen. The fix is deliberate type conversion with three built-in functions:

int("12")     # 12    -- text -> whole number
float("2.5")  # 2.5   -- text -> decimal number
str(54.0)     # "54.0"-- number -> text

int() turns text (or a float) into a whole number, float() into a decimal, and str() turns a number into text. You need these constantly at the two edges of a script: input almost always arrives as text (the input() of the next lesson, or a cell from a spreadsheet) and must be converted before you can calculate, and output often means gluing numbers into text for a message.

Watch what goes wrong without conversion, and right with it:

qty = "3"                 # came in as text
# total = qty * 1450      # would give "314501450..." nonsense or an error
total = int(qty) * 1450   # convert first -> 4350, correct
print("Total: " + str(total))   # convert back to glue into text

One caution: conversion must make sense. int("3") works, but int("three") or int("3.5") raises a ValueError, because that text is not a plain whole number. In real scripts you check first (with .isdigit(), or by handling the error, which Module 3 covers) - but the core discipline is simple and worth forming now: convert text to a number before you calculate, and a number back to text before you join it into a message.

It helps to picture the whole shape of a script through this lens: text comes in at one edge, you convert it to numbers, you do the real arithmetic and text-building in the middle, and you convert back to text to send results out. The numeric core is where the actual work happens; conversion is the customs check at each border. Get into the habit of asking, at every point a value enters or leaves your program, 'is this text or a number right now?' - and reaching for type() when you are unsure. That one reflex dissolves most of the confusion beginners have with data, and it is the exact discipline that keeps the pandas work in Module 4 from tripping over columns that quietly arrived as text.