Python Operators

or returns the first operand that is truthy, otherwise the last. An empty list is falsy, so evaluation skips to [1]. This is short-circuiting with values preserved, not converted to bool.

512. Exponentiation is right-associative—the rightmost ** groups first.

2 ** 3 ** 2
# same as 2 ** (3 ** 2) → 2 ** 9 → 512

(2 ** 3) ** 2   # if you need left grouping → 8 ** 2 → 64

+= on lists calls extend-like behavior in place (__iadd__), not rebinding a to a new object. Other names referencing the same list see the mutation.

Yes. PEP 8 recommends is for None because only one None exists. == can be overridden by a weird __eq__; is tests identity only.

CPython caches small integers (typically -5 to 256). Equal value does not imply same object for bigger ints—always use == for numeric equality.

-2. Bitwise NOT uses the underlying int: ~x == -(x+1). So ~1 == -2. Do not confuse with logical not True which is False.

and returns the first falsy value or the last operand. Here 0 is falsy, so expensive() is never called—useful for guarding expensive checks.

True. Chained comparisons expand with and; the middle operand is evaluated once and reused.

3 < 5 > 2
# equivalent to:
(3 < 5) and (5 > 2)

# idiomatic range check:
lo < x < hi

1. Modulo result shares sign with divisor (always non-negative here). Unlike some languages where remainder follows dividend sign, Python’s % is consistent with // floor division.

False. NaN is not equal to itself per IEEE rules. Use math.isnan(x) to test. Similarly tricky in sorting and dict keys.

Bitwise XOR assignment—classic swap trick with integers (pairwise XOR). In Python prefer tuple unpacking x, y = y, x for clarity unless teaching bitwise tricks.

True. Vacuous truth: no failing elements. Similarly any([]) is False. Interviewers use this to probe understanding of quantifiers.

As not (x == y) because == binds tighter than not. Use parentheses when mixing and/or/not with comparisons to avoid surprises.

Floor division rounds toward minus infinity: -3 // 2 == -2, not trunc toward zero. Pair it with % so (a // b) * b + (a % b) == a.

& is bitwise AND on ints/bools as bits; and is logical short-circuit returning operands. On booleans they coincide numerically but types/paths differ.

False. Fresh user objects compare unequal by default unless classes define __eq__. Identity differs too.

Since Python 3.5, @ is matrix multiplication (__matmul__)—mainly for NumPy. Built-in scalars do not implement it by default.

True. Non-empty string is truthy—the characters spell “False” but the string itself exists. Use distutils.util.strtobool or explicit parsing for config strings.

Implementation may intern some strings, but never rely on is for string equality—use ==. Identity tricks break across interpreters/builds.

(-3, 1). Quotient floors toward negative infinity; remainder matches %. Together they reconstruct -11.

It chains as (x == y) and (y == z), which implies transitivity for equality but still evaluates y twice—usually fine; contrast is chains which are rarer.

False, numeric value 0. Printed as False. Mixing bitwise and logical operators mentally causes confusion—keep contexts separate.

Not operator precedence—sort stability and key ties—items with equal keys keep relative order (stable sort). Combine with secondary keys from tuples if needed.

Lets you assign and test in one expression: if (n := len(s)) > 5:. Avoid duplicating expensive calls—still respect readability.