← Control Flow

Select a question from the sidebar

15 questions in this topic

Question 1 / 15

How do if/elif/else statements work in Python?

Python's conditional statement uses if, elif (else if), and else:

if condition1:
    # runs if condition1 is truthy
elif condition2:
    # runs if condition1 is falsy and condition2 is truthy
else:
    # runs if all conditions are falsy

Key rules:

if is required; elif and else are optional
You can have any number of elif blocks
Only the first matching branch executes (top-down)
There is no switch statement in Python < 3.10 (use match in 3.10+)
Python uses indentation (not braces) to define blocks
The condition can be any expression; Python evaluates its truthiness

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

Pseudo Code

if condition:
    action_a
elif other_condition:
    action_b
else:
    action_c

- Only one branch executes
- Top-down evaluation, first True wins
- else catches everything remaining

Code

# Basic if/elif/else
score = 85

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print(f"Score: {score}, Grade: {grade}")  # Score: 85, Grade: B

# Truthiness in conditions
name = ""
if name:
    print(f"Hello, {name}")
else:
    print("Name is empty")  # This runs

# Multiple conditions with logical operators
age = 25
has_license = True

if age >= 18 and has_license:
    print("Can drive")
elif age >= 18:
    print("Old enough but no license")
else:
    print("Too young")

# Nested if (sometimes better as elif)
x = 10
if x > 0:
    if x > 100:
        print("Large positive")
    else:
        print("Small positive")  # This runs
else:
    print("Non-positive")

# if without else
temperature = 100
if temperature > 95:
    print("Warning: high temperature!")  # This runs

# Checking multiple values
color = "red"
if color in ("red", "orange", "yellow"):
    print("Warm color")
elif color in ("blue", "green", "purple"):
    print("Cool color")
else:
    print("Unknown color")

Score: 85, Grade: B
Name is empty
Can drive
Small positive
Warning: high temperature!
Warm color

Key Points

•Only the first matching branch executes (top-down)
•elif and else are optional
•Any expression can be a condition (truthiness is evaluated)
•Python uses indentation to define blocks, not braces
•Use 'in' for checking membership instead of chained 'or'

Gotchas

•if x = 5 is a SyntaxError -- use == for comparison, not =
•if x == True is redundant and sometimes wrong -- just use if x
•An empty if block requires pass as a placeholder
•Order matters: if score >= 70 before score >= 80 would give wrong grade

Python uses if/elif/else for branching. Only the first matching branch runs. Conditions evaluate truthiness. Use indentation for blocks.

•First matching branch wins
•elif and else are optional

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C or below"
print(grade)  # B

Order of elif matters -- check most specific conditions first

Question 2 / 15

How do for loops work in Python and what makes them different from C-style loops?

Python's for loop iterates over any iterable (list, tuple, string, dict, set, file, generator, etc.). It does NOT use index-based counting like C/Java.

for item in iterable:
    # use item

Internally, Python calls iter() on the iterable to get an iterator, then calls next() repeatedly until StopIteration is raised.

Key differences from C-style loops:

No index variable needed
Iterates over values, not indices
Works with any iterable, not just arrays
Use enumerate() when you need both index and value
Use range() when you need a counting loop

Loop variable scope: The loop variable persists after the loop ends with the last value.

Pseudo Code

for item in iterable:
    process(item)

Equivalent to:
  iterator = iter(iterable)
  while True:
      try:
          item = next(iterator)
          process(item)
      except StopIteration:
          break

Code

# Iterate over a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
# apple, banana, cherry

# Iterate over a string
for char in "hello":
    print(char, end=" ")
print()  # h e l l o

# Iterate over a dict (keys by default)
user = {"name": "Alice", "age": 30}
for key in user:
    print(f"{key}: {user[key]}")

# Iterate over dict items (key-value pairs)
for key, value in user.items():
    print(f"{key}: {value}")

# Iterate with index using enumerate()
colors = ["red", "green", "blue"]
for i, color in enumerate(colors):
    print(f"{i}: {color}")
# 0: red, 1: green, 2: blue

# Custom start index
for i, color in enumerate(colors, start=1):
    print(f"{i}: {color}")
# 1: red, 2: green, 3: blue

# Counting loop with range()
for i in range(5):
    print(i, end=" ")
print()  # 0 1 2 3 4

# range with start, stop, step
for i in range(2, 10, 3):
    print(i, end=" ")
print()  # 2 5 8

# Reverse iteration
for i in range(5, 0, -1):
    print(i, end=" ")
print()  # 5 4 3 2 1

# Loop variable persists after loop
for x in [1, 2, 3]:
    pass
print(x)  # 3 (last value)

# Iterating over multiple lists with zip()
names = ["Alice", "Bob", "Charlie"]
ages = [30, 25, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age}")

apple
banana
cherry
h e l l o
name: Alice
age: 30
name: Alice
age: 30
0: red
1: green
2: blue
1: red
2: green
3: blue
0 1 2 3 4
2 5 8
5 4 3 2 1
3
Alice is 30
Bob is 25
Charlie is 35

Key Points

•For loops iterate over any iterable, not indices
•Use enumerate() for index + value
•Use range() for counting loops
•Use zip() to iterate over multiple iterables in parallel
•Loop variable persists after the loop with the last value

Gotchas

•Modifying a list while iterating over it can skip elements or cause errors
•The loop variable leaks into the enclosing scope
•for i in range(len(lst)) is un-Pythonic -- use enumerate() instead
•Iterating over a dict gives keys, not key-value pairs -- use .items()

Python's for loop iterates over any iterable (list, str, dict, etc.). Use enumerate() for index+value, range() for counting, zip() for parallel iteration.

•Iterates over values, not indices
•Use enumerate() when you need the index

for fruit in ["apple", "banana"]:
    print(fruit)

for i, val in enumerate(["a", "b", "c"]):
    print(i, val)

for i in range(5):
    print(i, end=" ")  # 0 1 2 3 4

apple
banana
0 a
1 b
2 c
0 1 2 3 4

Do not modify a list while iterating over it

Question 3 / 15

How do while loops work in Python and when should you use them instead of for loops?

A while loop repeats as long as a condition is truthy:

while condition:
    body

When to use while vs for:

Use for when iterating over a known collection or range
Use while when the number of iterations is unknown (e.g., reading input until sentinel, converging algorithms, polling)

Common patterns:

Sentinel loop: while (line := input()) != 'quit':
Flag loop: while not done:
Infinite loop with break: while True: ... break
Counter loop: while count > 0: (usually for is better)
Convergence: while abs(diff) > tolerance:

Pseudo Code

while condition:
    body
    # condition re-evaluated each iteration

while True:
    data = get_input()
    if data == sentinel:
        break
    process(data)

Code

# Basic while loop
count = 5
while count > 0:
    print(count, end=" ")
    count -= 1
print()  # 5 4 3 2 1

# While with unknown iterations
import random
random.seed(42)
attempts = 0
target = 7
while True:
    guess = random.randint(1, 10)
    attempts += 1
    if guess == target:
        break
print(f"Found {target} after {attempts} attempts")

