`iterator` is a more general concept: any object whose class has a `next` method (`__next__` in Python 3) and an `__iter__` method that does `return self`.

Every generator is an iterator, but not vice versa. A generator is built by calling a function that has one or more `yield` expressions (`yield` statements, in Python 2.5 and earlier), and is an object that meets the previous paragraph's definition of an `iterator`.

You may want to use a custom iterator, rather than a generator, when you need a class with somewhat complex state-maintaining behavior, or want to expose other methods besides `next` (and `__iter__` and `__init__`). Most often, a generator (sometimes, for sufficiently simple needs, a generator _expression_) is sufficient, and it's simpler to code because state maintenance (within reasonable limits) is basically "done for you" by the frame getting suspended and resumed.

For example, a generator such as:

 def squares(start, stop):
 for i in range(start, stop):
 yield i * i

 generator = squares(a, b)

or the equivalent generator expression (genexp)

 generator = (i*i for i in range(a, b))

would take more code to build as a custom iterator:

 class Squares(object):
 def __init__(self, start, stop):
 self.start = start
 self.stop = stop
 def __iter__(self): return self
 def next(self):
 if self.start >= self.stop:
 raise StopIteration
 current = self.start * self.start
 self.start += 1
 return current

 iterator = Squares(a, b)


But, of course, with class `Squares` you could easily offer extra methods, i.e.

 def current(self):
 return self.start

if you have any actual need for such extra functionality in your application.