An iterable is anything you can loop over (a list, string, dict); an iterator is the object that does the actual iteration, producing values one at a time and tracking its position. The distinction underlies how for loops work in Python.
Iterable → has __iter__() → returns an iterator
Iterator → has __next__() → returns the next value (and __iter__ returning itself)
# this for loop...
for x in [1, 2, 3]:
print(x)
# ...is roughly equivalent to:
it = iter([1, 2, 3]) # __iter__ → get an iterator from the iterable
while True:
try:
x = next(it) # __next__ → get the next value
print(x)
except StopIteration: # raised when exhausted → loop ends
break
A for loop calls iter() to get an iterator, then repeatedly calls next() until StopIteration signals the end. This protocol is what makes any iterable loopable.
nums = [1, 2, 3] # an ITERABLE (a list)
it = iter(nums) # an ITERATOR over it
next(it) # 1
next(it) # 2
next(it) # 3
next(it) # StopIteration
# the list is REUSABLE (get a fresh iterator each loop);
# an iterator is CONSUMED ONCE — exhausted after one pass
list(it) # [] — already used up
Key difference: an iterable (list) can be looped many times (each for gets a fresh iterator); an iterator is single-use — once exhausted, it's empty.
class Countdown:
def __init__(self, start): self.n = start
def __iter__(self): return self # the iterable returns itself as iterator
def __next__(self):
if self.n <= 0:
raise StopIteration # signal the end
self.n -= 1
return self.n + 1
for x in Countdown(3): # 3, 2, 1
print(x)
def gen(): yield 1; yield 2 # a generator function returns an iterator automatically
Generators are the easy way to create iterators — yield handles the __next__/StopIteration machinery for you.
The iterable/iterator distinction explains how for loops work in Python and how iteration is unified across all collections (lists, dicts, files, generators) via the iterator protocol.
Understanding it clarifies real behaviors — why an iterator can only be consumed once (a common bug: looping a generator/zip twice gives nothing the second time), why generators are iterators, and how to make your own objects iterable.
This protocol is the foundation of Python's elegant, consistent iteration model and is essential for working with generators, lazy evaluation, and custom iterable classes.