# While with else clause
n = 10
while n > 0:
    if n == 5:
        print("Found 5, breaking")
        break
    n -= 1
else:
    print("Loop completed without break")  # does not run

# Convergence example: Newton's method for sqrt
def newton_sqrt(n, tolerance=1e-10):
    guess = n / 2.0
    while True:
        new_guess = (guess + n / guess) / 2
        if abs(new_guess - guess) < tolerance:
            return new_guess
        guess = new_guess

print(newton_sqrt(25))  # 5.0
print(newton_sqrt(2))   # 1.4142135623730951

# Processing a stack/queue
stack = [1, 2, 3, 4, 5]
while stack:
    item = stack.pop()
    print(item, end=" ")
print()  # 5 4 3 2 1

# Two-pointer pattern
def is_palindrome(s):
    left, right = 0, len(s) - 1
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1
        right -= 1
    return True

print(is_palindrome("racecar"))  # True
print(is_palindrome("hello"))   # False

5 4 3 2 1
Found 7 after 11 attempts
Found 5, breaking
5.0
1.414213562373095
5 4 3 2 1
True
False

Key Points

•while loops repeat as long as condition is truthy
•Use while when number of iterations is unknown
•while True + break is a common pattern for input loops
•Condition is re-evaluated at the start of each iteration
•while can have an else clause (runs if no break)

Gotchas

•Forgetting to update the loop variable creates an infinite loop
•while lst: is idiomatic but modifying lst during iteration can cause issues
•while True without a break creates an infinite loop
•while condition vs if condition: while re-checks, if checks once

while loops repeat as long as the condition is truthy. Use while when the number of iterations is unknown. while True + break is a common pattern.

•Use while when iterations are unknown
•while True + break is a common pattern

count = 3
while count > 0:
    print(count)
    count -= 1
# 3, 2, 1

while True:
    data = input("Enter (q to quit): ")
    if data == "q":
        break

3
2
1
Enter (q to quit):

Forgetting to update the loop variable causes infinite loops

Question 4 / 15

What do break, continue, and pass do in Python?

break: Immediately exits the innermost loop. Skips the else clause of the loop.

continue: Skips the rest of the current iteration and jumps to the next iteration of the innermost loop.

pass: Does nothing. A no-op placeholder used where a statement is syntactically required but no action is needed.

Key differences:

break exits the loop entirely
continue skips to the next iteration
pass does nothing (the loop continues normally)

In nested loops: break and continue only affect the innermost loop. To break out of multiple loops, use a flag variable, a function with return, or restructure with exceptions.

Pseudo Code

break: exit loop immediately, skip else clause
continue: skip rest of this iteration, go to next
pass: do nothing, placeholder

for item in items:
    if should_skip(item):
        continue      # skip to next item
    if should_stop(item):
        break         # exit loop
    process(item)

Code

# break -- exit the loop
for i in range(10):
    if i == 5:
        break
    print(i, end=" ")
print()  # 0 1 2 3 4

# continue -- skip to next iteration
for i in range(10):
    if i % 2 == 0:
        continue  # skip even numbers
    print(i, end=" ")
print()  # 1 3 5 7 9

# pass -- do nothing placeholder
for i in range(5):
    if i == 3:
        pass  # TODO: handle this case later
    print(i, end=" ")
print()  # 0 1 2 3 4 (pass does nothing)

# pass in empty class/function definition
class NotImplementedYet:
    pass

def future_feature():
    pass

# break only affects innermost loop
for i in range(3):
    for j in range(3):
        if j == 1:
            break  # only breaks inner loop
        print(f"({i},{j})", end=" ")
    print()  # inner loop restarted for each i
# (0,0) (1,0) (2,0)

# break + else: finding an element
def find_first_negative(numbers):
    for n in numbers:
        if n < 0:
            print(f"Found negative: {n}")
            break
    else:
        print("No negatives found")

find_first_negative([1, 2, -3, 4])   # Found negative: -3
find_first_negative([1, 2, 3, 4])    # No negatives found

# Practical: skip invalid data with continue
raw_data = ["42", "hello", "17", "", "99", "world"]
numbers = []
for item in raw_data:
    if not item.isdigit():
        continue
    numbers.append(int(item))
print(numbers)  # [42, 17, 99]

# Breaking out of nested loops with function
def find_in_matrix(matrix, target):
    for i, row in enumerate(matrix):
        for j, val in enumerate(row):
            if val == target:
                return (i, j)
    return None

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(find_in_matrix(matrix, 5))  # (1, 1)

0 1 2 3 4
1 3 5 7 9
0 1 2 3 4
(0,0)
(1,0)
(2,0)
Found negative: -3
No negatives found
[42, 17, 99]
(1, 1)

Key Points

•break exits the innermost loop entirely
•continue skips to the next iteration
•pass is a no-op placeholder
•break skips the loop's else clause
•break/continue only affect the innermost loop

Gotchas

•break/continue only affect the innermost loop in nested loops
•Using continue in a while loop: make sure the loop variable is updated before continue
•pass and continue are different: pass continues executing the rest of the loop body
•There is no 'goto' in Python -- use functions or exceptions for multi-level breaks

break exits the loop. continue skips to the next iteration. pass does nothing (placeholder). All three only affect the innermost loop.

•break = exit loop, continue = skip iteration, pass = do nothing
•Only affect innermost loop

for i in range(10):
    if i == 5:
        break      # exits: prints 0-4
    if i % 2 == 0:
        continue   # skips even
    print(i, end=" ")  # 1 3

1 3

In while loops, make sure to update the counter before continue

Question 5 / 15

How do range(), enumerate(), and zip() work and when should you use each?

range(start, stop, step): Generates a sequence of integers. Lazy (does not store all values in memory).

range(5) -> 0, 1, 2, 3, 4
range(2, 8) -> 2, 3, 4, 5, 6, 7
range(0, 10, 2) -> 0, 2, 4, 6, 8

enumerate(iterable, start=0): Yields (index, value) pairs. Use when you need both index and value.

zip(*iterables): Pairs up elements from multiple iterables. Stops at the shortest iterable.

zip_longest(*iterables, fillvalue=None): From itertools, pads shorter iterables.

These three functions are the building blocks of Pythonic iteration. Using them avoids range(len(...)) antipatterns.

Pseudo Code

range(n): 0, 1, ..., n-1
range(a, b): a, a+1, ..., b-1
range(a, b, s): a, a+s, a+2s, ... (while < b)

enumerate(iterable): (0, item0), (1, item1), ...
enumerate(iterable, start=1): (1, item0), (2, item1), ...

zip(a, b): (a[0], b[0]), (a[1], b[1]), ... (stops at shortest)
zip(*matrix): transpose

Code

# range() basics
print(list(range(5)))         # [0, 1, 2, 3, 4]
print(list(range(2, 8)))      # [2, 3, 4, 5, 6, 7]
print(list(range(0, 10, 2)))  # [0, 2, 4, 6, 8]
print(list(range(10, 0, -1))) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# range is lazy (memory efficient)
r = range(1_000_000)
print(999_999 in r)   # True (uses __contains__, not iteration)
print(r[500_000])     # 500000 (supports indexing)
print(len(r))         # 1000000

