Values, variables, expressions and types

Programs compute with values: numbers, pieces of text, true-or-false answers and, later, collections of these. To work with values, a program gives them names, combines them with operators into expressions and converts them from one kind to another. This lesson covers Python's basic types, how variables really work, the arithmetic and comparison operators, the order in which Python evaluates expressions, and type conversion. These ideas are small individually, but nearly every bug in a beginner's program traces back to a misunderstanding of one of them, so it pays to get them exactly right.

Values and types

Every value in Python has a type, which determines what the value means and what operations make sense on it. The four types you will use constantly in this course are integers (int), such as 42 and minus 7; floating-point numbers (float), such as 3.14 and 2.0; strings (str), such as "hello" and "42"; and Booleans (bool), which have only two values, True and False. The built-in type function tells you the type of any value, which is a useful tool when a program behaves unexpectedly.

values = [42, -7, 3.14, 2.0, "hello", "42", True, False, None]
for v in values:
    print(f"{v!r:10} has type {type(v).__name__}")

42         has type int
-7         has type int
3.14       has type float
2.0        has type float
'hello'    has type str
'42'       has type str
True       has type bool
False      has type bool
None       has type NoneType

Note that 2.0 is a float, not an int, even though it equals 2, and that "42" in quotation marks is a string of two characters, not a number. Adding "42" and 1 is an error, because Python will not guess whether you meant arithmetic or text. The value None, of type NoneType, means "no value"; it is what a function returns when it does not return anything else, and you will meet it again in lesson 7.

Types matter because the same operator does different things on different types. The plus sign adds numbers but joins, or concatenates, strings; the asterisk multiplies numbers but repeats strings. This is called operator overloading, and Python uses it to make common operations read naturally. It also means that a value of the wrong type can produce a surprising result rather than an error, as when "3" * 4 gives "3333" instead of 12.

print(3 + 4, "3" + "4")
print(3 * 4, "3" * 4, "-" * 20)
print(type(3 + 4.0).__name__)      # mixing int and float gives float

7 34
12 3333 --------------------
float

Variables are names for objects

An assignment statement such as score = 87 gives a name to a value. It is tempting to think of a variable as a box that holds a value, and for numbers that picture usually works. The more accurate picture in Python is that every value is an object somewhere in memory, and a variable is a name, or label, that refers to an object. Assignment makes the name on the left refer to the object produced by the expression on the right. The equals sign in Python does not mean mathematical equality; it means "make this name refer to that value". That is why count = count + 1, which is nonsense as an equation, is perfectly sensible as an assignment: work out count + 1 using the current value, then make count refer to the result.

The name picture explains a behavior that surprises many beginners. If you write b = a, you do not copy anything: b now refers to the same object as a. For numbers and strings, which cannot be changed in place, this never causes trouble. For lists, which can be changed in place, a change made through one name is visible through the other. Lesson 9 returns to this, but it is worth seeing now.

a = [1, 2, 3]
b = a              # b refers to the SAME list as a
b.append(4)        # change the list through the name b
print("a:", a, " b:", b, " same object?", a is b)

c = a.copy()       # c refers to a NEW list with the same items
c.append(5)
print("a:", a, " c:", c, " same object?", a is c)

x = 10
y = x
y = y + 1          # makes y refer to a new int; x is unaffected
print("x:", x, " y:", y)

a: [1, 2, 3, 4]  b: [1, 2, 3, 4]  same object? True
a: [1, 2, 3, 4]  c: [1, 2, 3, 4, 5]  same object? False
x: 10  y: 11

Variable names must start with a letter or underscore and contain only letters, digits and underscores; they are case-sensitive, so Total and total are different names. Python's own keywords, such as if, for, while, def, return and True, cannot be used as names. By convention, Python programmers write variable and function names in lowercase with underscores between words, a style called snake_case, as in hours_worked or average_mark. Choosing descriptive names is one of the cheapest ways to make code readable: compare p = h * r with pay = hours * hourly_rate.

Arithmetic operators

Python's arithmetic operators are mostly familiar, with two that deserve special attention. The single slash, /, is true division and always gives a float: 7 / 2 is 3.5 and even 6 / 3 is 2.0. The double slash, //, is floor division and gives the largest whole number not greater than the true quotient: 7 // 2 is 3. The % symbol gives the remainder, called the modulo: 7 % 2 is 1. Floor division and modulo work together: for any integers a and b with b not zero, a equals b times (a // b) plus (a % b). The double asterisk, **, raises to a power.

Floor division and modulo are surprisingly useful. Converting 200 minutes into hours and minutes is 200 // 60 hours and 200 % 60 minutes. Checking whether a number is even is n % 2 == 0. Extracting the last digit of a number is n % 10, and removing it is n // 10, which is how the digit-sum function in lesson 7 works. Clock arithmetic, such as finding the day of the week 100 days from now, is modulo 7.

total_minutes = 200
print(f"{total_minutes} minutes = {total_minutes // 60} h {total_minutes % 60} min")

seconds = 98_765
hours, rest = divmod(seconds, 3600)     # divmod gives quotient and remainder together
minutes, secs = divmod(rest, 60)
print(f"{seconds} s = {hours} h {minutes} min {secs} s")

