Variables, numbers and basic types

Make a day02 folder for today’s files, open it in your editor, and run each script from its terminal, just as you did with day01.

On Day 1, every number you used was typed straight into the expression, like 30 - 12. That works once. But imagine a program that uses a ticket price in five places: if the price changes, you must find and edit all five, and missing one gives a wrong answer. Programs need a way to work a value out once, remember it, and refer to it by name.

A variable is a name that refers to a value. You create one with an assignment statement, which has three parts: a name, an equals sign, and an expression.

name = expression

Python runs an assignment in two steps. First it works out the expression on the right side. Then it attaches the name on the left side to that value. From then on, wherever you write the name, Python uses the value it refers to. The = sign is called the assignment operator. It does not mean “is equal to” as in math; read price = 4 as “price gets 4” or “let price refer to 4”.

Think of a variable as a name tag stuck on a value. Python keeps the value, and the tag lets you find it again.

ticket_price = 12
tickets_sold = 35
total = ticket_price * tickets_sold
print("Tickets sold:", tickets_sold)
print("Total:", total)

Tickets sold: 35
Total: 420

At the REPL, an assignment shows nothing, because a statement that only attaches a name has no value to show. Typing the name by itself is an expression, so the REPL shows its value:

>>> price = 4
>>> price
4
>>> price * 3
12

Now vary one thing: assign to a name that already has a value. The name moves to the new value, and the old value is forgotten. This lets you update a variable, even using its own old value on the right side.

score = 10
print("Start:", score)
score = score + 5
print("After bonus:", score)
score = 0
print("After reset:", score)

Start: 10
After bonus: 15
After reset: 0

Line 3, score = score + 5, would be nonsense as a math equation, but as an assignment it makes sense: the right side runs first, using the current value 10, and only then is score attached to the result, 15.

print("Total:", total)
total = 12 * 35

Traceback (most recent call last):
  File ".../day02/use_before_assign.py", line 1, in <module>
    print("Total:", total)
                    ^^^^^
NameError: name 'total' is not defined

apples = 6
apples = apples + 4
pears = apples - 3
apples = 2
print(apples, pears)

2 7

width = 8
20 = height
print(width * height)

  File ".../day02/reversed_assignment.py", line 2
    20 = height
    ^^
SyntaxError: cannot assign to literal here. Maybe you meant '==' instead of '='?

width = 8
height = 20
print(width * height)

160

You get to choose every variable name, so two questions follow: which names does Python accept, and which names make a program easy to read?

Python’s rules for names (programmers call them identifiers) are short:

1. A name may contain letters, digits, and the underscore _, and nothing else: no spaces, hyphens, or other symbols.
2. A name cannot start with a digit.
3. Capital and small letters count as different (Python is case-sensitive, as Day 1 showed), so score and Score are two different names.
4. A name cannot be a keyword, one of about 35 words Python reserves for its own grammar, such as class, if, for, True, False, and None. You will learn most of them over the coming days.

Why these rules? Python has to tell names apart from everything else on a line. A name starting with a digit would look like a number, a space would make one name look like two, and a hyphen looks like a minus sign.

On top of the rules there is a convention, a habit every Python programmer follows even though Python does not enforce it. Python’s official style guide says variable names use snake_case: all lowercase, with words joined by underscores, like ticket_price or max_speed_kmh. Choose names that say what the value means: tickets_sold tells a reader far more than t or x.

first_place = "Ana"
player2_score = 18
max_speed_kmh = 120
print(first_place, player2_score, max_speed_kmh)

Ana 18 120

Now vary the names so they break the rules. Each of these programs stops with a SyntaxError before anything runs:

2nd_place = "Ben"
print(2nd_place)

SyntaxError: invalid decimal literal

my score = 10
print(my score)

SyntaxError: invalid syntax

class = "Algebra"
print(class)

SyntaxError: invalid syntax