# enumerate() -- index + value
fruits = ["apple", "banana", "cherry"]
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")
# 0: apple, 1: banana, 2: cherry

# enumerate with custom start
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}. {fruit}")
# 1. apple, 2. banana, 3. cherry

# zip() -- parallel iteration
names = ["Alice", "Bob", "Charlie"]
scores = [95, 87, 92]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# zip stops at the shortest
short = [1, 2]
long = [10, 20, 30]
print(list(zip(short, long)))  # [(1, 10), (2, 20)]

# zip_longest for padding
from itertools import zip_longest
print(list(zip_longest(short, long, fillvalue=0)))  # [(1, 10), (2, 20), (0, 30)]

# zip to create dicts
keys = ["name", "age", "city"]
values = ["Alice", 30, "NYC"]
person = dict(zip(keys, values))
print(person)  # {'name': 'Alice', 'age': 30, 'city': 'NYC'}

# zip to transpose a matrix
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = list(zip(*matrix))
print(transposed)  # [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

# Unzip with zip(*)
pairs = [(1, "a"), (2, "b"), (3, "c")]
nums, letters = zip(*pairs)
print(nums)     # (1, 2, 3)
print(letters)  # ('a', 'b', 'c')

# Anti-pattern vs Pythonic
# BAD: for i in range(len(fruits)):
#          print(fruits[i])
# GOOD: for fruit in fruits:
#           print(fruit)
# GOOD: for i, fruit in enumerate(fruits):
#           print(i, fruit)

[0, 1, 2, 3, 4]
[2, 3, 4, 5, 6, 7]
[0, 2, 4, 6, 8]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
True
500000
1000000
0: apple
1: banana
2: cherry
1. apple
2. banana
3. cherry
Alice: 95
Bob: 87
Charlie: 92
[(1, 10), (2, 20)]
[(1, 10), (2, 20), (0, 30)]
{'name': 'Alice', 'age': 30, 'city': 'NYC'}
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
(1, 2, 3)
('a', 'b', 'c')

Key Points

•range() is lazy and supports membership testing and indexing
•enumerate() gives (index, value) pairs -- avoid range(len(...))
•zip() pairs elements from multiple iterables, stops at shortest
•zip(*matrix) transposes a matrix
•dict(zip(keys, values)) creates a dict from two lists

Gotchas

•range(5) does not include 5 -- it's [0, 5)
•zip() silently truncates to the shortest iterable -- use zip_longest if needed
•range() returns a range object, not a list -- use list(range(...)) to get a list
•enumerate() returns an iterator -- it's exhausted after one pass

range(n) generates 0 to n-1. enumerate(iterable) gives (index, value) pairs. zip(a, b) pairs elements from multiple iterables. All three are lazy (memory efficient).

•range for counting, enumerate for index+value, zip for parallel
•All are lazy iterators

for i in range(3):           # 0, 1, 2
    print(i)
for i, v in enumerate(["a","b"]):  # (0,'a'), (1,'b')
    print(i, v)
for a, b in zip([1,2], [3,4]):     # (1,3), (2,4)
    print(a, b)

zip stops at the shortest iterable

Question 6 / 15

What is the ternary conditional expression in Python?

Python's ternary expression (conditional expression) has the syntax:

value_if_true if condition else value_if_false

This is different from most languages which use condition ? true_val : false_val.

Key properties:

It is an expression, not a statement (returns a value)
Short-circuits: only the selected branch is evaluated
Can be nested (but should not be for readability)
Can be used in assignments, function calls, list comprehensions, etc.

When to use:

Simple value selection based on a condition
Inline in assignments or return statements
Inside comprehensions and f-strings

When NOT to use:

Complex logic with multiple branches (use if/elif/else)
When it hurts readability (nested ternaries are hard to read)

Pseudo Code

result = value_if_true if condition else value_if_false

Equivalent to:
  if condition:
      result = value_if_true
  else:
      result = value_if_false

Code

# Basic ternary
age = 20
status = "adult" if age >= 18 else "minor"
print(status)  # adult

# In a function return
def abs_value(n):
    return n if n >= 0 else -n

print(abs_value(-5))  # 5
print(abs_value(3))   # 3

# In an f-string
count = 1
print(f"Found {count} item{'s' if count != 1 else ''}")  # Found 1 item
count = 5
print(f"Found {count} item{'s' if count != 1 else ''}")  # Found 5 items

# In a list comprehension
numbers = [1, -2, 3, -4, 5]
absolutes = [x if x >= 0 else -x for x in numbers]
print(absolutes)  # [1, 2, 3, 4, 5]

# Short-circuit: only one branch is evaluated
def expensive_a():
    print("computing a")
    return "A"

def expensive_b():
    print("computing b")
    return "B"

result = expensive_a() if True else expensive_b()
# Only prints "computing a"
print(result)  # A

# Nested ternary (avoid this -- hard to read)
x = 0
result = "positive" if x > 0 else "negative" if x < 0 else "zero"
print(result)  # zero

# Better: use if/elif/else for multi-branch
if x > 0:
    result = "positive"
elif x < 0:
    result = "negative"
else:
    result = "zero"

# Ternary in function arguments
print("yes" if True else "no")  # yes

# Ternary with assignment (common pattern)
default = "world"
name = input_name if (input_name := "") else default  # uses walrus operator

adult
5
3
Found 1 item
Found 5 items
[1, 2, 3, 4, 5]
computing a
A
zero
yes

Key Points

•Syntax: value_if_true if condition else value_if_false
•It is an expression that returns a value
•Short-circuits: only the chosen branch evaluates
•Perfect for simple value selection in assignments
•Avoid nested ternaries for readability

Gotchas

•Python's ternary reads differently from C/JS: value first, then condition
•Nested ternaries are hard to read -- prefer if/elif/else
•Ternary has very low precedence: x = 1 + (2 if True else 3) -- use parentheses
•Cannot use statements (print, assignments) inside ternary -- only expressions

Python's ternary: value_if_true if condition else value_if_false. Returns a value, short-circuits. Use for simple value selection, avoid nesting.

•Syntax: true_val if condition else false_val
•It's an expression that returns a value

status = "adult" if age >= 18 else "minor"

# In list comprehension
result = [x if x > 0 else 0 for x in [-1, 2, -3, 4]]
print(result)  # [0, 2, 0, 4]

Reads value-first, unlike C's condition ? true : false

Question 7 / 15

How does the match/case statement work in Python 3.10+?

Python 3.10 introduced structural pattern matching with match/case (PEP 634). It is far more powerful than a simple switch statement.

Pattern types:

Literal patterns: Match specific values
Capture patterns: Bind to a variable
Wildcard pattern: _ matches anything (discards value)
Sequence patterns: [a, b, *rest] matches sequences
Mapping patterns: {"key": value} matches dicts
Class patterns: Point(x=0, y=0) matches objects
OR patterns: pattern1 | pattern2
Guard clauses: case x if x > 0:

