Python Loops — Interview Questions¶

# for — iterates over items
for fruit in ["apple", "banana"]:
    print(fruit)

# while — repeats until condition fails
count = 0
while count < 3:
    print(count)
    count += 1

for i in range(10):
    if i == 3:
        continue  # skip 3
    if i == 7:
        break     # stop at 7
    print(i)
# Output: 0, 1, 2, 4, 5, 6

print(list(range(1, 10, 2)))  # [1, 3, 5, 7, 9]

# else runs because no break was triggered
for n in [2, 4, 6]:
    if n % 2 != 0:
        break
else:
    print("All even!")  # This prints

# else does NOT run because break was triggered
for n in [2, 3, 6]:
    if n % 2 != 0:
        break
else:
    print("All even!")  # This does NOT print

for i, color in enumerate(["red", "green", "blue"], start=1):
    print(i, color)
# 1 red, 2 green, 3 blue

names = ["Alice", "Bob"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(name, age)
# Alice 25, Bob 30  — "35" is dropped

numbers = [n for n in numbers if n % 2 != 0]

for n in numbers[:]:
    if n % 2 == 0:
        numbers.remove(n)

# Syntax: [expression for item in iterable if condition]
squares = [x ** 2 for x in range(10) if x % 2 == 0]
# [0, 4, 16, 36, 64]

# This:
for x in [1, 2, 3]:
    print(x)

# Is equivalent to:
it = iter([1, 2, 3])  # calls __iter__()
while True:
    try:
        x = next(it)  # calls __next__()
        print(x)
    except StopIteration:
        break

# List comprehension — all values in memory
squares = [x**2 for x in range(1_000_000)]  # ~8 MB

# Generator — lazy, one at a time
squares = (x**2 for x in range(1_000_000))  # ~200 bytes

# Bug: all functions return 4
funcs = [lambda: i for i in range(5)]
print([f() for f in funcs])  # [4, 4, 4, 4, 4]

# Why: all lambdas share the same variable 'i'
# When called, 'i' is 4 (the last value from the loop)

funcs = [lambda i=i: i for i in range(5)]
print([f() for f in funcs])  # [0, 1, 2, 3, 4]

from functools import partial
funcs = [partial(lambda i: i, i) for i in range(5)]

import itertools
list(itertools.chain([1, 2], [3, 4]))  # [1, 2, 3, 4]

list(itertools.product("AB", [1, 2]))
# [('A', 1), ('A', 2), ('B', 1), ('B', 2)]

data = [("A", 1), ("A", 2), ("B", 3)]
for key, group in itertools.groupby(data, key=lambda x: x[0]):
    print(key, list(group))
# A [('A', 1), ('A', 2)]
# B [('B', 3)]

# ❌ O(n * m) — list lookup is O(m) per check
large_list = list(range(100_000))
for item in data:
    if item in large_list:  # O(m) each time
        process(item)

# ✅ O(n + m) — set lookup is O(1) per check
large_set = set(large_list)  # O(m) one-time conversion
for item in data:
    if item in large_set:   # O(1) each time
        process(item)

# Without walrus — duplicated call
line = input(">> ")
while line != "quit":
    process(line)
    line = input(">> ")

# With walrus — DRY
while (line := input(">> ")) != "quit":
    process(line)

# In list comprehension — filter + use match
import re
results = [
    m.group()
    for text in texts
    if (m := re.search(r"\d+", text))
]

import dis
def f():
    for i in range(10):
        pass
dis.dis(f)  # Shows FOR_ITER (or FOR_ITER_RANGE after warmup)

from typing import Generator, Iterable
import gzip
import json
import re

def read_lines(path: str) -> Generator[str, None, None]:
    opener = gzip.open if path.endswith(".gz") else open
    with opener(path, "rt", buffering=8192) as f:
        yield from f  # yields one line at a time

def parse_json_lines(lines: Iterable[str]) -> Generator[dict, None, None]:
    for line in lines:
        try:
            yield json.loads(line)
        except json.JSONDecodeError:
            continue

def filter_errors(records: Iterable[dict]) -> Generator[dict, None, None]:
    for record in records:
        if record.get("level") == "ERROR":
            yield record

def extract_fields(records: Iterable[dict]) -> Generator[dict, None, None]:
    for record in records:
        yield {
            "timestamp": record["ts"],
            "message": record["msg"],
            "service": record.get("service", "unknown"),
        }

# Pipeline — O(1) memory regardless of file size
pipeline = extract_fields(filter_errors(parse_json_lines(read_lines("app.log.gz"))))
for record in pipeline:
    write_to_output(record)

import timeit
n = 10_000_000
t1 = timeit.timeit(lambda: sum(range(n)), number=10)
t2 = timeit.timeit(lambda: sum(i for i in range(n)), number=10)
print(f"sum(range):     {t1:.3f}s")
print(f"sum(generator): {t2:.3f}s")
# sum(range) is typically 2-3x faster