Lesson 4: Operators & Expressions

What are Operators?

Operators are the verbs of programming — they tell Python what to do with values. You already use them in math class; Python just gives them superpowers like integer division and modulo. An expression is any combination of values and operators that Python can evaluate to a single result.

What You'll Learn in This Lesson

• Use arithmetic, comparison, and logical operators
• Understand operator precedence (order of operations)
• Use assignment shortcuts like +=
• Split numbers into digits with // and %
• Understand the difference between = and ==

Arithmetic Operators

Two operators deserve special attention:

• // floor division drops the decimal part: 17 // 5 is 3 (not 3.4).
• % modulo returns the remainder: 17 % 5 is 2, because 17 = 3*5 + 2.

Pizza visualization for modulo: 17 slices ÷ 5 friends = 3 full slices each, and 2 slices left over. The // gives you 3, the % gives you 2.

+ and * also work on other types:

print("Py" + "thon")      # 'Python' — concatenation
print("ha" * 3)           # 'hahaha' — repetition
print([1, 2] + [3, 4])    # [1, 2, 3, 4] — list concatenation (Lesson 8)

This is called operator overloading — the same symbol means different things depending on the type. It is convenient but a common source of surprises: "5" + 5 raises TypeError because a string and an int don't mix.

Comparison Operators

Comparisons always return a boolean — True or False:

Never confuse = (assignment) with == (comparison). A single = stores a value; a double == asks a question.

Comparisons chain naturally in Python:

age = 25
print(18 <= age < 60)   # True — chained comparison, one expression

That single line is equivalent to 18 <= age and age < 60 — Python lets you write the math-style version directly.

Logical Operators

Logical operators combine booleans:

These let you write real-world rules: "Can enter if age ≥ 18 and has ID".

Short-circuiting is a powerful side effect: Python evaluates and/or left to right and stops as soon as the answer is decided. In a and b, if a is falsy, b never runs. In a or b, if a is truthy, b never runs. This is used to write safe one-liners:

# Only divide if denominator is non-zero
result = x / y if y != 0 else 0

Precedence — Order of Operations

Python follows standard math rules. From highest to lowest priority:

1. Parentheses ( )
2. Exponents **
3. *, /, //, % (left to right)
4. +, - (left to right)
5. Comparisons (==, >, ...)
6. not, then and, then or
7. Assignment =

print(3 + 4 * 2)      # 11  (multiplication first)
print((3 + 4) * 2)    # 14  (parentheses override)
print(2 ** 3 ** 2)    # 512 — ** binds right-to-left: 2 ** (3 ** 2)

Rule of thumb: when in doubt, add parentheses. Clarity beats cleverness every time.

Assignment Shortcuts

x += 5 is shorthand for x = x + 5. The shortcut works with most operators:

These keep counters, totals, and accumulators compact — you will use += on almost every loop you write.

Real-World Uses of // and %

• Time math: total_minutes = 130 → hours = 130 // 60 (2), mins = 130 % 60 (10).
• Even/odd checks: n % 2 == 0 means even.
• Splitting digits: 123 % 10 → 3; 123 // 10 → 12.
• Cycling/wrapping: index % len(items) wraps an index around a list forever.
• Coin/cash change: divide by the largest denomination with //, keep the remainder with %.

Common Mistakes to Avoid

• Mistake: Using = inside an if condition — Fix: always use == for comparison.
• Mistake: Expecting 7 / 2 to give 3 — Fix: / always gives a float (3.5); use // for integer division.
• Mistake: Forgetting that and binds tighter than or — Fix: add parentheses to make the logic explicit.
• Mistake: "5" + 5 — Fix: cast first: int("5") + 5.
• Mistake: Assuming ** binds left-to-right — Fix: it binds right-to-left: 2 ** 3 ** 2 is 512.
• Mistake: Using % when you want / on negative numbers — Fix: -7 % 3 is 2 in Python (not -1); remember modulo results share the sign of the divisor.

Professional Tips & Tricks

• Never use = inside conditions — that is assignment. Use == for comparison.
• Wrap long boolean conditions in parentheses for readability.
• Use // and % together to split numbers into digits, coins, or time units.
• Leverage chained comparisons: 18 <= age < 60 is clearer than two separate checks.
• Use += for accumulators inside loops.

Key Takeaways

• Arithmetic: / always floats; // floors; % gives the remainder.
• Comparisons return True/False; == compares, = assigns.
• and/or/not combine booleans; and/or short-circuit.
• Parentheses control precedence — use them liberally.
• +=, -=, *= are assignment shortcuts.
• // and % are the real-world workhorses for time, digits, and wrapping.

Next up: Control flow — conditionals and loops that make decisions.