The generator in python saves the algorithm, and the value will be calculated only when the value is really needed. It is a lazy evaluation.

There are two ways to create a generator.

The first method: Change [] in a list generation expression to () to create a generator:

>>> L = [x * x for x in range(10)]>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]>>> g = (x * x for x in range(10)) # Note that after changing [] to (), instead of generating a tuple, a generator>>> g at 0x1022ef630>

Second way: Use the yield keyword in the function, and the function becomes a generator.

After there is yield in the function, the execution will stop when yield is reached, and the calculation will be continued when further calculation is needed. So it doesn't matter even if the generator function has an infinite loop, it will calculate as much as it needs to count, and it won't continue counting if it doesn't need to.

def fib():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
f = fib()
print f, next(f), next(f), next(f)
# 0 1 1

As in the above example, when f is output for the first time, it is a generator, and every time next is executed, it will be executed to yield a.

Of course, next() is rarely used. We can directly use a for loop to traverse a generator. In fact, the internal implementation of the for loop is to continuously call next().

The generator can avoid unnecessary calculations and improve performance; it also saves space and can realize infinite loop (infinite) data structures.

Generator syntax
Generator expression: The same as list parsing syntax, but replace the [] of list parsing with ()
What generator expressions can do List parsing can basically handle things, but when the sequence to be processed is relatively large, list parsing consumes more memory.

Generator function: If the yield keyword appears in a function, then the function is no longer an ordinary function, but a generator function.

In Python, yield is such a generator.

The operating mechanism of the yield generator:

When you ask the generator for a number, the generator will execute until the yield statement appears, and the generator will The parameters are given to you, and then the generator will not continue to run. When you ask him for the next number, he will start from the last state. Start running until the yield statement appears, give you the parameters, and then stop. This is repeated until the function exits.

Use of yield:

In Python, when you define a function and use the yield keyword, the function is a generator, and its execution will be the same as other ordinary functions. There are many differences. The function returns an object, instead of getting the result value like the return statement you usually use. If you want to get the value, you have to call the next() function

Take Fibonacci as an example:

#coding:utf8
def fib(max): #10
    n, a, b = 0, 0, 1
    while n < max: #n<10
        #print(b)
        yield b
        a, b = b, a + b

        n += 1
    return 

f = fib(10)
for i in f:
    print f

From the above description of the operating mechanism, we can know that when the program reaches the yield line, it will not continue to execute. Instead, it returns an iterator object containing the status of all parameters of the current function. The purpose is to be able to access all the parameter values ​​of the function when it is called for the second time, instead of reassigning them.

When the program is called for the first time:

def fib(max): #10
    n, a, b = 0, 0, 1
    while n < max: #n<10
        #print(b)
        yield b   #这时a,b值分别为0,1，当然，程序也在执行到这时，返回
        a, b = b, a + b

#coding:UTF8

class Fib:  
    def __init__(self, max):  
        self.max = max
        print self.max
    def __iter__(self):  
        self.a = 0  
        self.b = 1 
        self.n = 0 
        return self  
    def next(self):  
        fib = self.n  
        if fib >= self.max:  
            raise StopIteration  
        self.a, self.b = self.b, self.a + self.b  
        self.n += 1
        return self.a
    
f = Fib(10)
for i in f:
    print i

     close(...)
 |      close() -> raise GeneratorExit inside generator.
 |  
 |  next(...)
 |      x.next() -> the next value, or raise StopIteration
 |  
 |  send(...)
 |      send(arg) -> send 'arg' into generator,
 |      return next yielded value or raise StopIteration.
 |  
 |  throw(...)
 |      throw(typ[,val[,tb]]) -> raise exception in generator,
 |      return next yielded value or raise StopIteration.

#coding:UTF8

def fib():
    yield 1
    yield 2
    yield 3

f = fib()
print f.next()
f.close()
print f.next()

def gen():
    value=0
    while True:
        receive=yield value
        if receive=='e':
            break
        value = 'got: %s' % receive
 
g=gen()
print(g.send(None))     
print(g.send('aaa'))
print(g.send(3))
print(g.send('e'))

0
got: aaa
got: 3
Traceback (most recent call last):
  File "1.py", line 15, in <module>
    print(g.send(&#39;e&#39;))
StopIteration

def gen():
    while True: 
        try:
            yield 'normal value'
            yield 'normal value 2'
            print('here')
        except ValueError:
            print('we got ValueError here')
        except TypeError:
            break
 
g=gen()
print(next(g))
print(g.throw(ValueError))
print(next(g))
print(g.throw(TypeError))