← Python

Operators & Expressions

Control Flow

← Operators & Expressions

Select a question from the sidebar

12 questions in this topic

Question 1 / 12

What are the arithmetic operators in Python and how do they behave with different types?

Python provides these arithmetic operators:

Operator	Operation	Example
`+`	Addition	`5 + 3` = `8`
`-`	Subtraction	`5 - 3` = `2`
`*`	Multiplication	`5 * 3` = `15`
`/`	True division	`7 / 2` = `3.5`
`//`	Floor division	`7 // 2` = `3`
`%`	Modulo	`7 % 2` = `1`
`**`	Exponentiation	`2 ** 3` = `8`

True division (/) always returns a float, even for integers: 6 / 3 gives 2.0.

Floor division (//) rounds toward negative infinity: -7 // 2 gives -4, not -3.

Modulo (%) follows the sign of the divisor in Python: -7 % 2 gives 1 (not -1 as in C).

Type promotion: int op float gives float; int op complex gives complex.

Operators also work on non-numeric types: + concatenates strings/lists, * repeats sequences.

Pseudo Code

/ always returns float: 6 / 3 = 2.0
// floors toward negative infinity: -7 // 2 = -4
% follows divisor's sign: -7 % 2 = 1
** is exponentiation: 2 ** 3 = 8

Invariant: a == (a // b) * b + (a % b)

Code

# Basic arithmetic
print(5 + 3)    # 8
print(5 - 3)    # 2
print(5 * 3)    # 15
print(7 / 2)    # 3.5 (true division, always float)
print(6 / 3)    # 2.0 (still float!)
print(7 // 2)   # 3 (floor division)
print(7 % 2)    # 1 (modulo)
print(2 ** 10)  # 1024 (exponentiation)

# Floor division rounds toward negative infinity
print(7 // 2)    # 3
print(-7 // 2)   # -4 (not -3!)
print(7.5 // 2)  # 3.0 (floor div with float gives float)

# Modulo follows the divisor's sign
print(7 % 3)     # 1
print(-7 % 3)    # 2 (not -1!)
print(7 % -3)    # -2

# The invariant always holds: a == (a // b) * b + (a % b)
a, b = -7, 2
print(a == (a // b) * b + (a % b))  # True

# Type promotion
print(type(5 + 3.0))   # <class 'float'>
print(type(5 + 3j))    # <class 'complex'>

# Operators on non-numeric types
print("hello" + " world")  # 'hello world'
print("ha" * 3)            # 'hahaha'
print([1, 2] + [3, 4])    # [1, 2, 3, 4]
print([0] * 5)             # [0, 0, 0, 0, 0]

8
2
15
3.5
2.0
3
1
1024
3
-4
3.0
1
2
-2
True
<class 'float'>
<class 'complex'>
hello world
hahaha
[1, 2, 3, 4]
[0, 0, 0, 0, 0]

Key Points

•/ always returns float, even for exact integer division
•// floors toward negative infinity, not toward zero
•% follows the divisor's sign, unlike C
•The invariant a == (a // b) * b + (a % b) always holds
•+ concatenates sequences, * repeats them

Gotchas

•-7 // 2 is -4 (floor), not -3 (truncation) -- different from C/Java
•-7 % 2 is 1 in Python, but -1 in C/Java
•6 / 3 gives 2.0, not 2 -- use // for integer result
•[0] * 3 creates [0, 0, 0] with shared references -- fine for immutables, dangerous for mutables: [[]] * 3 shares the same inner list

Python has +, -, *, / (true div, returns float), // (floor div), % (modulo), ** (power). Floor division rounds toward negative infinity. Modulo follows the divisor's sign.

•/ always returns float
•// floors toward negative infinity

print(7 / 2)     # 3.5 (always float)
print(7 // 2)    # 3 (floor)
print(-7 // 2)   # -4 (toward -inf, not -3)
print(-7 % 2)    # 1 (not -1)
print(2 ** 10)   # 1024

-7 // 2 is -4 in Python, but -3 in C/Java

Question 2 / 12

How do comparison operators work in Python, and what is chained comparison?

Python provides six comparison operators: ==, !=, <, >, <=, >=.

All comparisons return bool (True or False).

Chained comparisons are a Pythonic feature that lets you write mathematical-style ranges: 1 < x < 10 is equivalent to 1 < x and x < 10, but x is evaluated only once.

This works with any comparison operators, even mixed: a < b <= c > d.

Comparison behavior by type:

Numbers: mathematical comparison (int and float can be compared)
Strings: lexicographic (Unicode codepoint) comparison
Lists/tuples: element-by-element comparison
Sets: subset/superset relationships
Different incompatible types: TypeError for ordering (<, >), but == returns False

Pseudo Code

Chained: a < b < c  <==>  a < b and b < c
  - b is evaluated only once
  - works with any mix of comparison operators

String: 'apple' < 'banana' (lexicographic)
List: [1, 2] < [1, 3] (element-by-element)
Set: {1} < {1, 2} (proper subset)

Code

# Basic comparisons
print(5 == 5)     # True
print(5 != 3)     # True
print(5 > 3)      # True
print(5 >= 5)     # True

# Chained comparisons -- Pythonic!
x = 5
print(1 < x < 10)      # True (1 < 5 and 5 < 10)
print(1 < x < 3)       # False (5 < 3 is False)
print(1 <= x <= 10)    # True
print(1 < x > 3)       # True (1 < 5 and 5 > 3)

# x is evaluated only once in chains
def get_value():
    print("called!")
    return 5

result = 1 < get_value() < 10  # prints "called!" only once
print(result)  # True

# String comparison (lexicographic)
print("apple" < "banana")   # True
print("abc" < "abd")        # True
print("A" < "a")            # True (uppercase < lowercase in Unicode)

# List/tuple comparison (element by element)
print([1, 2, 3] < [1, 2, 4])  # True (differs at index 2)
print([1, 2] < [1, 2, 0])     # True (shorter < longer when prefix matches)
print((1, 2) == (1, 2))       # True

# Set comparison (subset/superset)
print({1, 2} < {1, 2, 3})     # True (proper subset)
print({1, 2} <= {1, 2})       # True (subset or equal)
print({1, 2} < {1, 2})        # False (not proper subset)

# Cross-type comparison
print(5 == 5.0)       # True (int and float)
print(5 == "5")       # False (no error, just False)
try:
    5 < "5"
except TypeError as e:
    print(f"Error: {e}")  # '<' not supported between int and str

True
True
True
True
True
False
True
True
called!
True
True
True
True
True
True
True
True
True
False
True
False
Error: '<' not supported between instances of 'int' and 'str'

Key Points

•Chained comparisons: 1 < x < 10 evaluates x only once
•Strings compare lexicographically by Unicode codepoint
•Lists/tuples compare element by element, shorter is less
•Sets use < for proper subset, <= for subset-or-equal
•== across incompatible types returns False; < raises TypeError

Gotchas

•'A' < 'a' is True because uppercase letters have lower Unicode codepoints
•5 == 5.0 is True but 5 is 5.0 is False
•'10' < '9' is True (lexicographic, not numeric)
•Comparing None with < or > raises TypeError in Python 3

Python supports ==, !=, <, >, <=, >=. Chained comparisons like 1 < x < 10 work and evaluate x only once. Strings compare lexicographically, lists element-by-element, sets by subset relation.

•Chained comparisons evaluate middle expression once
•Different types for < raise TypeError

x = 5
print(1 < x < 10)    # True
print("apple" < "banana")   # True (lexicographic)
print([1, 2] < [1, 3])     # True (element-by-element)

True
True
True

'10' < '9' is True -- string comparison is lexicographic, not numeric

Question 3 / 12

How do logical operators (and, or, not) work in Python? What is short-circuit evaluation?

Python's logical operators are and, or, and not (keywords, not symbols).

Short-circuit evaluation:

and returns the first falsy value, or the last value if all are truthy
or returns the first truthy value, or the last value if all are falsy
not always returns a bool

Key insight: and and or do NOT necessarily return True/False. They return one of their operands. This is useful for default values and guard patterns.

Truthiness rules: Falsy values: False, None, 0, 0.0, "", [], (), {}, set(), 0j Everything else is truthy.

Short-circuit means:

and does not evaluate the right side if the left is falsy
or does not evaluate the right side if the left is truthy
This can prevent errors and improve performance

Pseudo Code

and: returns first falsy, or last value if all truthy
  0 and 5 -> 0
  3 and 5 -> 5

or: returns first truthy, or last value if all falsy
  0 or 5 -> 5
  3 or 5 -> 3

not: always returns bool
  not 0 -> True
  not 5 -> False

Code

# 'and' returns first falsy value, or last value
print(3 and 5)       # 5 (both truthy, return last)
print(0 and 5)       # 0 (first is falsy, return it)
print(3 and 0)       # 0 (second is falsy, return it)
print("" and "hi")   # '' (first is falsy)
print("hi" and "bye")  # 'bye' (both truthy, return last)

# 'or' returns first truthy value, or last value
print(3 or 5)        # 3 (first is truthy, return it)
print(0 or 5)        # 5 (first falsy, check second)
print(0 or "")       # '' (both falsy, return last)
print("" or "default")  # 'default'

# 'not' always returns bool
print(not 0)         # True
print(not 42)        # False
print(not "")        # True
print(not "hello")   # False

# Short-circuit prevents evaluation
def expensive():
    print("evaluated!")
    return True

result = False and expensive()  # expensive() is never called
print(result)  # False

result = True or expensive()   # expensive() is never called
print(result)  # True

# Practical: default values with 'or'
name = "" or "Anonymous"
print(name)  # 'Anonymous'

user_input = input("Name: ") if False else "default"  # example pattern

# Practical: guard with 'and'
lst = []
first = lst and lst[0]   # short-circuits, avoids IndexError
print(first)  # [] (falsy, never accesses lst[0])

lst = [42]
first = lst and lst[0]   # lst is truthy, so evaluates lst[0]
print(first)  # 42

# Operator precedence: not > and > or
print(True or False and False)   # True (and binds tighter)
print((True or False) and False) # False

5
0
0

bye
3
5

default
True
False
True
False
False
True
Anonymous
[]
42
True
False

Key Points

•and/or return operands, not necessarily True/False
•and returns first falsy value or last value
•or returns first truthy value or last value
•Short-circuit: right side may never be evaluated
•Precedence: not > and > or

Gotchas

•'and'/'or' return actual values, not bools -- 0 or 5 gives 5, not True
•Using 'or' for defaults fails with legitimate falsy values: 0 or 'default' gives 'default' even if 0 was intended
•Precedence: 'not a == b' means 'not (a == b)', not '(not a) == b'
•Short-circuit can hide bugs -- side effects in the right operand may not execute

and returns the first falsy value or the last value. or returns the first truthy value or the last value. not returns a bool. Short-circuit evaluation means the right operand may not be evaluated.

•and/or return operands, not bools
•Short-circuit: right side may not execute

print(0 and 5)       # 0 (short-circuits)
print(0 or 5)        # 5 (first truthy)
print("" or "default")  # 'default'
print(not 0)         # True

0
5
default
True

0 or 'default' gives 'default' even if 0 was the intended value

Question 4 / 12

What are bitwise operators in Python and when would you use them?

Bitwise operators work on the binary representation of integers:

Operator	Operation	Example
`&`	AND	`5 & 3` = `1`
`\\|`	OR	`5 \\| 3` = `7`
`^`	XOR	`5 ^ 3` = `6`
`~`	NOT (complement)	`~5` = `-6`
`<<`	Left shift	`5 << 1` = `10`
`>>`	Right shift	`5 >> 1` = `2`

Common use cases:

Flags and permissions (Unix file permissions)
Efficient multiplication/division by powers of 2
Bit masking and extraction
Cryptography and hashing
Low-level protocol encoding
XOR swap, XOR parity checks

Python-specific: Since integers are arbitrary precision, bitwise operations work on arbitrarily large numbers. The ~ operator gives -(x+1) due to two's complement.

Pseudo Code

5 in binary:  101
3 in binary:  011

5 & 3 = 001 = 1  (AND: both bits 1)
5 | 3 = 111 = 7  (OR: either bit 1)
5 ^ 3 = 110 = 6  (XOR: bits differ)
~5 = -(5+1) = -6 (NOT: invert + two's complement)
5 << 1 = 1010 = 10  (left shift = multiply by 2)
5 >> 1 = 10 = 2     (right shift = integer divide by 2)

Code

# Bitwise AND -- common bits
print(5 & 3)    # 1  (101 & 011 = 001)

# Bitwise OR -- any bit
print(5 | 3)    # 7  (101 | 011 = 111)

# Bitwise XOR -- differing bits
print(5 ^ 3)    # 6  (101 ^ 011 = 110)

# Bitwise NOT -- inverts all bits
print(~5)       # -6 (two's complement: -(5+1))

# Left shift -- multiply by 2^n
print(5 << 1)   # 10 (5 * 2)
print(5 << 3)   # 40 (5 * 8)

# Right shift -- integer divide by 2^n
print(20 >> 1)  # 10 (20 // 2)
print(20 >> 2)  # 5  (20 // 4)

# Practical: permission flags
READ = 0b100    # 4
WRITE = 0b010   # 2
EXEC = 0b001    # 1

permissions = READ | WRITE  # combine: 0b110 = 6
print(f"Permissions: {permissions:03b}")  # 110

# Check if permission is set
print(bool(permissions & READ))   # True
print(bool(permissions & EXEC))   # False

# Add a permission
permissions |= EXEC
print(f"Permissions: {permissions:03b}")  # 111

# Remove a permission
permissions &= ~WRITE
print(f"Permissions: {permissions:03b}")  # 101

# Toggle a permission with XOR
permissions ^= READ
print(f"Permissions: {permissions:03b}")  # 001

# Check if a number is even/odd
def is_even(n):
    return (n & 1) == 0

print(is_even(4))  # True
print(is_even(7))  # False

# XOR swap (no temp variable needed)
a, b = 5, 3
a ^= b
b ^= a
a ^= b
print(a, b)  # 3 5

1
7
6
-6
10
40
10
5
Permissions: 110
True
False
Permissions: 111
Permissions: 101
Permissions: 001
True
False
3 5

Key Points

•& (AND), | (OR), ^ (XOR), ~ (NOT), << (left shift), >> (right shift)
•Left shift by n multiplies by 2^n, right shift divides by 2^n
•Common for flags, permissions, and bit masking
•~x equals -(x+1) in Python due to two's complement
•n & 1 checks if a number is odd

Gotchas

•~ on Python's arbitrary-precision int gives -(x+1), not a fixed-width inversion
•Bitwise operators have lower precedence than comparison operators: x & 3 == 1 means x & (3 == 1)
•Do not confuse & (bitwise AND) with 'and' (logical AND)
•Do not confuse | (bitwise OR) with 'or' (logical OR)

Bitwise operators: & (AND), | (OR), ^ (XOR), ~ (NOT), << (left shift), >> (right shift). They work on binary representations. Common for flags, permissions, and checking even/odd (n & 1).

•Work on binary representations of integers
•Common for flags and bitmask operations

print(5 & 3)    # 1  (AND)
print(5 | 3)    # 7  (OR)
print(5 ^ 3)    # 6  (XOR)
print(5 << 1)   # 10 (multiply by 2)
print(5 >> 1)   # 2  (divide by 2)

# Check odd/even
print(7 & 1)    # 1 (odd)
print(8 & 1)    # 0 (even)

Bitwise & | have lower precedence than == -- use parentheses

Question 5 / 12

What are identity operators (is, is not) and membership operators (in, not in)?

Identity operators (is, is not): Check whether two variables reference the same object in memory (same id()). They do NOT compare values.

Membership operators (in, not in): Check whether a value exists within a container. They call the __contains__ method, or iterate through the object.

in works with:

Lists, tuples, sets: checks if element is present
Dicts: checks if key exists (not value)
Strings: checks if substring exists
Any object implementing __contains__ or __iter__

Performance of in:

set/frozenset/dict: O(1) average (hash lookup)
list/tuple: O(n) (linear scan)
str: O(n) for substring search

Pseudo Code

Identity:
  a is b     -> id(a) == id(b)  (same object?)
  a is not b -> id(a) != id(b)

Membership:
  x in collection   -> is x present?
  x not in collection -> is x absent?

Performance:
  set/dict: O(1) lookup
  list/tuple: O(n) scan
  str: O(n) substring search

Code

# Identity operators
a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(a is b)       # True (same object)
print(a is c)       # False (different objects, same value)
print(a is not c)   # True

# Always use 'is' for None, True, False
x = None
print(x is None)       # True -- correct
print(x is not None)   # False

# Membership with lists/tuples
print(3 in [1, 2, 3])          # True
print(4 not in (1, 2, 3))     # True

# Membership with sets -- O(1)
colors = {"red", "green", "blue"}
print("red" in colors)         # True
print("yellow" not in colors)  # True

# Membership with dicts -- checks KEYS, not values
user = {"name": "Alice", "age": 30}
print("name" in user)    # True (key exists)
print("Alice" in user)   # False (Alice is a value, not a key)
print(30 in user)         # False (30 is a value)

# To check values:
print("Alice" in user.values())  # True

# Membership with strings -- substring check
print("hell" in "hello")    # True (substring)
print("xyz" not in "hello") # True

# Performance comparison
import timeit

big_list = list(range(100000))
big_set = set(range(100000))

list_time = timeit.timeit(lambda: 99999 in big_list, number=1000)
set_time = timeit.timeit(lambda: 99999 in big_set, number=1000)
print(f"List lookup: {list_time:.4f}s")
print(f"Set lookup:  {set_time:.4f}s")  # Much faster!

True
False
True
True
False
True
True
True
True
True
False
False
True
True
True
List lookup: 0.3130s
Set lookup:  0.0000s

Key Points

•'is' checks identity (same object), '==' checks equality (same value)
•Use 'is' only for None, True, False
•'in' checks membership in any container
•'in' on a dict checks keys, not values
•set/dict 'in' is O(1), list/tuple 'in' is O(n)

Gotchas

•'in' on a dict checks KEYS only -- use 'x in d.values()' for value lookup
•'is' on integers may give unexpected True for small numbers (-5 to 256) due to caching
•'abc' in 'xabcx' is True -- 'in' checks substrings for strings
•'not in' is a single operator, not 'not (x in y)' -- though they give the same result

is/is not check object identity (same memory). in/not in check membership. Use is for None. in checks keys for dicts, substrings for strings. Set/dict in is O(1), list is O(n).

•'is' for identity, 'in' for membership
•Dict 'in' checks keys, not values

a = [1, 2]
b = a
print(a is b)          # True (same object)

print(3 in [1, 2, 3])       # True
print("name" in {"name": "Alice"})  # True (checks keys)
print("hell" in "hello")     # True (substring)

True
True
True
True

'in' on dict checks KEYS only, not values

Question 6 / 12

What is operator precedence in Python and what are the common pitfalls?

Operator precedence determines the order in which operators are evaluated. From highest to lowest priority:

() -- Parentheses (grouping)
** -- Exponentiation
~, +x, -x -- Unary NOT, positive, negative
*, /, //, % -- Multiplication, division, floor div, modulo
+, - -- Addition, subtraction
<<, >> -- Bitwise shifts
& -- Bitwise AND
^ -- Bitwise XOR
| -- Bitwise OR
==, !=, <, >, <=, >=, is, in -- Comparisons
not -- Logical NOT
and -- Logical AND
or -- Logical OR
if else -- Ternary conditional
=, +=, etc. -- Assignment

Exponentiation is right-associative: 2 ** 3 ** 2 = 2 ** 9 = 512 All others are left-associative: 10 - 5 - 2 = (10 - 5) - 2 = 3

When in doubt, use parentheses for clarity.

Pseudo Code

Highest to lowest:
  () > ** > unary > * / // % > + - > shifts > & > ^ > | > comparisons > not > and > or

Right-associative: **
Left-associative: everything else

Rule of thumb: when in doubt, use parentheses

Code

# Exponentiation binds tighter than unary minus
print(-2 ** 2)     # -4, not 4! It's -(2**2)
print((-2) ** 2)   # 4

# Exponentiation is right-associative
print(2 ** 3 ** 2)     # 512 = 2 ** (3 ** 2) = 2 ** 9
print((2 ** 3) ** 2)   # 64

# Multiplication before addition
print(2 + 3 * 4)     # 14, not 20
print((2 + 3) * 4)   # 20

# Comparison before logical
print(1 < 2 and 3 < 4)  # True (comparisons first, then 'and')

# 'not' binds looser than comparisons
print(not 1 == 2)     # True = not (1 == 2) = not False
# print(not 1 == 2) is NOT (not 1) == 2

# Bitwise operators have LOW precedence!
print(5 & 3 == 1)     # False! Parsed as 5 & (3 == 1) = 5 & True = 1... wait
print((5 & 3) == 1)   # True  (5 & 3 = 1, then 1 == 1)
# Always use parentheses with bitwise operators!

# 'or' has lower precedence than 'and'
print(True or False and False)   # True = True or (False and False)
print((True or False) and False) # False

# Ternary has very low precedence
x = 5
result = "positive" if x > 0 else "non-positive"
print(result)  # 'positive'

# Assignment is lowest (can't be used in expressions normally)
# Use walrus operator := for assignment expressions
import re
if (match := re.search(r'\d+', 'abc123')):
    print(match.group())  # 123

-4
4
512
64
14
20
True
True
True
True
True
False
positive
123

Key Points

•** is right-associative: 2**3**2 = 2**(3**2) = 512
•-2**2 is -4, not 4 -- ** binds tighter than unary minus
•Bitwise operators have lower precedence than comparison operators
•'not' has lower precedence than comparisons: not 1 == 2 means not (1 == 2)
•When in doubt, use parentheses

Gotchas

•-2**2 is -4 because ** binds tighter than unary -
•5 & 3 == 1 is parsed as 5 & (3 == 1) -- always parenthesize bitwise operators
•True or False and False is True, not False -- 'and' binds tighter than 'or'
•not in and is not are single operators, not combinations

Precedence from highest: () > ** > unary > *////% > +- > shifts > &^| > comparisons > not > and > or. ** is right-associative. Bitwise operators have surprisingly low precedence. When in doubt, use parentheses.

•** is right-associative and binds tighter than unary -
•Bitwise ops have lower precedence than comparisons

print(-2 ** 2)        # -4 (** before unary -)
print(2 ** 3 ** 2)    # 512 (right-associative)
print(5 & 3 == 1)     # False (== before &!)
print((5 & 3) == 1)   # True (explicit grouping)

-4
512
True
True

-2**2 is -4, not 4

Question 7 / 12

How does short-circuit evaluation work with 'and' and 'or', and what are practical uses?

Short-circuit evaluation means Python stops evaluating a boolean expression as soon as the result is determined:

and: if the left operand is falsy, the right is never evaluated (result is already falsy)
or: if the left operand is truthy, the right is never evaluated (result is already truthy)

Practical patterns:

Default values with or: name = user_name or "Anonymous"
Guard clauses with and: lst and lst[0] (safe access)
Conditional execution: debug and print("debug info")
Null-safe chaining: obj and obj.method()

Important: Since and/or return operands (not bools), these patterns return actual values, which is both powerful and occasionally confusing.

Pseudo Code

Short-circuit rules:
  False and ANYTHING -> False (ANYTHING never evaluated)
  True or ANYTHING -> True (ANYTHING never evaluated)

Patterns:
  x or default -> default value if x is falsy
  guard and action -> only act if guard is truthy
  a and b or c -> like ternary (but has edge cases)

Code

# Short-circuit: right side not evaluated
def side_effect():
    print("I was called!")
    return True

result = False and side_effect()  # side_effect() never called
print(result)  # False

result = True or side_effect()   # side_effect() never called
print(result)  # True

# Pattern 1: Default values with 'or'
user_name = ""
display_name = user_name or "Anonymous"
print(display_name)  # 'Anonymous'

config_port = 0  # Caution: 0 is falsy!
port = config_port or 8080
print(port)  # 8080 (bug if 0 was intentional!)

# Pattern 2: Guard clause with 'and'
data = []
first = data and data[0]    # short-circuits, no IndexError
print(first)  # []

data = [42, 99]
first = data and data[0]    # data is truthy, evaluates data[0]
print(first)  # 42

# Pattern 3: Conditional execution
debug = True
debug and print("Debug: processing started")  # prints

debug = False
debug and print("Debug: processing started")  # does NOT print

# Pattern 4: Chain of fallbacks
def get_name(user):
    return user.get("display_name") or user.get("username") or "Unknown"

print(get_name({"username": "alice"}))            # 'alice'
print(get_name({"display_name": "Alice B."}))     # 'Alice B.'
print(get_name({}))                                # 'Unknown'

# Avoiding side effects with short-circuit
def divide(a, b):
    return b != 0 and a / b

print(divide(10, 2))   # 5.0
print(divide(10, 0))   # False (no ZeroDivisionError)

False
True
Anonymous
8080
[]
42
Debug: processing started
alice
Alice B.
Unknown
5.0
False

Key Points

•and: stops at first falsy, or returns first truthy (or last value)
•or: stops at first truthy, returns first truthy (or last value)
•Right operand may never be evaluated
•'x or default' is a common pattern for default values
•'guard and expr' is a common pattern for safe access

Gotchas

•'x or default' fails for legitimate falsy values: 0 or default gives default
•'a and b or c' is NOT a safe ternary -- fails if b is falsy
•Side effects in short-circuited expressions silently skip
•Use 'x if condition else y' instead of 'condition and x or y'

Short-circuit: and stops at first falsy, or stops at first truthy. The right side may never execute. Useful for defaults (x or default), guards (lst and lst[0]), and conditional execution.

•and: stops at first falsy; or: stops at first truthy
•Useful for defaults and guard clauses

# Default value
name = "" or "Anonymous"  # 'Anonymous'

# Guard clause
lst = []
first = lst and lst[0]  # [] (no IndexError)

# Fallback chain
result = None or 0 or "" or "found"  # 'found'

'0 or default' gives default even if 0 was intended

Question 8 / 12

What are augmented assignment operators and how do they differ for mutable vs immutable types?

Augmented assignment operators combine an operation with assignment: +=, -=, *=, /=, //=, %=, **=, &=, |=, ^=, <<=, >>=.

x += y is not always the same as x = x + y!

For immutable types (int, str, tuple):

x += y creates a new object and rebinds x -- equivalent to x = x + y

For mutable types (list, set, dict):

x += y calls __iadd__ which modifies in-place -- NOT the same as x = x + y
x = x + y creates a new object

This distinction matters when other names reference the same object.

Pseudo Code

Immutable (int, str, tuple):
  x += y  ->  x = x.__iadd__(y)  ->  x = x.__add__(y)  ->  new object

Mutable (list, set):
  x += y  ->  x.__iadd__(y)  ->  modifies x in place
  x = x + y  ->  x.__add__(y)  ->  creates new object

Code

# Immutable: += creates new object
x = 5
print(id(x))
x += 3       # x = x + 3, creates new int(8)
print(id(x))  # different id
print(x)      # 8

# Mutable list: += modifies in-place
a = [1, 2]
b = a          # b references same list
print(id(a))
a += [3, 4]    # calls __iadd__, modifies in-place
print(id(a))   # SAME id
print(a)       # [1, 2, 3, 4]
print(b)       # [1, 2, 3, 4] -- b sees the change!

# Mutable list: a = a + [3, 4] creates NEW list
a = [1, 2]
b = a
a = a + [3, 4]  # creates new list, rebinds a
print(a)  # [1, 2, 3, 4]
print(b)  # [1, 2] -- b still points to old list!

# Tuple: += creates new tuple
t = (1, 2)
print(id(t))
t += (3, 4)  # creates new tuple
print(id(t))  # different id
print(t)      # (1, 2, 3, 4)

# Set augmented operators
s = {1, 2, 3}
s |= {4, 5}     # in-place union
print(s)         # {1, 2, 3, 4, 5}
s &= {2, 3, 4}  # in-place intersection
print(s)         # {2, 3, 4}
s -= {4}         # in-place difference
print(s)         # {2, 3}

# The famous tuple-in-list gotcha
t = ([1, 2],)
try:
    t[0] += [3]  # raises TypeError but STILL modifies the list!
except TypeError as e:
    print(f"Error: {e}")
print(t)  # ([1, 2, 3],) -- the list was modified despite the error!

4308606784
4308606880
8
4303449152
4303449152
[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2]
4382087552
4381991984
(1, 2, 3, 4)
{1, 2, 3, 4, 5}
{2, 3, 4}
{2, 3}
Error: 'tuple' object does not support item assignment
([1, 2, 3],)

Key Points

•+= on mutable types modifies in-place (calls __iadd__)
•+= on immutable types creates a new object
•a += b is NOT always the same as a = a + b for mutable types
•Other names referencing the same mutable object will see in-place changes
•Set supports |=, &=, -=, ^= for in-place operations

Gotchas

•lst += [x] modifies the list in-place; lst = lst + [x] creates a new list
•t[0] += [3] on a tuple of lists raises TypeError BUT still modifies the list
•Augmented assignment on a tuple variable creates a new tuple
•If a function receives a list and uses +=, it modifies the caller's list

+= on mutable types (list, set) modifies in-place. On immutable types (int, str, tuple) it creates a new object. a += b is NOT the same as a = a + b for mutable types because the former modifies in-place.

•+= on lists modifies in-place
•+= on ints/strs creates new objects

a = [1, 2]
b = a
a += [3]     # in-place: b sees the change
print(b)     # [1, 2, 3]

a = [1, 2]
b = a
a = a + [3]  # new list: b unchanged
print(b)     # [1, 2]

[1, 2, 3]
[1, 2]

lst += [x] and lst = lst + [x] behave differently when other names reference lst

Question 9 / 12

How does the walrus operator (:=) work and when should you use it?

The walrus operator (:=), introduced in Python 3.8 (PEP 572), is an assignment expression. It assigns a value to a variable and returns that value, all within an expression.

Regular assignment (=) is a statement and cannot be used inside expressions. The walrus operator fills this gap.

Common use cases:

While loops with initialization: avoid duplicating the input call
Filtering with computed values: avoid computing twice
Regex matching: assign and check in one step
List comprehension filtering: compute once, filter and use

When NOT to use:

When a regular assignment would be clearer
For top-level assignments (just use =)
When it makes the code harder to read (readability counts!)

Pseudo Code

Syntax: variable := expression
  - assigns expression to variable
  - returns the value of expression
  - can be used inside if, while, comprehensions

Pattern:
  if (match := re.search(pattern, text)):
      use(match)

  while (line := input()) != 'quit':
      process(line)

Code

# Without walrus: duplicated call
import re

text = "The answer is 42"
match = re.search(r'\d+', text)
if match:
    print(f"Found: {match.group()}")

# With walrus: assign and check in one step
if (match := re.search(r'\d+', text)):
    print(f"Found: {match.group()}")  # Found: 42

# While loop without walrus
while True:
    line = input("Enter text (quit to stop): ")
    if line == "quit":
        break
    print(f"You said: {line}")

# While loop with walrus (cleaner)
# while (line := input("Enter text: ")) != "quit":
#     print(f"You said: {line}")

# List comprehension: compute once, filter and use
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Without walrus: calls expensive function twice
def process(x):
    return x ** 2 - 10

results = [process(x) for x in data if process(x) > 0]  # process called twice!
print(results)  # [-9, -6, -1, 6, 15, 26, 39, 54, 71, 90] filtered

# With walrus: compute once
results = [y for x in data if (y := process(x)) > 0]
print(results)  # [6, 15, 26, 39, 54, 71, 90]

# Reading a file in chunks
import io
fake_file = io.BytesIO(b"Hello World! This is test data.")
while (chunk := fake_file.read(8)):
    print(chunk)

# Nested conditions simplified
numbers = [2, 8, 0, 5, 3, 7]
if (n := len(numbers)) > 5:
    print(f"List has {n} elements")  # List has 6 elements

Found: 42
Found: 42
Enter text (quit to stop):

Key Points

•Walrus operator := assigns and returns a value in one expression
•Available since Python 3.8 (PEP 572)
•Useful in while loops, if statements, and comprehensions
•Avoids duplicate function calls in filter-and-use patterns
•Use sparingly -- readability counts

Gotchas

•:= cannot be used at the top level of a statement -- use regular = instead
•Walrus operator has very low precedence -- often needs parentheses
•Overusing := can make code harder to read
•:= in comprehensions creates the variable in the enclosing scope, not the comprehension scope

The walrus operator := (Python 3.8+) assigns a value AND returns it in one expression. Useful in if/while conditions and comprehensions to avoid duplicate computation.

•:= assigns and returns in one expression
•Avoids duplicate computation in filter patterns

import re
text = "Price: $42"
if (match := re.search(r'\d+', text)):
    print(match.group())  # 42

# Filter with single computation
data = [1, 2, 3, 4, 5]
results = [y for x in data if (y := x ** 2) > 10]
print(results)  # [16, 25]

42
[16, 25]

:= in comprehensions leaks the variable into the enclosing scope

Question 10 / 12

How do chained comparisons work in Python?

Python allows you to chain comparison operators in a way that mirrors mathematical notation:

a < b < c is equivalent to (a < b) and (b < c), but b is evaluated only once.

You can chain any comparison operators: <, <=, >, >=, ==, !=, is, is not, in, not in.

The chain can be arbitrarily long: a < b <= c > d != e.

How it works internally:

a op1 b op2 c becomes a op1 b and b op2 c
Each intermediate value is evaluated at most once
Short-circuit applies: if any comparison is False, the rest are not evaluated

This is one of Python's most elegant features and makes range checks very readable.

Pseudo Code

a < b < c    <==>  a < b and b < c (b evaluated once)
a < b <= c   <==>  a < b and b <= c
a == b == c  <==>  a == b and b == c
a < b > c    <==>  a < b and b > c

Short-circuit: if a < b is False, c is never evaluated

Code

# Range check -- most common use
age = 25
print(18 <= age < 65)   # True (working age)

# Equivalent but less readable
print(18 <= age and age < 65)  # True

# Multiple equality check
a = b = c = 5
print(a == b == c)   # True (all equal)

# Mixed operators
x = 3
print(1 < x <= 3 < 10)  # True (1<3 and 3<=3 and 3<10)

# b is evaluated only once
count = 0
def get_value():
    global count
    count += 1
    return 5

result = 1 < get_value() < 10  # get_value() called once
print(count)   # 1
print(result)  # True

# Short-circuit in chains
count = 0
def expensive():
    global count
    count += 1
    return 5

result = 10 < 3 < expensive()  # 10 < 3 is False, expensive() never called
print(count)  # 0

# Practical: checking sorted order
def is_sorted_triple(a, b, c):
    return a <= b <= c

print(is_sorted_triple(1, 2, 3))  # True
print(is_sorted_triple(1, 3, 2))  # False

# Checking if value is one of several
x = 5
# Don't do this (it doesn't work as expected):
# x == 1 or 2 or 3  -> this is x == 1, or 2, or 3 -> always truthy!

# Do this instead:
print(x in (1, 2, 3))  # False
print(x in (3, 4, 5))  # True

# Gotcha: chained 'is' checks
a = 256
print(a is a is a)  # True (a is a and a is a)

True
True
True
True
1
True
0
True
False
False
True
True

Key Points

•a < b < c evaluates b only once
•Works with any comparison operators: <, <=, ==, !=, is, in
•Short-circuit applies: stops at first False comparison
•Much more readable than explicit 'and' chains for range checks
•Can chain arbitrarily many comparisons

Gotchas

•x == 1 or 2 or 3 does NOT check if x is 1, 2, or 3 -- use x in (1, 2, 3)
•Chained != does not mean 'all different': a != b != c allows a == c
•a < b > c is valid but rarely readable -- use with caution
•Chained 'is' can be surprising: a is b is True checks a is b and b is True

Python chains comparisons: 1 < x < 10 means 1 < x and x < 10 with x evaluated only once. Works with any comparison operators. Short-circuits on first False.

•Middle values evaluated only once
•Short-circuits on first False

age = 25
print(18 <= age < 65)  # True (range check)

a = b = c = 5
print(a == b == c)     # True (all equal)

True
True

x == 1 or 2 does NOT mean x == 1 or x == 2

Question 11 / 12

What is the divmod() function and when is it useful?

divmod(a, b) returns a tuple (a // b, a % b) -- the quotient and remainder in a single call. It is more efficient than computing // and % separately because the CPU computes both in a single division instruction.

Signature: divmod(a, b) -> (quotient, remainder)

Use cases:

Time conversion: converting seconds to hours/minutes/seconds
Currency: splitting into larger denominations
Pagination: calculating pages and remaining items
Base conversion: repeatedly dividing to extract digits
Euclidean algorithm: for GCD computation

Pseudo Code

divmod(a, b) returns (a // b, a % b)

Use cases:
  seconds -> (minutes, remaining_seconds)
  total_items -> (full_pages, remaining_items)
  dividend -> (quotient, remainder)

Code

# Basic usage
print(divmod(17, 5))   # (3, 2) -- 17 = 5*3 + 2
print(divmod(10, 3))   # (3, 1)
print(divmod(7, 2))    # (3, 1)

# Negative numbers (floor division rules apply)
print(divmod(-17, 5))  # (-4, 3) -- -17 = 5*(-4) + 3

# Works with floats too
print(divmod(7.5, 2.5))  # (3.0, 0.0)

# Time conversion: seconds to hours, minutes, seconds
def format_time(total_seconds):
    minutes, seconds = divmod(total_seconds, 60)
    hours, minutes = divmod(minutes, 60)
    return f"{hours:02d}:{minutes:02d}:{seconds:02d}"

print(format_time(3661))   # 01:01:01
print(format_time(7384))   # 02:03:04
print(format_time(90))     # 00:01:30

# Pagination
def paginate(total_items, per_page):
    full_pages, remaining = divmod(total_items, per_page)
    total_pages = full_pages + (1 if remaining else 0)
    return total_pages

print(paginate(100, 10))  # 10
print(paginate(101, 10))  # 11
print(paginate(95, 10))   # 10

# Base conversion (integer to any base)
def to_base(number, base):
    if number == 0:
        return "0"
    digits = []
    while number:
        number, remainder = divmod(number, base)
        digits.append(str(remainder))
    return "".join(reversed(digits))

print(to_base(255, 16))  # 'ff'... wait, need hex digits
print(to_base(42, 2))    # '101010'
print(to_base(100, 8))   # '144'

# Change-making
def make_change(cents):
    denominations = [25, 10, 5, 1]
    result = {}
    for coin in denominations:
        count, cents = divmod(cents, coin)
        if count:
            result[coin] = count
    return result

print(make_change(87))  # {25: 3, 10: 1, 1: 2}

(3, 2)
(3, 1)
(3, 1)
(-4, 3)
(3.0, 0.0)
01:01:01
02:03:04
00:01:30
10
11
10
1515
101010
144
{25: 3, 10: 1, 1: 2}

Key Points

•divmod(a, b) returns (a // b, a % b) in one call
•More efficient than separate // and % operations
•Perfect for time conversions, pagination, and base conversion
•Works with both integers and floats
•Follows Python's floor division rules for negative numbers

Gotchas

•divmod(-17, 5) gives (-4, 3), not (-3, -2) -- follows floor division
•divmod(a, 0) raises ZeroDivisionError
•divmod with floats can have precision issues
•divmod is slightly faster than separate // and % but the difference is negligible for single calls

divmod(a, b) returns (a // b, a % b) as a tuple. Useful for time conversions, pagination, and base conversion. More efficient than computing quotient and remainder separately.

•Returns (quotient, remainder) tuple
•Efficient for time/pagination calculations

print(divmod(17, 5))  # (3, 2)

# Time conversion
minutes, seconds = divmod(90, 60)
print(f"{minutes}m {seconds}s")  # 1m 30s

# Pagination
pages, remaining = divmod(101, 10)
print(pages + (1 if remaining else 0))  # 11

(3, 2)
1m 30s
11

Follows floor division for negatives: divmod(-17, 5) = (-4, 3)

Question 12 / 12

What are assignment operators in Python and how does unpacking assignment work?

Python provides several forms of assignment:

Simple assignment: x = 5

Augmented assignment: x += 5, x -= 3, x *= 2, etc.

Multiple assignment: a = b = c = 0 (all reference same object)

Tuple unpacking: a, b = 1, 2

Extended unpacking (*): first, *rest = [1, 2, 3, 4]

Walrus operator (:=): Assignment expression (Python 3.8+)

Unpacking is one of Python's most powerful features. It works with any iterable and supports a star * to capture remaining elements.

Rules for star unpacking:

Only one *variable per assignment
The starred variable gets a list (possibly empty)
Can appear anywhere: beginning, middle, or end

Pseudo Code

Simple: x = 5
Multiple: a = b = c = 0
Unpacking: a, b = 1, 2
Swap: a, b = b, a
Star: first, *rest = [1, 2, 3, 4]
Nested: (a, b), c = (1, 2), 3

Code

# Simple and multiple assignment
x = 5
a = b = c = 0
print(a, b, c)  # 0 0 0

# Tuple unpacking
a, b = 1, 2
print(a, b)  # 1 2

# Swap
a, b = b, a
print(a, b)  # 2 1

# Unpack from any iterable
a, b, c = [10, 20, 30]
print(a, b, c)  # 10 20 30

a, b, c = "abc"
print(a, b, c)  # a b c

a, b, c = range(3)
print(a, b, c)  # 0 1 2

# Extended unpacking with *
first, *rest = [1, 2, 3, 4, 5]
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

*init, last = [1, 2, 3, 4, 5]
print(init)   # [1, 2, 3, 4]
print(last)   # 5

first, *middle, last = [1, 2, 3, 4, 5]
print(first)   # 1
print(middle)  # [2, 3, 4]
print(last)    # 5

# Star with only one element
a, *b = [1]
print(a)  # 1
print(b)  # [] (empty list)

# Nested unpacking
(a, b), (c, d) = (1, 2), (3, 4)
print(a, b, c, d)  # 1 2 3 4

(a, b), c = [1, 2], 3
print(a, b, c)  # 1 2 3

# Practical: iterating with unpacking
coordinates = [(1, 2), (3, 4), (5, 6)]
for x, y in coordinates:
    print(f"x={x}, y={y}")

# Ignore values with _
first, _, _, last = [1, 2, 3, 4]
print(first, last)  # 1 4

_, *_, last = [1, 2, 3, 4, 5]
print(last)  # 5

# Unpack dict items
user = {"name": "Alice", "age": 30}
for key, value in user.items():
    print(f"{key}: {value}")

0 0 0
1 2
2 1
10 20 30
a b c
0 1 2
1
[2, 3, 4, 5]
[1, 2, 3, 4]
5
1
[2, 3, 4]
5
1
[]
1 2 3 4
1 2 3
x=1, y=2
x=3, y=4
x=5, y=6
1 4
5
name: Alice
age: 30

Key Points

•Tuple unpacking: a, b = 1, 2
•Star unpacking: first, *rest = iterable
•Swap without temp: a, b = b, a
•Works with any iterable (list, str, range, etc.)
•Use _ to ignore unwanted values

Gotchas

•a = b = [] makes both reference the SAME list
•Only one starred variable per assignment allowed
•ValueError if the number of values does not match the number of targets (without star)
•_ is a valid variable name and can be overwritten -- it's just a convention for 'ignored'

Python supports simple (x = 5), multiple (a = b = 0), unpacking (a, b = 1, 2), and star unpacking (first, *rest = [1,2,3]). Swap with a, b = b, a. Use _ for ignored values.

•Unpacking works with any iterable
•Star captures remaining items as a list

a, b = 1, 2
a, b = b, a          # swap
first, *rest = [1, 2, 3, 4]
print(first)         # 1
print(rest)          # [2, 3, 4]

1
[2, 3, 4]

a = b = [] makes both names reference the SAME list

Built by onllm.dev

Home GitHub Support awesomePrep