Variables and Data Types

A variable is a name that points to a value. You create one with a single = sign - the assignment operator - putting the name on the left and the value on the right:

ceiling_height = 2.7
room_name = "Master Bedroom"
sockets = 6

Read = not as 'equals' but as 'gets' or 'is set to': ceiling_height gets the value 2.7. From then on, wherever you write ceiling_height, Python substitutes 2.7. That is the whole point - you name a value once and reuse it by name, so your code reads in meaningful terms rather than mystery numbers.

The real power is that a variable can change, and everything using its name updates. And you can compute new variables from old ones:

length = 5.0
width = 4.0
area = length * width      # area is now 20.0
length = 6.0               # change one input...
area = length * width      # ...recompute; area is now 24.0
print(area)                # 24.0

Think of a variable as a labelled box: the label is the name, the contents are the value, and you can swap the contents whenever you like. Naming your values - area, rate, sockets - instead of scattering raw numbers through your code is the difference between a script you can read next month and one you cannot. This tiny idea, a name pointing at a value, is the foundation everything else stands on.

One pattern you will meet constantly is a variable that updates itself. Because = means 'compute the right side, then store it under the left name', a line like count = count + 1 is perfectly sensible: take the current count, add one, and put the result back in the same box. Python even has a shorthand for it, count += 1, which does exactly the same thing - and -=, *= and /= work the same way. You will see these everywhere once loops arrive, where a running total or a counter grows step by step; meeting the idea now, on a single line, means it will not surprise you later.

Every value in Python has a type - what kind of thing it is - and the type decides what you can do with it. Four types cover the vast majority of everyday scripting.

`int` is an integer: a whole number, positive or negative, with no decimal point - 3, -5, 240. Use it for things you count: sockets, floors, tiles, people.

`float` is a floating-point number: a number with a decimal point - 2.7, 0.5, 18.0. Use it for things you measure: lengths, areas, rates, money. Note that 18 is an int but 18.0 is a float; the decimal point is what tells them apart.

`str` is a string: text, written inside quotes - "oak", "Room 4", "2.7m". Single or double quotes both work ('oak' equals "oak"); pick one and be consistent. Anything in quotes is text, even "12" - which looks like a number but is not one, a distinction the next lesson leans on hard.

`bool` is a Boolean: one of exactly two values, True or False (capitalised, no quotes). Booleans are how code answers yes/no questions - is this room bigger than 15 sqm? - and they power every decision your programs make in Module 2.

floors = 3            # int
slab_thickness = 0.15 # float
material = "concrete" # str
is_load_bearing = True # bool

These four - count, measure, text, yes/no - are the raw materials. Almost every value you handle for a long while is one of them.

One more you should recognise even though you will rarely type it: `None`. It is Python's word for 'nothing here yet' - a deliberate empty value, distinct from 0 or an empty string. You will meet it when a value has not been set or a lookup finds nothing, and knowing the name saves confusion later. Types also mix in sensible ways: combine an int and a float in arithmetic and Python quietly promotes the result to a float (3 * 2.5 is 7.5), because a float can hold everything an int can. What it will not do is silently mix text and numbers - that boundary is real and deliberate, and the next lesson is largely about crossing it safely.

When you are unsure what kind of value you are holding - and you often will be, especially with data that comes from a file - Python tells you. The built-in `type()` function reports a value's type:

print(type(3))        # <class 'int'>
print(type(2.7))      # <class 'float'>
print(type("oak"))    # <class 'str'>
print(type(True))     # <class 'bool'>

That <class 'int'> is just Python's way of saying 'this is an int'. You can call type() on a variable too, which is a genuinely useful habit when a script misbehaves:

tile_count = "48"
print(type(tile_count))   # <class 'str'>  -- aha, that is text, not a number

This one line explains a huge share of beginner confusion. A value that looks like a number - "48" - can secretly be a string, and Python will refuse to do arithmetic on it or will do something surprising (as you will see, "48" * 2 gives "4848", not 96). When code does not behave, print(type(x)) is often the fastest way to see why: you were treating text as a number, or a float as an int. Reaching for type() to check your assumptions is a small diagnostic move that will save you real time throughout the course.

Here is something Python does that many languages do not: you never declare a type. You do not tell Python 'this variable will hold an integer'. You just assign a value, and Python infers the type from what you gave it. This is called dynamic typing, and it is a big part of why Python feels light to write:

x = 5          # x is an int now
x = 5.0        # x is a float now
x = "five"     # x is a str now
x = True       # x is a bool now

The same name happily holds different types at different times, because the value carries the type, not the name. Compare this to more ceremonious languages where you would write the type explicitly every time - Python spares you that, so you can move fast.

That freedom has a flip side worth naming early. Because nothing stops you reassigning a variable to a totally different kind of thing, a slip - accidentally overwriting a number with text, say - will not be caught until the code runs and misbehaves. Python trusts you. In practice this is rarely a problem for the small scripts you will write, and the fix is simple discipline: give variables clear names, keep each one holding one kind of thing, and reach for type() when something surprises you. Dynamic typing is a convenience you will come to appreciate; just stay aware that you are the one keeping track of what each box holds.

Python is relaxed about types but has firm, simple rules for names. A variable name can use letters, digits and underscores; it must not start with a digit; and it cannot contain spaces or most punctuation. room_area is fine; 2nd_floor, room area and room-area are not. Names are also case-sensitive: Area and area are two different variables, a subtle source of bugs, so stay consistent.

Beyond the rules is a strong convention. Python code overwhelmingly uses snake_case - lowercase words joined by underscores - for variable names: ceiling_height, tile_count, is_load_bearing. Following it makes your code look like everyone else's, which matters more than it sounds when you read examples or ask an AI assistant for help.

The deeper point is that names are documentation. Compare these two lines that do the identical calculation:

c = a * b * 1.08                       # what on earth is this?
tile_cost = area * rate * waste_factor # oh, a tile cost with waste

Both run. Only one tells you what it means six weeks later. Good names turn code into something close to readable prose - the whole reason Python is a good first language. Spend the extra two seconds to write wall_area instead of w; it is the cheapest, highest-return habit in programming, and the reader you are helping is usually yourself.

Two small cautions round this out. A handful of words are reserved by the language itself - if, for, True, class, import and a few dozen others - and you cannot use them as variable names; if a name lights up as a keyword in your editor, pick another. And avoid quietly overwriting the names of built-in tools: naming a variable list, str, type or sum works, but it shadows the function of the same name so you can no longer call it. When you want a value to signal 'this must not change' - a fixed rate, a conversion constant - the convention is to name it in ALL_CAPS, like SQM_PER_LITRE = 10. Python will not stop you changing it, but the capitals tell every reader you did not intend to.