Patterns are checked top-down; the first match wins. The _ wildcard is the catch-all (like default in switch).

Pseudo Code

match subject:
    case pattern1:
        action1
    case pattern2 if guard:
        action2
    case _:
        default_action

Patterns: literal, capture, wildcard, sequence, mapping, class, OR, guard

Code

# Literal pattern matching
def http_status(status):
    match status:
        case 200:
            return "OK"
        case 301:
            return "Moved Permanently"
        case 404:
            return "Not Found"
        case 500:
            return "Internal Server Error"
        case _:
            return "Unknown"

print(http_status(200))  # OK
print(http_status(404))  # Not Found
print(http_status(999))  # Unknown

# OR patterns
def categorize_status(status):
    match status:
        case 200 | 201 | 204:
            return "Success"
        case 301 | 302:
            return "Redirect"
        case 400 | 401 | 403 | 404:
            return "Client Error"
        case 500 | 502 | 503:
            return "Server Error"
        case _:
            return "Unknown"

print(categorize_status(201))  # Success

# Sequence pattern matching
def process_command(command):
    match command.split():
        case ["quit"]:
            return "Quitting"
        case ["go", direction]:
            return f"Going {direction}"
        case ["get", item, "from", location]:
            return f"Getting {item} from {location}"
        case ["say", *words]:
            return f"Saying: {' '.join(words)}"
        case _:
            return "Unknown command"

print(process_command("quit"))                     # Quitting
print(process_command("go north"))                 # Going north
print(process_command("get sword from chest"))     # Getting sword from chest
print(process_command("say hello world"))          # Saying: hello world

# Mapping pattern matching
def process_event(event):
    match event:
        case {"type": "click", "button": button}:
            return f"Clicked {button} button"
        case {"type": "keypress", "key": key}:
            return f"Pressed {key}"
        case {"type": "scroll", "direction": direction}:
            return f"Scrolled {direction}"
        case _:
            return "Unknown event"

print(process_event({"type": "click", "button": "left", "x": 100}))
# Clicked left button (extra keys are ignored)

# Guard clauses
def classify_number(n):
    match n:
        case n if n < 0:
            return "negative"
        case 0:
            return "zero"
        case n if n < 100:
            return "small positive"
        case _:
            return "large positive"

print(classify_number(-5))   # negative
print(classify_number(0))    # zero
print(classify_number(42))   # small positive
print(classify_number(500))  # large positive

OK
Not Found
Unknown
Success
Quitting
Going north
Getting sword from chest
Saying: hello world
Clicked left button
negative
zero
small positive
large positive

Key Points

•match/case uses structural pattern matching (not just value comparison)
•_ is the wildcard catch-all pattern
•OR patterns use | (pipe)
•Sequence patterns can capture with * for variable length
•Guard clauses add conditions with 'if'

Gotchas

•match/case requires Python 3.10+ -- not available in earlier versions
•case variable: captures any value into variable -- it does NOT compare to existing variable
•To match against a constant variable, use dotted names: case Status.OK:
•Mapping patterns ignore extra keys -- {'key': val} matches {'key': 1, 'extra': 2}

Python 3.10+ match/case provides structural pattern matching. Supports literals, sequences, mappings, OR patterns (|), guards (if), and wildcards (_). Much more powerful than a switch statement.

•Structural pattern matching, not just value comparison
•Requires Python 3.10+

def handle(command):
    match command.split():
        case ["go", direction]:
            return f"Going {direction}"
        case ["quit"]:
            return "Bye"
        case _:
            return "Unknown"

print(handle("go north"))  # Going north

Going north

case var: captures any value -- does NOT compare to existing variable 'var'

Question 8 / 15

What is the else clause on loops (for/while...else) and when is it useful?

In Python, both for and while loops can have an else clause. The else block runs only if the loop completed normally (was NOT terminated by break).

Think of it as: "if no break occurred."

When else runs:

Loop finishes all iterations naturally
Loop condition becomes False (for while)
Loop iterable is exhausted (for for)
Loop body never executes (empty iterable or False condition)

When else does NOT run:

break is executed

Common use case: Searching for an item -- the else handles the "not found" case.

The name else is widely considered confusing. Many Python developers think nobreak would have been a better keyword.

Pseudo Code

for item in collection:
    if found(item):
        break       # else does NOT run
else:
    not_found()     # runs only if no break

# Equivalent without for/else:
found_flag = False
for item in collection:
    if found(item):
        found_flag = True
        break
if not found_flag:
    not_found()

Code

# for...else: search pattern
def find_prime_factor(n):
    for i in range(2, n):
        if n % i == 0:
            print(f"{n} has factor {i}")
            break
    else:
        print(f"{n} is prime")  # runs if no break (no factor found)

find_prime_factor(7)    # 7 is prime
find_prime_factor(12)   # 12 has factor 2
find_prime_factor(97)   # 97 is prime

# while...else
def search_list(lst, target):
    index = 0
    while index < len(lst):
        if lst[index] == target:
            print(f"Found {target} at index {index}")
            break
        index += 1
    else:
        print(f"{target} not found")  # runs if while condition became False

search_list([10, 20, 30], 20)  # Found 20 at index 1
search_list([10, 20, 30], 99)  # 99 not found

# else runs even if loop body never executes
for item in []:
    print("never runs")
else:
    print("else runs!")  # prints: else runs!

# Practical: checking if all elements satisfy a condition
def all_positive(numbers):
    for n in numbers:
        if n <= 0:
            print(f"Found non-positive: {n}")
            break
    else:
        print("All numbers are positive")

all_positive([1, 2, 3])     # All numbers are positive
all_positive([1, -2, 3])    # Found non-positive: -2

# Nested loop with else
def find_in_matrix(matrix, target):
    for i, row in enumerate(matrix):
        for j, val in enumerate(row):
            if val == target:
                print(f"Found at ({i}, {j})")
                break
        else:
            continue  # inner loop did not break, continue outer
        break  # inner loop broke, break outer too
    else:
        print("Not found")

find_in_matrix([[1,2],[3,4],[5,6]], 4)   # Found at (1, 1)
find_in_matrix([[1,2],[3,4],[5,6]], 99)  # Not found

7 is prime
12 has factor 2
97 is prime
Found 20 at index 1
99 not found
else runs!
All numbers are positive
Found non-positive: -2
Found at (1, 1)
Not found

Key Points

•else on a loop runs only if the loop was NOT terminated by break
•Think of it as 'nobreak' rather than 'else'
•Useful for search patterns: 'not found' handling
•else runs even if the loop body never executes (empty iterable)
•Works on both for and while loops

Gotchas

•The name 'else' is misleading -- it means 'if no break happened'
•else runs on empty iterables (for x in []: else: runs)
•else does NOT run if an exception occurs inside the loop
•Many Python developers avoid this feature due to its confusing semantics

The else clause on a loop runs only if no break occurred. Think of it as "nobreak". Useful for search patterns where you need to handle the "not found" case.

•else runs only if no break occurred
•Think of it as 'nobreak'

