Values, types and variables

Every program works with values: the number of bags on a shelf, the price of a latte, the name of a coffee, whether the roaster is switched on. Before a program can calculate anything, it needs a way to hold those values and refer to them. This lesson covers the kinds of value Python works with, called types, and the names you give values so that you can use them again, called variables. By the end you will be able to store Ridgeline's stock figures in well-named variables, convert between text and numbers, and read a value typed in by a person.

These ideas look simple, and in a sense they are, but they shape everything that follows. Most beginner bugs come from a value being a different type from the one the programmer assumed, or from a variable holding a different value from the one they thought. Time spent understanding exactly what a variable is will repay itself in every later lesson.

Values and types

A value is a single piece of data. The number 42 is a value; so is the text Sunrise Blend, and so is the price 18.50. Every value in Python has a type, which decides what the value can do. You can multiply two numbers, but multiplying two pieces of text makes no sense; you can make text uppercase, but not a number. Python checks the type of each value when it uses it, and that check is the source of many helpful error messages.

Four types cover almost everything in this course's early lessons. An int, short for integer, is a whole number such as 42, 0 or -7. A float, short for floating-point number, is a number with a decimal point, such as 18.50 or 0.15. A str, short for string, is text, written inside quotation marks, such as 'Ethiopia Guji'. A bool, short for Boolean, is one of just two values, True or False, and is used for yes-or-no facts such as whether a coffee needs reordering. Python also has a special value, None, that means no value at all; it appears when something has not been set yet or a function has nothing to give back.

The built-in function type tells you the type of any value. It is a useful tool when a program behaves strangely: printing the type of a suspicious value often reveals that it is a string of digits rather than a number, or a float where you expected an integer.

print(type(42))
print(type(18.50))
print(type("Sunrise Blend"))
print(type(True))
print(type(None))
print(type("42"))

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'NoneType'>
<class 'str'>

Look at the last line. The value '42' in quotation marks is a string that happens to contain digits, not a number. To Python, '42' and 42 are entirely different things, as different as the word forty-two written on a sticky note and a pile of forty-two coffee bags. Keeping that difference in mind will save you a great deal of confusion when you start reading input from people and files, which always arrives as text.

Variables: names for values

A variable is a name that refers to a value. You create one with an assignment statement, which has a name on the left, an equals sign, and an expression on the right. Python works out the value of the right-hand side first, then attaches the name on the left to that value. After that, wherever you write the name, Python uses the value.

sku = "RC-101"
name = "Sunrise Blend"
price = 18.50
stock = 42
reorder_point = 10
print(name, "costs", price, "and there are", stock, "bags")
print("Stock value:", price * stock)
print("Bags above the reorder point:", stock - reorder_point)

Sunrise Blend costs 18.5 and there are 42 bags
Stock value: 777.0
Bags above the reorder point: 32

The equals sign in Python does not mean 'is equal to' in the mathematical sense. It is an instruction: make this name refer to this value. Reading it as 'gets' or 'is set to' helps. That is why a line like stock = stock - 3, which would be nonsense as an equation, is perfectly sensible in a program: work out the current stock minus three, then make stock refer to the result.

A good mental picture, shown in the figure, is that a variable is a name tag tied to a value, rather than a box that contains it. When you assign a new value to the name, the tag moves to the new value. The difference matters later, when two names can be tied to the same list, but even now it explains why assignment never changes the old value: it just points the name somewhere else.

Once Theo sells three bags of Sunrise Blend and Kai roasts a fresh batch of thirty, the stock changes. The program below follows those events. Press Edit and run, then try changing the number of bags sold to see the final figure change.

stock = 42
print("Opening stock:", stock)
stock = stock - 3      # three bags sold online
print("After online orders:", stock)
stock = stock + 30     # a fresh batch is bagged
print("After roasting:", stock)
stock -= 5             # five bags sold in the cafe
print("Closing stock:", stock)

Opening stock: 42
After online orders: 39
After roasting: 69
Closing stock: 64

The last update uses an augmented assignment, -=, which is shorthand for stock = stock - 5. Python has the same shorthand for the other arithmetic operators, such as += and *=. These short forms are common in real code, especially for running totals and counters, so it is worth getting used to them early.

Naming rules and conventions

Python has a few strict rules for variable names. A name may contain letters, digits and underscores, but it must not begin with a digit and it must not contain spaces or punctuation. Names are case-sensitive, so stock, Stock and STOCK are three different variables. A name cannot be one of Python's reserved keywords, such as if, for, while, def, class, True or None, because those words already have a meaning in the language.

Beyond the rules, Python programmers follow a style guide called PEP 8. It recommends lowercase names with words separated by underscores, a style known as snake_case: roasted_kg rather than roastedKg or RoastedKG. Names written entirely in capitals, such as REORDER_POINT, signal a constant, a value that is set once and not meant to change while the program runs. Python does not enforce this; it is a message from one programmer to another.

The most important convention is not in any rulebook: choose names that say what the value means. A variable called x tells the reader nothing, while bags_sold_today tells them almost everything. Long names cost a little typing; unclear names cost hours of puzzling later. Single letters are fine in a few traditional places, such as i for a loop counter, but for anything that represents a real quantity, spell it out, and include the unit when there could be doubt, as in green_kg or roast_minutes.

Numbers in more detail

