Operators and Expressions in Python

An expression is any piece of code that produces a value: 3, price * 2, name + "!", age >= 18. An operator is the symbol that combines values (the operands) into a new value.

The result's type depends on the operator and the operands. Combining two ints with +, -, *, //, % or ** (with a non-negative exponent) gives an int. If either operand is a float, the result is a float. The / operator always gives a float.

a // b divides and rounds down to the nearest integer; a % b is what is left over. Together they satisfy a simple rule: (a // b) * b + a % b == a. The built-in divmod(a, b) returns both at once.

These two operators come up constantly:

• Unit conversion: minutes = seconds // 60, seconds_left = seconds % 60.
• Divisibility: n % 2 == 0 means n is even; n % 5 == 0 means a multiple of 5.
• Digits: n % 10 is the last digit of n, and n // 10 removes it.
• Wrapping around: (index + 1) % length steps through positions and returns to 0 at the end.

With negative numbers, "round down" means toward minus infinity, so -7 // 2 is -4, and the remainder takes the sign of the divisor: -7 % 2 is 1. The rule above still holds.

When an expression has several operators, precedence decides the order, as in school arithmetic: ** binds tightest, then unary minus, then *, /, // and %, then + and -. Operators with the same precedence run left to right, with one exception: ** runs right to left, so 2 ** 3 ** 2 is 2 ** 9.

Two results surprise people: -2 ** 2 is -4 (the power is applied before the minus sign), and 10 - 4 - 3 is 3, not 9.

When in doubt, add parentheses. They cost nothing and make the intended order obvious to readers.

Updating a variable from its own value is so common that every arithmetic operator has a shorthand: x += 5 means x = x + 5. The same pattern works for -=, *=, /=, //=, %= and **=.

These are statements, not expressions: they update the name and produce no value, so print(x += 1) is a syntax error. Python also has no ++ or --; write count += 1.

Floats are stored in binary with about 15–17 significant decimal digits. Most decimal fractions, including 0.1, cannot be stored exactly, just as 1/3 cannot be written exactly in decimal. The tiny errors are normally invisible but show up in comparisons and repeated sums.

Three habits avoid trouble:

1. Never compare floats with ==. Use math.isclose(a, b) or check that the difference is very small.
2. Round only for display, with round(x, 2) or an f-string such as f"{x:.2f}", and keep full precision in calculations.
3. Use integers for money, counting cents, or the decimal module when exact decimal arithmetic is required.

Comparisons produce a bool: == (equal), != (not equal), <, <=, > and >=. Numbers compare by value, so 3 == 3.0 is True. Strings compare character by character using each character's code, so "apple" < "banana" is True, but every upper-case letter sorts before every lower-case one: "Zebra" < "apple" is also True.

Python allows chained comparisons: 0 <= score <= 100 means 0 <= score and score <= 100, written the way a mathematician would.

Use == to compare values. The is operator checks whether two names refer to the very same object; reserve it for None (x is None).

The logical operators combine conditions:

• a and b is true only when both are true.
• a or b is true when at least one is true.
• not a flips a truth value.

Precedence is not, then and, then or, so a or b and c means a or (b and c). Parentheses keep mixed conditions readable.

Both and and or short-circuit: they stop as soon as the answer is known. In x != 0 and 10 / x > 1, the division never runs when x is 0. They also return one of their operands rather than a plain True/False: or returns the first truthy operand, which gives the common default-value idiom name = typed_name or "Guest".

Operators cover arithmetic; the standard library's math module adds the rest. import math at the top of a program gives you math.sqrt, math.floor, math.ceil, math.pi, math.gcd and many more. A few useful built-ins need no import at all: abs(), min(), max(), round() and pow().

Modules get their own lesson later in the course; for now, treat import math as "make the math tools available".

Both problems are pure arithmetic with // and %: turn a number of seconds into clock time, and split a bill into fair shares without losing a cent.