In the first, Python reads 2 as the start of a number and then finds letters glued to it, which no number can contain (“decimal literal” means a number written in ordinary digits). In the second, Python sees two names, my and score, side by side, which breaks the grammar. In the third, class is a keyword, so it cannot be a variable name. The fixes are second_place, my_score, and a name like class_name.

On Day 1, 8 / 2 printed 4.0 instead of 4, and the lesson promised an explanation. Here it is.

Every value in Python has a type: the kind of value it is. The type decides how the value is stored and what you can do with it. Numbers come in two main types:

• An int (short for integer) is a whole number, with no decimal point: 42, 0, -7. Python ints can be as large as you like.
• A float (short for floating-point number) is a number with a decimal point: 3.5, 0.45, -2.0. Floats can hold fractions, but (as 2.9 shows) only approximately.

42 and 42.0 are the same amount, but not the same type. The decimal point is what makes a number a float.

To ask Python for a value’s type, call the built-in function type() with the value as its argument. The REPL shows the answer as <class 'int'> or <class 'float'>; “class” is Python’s word for a type, so read <class 'int'> as “the type is int”.

>>> type(42)
<class 'int'>
>>> type(-7)
<class 'int'>
>>> type(42.0)
<class 'float'>
>>> type(3.5)
<class 'float'>

When you combine two numbers, the types of the inputs decide the type of the result:

• +, -, and * with two ints give an int.
• If either number is a float, the result is a float.
• / always gives a float, even when both numbers are ints and the division comes out even.

>>> 6 + 4
10
>>> 6 + 4.0
10.0
>>> 3 * 2.5
7.5
>>> 8 / 2
4.0
>>> type(8 / 2)
<class 'float'>

Why does / always give a float? Most divisions do not come out even (7 / 2 is 3.5), and if / gave an int only when the answer happened to be whole, a program could not know which type to expect. So / is predictable: always a float.

pages = 320
weight_kg = 0.45
print(pages, type(pages))
print(weight_kg, type(weight_kg))
print(pages * 2, type(pages * 2))
print(pages / 2, type(pages / 2))

320 <class 'int'>
0.45 <class 'float'>
640 <class 'int'>
160.0 <class 'float'>

>>> 3 + 4.0
>>> type(9 - 2)
>>> type(9 / 3)

>>> 3 + 4.0
7.0
>>> type(9 - 2)
<class 'int'>
>>> type(9 / 3)
<class 'float'>

A movie is 135 minutes long. How many hours and minutes is that? 135 / 60 gives 2.25, which is true but not what you want. You want “2 hours and 15 minutes”: a whole number of hours, and the minutes left over. Python has an operator for each part.

• Floor division // divides and then rounds down to a whole number. 135 // 60 is 2, because 60 fits into 135 two whole times. (“Floor” means the whole number at or below the answer, like the floor below you.)
• Modulo % (also called the remainder operator) gives what is left over after floor division. 135 % 60 is 15, because two 60s make 120, and 135 - 120 is 15. The % sign here has nothing to do with percentages.
• Exponentiation ** raises a number to a power. 2 ** 10 means 2 multiplied by itself 10 times, which is 1024.

>>> 135 / 60
2.25
>>> 135 // 60
2
>>> 135 % 60
15
>>> 2 ** 10
1024
>>> 10 ** 2
100
>>> 9 ** 0.5
3.0

Check // and % against each other: 2 whole hours of 60 minutes plus 15 left over is 2 × 60 + 15 = 135, the number you started with. That check always works, because // counts the whole groups and % counts what is left.

The last line raises 9 to the power 0.5, which is the square root of 9. It gives 3.0, a float, because one of the inputs is a float: the type rules from 2.3 apply to //, %, and ** too.

total_minutes = 135
hours = total_minutes // 60
minutes = total_minutes % 60
print(total_minutes, "minutes is", hours, "hours and", minutes, "minutes")

135 minutes is 2 hours and 15 minutes

Now vary the numbers, to see what the rules really depend on:

>>> 14 % 2
0
>>> 15 % 2
1
>>> 7.5 // 2
3.0
>>> -7 // 2
-4

• % 2 gives 0 for every even number and 1 for every odd number, so the remainder tells you whether a number is even.
• 7.5 // 2 gives 3.0: still rounded down to a whole number, but a float, because 7.5 is a float.
• -7 // 2 gives -4, not -3. The exact answer is -3.5, and rounding down means toward the lower number, which for negatives is -4. Floor division always rounds down, never just “chops off” the decimal.

One more edge case: dividing by zero has no answer, so /, //, and % all stop the program with a ZeroDivisionError:

pizza_slices = 12
people = 0
print("Each person gets", pizza_slices // people)

Traceback (most recent call last):
  File ".../day02/share_pizza.py", line 3, in <module>
    print("Each person gets", pizza_slices // people)
                              ~~~~~~~~~~~~~^^~~~~~~~
ZeroDivisionError: division by zero

Read it as you learned on Day 1, from the bottom up: the last line names the error, and the ^^ marks point at the // that failed. Like a NameError, it happens while the program runs, so any lines before line 3 would already have run.

>>> 17 // 5
>>> 17 % 5
>>> 17 / 5
>>> 2 ** 5

>>> 17 // 5
3
>>> 17 % 5
2
>>> 17 / 5
3.4
>>> 2 ** 5
32

With seven arithmetic operators, an expression like 10 + 3 ** 2 * 2 - 8 // 3 needs a clear rule for what happens first. Day 1 gave part of it: multiplication and division before addition and subtraction, parentheses first. Here is the full rule for today’s operators.

Operator precedence is the order in which Python applies operators. From first to last:

Operators on the same row are applied left to right, in the order they appear, with one exception: a chain of ** is worked out from the right.

>>> 10 + 3 ** 2 * 2 - 8 // 3
26
>>> 100 / 10 / 2
5.0
>>> 2 ** 3 ** 2
512
>>> (2 ** 3) ** 2
64

Now vary one thing in a real calculation: the parentheses. To average two test scores, you add them and divide by 2.

>>> 88 + 94 / 2
135.0
>>> (88 + 94) / 2
91.0

Without parentheses, / happens before +, so Python divides only 94 by 2 and adds 88, giving 135.0, which is not an average. With parentheses, the addition happens first, and the average is 91.0.

>>> -3 ** 2
-9
>>> (-3) ** 2
9

>>> 7 + 8 // 3 * 2
>>> (7 + 8) // 3 * 2
>>> 2 * 3 ** 2

>>> 7 + 8 // 3 * 2
11
>>> (7 + 8) // 3 * 2
10
>>> 2 * 3 ** 2
18

Not every fact a program stores is a number. Is the library open? Has a player finished? Some facts are simply yes or no, and some values do not exist yet, like the winner of a game that has not ended. Python has types for both.

A bool (short for Boolean) is a value that is either True or False. Those are the only two bool values. They are keywords, spelled with a capital letter and no quotes. On Day 4 you will make bools by comparing values (is the score over 50?); today you store and print them.

None is a special value that means “no value here”. Its type is called NoneType, and None is its only value. A program uses None for something that is not known yet, such as a due date for a library card with no books out.

>>> is_open = True
>>> is_open
True
>>> type(is_open)
<class 'bool'>
>>> type(False)
<class 'bool'>
>>> winner = None
>>> winner
>>> print(winner)
None
>>> type(winner)
<class 'NoneType'>

Look at the line >>> winner. The REPL shows nothing, because it does not display a None result (there is no value to show). print does show it, as the word None. If the REPL ever seems to show nothing, None may be the reason.

books_borrowed = 3
has_overdue_books = False
next_due_date = None
print("Books:", books_borrowed)
print("Overdue:", has_overdue_books)
print("Next due date:", next_due_date)

Books: 3
Overdue: False
Next due date: None

is_member = true
print("Member:", is_member)

Traceback (most recent call last):
  File ".../day02/lowercase_true.py", line 1, in <module>
    is_member = true
                ^^^^
NameError: name 'true' is not defined. Did you mean: 'True'?

Numbers do not always arrive as numbers. On Day 3, a program will ask the user to type their age, and whatever they type arrives as text: the string "15", not the int 15. Files hold text too. The digits look the same, but the type is different, and the type decides what you can do:

age_text = "15"
print(age_text - 1)

Traceback (most recent call last):
  File ".../day02/text_minus_number.py", line 2, in <module>
    print(age_text - 1)
          ~~~~~~~~~^~~
TypeError: unsupported operand type(s) for -: 'str' and 'int'

A TypeError means an operation was used on a type that does not support it. An operand is a value an operator works on, and str is Python’s name for the string type. So the message says: - does not work with a string and an int. Subtracting from text makes no sense, and Python will not guess that you meant the number.

The fix is type conversion: making a new value of a different type from an existing one. Python’s type names double as conversion functions:

• int(value) makes an int: from a string of digits, or from a float by dropping everything after the decimal point.
• float(value) makes a float: from a string like "2.5", or from an int.
• str(value) makes a string: the text you would see if you printed the value.

>>> int("42")
42
>>> int("42") - 1
41
>>> float("2.5")
2.5
>>> float(3)
3.0
>>> int(3.9)
3
>>> int(-3.9)
-3
>>> str(42)
'42'
>>> type(str(42))
<class 'str'>

Notice three things:

• int(3.9) gives 3, not 4. int() does not round; it drops the decimal part, so int(-3.9) is -3. (2.9 shows how to round.)
• str(42) shows as '42' with quotes. The REPL puts quotes around a string to show you it is text; print would show just 42. The REPL uses single quotes, which mean the same as double quotes.
• Converting makes a new value. It does not change the original: after int(price_text), price_text is still a string.

price_text = "12"
quantity_text = "3"
price = int(price_text)
quantity = int(quantity_text)
print("Total:", price * quantity)
print(type(price_text), type(price))

Total: 36
<class 'str'> <class 'int'>

Now vary the text: give int() a string with a decimal point.

height_text = "1.75"
height = int(height_text)
print("Height:", height)

Traceback (most recent call last):
  File ".../day02/int_from_decimal_text.py", line 2, in <module>
    height = int(height_text)
ValueError: invalid literal for int() with base 10: '1.75'

A ValueError means the type was acceptable (int() does take strings) but this particular value was not. int() accepts only a string of whole-number digits, optionally with a minus sign (“base 10” just means ordinary digits 0–9), and "1.75" is not one. int("forty") fails the same way. For text with a decimal point, use float():

height_text = "1.75"
height = float(height_text)
print("Height:", height)

Height: 1.75

>>> int(7.99)
>>> float("10")
>>> str(5 + 5)
>>> int("8") * 2

>>> int(7.99)
7
>>> float("10")
10.0
>>> str(5 + 5)
'10'
>>> int("8") * 2
16

age_text = "15"
years_left = 18 - age_text
print("Years until 18:", years_left)

TypeError: unsupported operand type(s) for -: 'int' and 'str'

age_text = "15"
years_left = 18 - int(age_text)
print("Years until 18:", years_left)

Years until 18: 3

In 2.1 you reassigned a variable to a new number. Can a name that refers to an int later refer to a float, or a string? In some programming languages, no: you declare that a variable holds whole numbers, and it may only ever hold whole numbers. Python works differently.

In Python, the value has a type, and the name does not. A name is only a tag pointing at a value, and you can move the tag to any value of any type. This is called dynamic typing: the type that goes with a name is decided while the program runs, by whatever value it refers to at that moment. Moving a name to a new value is called rebinding it.

This is where the name-tag analogy beats the idea of a box: a box sized for whole numbers could not hold text, but a tag can be stuck on anything.

reading = 72
print(reading, type(reading))
reading = 72.5
print(reading, type(reading))
reading = "72 degrees"
print(reading, type(reading))
reading = None
print(reading, type(reading))

72 <class 'int'>
72.5 <class 'float'>
72 degrees <class 'str'>
None <class 'NoneType'>

temperature = 21
temperature = "warm"
print(temperature - 5)

Traceback (most recent call last):
  File ".../day02/temperature_mixup.py", line 3, in <module>
    print(temperature - 5)
          ~~~~~~~~~~~~^~~
TypeError: unsupported operand type(s) for -: 'str' and 'int'

value = 7
value = value * 2
value = value / 7
print(value, type(value))
value = str(value)
print(value, type(value))

2.0 <class 'float'>
2.0 <class 'str'>

Try this in the REPL, and expect a surprise:

>>> 0.1 + 0.2
0.30000000000000004
>>> 1.1 * 3
3.3000000000000003
>>> 1 + 2
3

0.1 + 0.2 is not exactly 0.3. Nothing is broken; every programming language that uses standard floats gets the same result. The reason is how a computer stores numbers.

A computer stores numbers in binary, using only the digits 0 and 1. Whole numbers convert to binary exactly, so ints are always exact: 1 + 2 is exactly 3. Many fractions do not. Think of 1/3 in ordinary decimal: 0.3333…, with threes forever. You can write 0.33 or 0.3333333, but never exactly one third. In binary, 0.1 is like that: it repeats forever, so Python stores the closest value it can fit. That stored value is a tiny bit off, the tiny errors add up, and sometimes they show in the last digit. This is called floating-point imprecision (or rounding error).

The error is tiny (about 0.00000000000000004 here), so it almost never matters for a calculation. It matters when you show the result: nobody wants to read a price of 3.3000000000000003. The fix is to round when you display a value.

The built-in function round(number, digits) rounds a number to that many digits after the decimal point. With no second argument, it rounds to the nearest whole number and gives an int.

>>> round(0.1 + 0.2, 2)
0.3
>>> round(3.14159, 2)
3.14
>>> round(2.50, 2)
2.5
>>> round(7.6)
8
>>> type(round(7.6))
<class 'int'>

• round(0.1 + 0.2, 2) gives 0.3: the tiny error disappears once you keep only two decimal places.
• round(2.50, 2) shows 2.5, not 2.50. round changes the value, not how many zeros are shown; a float never prints trailing zeros. Day 3 shows how to always print two decimal places.
• round(7.6) is the int 8. Unlike int(), which drops the decimal part, round() goes to the nearest whole number.

total_cost = 10
items = 3
unit_price = total_cost / items
print("Exact:", unit_price)
print("Rounded:", round(unit_price, 2))

Exact: 3.3333333333333335
Rounded: 3.33

unit_price = round(10 / 3, 2)
print("Price of 3:", unit_price * 3)

Price of 3: 9.99

>>> round(7 / 3, 2)
>>> round(1.1 * 3, 1)

>>> round(7 / 3, 2)
2.33
>>> round(1.1 * 3, 1)
3.3

Jordan is planning a 523-kilometre road trip at an average 90 km/h. The car uses 6.8 litres of fuel per 100 km, and fuel costs 1.89 per litre. The distance arrives as text (as if typed in), so it has to be converted. The # comments are from Day 1; the blank lines just split the program into steps.

# Road trip planner
distance_text = "523"  # kilometres, as text
distance_km = int(distance_text)
speed_kmh = 90
litres_per_100_km = 6.8
price_per_litre = 1.89

total_minutes = distance_km * 60 // speed_kmh
hours = total_minutes // 60
minutes = total_minutes % 60

fuel_litres = distance_km / 100 * litres_per_100_km
fuel_cost = fuel_litres * price_per_litre

print("Distance:", distance_km, "km")
print("Driving time:", hours, "hours", minutes, "minutes")
print("Fuel needed:", round(fuel_litres, 1), "litres")
print("Fuel cost:", round(fuel_cost, 2))

Distance: 523 km
Driving time: 5 hours 48 minutes
Fuel needed: 35.6 litres
Fuel cost: 67.22

Follow the values and types, in the order Python runs the lines:

The last two lines round only when printing (2.9): round(fuel_litres, 1) shows 35.6 and round(fuel_cost, 2) shows 67.22. Notice line 8: * and // share a precedence row, so Python multiplies first because it comes first, giving whole minutes. Writing distance_km // speed_kmh * 60 instead would round down to 5 hours before converting to minutes and lose the 48 extra minutes.

• A variable is a name that refers to a value. An assignment works out the right side first, then attaches the name on the left; assigning again replaces the value. Names use letters, digits, and underscores, never start with a digit, are not keywords, and by convention are descriptive snake_case.
• Every value has a type: int (whole numbers), float (decimals), bool (True or False), None (no value), and str (text). type() reports it.
• / always gives a float, // divides and rounds down, % gives the remainder, and ** raises to a power. A float anywhere in a calculation makes the result a float.
• Precedence: parentheses, then **, then a negative sign, then * / // %, then + -, left to right within a row. Parentheses make any order certain.
• int(), float(), and str() make new values of another type. Python is dynamically typed: a name can be rebound to a value of any type.
• Floats are stored approximately, so 0.1 + 0.2 shows a tiny error. Calculate with full values and round() only for display.

Do these in your day02 folder. Type each program yourself, run it, and only then open the answer. Change the starting values and run them again to test your program.

# Convert a temperature from Fahrenheit to Celsius
fahrenheit = 72
celsius = (fahrenheit - 32) * 5 / 9
print(fahrenheit, "degrees Fahrenheit is", round(celsius, 1), "degrees Celsius")

72 degrees Fahrenheit is 22.2 degrees Celsius

# Split a number of seconds into hours, minutes and seconds
total_seconds = 7384
hours = total_seconds // 3600
seconds_left = total_seconds % 3600
minutes = seconds_left // 60
seconds = seconds_left % 60
print(total_seconds, "seconds is", hours, "hours,", minutes, "minutes and", seconds, "seconds")

7384 seconds is 2 hours, 3 minutes and 4 seconds

# Compound interest: the balance grows by the rate once per year
principal = 1000
rate = 0.05
years = 10
amount = principal * (1 + rate) ** years
interest = amount - principal
print("Final amount:", round(amount, 2))
print("Interest earned:", round(interest, 2))

Final amount: 1628.89
Interest earned: 628.89

coins = 87
quarters = coins // 25
coins = coins % 25
dimes = coins // 10
coins = coins % 10
print(quarters, dimes, coins)

3 1 2

length_text = "2.5"
width_text = "4"
area = int(length_text) * int(width_text)
print("Area:", area)

ValueError: invalid literal for int() with base 10: '2.5'

length_text = "2.5"
width_text = "4"
area = float(length_text) * float(width_text)
print("Area:", area)

Area: 10.0

average score = 80 + 90 / 2
print(average score)

SyntaxError: invalid syntax

average_score = (80 + 90) / 2
print(average_score)

85.0

The official Python Tutorial’s introduction shows the same operators, plus a few extra details, in its Numbers subsection: An Informal Introduction to Python: Numbers.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can create a variable and trace how its value changes. Reread
• I can tell whether a name is legal and write it in snake_case. Reread
• I can predict whether a result is an int or a float. Reread
• I can use // and % to split a quantity into whole groups and a remainder. Reread
• I can evaluate an expression in precedence order. Reread
• I can use True, False, and None correctly. Reread
• I can convert values with int(), float(), and str(). Reread
• I can explain how a name can refer to values of different types. Reread
• I can explain why 0.1 + 0.2 is not exactly 0.3 and round a result for display. Reread