Integers in Python can be as large as you like; Python simply uses more memory for very large numbers. You can write large integers with underscores to make them readable, as in 1_000_000, and Python ignores the underscores. Floats are different. They are stored in a fixed amount of memory using binary fractions, which means most decimal fractions cannot be represented exactly. The result is small rounding errors that surprise everyone the first time.

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(round(0.1 + 0.2, 2))
print(18.50 * 3)
print(1_000_000 + 1)
print(7 / 2, type(7 / 2))

0.30000000000000004
False
0.3
55.5
1000001
3.5 <class 'float'>

The value 0.30000000000000004 is not a bug in Python; every language that uses standard floating-point numbers behaves the same way. For everyday calculations the error is far too small to matter, and rounding the result for display, with round or with the formatting tools in lesson 4, hides it. It does matter when you compare floats for exact equality, so avoid testing whether two floats are exactly equal. For money in real accounting software, programmers use whole numbers of cents or Python's decimal module; Anita's bookkeeping tools in later courses will do that, while this course uses floats to keep the examples simple.

The last line shows another point: dividing two integers with / always gives a float, even when the answer is a whole number, so 8 / 2 is 4.0. Lesson 3 introduces the // operator for whole-number division and explains when to use each.

Converting between types

Values can be converted from one type to another with functions named after the types: int, float, str and bool. Converting is often essential. Text read from a keyboard or a file is always a string, so before you can do arithmetic with it you must convert it to a number. Going the other way, you sometimes need to turn a number into a string to join it to other text.

bags_text = "42"
bags = int(bags_text)
print(bags + 3)
price = float("18.50")
print(price * 2)
print(int(19.99))            # int() drops the fraction, it does not round
print(round(19.99))
label = "Bags: " + str(bags)
print(label)
print(bool(0), bool(42), bool(""), bool("Kai"))

45
37.0
19
20
Bags: 42
False True False True

Two details deserve attention. First, int applied to a float throws away the fractional part rather than rounding, so int(19.99) is 19; use round if rounding is what you want. Second, bool turns zero, empty strings and None into False and almost everything else into True. That rule, called truthiness, becomes useful in lesson 5.

Not every conversion succeeds. Asking for int('forty-two') or int('18.50') makes no sense to Python, so it stops with a ValueError. The message is clear about what went wrong, and lesson 11 shows how a program can catch such errors and ask again instead of stopping.

print(int("18.50"))
Traceback (most recent call last):
  File "convert.py", line 1, in <module>
    print(int("18.50"))
          ^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: '18.50'

Reading input from a person

So far every value has been written into the program itself, which is called hard-coding. Real tools let people supply values while the program runs. The input function displays a prompt, waits for the person to type a line and press Enter, and returns what they typed as a string. To use the answer as a number, convert it.

name = input("Coffee name: ")
bags = int(input("Bags in stock: "))
price = float(input("Price per bag: "))
print(name, "stock is worth", bags * price)

Coffee name: Colombia Huila
Bags in stock: 27
Price per bag: 19.75
Colombia Huila stock is worth 533.25

When you run this listing in the page, the editor shows an Input box: type one answer per line, such as Colombia Huila, 27 and 19.75, and Python reads them in order as if you had typed them at the keyboard. In a terminal, the program pauses at each prompt instead. See how the int and float calls wrap the input calls: Python runs input first, gets a string, and passes it straight to the conversion. If you forget the conversion, bags * price fails, because Python will not multiply a string by a float.

A common slip is to compare or add input without converting it. If two people each type 3 and the program adds the raw answers, the result is '33', because adding two strings joins them. The next lesson explains why; the cure is always to convert first.

green_kg = 12.0       # in the real program: float(input("Green kg: "))
roasted_kg = 10.2     # in the real program: float(input("Roasted kg: "))
lost_kg = green_kg - roasted_kg
loss_fraction = lost_kg / green_kg
print("Unrounded loss:", lost_kg)
print("Weight lost (kg):", round(lost_kg, 2))
print("Loss as a fraction:", round(loss_fraction, 3))

Unrounded loss: 1.8000000000000007
Weight lost (kg): 1.8
Loss as a fraction: 0.15

# Create the four variables here

print(price * stock)

How Python stores values

Behind the scenes, every value in a running Python program is an object stored somewhere in the computer's memory, and every variable is a reference to one of those objects. The built-in function id returns a number that identifies an object while the program runs; two names that refer to the same object have the same id. You will rarely need id in practice, but it makes the name-tag picture concrete.

stock = 42
also_stock = stock
print(id(stock) == id(also_stock))
stock = stock + 1
print(stock, also_stock)
print(id(stock) == id(also_stock))

True
43 42
False

After also_stock = stock, both names are tied to the same value, 42. When stock is reassigned to 43, only the stock tag moves; also_stock still refers to 42. Numbers, strings and Booleans can never be changed in place, a property called being immutable, so this behaviour is always safe with them. Lists, which arrive in lesson 8, can be changed in place, and there the shared-tag picture becomes essential.

Python is also dynamically typed: a variable has no fixed type of its own, so the same name can refer to an int now and a string later. That flexibility is convenient but can hide mistakes, which is why many teams add optional type hints, a notation covered in PYTH-102, and why clear names matter so much.

online = input("Online: ")
cafe = input("Cafe: ")
print("Total bags sold:", online + cafe)