Values, Types & Variables

Values and types

A value is a piece of data: 42, 3.14, "hello", True. Every value is an object in memory, and every object has a type. The type decides two things: what the value can represent, and which operations work on it. You can add two numbers; you cannot divide a word by a word.

Code that writes a value directly, like 42 or "hi", is called a literal.

(repr shows a value the way you would type it in code; the for loop repeats the print for each value. You will study loops properly in M04.)

Integers: whole numbers of any size

An int is a whole number, positive, negative, or zero. Many languages limit integers to 64 bits (about 9.2 quintillion). Python integers have arbitrary precision: they grow as large as your memory allows. You never get an "overflow".

Underscores can make long literals readable: 1_000_000 is the same as 1000000. You can also write integers in other bases: 0b1010 (binary), 0o12 (octal), and 0xA (hexadecimal) are all ten.

Above: how the integer is stored as bits (binary digits, 0 or 1). Change the value and watch the bits change.

Floats: real numbers, approximately

A float ("floating-point number") represents a real number like 3.14 or -0.001. Any literal with a decimal point or an exponent (2.5e3 means 2.5 × 10³) is a float, and dividing with / always gives a float: 6 / 2 is 3.0.

Why 0.1 + 0.2 is not 0.3

This surprises everyone, and it is not a Python bug. Floats follow the IEEE-754 standard used by virtually every CPU. A float is stored in 64 bits: 1 sign bit, 11 exponent bits, and 52 bits of fraction. Just as 1/3 cannot be written exactly in decimal (0.3333…), 1/10 cannot be written exactly in binary. So 0.1 is stored as the nearest representable binary fraction, which is a tiny bit more than 0.1. Small errors add up.

Look at the fraction bits for 0.1: the pattern 1001 1001 1001… repeats forever in binary, so it must be cut off and rounded. Try 0.5 or 0.25: those are exact, because they are powers of two.

What to do about it

The special float values inf (infinity) and nan ("not a number", the result of undefined operations) also come from IEEE-754. nan is not even equal to itself.

Complex numbers

Python also has a built-in complex type, written with j for the imaginary unit (as engineers do): (1 + 2j) * (3 - 1j) is (5+5j). Use .real and .imag to get the parts. You will mostly meet complex numbers in scientific code.

Remember: floats are fast approximations; compare them with math.isclose; use Decimal for money and Fraction for exact ratios.

Operators and precedence

An operator is a symbol that combines values, like +. The values it works on are called operands.

// and % are partners: for any a and nonzero b, (a // b) * b + a % b == a. The built-in divmod(a, b) returns both at once. They are everywhere in real programs: converting minutes into hours and minutes, checking if a number is even (n % 2 == 0), wrapping around a clock.

Precedence

Precedence is the order in which operators are applied, just like in school maths. From highest to lowest: **, then unary minus -x, then * / // %, then + -, then comparisons (< == != and so on), then not, and, or. Operators on the same level go left to right, except **, which goes right to left.

Augmented assignment

Updating a variable based on its old value is so common that there is a shortcut. count += 1 means count = count + 1. There are versions for every operator: -=, *=, /=, //=, %=, **=.

bool and None

A Boolean (named after mathematician George Boole) is one of two values: True or False. Comparisons produce Booleans: 3 < 5 is True. Python lets you chain comparisons the way mathematicians write them: 0 <= age < 130.

Combine Booleans with and (both must be true), or (at least one), and not (flip it). Surprisingly, bool is a kind of int: True behaves like 1 and False like 0, so sum of a list of Booleans counts the true ones.

None is Python's way of saying "nothing" or "no value yet". It is the only value of its type. A function that does not return anything returns None, which is why print(print("hi")) prints hi and then None.

Names are references to objects

This section contains the most important idea in the module. In some languages a variable is a box that holds a value. In Python, a variable is a name that refers to an object, like a luggage tag tied to a suitcase. Assignment x = 42 does two things: it makes (or finds) the object 42, and it ties the tag x to it. This is called binding a name.

Consequences:

• y = x does not copy anything. It ties a second tag to the same object. Two names for one object are called aliases.
• Assigning a new value to a name (rebinding) moves that tag to a different object. Other names are unaffected.

Explore the scenarios: alias (two names, one list), rebind (moving a tag), and immutable (what happens with numbers).

Step through the same idea with the tracer. Watch the "obj N" identity tags: when two names show the same tag, they refer to the same object.

After line 3, cart also contains "pear", because there was only ever one list. Line 4 rebinds cart to a brand-new list, and same_cart still refers to the old one.

Identity vs equality: is vs ==

Every object has an identity, a unique number for as long as it exists, which id(obj) returns. Two different questions follow:

• a == b: are they equal (same value)?
• a is b: are they the same object (same identity)?

Dynamic typing, strong typing, and mutability

Dynamic typing

In Python, names have no type; objects do. A name can refer to an int now and a string later. This is dynamic typing: types are checked while the program runs, not before. (In statically typed languages such as Java, a variable's type is fixed when you write the code.)

Strong typing

Python is also strongly typed: it does not silently convert between unrelated types. "3" + 4 raises a TypeError rather than guessing whether you meant "34" or 7. "Explicit is better than implicit." (Numbers do mix sensibly: 1 + 2.5 is 3.5.)

Mutable and immutable

An object is mutable if it can be changed in place after it is created, and immutable if it cannot. All the types in this module (int, float, bool, None, and also str) are immutable. Lists are mutable.

This is why x = x + 1 never surprises you with numbers: the int object 10 cannot change, so Python makes a new object 11 and rebinds x. Any alias still sees 10. With a list, append changes the one shared object, and every alias sees the change.

Type conversion and input()

Each type's name is also a function that converts to it:

Reading input

input(prompt) shows the prompt, waits for the user to type a line and press Enter, and returns what they typed, always as a string. If you need a number, convert it.

In the browser, typed input is pre-filled for you (here 21 and 4.5). When you run the script locally with pixi run python, you type the answers.

Practice

total_minutes = 135
hours, minutes = divmod(total_minutes, 60)
print(hours, "h", minutes, "m")

a, b, c = 10, 20, 30
average = (a + b + c) / 3
print(average)

import math
from decimal import Decimal

close = math.isclose(0.1 + 0.2, 0.3)
total = Decimal("19.99") + Decimal("5.01") + Decimal("0.10")
print(close, total)

original = [1, 2]
alias = original
copy = list(original)
alias.append(3)

quantity = int(input("Quantity? "))
price = float(input("Price? "))
print(quantity * price)

Mini-project: a unit converter

Temperature in Celsius? 21.5
21.5 C = 70.7 F
Distance in km? 10
10.0 km = 6.214 miles
Duration in seconds? 4000
4000 s = 1 h 6 min 40 s

Quiz

Recap

• Every value is an object with a type; the type decides what operations make sense.
• int has arbitrary precision; float is IEEE-754 and approximate.
• Compare floats with math.isclose; use Decimal for money and Fraction for exact ratios.
• // floors, % gives the remainder, ** is power and binds tightest; parenthesize when unsure.
• Names are references. Assignment binds; y = x creates an alias; rebinding moves one name only.
• == compares values, is compares identity.
• Python is dynamically and strongly typed. Numbers and strings are immutable; lists are mutable.
• input() returns a string; convert it with int() or float().

Going further

• Floating-point arithmetic: issues and limitations
• Numeric types in the standard library reference
• decimal and fractions
• Operator precedence table
• Ned Batchelder: Facts and myths about Python names and values
• Next: M03 · Strings & Text