A function that remembers where it stopped

def squares(n):
    for i in range(n):
        yield i * i

g = squares(4)
print(next(g), next(g))   # 0 1
print(list(g))            # [4, 9]
print(list(g))            # []

yield pauses the function and hands back one value. The next next() call resumes from the same line. After the last value the generator is used up, so the second list(g) is empty. This is the classic exam trap: a generator can be consumed only once.

Why use one: memory

import sys
sys.getsizeof([i for i in range(100000)]) > sys.getsizeof((i for i in range(100000)))
# True

A list comprehension builds all 100000 values at once. A generator expression keeps only its current state and makes each value when asked.

Infinite sequences

from itertools import islice

def evens():
    n = 0
    while True:
        yield n
        n += 2

print(list(islice(evens(), 5)))   # [0, 2, 4, 6, 8]

This would never finish as a list. As a generator it is fine, because you take only what you need.

What a for loop really does

it = iter([10, 20])
print(next(it), next(it))   # 10 20
try:
    next(it)
except StopIteration:
    print("StopIteration")

A for loop calls iter() once, then next() again and again, and stops quietly when StopIteration is raised.

Quick rules

• Use a generator when you read data once, in order, and it may be large.
• Use a list when you need indexing, len() or several passes.
• A generator that you loop over twice gives nothing the second time.

A longer version with 8 tested examples and exam questions is on the TechVani notes site: Python Iterators and Generators: yield, Lazy Evaluation and 8 Tested Examples

Loops

• A loop for (i = 1; i <= n; i++) runs n times, so O(n).
• A loop where i doubles each step (i = i * 2) runs about log2(n) times, so O(log n).
• Nested loops multiply, but only if the inner count does not depend on the outer variable in a way that changes the sum. For for i in 1..n with inner for j in 1..i, the total is n(n+1)/2, which is O(n^2).

Recurrences (master theorem) For T(n) = a T(n/b) + f(n), compare f(n) with n^(log_b a):

• If f(n) is smaller by a polynomial factor, T(n) = Theta(n^(log_b a)).
• If they are the same order, T(n) = Theta(n^(log_b a) log n).
• If f(n) is larger (and the regularity condition holds), T(n) = Theta(f(n)).

Example: T(n) = 2T(n/2) + n. Here n^(log_2 2) = n, same order as f(n), so T(n) = Theta(n log n), which is merge sort.

I solved 6 more loop and recurrence problems step by step on my blog TechVani (originally published there): https://techvaniai.blogspot.com/2026/10/time-complexity-questions-6-solved-loop.html

A quick worked example. Two processes, two resources. P1 holds R1 and waits for R2. P2 holds R2 and waits for R1. Draw the wait-for graph: P1 -> P2 -> P1. That cycle is the circular wait, and since each resource has one instance, a cycle means deadlock.

How to prevent it in practice: make every process request resources in one fixed order (this kills circular wait), or make a process request everything up front (this kills hold and wait).

For the Banker's algorithm, keep a table of Allocation, Max and Available. Compute Need = Max - Allocation, then look for any process whose Need fits in Available. Run it, add its Allocation back to Available, and repeat. If you can finish all processes this way, the state is safe.

I covered this and other OS topics (processes, scheduling, memory, file systems) in a 96 minute Hinglish revision video: https://www.youtube.com/watch?v=RSR2sqyR5pE

More notes on Telegram: https://t.me/techvaniai