for n in [2, 3, 5, 7]:
    if n % 2 == 0:
        print(f"Found even: {n}")
        break
else:
    print("No even found")
# Output: Found even: 2 (else does NOT run)

else runs even for empty iterables -- the loop 'completed' trivially

Question 9 / 15

How do nested loops work and what are common patterns for working with them?

Nested loops are loops within loops. The inner loop completes all its iterations for each iteration of the outer loop.

Common patterns:

Matrix/grid traversal: Iterating over rows and columns
Cartesian product: All combinations of two sequences
Triangle patterns: Inner loop depends on outer variable
Finding pairs: All pairs from a collection

Performance: Nested loops multiply iteration counts. Two loops of n iterations each give n^2 iterations. Be cautious with large datasets.

Breaking out of nested loops:

Use a function with return
Use a flag variable
Use itertools.product() for Cartesian product
Use the for/else + continue/break pattern

Pseudo Code

Outer loop: n iterations
  Inner loop: m iterations
  Total iterations: n * m

Patterns:
  Grid: for row in range(R): for col in range(C):
  Pairs: for i in range(n): for j in range(i+1, n):
  Product: itertools.product(a, b)

Code

# Matrix traversal
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

for row in matrix:
    for val in row:
        print(val, end=" ")
    print()
# 1 2 3
# 4 5 6
# 7 8 9

# With indices
for i in range(len(matrix)):
    for j in range(len(matrix[i])):
        print(f"({i},{j})={matrix[i][j]}", end="  ")
    print()

# All pairs from a list
numbers = [1, 2, 3, 4]
for i in range(len(numbers)):
    for j in range(i + 1, len(numbers)):
        print(f"({numbers[i]}, {numbers[j]})", end=" ")
print()
# (1,2) (1,3) (1,4) (2,3) (2,4) (3,4)

# Multiplication table
for i in range(1, 6):
    for j in range(1, 6):
        print(f"{i*j:3}", end="")
    print()

# itertools.product -- cleaner Cartesian product
from itertools import product

colors = ["red", "blue"]
sizes = ["S", "M", "L"]
for color, size in product(colors, sizes):
    print(f"{color}-{size}", end=" ")
print()
# red-S red-M red-L blue-S blue-M blue-L

# Breaking out of nested loops with a function
def find_target(matrix, target):
    for i, row in enumerate(matrix):
        for j, val in enumerate(row):
            if val == target:
                return (i, j)
    return None

result = find_target(matrix, 5)
print(result)  # (1, 1)

# Triangle pattern
n = 5
for i in range(1, n + 1):
    for j in range(i):
        print("*", end="")
    print()
# *
# **
# ***
# ****
# *****

# Flattening nested loops with comprehension
flat = [val for row in matrix for val in row]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

1 2 3
4 5 6
7 8 9
(0,0)=1  (0,1)=2  (0,2)=3
(1,0)=4  (1,1)=5  (1,2)=6
(2,0)=7  (2,1)=8  (2,2)=9
(1, 2) (1, 3) (1, 4) (2, 3) (2, 4) (3, 4)
1  2  3  4  5
2  4  6  8 10
3  6  9 12 15
4  8 12 16 20
5 10 15 20 25
red-S red-M red-L blue-S blue-M blue-L
(1, 1)
*
**
***
****
*****
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Key Points

•Inner loop fully executes for each outer iteration
•Use itertools.product() for cleaner Cartesian products
•Use a function + return to break out of nested loops
•Nested loops multiply iteration count: O(n * m)
•List comprehensions can replace simple nested loops

Gotchas

•break only exits the innermost loop
•Nested loops can be O(n^2) or worse -- watch performance
•In list comprehensions, the outer loop comes first: [x for row in matrix for x in row]
•Modifying a list while iterating over it in nested loops is especially dangerous

Nested loops: inner loop runs completely for each outer iteration. Use itertools.product() for Cartesian products. Use a function + return to break out of multiple levels.

•Inner loop fully executes per outer iteration
•Use itertools.product for Cartesian products

# Matrix traversal
for row in [[1,2],[3,4]]:
    for val in row:
        print(val, end=" ")
    print()
# 1 2
# 3 4

from itertools import product
for a, b in product("ab", "12"):
    print(f"{a}{b}", end=" ")  # a1 a2 b1 b2

1 2
3 4
a1 a2 b1 b2

break only exits the innermost loop

Question 10 / 15

How do you create and use infinite loops in Python?

An infinite loop runs forever until explicitly stopped with break, return, or an unhandled exception.

The standard pattern is while True: with a break condition inside.

Common use cases:

Interactive prompts: Keep asking for input until sentinel
Event loops: GUI, game loops, server request handlers
Retry logic: Keep trying until success or max attempts
Daemon processes: Background services
Menu systems: Display menu, process choice, repeat

Avoiding accidental infinite loops:

Always ensure a path to break or return
Update loop variables in while conditions
Use timeouts or max iteration limits
Ctrl+C sends KeyboardInterrupt to stop a stuck loop

Pseudo Code

while True:
    data = get_input()
    if exit_condition(data):
        break
    process(data)

while True:
    try:
        result = risky_operation()
        break  # success, exit loop
    except RetryableError:
        continue  # try again

Code

# Input loop with sentinel
while True:
    response = input("Enter command (quit to exit): ")
    if response.lower() == "quit":
        print("Goodbye!")
        break
    print(f"Processing: {response}")

# Retry with max attempts
import random

def unreliable_operation():
    if random.random() < 0.7:
        raise ConnectionError("Network error")
    return "Success!"

max_retries = 5
for attempt in range(1, max_retries + 1):
    try:
        result = unreliable_operation()
        print(f"Attempt {attempt}: {result}")
        break
    except ConnectionError as e:
        print(f"Attempt {attempt}: {e}")
        if attempt == max_retries:
            print("All retries exhausted")

# Menu system
def show_menu():
    menu = {
        "1": ("Add item", lambda: print("Adding...")),
        "2": ("List items", lambda: print("Listing...")),
        "3": ("Exit", None)
    }

    while True:
        print("\n--- Menu ---")
        for key, (label, _) in menu.items():
            print(f"  {key}. {label}")

        choice = input("Choose: ")
        if choice == "3":
            print("Exiting...")
            break
        elif choice in menu:
            _, action = menu[choice]
            if action:
                action()
        else:
            print("Invalid choice")

# Infinite generator
def counter(start=0):
    n = start
    while True:
        yield n
        n += 1

c = counter()
print(next(c))  # 0
print(next(c))  # 1
print(next(c))  # 2

# Using itertools for controlled infinite iteration
from itertools import islice, count

# Take first 5 from infinite counter
for n in islice(count(10), 5):
    print(n, end=" ")
print()  # 10 11 12 13 14

Enter command (quit to exit):

Key Points

•while True + break is the standard infinite loop pattern
•Always ensure a path to break/return
•Common for input loops, menus, retry logic, and generators
•Ctrl+C sends KeyboardInterrupt to stop a stuck loop
•Use itertools for controlled infinite sequences

Gotchas

