问2021-09-26：搜索旋转排序数组。整数数组 nums 按升序排列，数组中的值 互不相同 。在？

迭代器:

Iterator are objects which uses next() method to get next value of sequence.

生成器:

A generator is a function that produces or yields a sequence of values using yield method.

Every next() method call on generator object(for ex: f as in below example) returned by generator function(for ex: foo() function in below example), generates next value in sequence.

When a generator function is called, it returns an generator object without even beginning execution of the function. When next() method is called for the first time, the function starts executing until it reaches yield statement which returns the yielded value. The yield keeps track of i.e. remembers last execution. And second next() call continues from previous value.

The following example demonstrates the interplay between yield and call to next method on generator object.

>>> def foo():

...     print "begin"

...     for i in range(3):

...         print "before yield", i

...         yield i

...         print "after yield", i

...     print "end"

...

>>> f = foo()

>>> f.next()

begin

before yield 0            # Control is in for loop

0

>>> f.next()

after yield 0             

before yield 1            # Continue for loop

1

>>> f.next()

after yield 1

before yield 2

2

>>> f.next()

after yield 2

end

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

StopIteration

>>>

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.