Python Operators and Precedence

/ always returns a float. // rounds down, towards negative infinity, so -17 // 4 is -5, not -4. % returns the remainder that goes with that floor result, and it takes the sign of the right-hand operand: -17 % 4 is 3 because -5 * 4 + 3 == -17. The rule a == (a // b) * b + a % b always holds.

*(-17) ** 4 is 83521, but -17 ** 4 without brackets is -83521, as explained under precedence below. Mixing int and float gives a float; + and * also work on strings and lists, joining and repeating them.

== asks "do these have equal values?" is asks "are these the very same object in memory?"

a = [1, 2]
b = [1, 2]
c = a
print(a == b, a is b)   # True False: equal values, different lists
print(a is c)           # True: two names, one list

Use is for singletons, objects of which only one exists: x is None, x is True. For numbers and strings, always use ==. CPython reuses some small integers and short strings, so is sometimes appears to work for them, but that is an implementation detail that changes between versions and values. Python 3.8 and later even print a SyntaxWarning for x is "text" with a literal.

!= and is not are the negated forms. not x == y is valid but harder to read than x != y.

in and not in test containment and read like English:

codes = {"A4", "A3", "POSTER"}
print("A4" in codes)              # True
print("ink" in "pink ink")        # True: substring test
prices = {"A4": 0.10, "A3": 0.25}
print(0.10 in prices)             # False: dictionaries test keys
print(0.10 in prices.values())    # True

Membership in sets and dictionaries is fast at any size; in lists and strings Python scans item by item.

Bitwise operators work on the binary digits of integers: & (and), | (or), ^ (exclusive or), ~ (invert), << and >> (shift). They're used for compact flags and permissions:

COLOUR, DOUBLE_SIDED, STAPLED = 1, 2, 4
job = COLOUR | STAPLED            # 5, binary 101
print(bool(job & DOUBLE_SIDED))   # False
print(bool(job & STAPLED))        # True

Don't confuse & with and: & combines bits and always evaluates both sides.

From highest (evaluated first) to lowest, the operators you'll use most are:

1. () brackets
2. ** power (right-associative)
3. unary -x, +x, ~x
4. *, /, //, %
5. +, -
6. <<, >>, then &, then ^, then |
7. comparisons, in, not in, is, is not
8. not, then and, then or

Operators on the same level are evaluated left to right, except **, which groups from the right: 2 ** 3 ** 2 is 2 ** 9 = 512. Because ** binds tighter than unary minus, -2 ** 2 is -(2 ** 2) = -4, while (-2) ** 2 is 4.

You don't need to memorise the whole table. Remember that arithmetic happens before comparisons, comparisons before not/and/or, and add brackets whenever a reader might hesitate. Brackets cost nothing and prevent bugs.

Task: write a quote formula with explicit parentheses and distinguish logical, membership and bitwise operations. Calculate a price of £0.08 per sheet plus a £5 setup fee, with 10% off when the job is over 400 sheets; check the size code is in an allowed set; and test a finishing flag with &.

ALLOWED = {"A4", "A3"}
STAPLED, FOLDED = 1, 2

sheets, size, finish = 444, "A4", STAPLED | FOLDED
base = (sheets * 0.08) + 5
total = base * (0.9 if sheets > 400 else 1)

print(size in ALLOWED and sheets > 0)    # logical + membership
print(bool(finish & FOLDED))             # bitwise flag test
print(round(total, 2))                   # 36.47

For the worked check, 2 + 3 * 4 evaluates to 14, because multiplication has higher precedence than addition.

The language reference lists the full operator precedence table. Continue with booleans and expressions for and/or details, and the numbers lesson for rounding. Practise with the Python exercises and Python quiz.