•Forgetting the break condition creates a truly infinite loop
•In while loops, make sure continue does not skip the variable update
•Infinite generators are memory-efficient but must be consumed carefully
•time.sleep() in a loop prevents CPU spinning but slows responsiveness

while True: with break is the standard infinite loop pattern. Used for input loops, menus, retry logic, and event loops. Always ensure a path to break.

•while True + break is the standard pattern
•Always have a break condition

while True:
    cmd = input("Command (q=quit): ")
    if cmd == "q":
        break
    print(f"Running: {cmd}")

Command (q=quit):

Forgetting break creates a truly infinite loop -- use Ctrl+C to stop

Question 11 / 15

How does loop unpacking work in Python?

Loop unpacking (also called loop destructuring) lets you unpack each element of an iterable directly into multiple variables in the for statement.

When iterating over an iterable of tuples/lists, you can assign each element to a separate variable.

Works with:

for k, v in dict.items()
for i, val in enumerate(lst)
for a, b in zip(list1, list2)
for x, y, z in list_of_tuples
for first, *rest in nested_lists

You can also nest unpacking and use the star * operator for extended unpacking.

Pseudo Code

for a, b in [(1, 2), (3, 4)]:
    use a and b

for key, value in dict.items():
    use key and value

for first, *rest in [[1,2,3], [4,5,6]]:
    first is 1 or 4, rest is [2,3] or [5,6]

Code

# Basic tuple unpacking in loop
points = [(1, 2), (3, 4), (5, 6)]
for x, y in points:
    print(f"x={x}, y={y}")
# x=1, y=2 / x=3, y=4 / x=5, y=6

# Dict items unpacking
user = {"name": "Alice", "age": 30, "city": "NYC"}
for key, value in user.items():
    print(f"{key}: {value}")

# Enumerate unpacking
fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits, 1):
    print(f"{index}. {fruit}")

# Zip unpacking
names = ["Alice", "Bob"]
scores = [95, 87]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# Extended unpacking with *
data = [("Alice", 95, 87, 92), ("Bob", 80, 75, 88)]
for name, *grades in data:
    print(f"{name}: avg = {sum(grades)/len(grades):.1f}")
# Alice: avg = 91.3
# Bob: avg = 81.0

# Nested unpacking
nested = [((1, 2), "a"), ((3, 4), "b")]
for (x, y), label in nested:
    print(f"{label}: ({x}, {y})")
# a: (1, 2) / b: (3, 4)

# Ignoring values with _
records = [("Alice", 30, "NYC"), ("Bob", 25, "LA")]
for name, _, city in records:
    print(f"{name} from {city}")
# Alice from NYC / Bob from LA

# Unpacking in comprehension
pairs = [(1, "one"), (2, "two"), (3, "three")]
result = {num: word for num, word in pairs}
print(result)  # {1: 'one', 2: 'two', 3: 'three'}

# Real-world: CSV-like data
csv_data = [
    "Alice,30,NYC",
    "Bob,25,LA",
    "Charlie,35,Chicago"
]
for line in csv_data:
    name, age, city = line.split(",")
    print(f"{name} (age {age}) lives in {city}")

x=1, y=2
x=3, y=4
x=5, y=6
name: Alice
age: 30
city: NYC
1. apple
2. banana
3. cherry
Alice: 95
Bob: 87
Alice: avg = 91.3
Bob: avg = 81.0
a: (1, 2)
b: (3, 4)
Alice from NYC
Bob from LA
{1: 'one', 2: 'two', 3: 'three'}
Alice (age 30) lives in NYC
Bob (age 25) lives in LA
Charlie (age 35) lives in Chicago

Key Points

•Unpack tuples/lists directly in for statement
•Works with dict.items(), enumerate(), zip()
•Star unpacking (*rest) captures remaining elements
•Nested unpacking for complex structures
•Use _ to ignore unwanted values

Gotchas

•ValueError if the number of variables does not match tuple size
•_ is a valid variable -- it gets overwritten in each iteration
•Star unpacking always creates a list, even if empty
•Nested unpacking requires matching parentheses structure

Unpack each element directly in the for statement: for x, y in points:, for k, v in dict.items():. Use * for extended unpacking and _ to ignore values.

•Unpack directly in for statement
•Star * captures remaining elements

for k, v in {"a": 1, "b": 2}.items():
    print(k, v)

for name, *grades in [("Alice", 90, 85), ("Bob", 80, 75)]:
    print(name, sum(grades) / len(grades))

a 1
b 2
Alice 87.5
Bob 77.5

ValueError if tuple size does not match number of variables

Question 12 / 15

How does the 'pass' statement differ from Ellipsis (...) as a placeholder?

pass is a statement that does nothing. It is used as a placeholder where a statement is syntactically required.

... (Ellipsis) is a literal value (an object of type ellipsis). It was originally for NumPy slicing but is now commonly used as a placeholder in function bodies, especially with type stubs.

When to use pass:

Empty class bodies
Empty loop bodies
Empty except blocks (to silently ignore)
Any place requiring a statement but no action

When to use ... (Ellipsis):

Type stub files (.pyi)
Abstract method bodies (in conjunction with @abstractmethod)
As a sentinel value in function signatures
In Protocol definitions

Functionally, both work as placeholders. pass is the traditional choice; ... is gaining popularity in type-hinted code.

Pseudo Code

pass: explicit no-op statement
  - Traditional placeholder
  - Required where a statement is needed

...: Ellipsis literal object
  - Modern placeholder in type stubs
  - Also used in NumPy for advanced slicing
  - Used in Protocol definitions

Code

# pass as placeholder
class NotImplementedYet:
    pass

def future_feature():
    pass

for i in range(10):
    pass  # TODO: implement

try:
    risky_operation()
except Exception:
    pass  # silently ignore (usually bad practice)

# Ellipsis as placeholder
class MyProtocol:
    def method(self) -> None: ...

def stub_function() -> int: ...

# Ellipsis in type hints
from typing import Callable, Tuple

# Function that takes any arguments
handler: Callable[..., None]  # ... means any signature

# Variable-length homogeneous tuple
coords: Tuple[int, ...]  # any number of ints

# Ellipsis is an object
print(type(...))       # <class 'ellipsis'>
print(... is Ellipsis)  # True (singleton)
print(bool(...))       # True (truthy)

# Ellipsis in NumPy (advanced use)
import numpy as np
arr = np.zeros((2, 3, 4))
print(arr[..., 0].shape)  # (2, 3) -- select first element along last axis

# Both work as function body placeholders
def with_pass():
    pass

def with_ellipsis():
    ...

# Both return None
print(with_pass())      # None
print(with_ellipsis())  # None

# Convention: pass = "intentionally empty"
#             ... = "to be implemented" or "type stub"

<class 'ellipsis'>
True
True

Key Points

•pass is a no-op statement, ... is the Ellipsis literal object
•Both work as placeholders in function/class bodies
•pass is traditional; ... is modern/type-stub style
•Ellipsis is used in type hints: Callable[..., int], Tuple[int, ...]
•Ellipsis is a singleton: ... is Ellipsis