days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
today = 3                                # Thursday
print("100 days after Thursday is", days[(today + 100) % 7])

for n in (-7, 7):
    print(f"{n} // 2 = {n // 2},  {n} % 2 = {n % 2}")

200 minutes = 3 h 20 min
98765 s = 27 h 26 min 5 s
100 days after Thursday is Sat
-7 // 2 = -4,  -7 % 2 = 1
7 // 2 = 3,  7 % 2 = 1

The last two lines show a detail worth knowing: Python's floor division rounds toward negative infinity, so minus 7 // 2 is minus 4, not minus 3, and the remainder takes the sign of the divisor, so minus 7 % 2 is 1. Some other languages, including C in CMPUT-201, round toward zero instead. When negative numbers are possible, check which rule your language uses.

Precedence: the order of evaluation

When an expression has several operators, Python applies them in a fixed order of precedence, much as in school algebra. Exponents bind tightest, then negation, then multiplication and the division family, then addition and subtraction, then comparisons, then the Boolean operators not, and, or. Operators at the same level are applied left to right, except **, which goes right to left, so 2 ** 3 ** 2 is 2 ** 9 = 512. When in doubt, add parentheses: they cost nothing and make your intention clear to readers.

print(2 + 3 * 4)          # multiplication first: 14
print((2 + 3) * 4)        # parentheses first: 20
print(-3 ** 2)            # ** binds tighter than negation: -(3**2) = -9
print((-3) ** 2)          # 9
print(2 ** 3 ** 2)        # right to left: 2 ** 9 = 512
print(10 - 4 - 3)         # left to right: (10 - 4) - 3 = 3
print(100 / 10 / 5)       # left to right: 2.0

14
20
-9
9
512
3
2.0

Comparisons and Boolean values

Comparison operators compare two values and produce a Boolean: == for equal (two equals signs, because one is assignment), != for not equal, and <, <=, > and >=. Python allows chained comparisons that read like mathematics: 0 <= mark <= 100 means mark is at least 0 and at most 100. Strings compare alphabetically by code point, so "apple" < "banana" is True, but "Zebra" < "apple" is also True, because uppercase letters have smaller code points than lowercase ones, as lesson 2 showed.

Booleans can be combined with and, or and not. The expression a and b is True only if both are True; a or b is True if at least one is; not a reverses a. Python evaluates and and or lazily, or with short-circuit evaluation: in a and b, if a is False, b is never evaluated, because the answer is already known. This is useful for guarding against errors, as in count > 0 and total / count > 50, which never divides by zero.

mark = 85
print(mark >= 80, mark == 85, mark != 85)
print(0 <= mark <= 100)                    # chained comparison
print("apple" < "banana", "Zebra" < "apple")

count, total = 0, 0
print(count > 0 and total / count > 50)    # short-circuit: no division happens

age, has_permit = 17, True
can_drive_alone = age >= 16 and has_permit
print("can drive alone:", can_drive_alone)

True True False
True
True True
False
can drive alone: True

Converting between types

Programs constantly convert values from one type to another. Data read from the keyboard or a file arrives as text, so "42" must become the number 42 before arithmetic. Results must become text before being joined into messages. The built-in functions int, float, str and bool perform conversions. Converting a float to an int with int truncates toward zero; to round to the nearest whole number, use round instead. Be aware that Python's round uses round-half-to-even, sometimes called banker's rounding, so round(2.5) is 2 and round(3.5) is 4; this avoids a small upward bias when many values are rounded.

print(int("42") + 1)          # text to integer
print(float("3.5") * 2)       # text to float
print("Total: " + str(17))    # number to text
print(int(7.9), int(-7.9))    # truncates toward zero
print(round(7.9), round(2.5), round(3.5), round(2.675, 2))
print(bool(0), bool(42), bool(""), bool("no"))   # empty and zero are False

for text in ["12", " 12 ", "12.5", "twelve"]:
    try:
        print(f"int({text!r}) = {int(text)}")
    except ValueError:
        print(f"int({text!r}) fails: not a whole number in text form")

43
7.0
Total: 17
7 -7
8 2 4 2.67
False True False True
int('12') = 12
int(' 12 ') = 12
int('12.5') fails: not a whole number in text form
int('twelve') fails: not a whole number in text form

Two results deserve comment. round(2.675, 2) gives 2.67, not 2.68, because 2.675 cannot be stored exactly as a float and is actually slightly less than 2.675, an echo of lesson 2. And bool converts zero, empty strings and empty collections to False and almost everything else to True, including the string "no". This notion of truthiness lets you write if name: to mean "if name is not empty", which is idiomatic Python but should be used with care.

Python is dynamically typed: a variable has no fixed type, so the same name can refer to an int now and a string later. That flexibility makes Python quick to write, but it also means type mistakes are discovered only when the program runs. Modern Python lets you add optional type hints, such as def area(width: float, height: float) -> float:, which document intent and let tools such as mypy check types before the program runs. Python itself ignores the hints at run time. CMPUT-274 and CMPUT-325 explore static and dynamic typing in depth.

def area(width: float, height: float) -> float:
    """Return the area of a rectangle."""
    return width * height

print(area(3, 4.5))
print(area.__annotations__)

13.5
{'width': <class 'float'>, 'height': <class 'float'>, 'return': <class 'float'>}