Gotchas

•pass can only be used as a statement; ... can be used as a value/expression
•Ellipsis in except blocks returns ... instead of None if it's the last expression
•An empty function body without pass or ... is a SyntaxError
•Using pass in except: to silently swallow exceptions is usually bad practice

pass is a no-op statement for empty blocks. ... (Ellipsis) is a literal object used as a modern placeholder (especially in type stubs). Both work as function body placeholders.

•pass = no-op statement, ... = Ellipsis object
•Both work as placeholders

# Traditional placeholder
def todo():
    pass

# Modern/type-stub style
def stub() -> int: ...

# Ellipsis in type hints
from typing import Callable
handler: Callable[..., None]  # any args, returns None

An empty function body without pass or ... is a SyntaxError

Question 13 / 15

How do you iterate over a dictionary in Python?

There are several ways to iterate over a dictionary:

for key in dict: -- iterates over keys (default)
for key in dict.keys(): -- explicitly iterates over keys
for value in dict.values(): -- iterates over values
for key, value in dict.items(): -- iterates over key-value pairs

Since Python 3.7, dictionaries maintain insertion order (this was an implementation detail in CPython 3.6 and became a language guarantee in 3.7).

Performance note: .keys(), .values(), and .items() return view objects, not lists. They are dynamic views that reflect changes to the dict. They are lightweight and memory-efficient.

Pseudo Code

for key in dict:           # keys only
for key in dict.keys():    # keys only (explicit)
for value in dict.values(): # values only
for key, value in dict.items(): # key-value pairs

All views are dynamic -- reflect dict changes
Dicts maintain insertion order (Python 3.7+)

Code

user = {"name": "Alice", "age": 30, "city": "NYC"}

# Iterate over keys (default)
for key in user:
    print(key, end=" ")
print()  # name age city

# Iterate over values
for value in user.values():
    print(value, end=" ")
print()  # Alice 30 NYC

# Iterate over key-value pairs
for key, value in user.items():
    print(f"{key}: {value}")
# name: Alice / age: 30 / city: NYC

# View objects are dynamic
keys_view = user.keys()
print(list(keys_view))  # ['name', 'age', 'city']

user["email"] = "alice@example.com"
print(list(keys_view))  # ['name', 'age', 'city', 'email'] -- view updated!

# Sorted iteration
for key in sorted(user):
    print(f"{key}: {user[key]}")

# Reverse iteration (Python 3.8+)
for key in reversed(user):
    print(key, end=" ")
print()

# Dict comprehension from iteration
scores = {"Alice": 95, "Bob": 87, "Charlie": 92}
high_scorers = {name: score for name, score in scores.items() if score >= 90}
print(high_scorers)  # {'Alice': 95, 'Charlie': 92}

# Common pattern: modify dict while iterating (use copy)
prices = {"apple": 1.0, "banana": 0.5, "cherry": 2.0}
# Cannot modify dict size during iteration
for item, price in list(prices.items()):  # list() creates a copy
    if price < 1.0:
        del prices[item]
print(prices)  # {'apple': 1.0, 'cherry': 2.0}

# Checking membership
print("name" in user)           # True (checks keys)
print("Alice" in user.values())  # True (checks values)

name age city
Alice 30 NYC
name: Alice
age: 30
city: NYC
['name', 'age', 'city']
['name', 'age', 'city', 'email']
age: 30
city: NYC
email: alice@example.com
name: Alice
email city age name
{'Alice': 95, 'Charlie': 92}
{'apple': 1.0, 'cherry': 2.0}
True
True

Key Points

•Default iteration is over keys
•.items() gives key-value pairs, .values() gives values
•Views are dynamic and memory-efficient
•Dicts maintain insertion order since Python 3.7
•Use list(dict.items()) to safely modify dict during iteration

Gotchas

•Modifying dict size during iteration raises RuntimeError -- iterate over a copy
•'in' on a dict checks keys, not values
•dict.keys() returns a view, not a list -- use list() if you need a list
•Iterating over a dict gives strings (keys), not tuples -- use .items() for pairs

Iterate keys with for k in d:, values with for v in d.values():, pairs with for k, v in d.items():. Dicts maintain insertion order (Python 3.7+). Views are dynamic.

•Default iteration = keys
•Use .items() for key-value pairs

d = {"a": 1, "b": 2}
for k, v in d.items():
    print(k, v)
# a 1
# b 2

# Modify during iteration: use list() copy
for k in list(d.keys()):
    if d[k] < 2:
        del d[k]

a 1
b 2

Cannot modify dict size during iteration without copying first

Question 14 / 15

What are some common loop patterns and anti-patterns in Python?

Anti-patterns (avoid these):

for i in range(len(lst)) -- use for item in lst or enumerate()
Manual index tracking -- use enumerate()
Building string with += in loop -- use join()
Checking existence before accessing -- use EAFP (try/except)
Nested loops for simple transforms -- use comprehensions

Pythonic patterns (use these):

enumerate() for index+value
zip() for parallel iteration
any()/all() for existence/universal checks
List comprehensions for simple transforms
itertools for complex iteration patterns
reversed() and sorted() for order control

Pseudo Code

Anti-patterns:
  for i in range(len(lst)):  -> for item in lst:
  for i in range(len(lst)):  -> for i, item in enumerate(lst):
  s = '' loop s += x         -> ''.join(items)
  found = False; for...      -> any(condition for x in items)

Good patterns:
  enumerate(), zip(), any(), all()
  list comprehensions
  itertools functions

Code

# ANTI-PATTERN: range(len(...))
fruits = ["apple", "banana", "cherry"]

# Bad
for i in range(len(fruits)):
    print(fruits[i])

# Good
for fruit in fruits:
    print(fruit)

# ANTI-PATTERN: manual index
# Bad
i = 0
for fruit in fruits:
    print(f"{i}: {fruit}")
    i += 1

# Good
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# ANTI-PATTERN: string concatenation in loop
words = ["hello", "world", "python"]

# Bad (creates many temporary strings)
result = ""
for word in words:
    result += word + " "

# Good
result = " ".join(words)
print(result)  # hello world python

# ANTI-PATTERN: flag variable for search
numbers = [1, 3, 5, 8, 9]

# Bad
found_even = False
for n in numbers:
    if n % 2 == 0:
        found_even = True
        break

# Good
found_even = any(n % 2 == 0 for n in numbers)
print(found_even)  # True

# ANTI-PATTERN: building list with append
# Bad
squares = []
for n in range(10):
    squares.append(n ** 2)

# Good
squares = [n ** 2 for n in range(10)]
print(squares)

# PATTERN: use zip for parallel lists
names = ["Alice", "Bob"]
scores = [95, 87]

# Bad
for i in range(len(names)):
    print(f"{names[i]}: {scores[i]}")

# Good
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# PATTERN: all() for universal check
def all_positive(numbers):
    return all(n > 0 for n in numbers)

print(all_positive([1, 2, 3]))   # True
print(all_positive([1, -2, 3]))  # False

# PATTERN: dict comprehension from two lists
keys = ["a", "b", "c"]
vals = [1, 2, 3]
result = dict(zip(keys, vals))
print(result)  # {'a': 1, 'b': 2, 'c': 3}

# PATTERN: itertools for complex iteration
from itertools import chain, groupby

# Flatten multiple lists
lists = [[1, 2], [3, 4], [5, 6]]
flat = list(chain.from_iterable(lists))
print(flat)  # [1, 2, 3, 4, 5, 6]

apple
banana
cherry
apple
banana
cherry
0: apple
1: banana
2: cherry
0: apple
1: banana
2: cherry
hello world python
True
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Alice: 95
Bob: 87
Alice: 95
Bob: 87
True
False
{'a': 1, 'b': 2, 'c': 3}
[1, 2, 3, 4, 5, 6]

Key Points

•Avoid range(len(...)) -- use direct iteration or enumerate()
•Use join() instead of += for string building
•Use any()/all() instead of flag variables
•Use comprehensions for simple transforms
•Use zip() for parallel iteration

Gotchas

•any() and all() short-circuit -- efficient for large iterables
•Comprehensions can be less readable when logic is complex -- use loops then
•join() only works on strings -- convert elements first: ' '.join(str(x) for x in nums)
•Modifying a list while iterating: iterate over a copy or build a new list

Avoid range(len(...)) (use enumerate), string += in loops (use join), and flag variables (use any()/all()). Prefer comprehensions, zip(), and itertools for Pythonic code.

•Use enumerate, zip, join, any/all, comprehensions
•Avoid range(len), manual counters, string += in loops

# Bad: range(len(...))
for i in range(len(lst)): print(lst[i])
# Good: direct or enumerate
for item in lst: print(item)
for i, item in enumerate(lst): print(i, item)

# Bad: += in loop. Good: join
result = " ".join(words)

# Bad: flag. Good: any()
has_even = any(n % 2 == 0 for n in numbers)

join() only works on strings -- convert non-strings first

Question 15 / 15

How do you iterate in reverse or sorted order in Python?

reversed(seq): Returns a reverse iterator over a sequence. Works with lists, tuples, strings, ranges, and any object with __reversed__ or __len__+__getitem__.

sorted(iterable, key=None, reverse=False): Returns a new sorted list. Works with any iterable. Does not modify the original.

list.sort(key=None, reverse=False): Sorts a list in-place. Returns None.

key parameter: A function applied to each element for comparison. Common keys: str.lower, len, lambda x: x[1].

Differences:

reversed() is O(1) memory, sorted() is O(n)
reversed() returns an iterator, sorted() returns a list
reversed() preserves the original, list.sort() modifies in-place

Pseudo Code

reversed(seq) -> iterator in reverse order
sorted(iterable) -> new sorted list
list.sort() -> sorts in-place, returns None

sorted(data, key=func) -> sort by func(element)
sorted(data, reverse=True) -> descending order

Code

# reversed() -- reverse iteration
for i in reversed([1, 2, 3, 4, 5]):
    print(i, end=" ")
print()  # 5 4 3 2 1

# reversed() with range
for i in reversed(range(5)):
    print(i, end=" ")
print()  # 4 3 2 1 0

# reversed() with string
for c in reversed("hello"):
    print(c, end="")
print()  # olleh

# sorted() -- returns a NEW sorted list
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(sorted(numbers))        # [1, 1, 2, 3, 4, 5, 6, 9]
print(numbers)                # [3, 1, 4, 1, 5, 9, 2, 6] -- original unchanged
print(sorted(numbers, reverse=True))  # [9, 6, 5, 4, 3, 2, 1, 1]

# sorted() with key function
words = ["banana", "apple", "cherry", "date"]
print(sorted(words))                    # ['apple', 'banana', 'cherry', 'date']
print(sorted(words, key=len))            # ['date', 'apple', 'banana', 'cherry']
print(sorted(words, key=str.lower))      # case-insensitive sort

# Sort complex objects by attribute
students = [
    {"name": "Charlie", "grade": 85},
    {"name": "Alice", "grade": 95},
    {"name": "Bob", "grade": 90}
]

by_grade = sorted(students, key=lambda s: s["grade"], reverse=True)
for s in by_grade:
    print(f"{s['name']}: {s['grade']}")
# Alice: 95 / Bob: 90 / Charlie: 85

# list.sort() -- in-place, returns None
nums = [3, 1, 4, 1, 5]
result = nums.sort()
print(result)  # None!
print(nums)    # [1, 1, 3, 4, 5]

# Sort by multiple criteria
from operator import itemgetter

data = [("Alice", 95), ("Bob", 87), ("Charlie", 95), ("David", 87)]
# Sort by grade desc, then name asc
result = sorted(data, key=lambda x: (-x[1], x[0]))
print(result)  # [('Alice', 95), ('Charlie', 95), ('Bob', 87), ('David', 87)]

# Stable sort: equal elements maintain relative order
# Python's sort is Timsort (stable)

# Iterate sorted dict by value
scores = {"Alice": 95, "Bob": 87, "Charlie": 92}
for name in sorted(scores, key=scores.get, reverse=True):
    print(f"{name}: {scores[name]}")
# Alice: 95 / Charlie: 92 / Bob: 87

5 4 3 2 1
4 3 2 1 0
olleh
[1, 1, 2, 3, 4, 5, 6, 9]
[3, 1, 4, 1, 5, 9, 2, 6]
[9, 6, 5, 4, 3, 2, 1, 1]
['apple', 'banana', 'cherry', 'date']
['date', 'apple', 'banana', 'cherry']
['apple', 'banana', 'cherry', 'date']
Alice: 95
Bob: 90
Charlie: 85
None
[1, 1, 3, 4, 5]
[('Alice', 95), ('Charlie', 95), ('Bob', 87), ('David', 87)]
Alice: 95
Charlie: 92
Bob: 87

Key Points

•reversed() returns an iterator, sorted() returns a new list
•sorted() accepts key and reverse parameters
•list.sort() modifies in-place and returns None
•Python's sort is stable (Timsort)
•Use lambda or operator.itemgetter for custom sort keys

Gotchas

•list.sort() returns None -- do not assign it: sorted_list = nums.sort() is a bug
•sorted() creates a new list (memory cost), list.sort() does not
•reversed() returns an iterator that can only be consumed once
•Sorting mixed types (int and str) raises TypeError in Python 3

reversed(seq) gives a reverse iterator. sorted(iterable) returns a new sorted list. list.sort() sorts in-place (returns None). Use key= for custom sort criteria.

•sorted() returns new list, list.sort() modifies in-place
•Use key= for custom sort criteria

print(sorted([3, 1, 4], reverse=True))  # [4, 3, 1]
print(sorted(["c", "a", "b"]))          # ['a', 'b', 'c']

for i in reversed(range(5)):
    print(i, end=" ")  # 4 3 2 1 0

[4, 3, 1]
['a', 'b', 'c']
4 3 2 1 0

list.sort() returns None -- do not assign its result

Built by onllm.dev

Home GitHub Support awesomePrep