1. The difference between iterator and generator:

1. The generator is a special iterator, so the usage of the iterator can be used in the generator
2. To define an iterator, you need to implement the __iter__() method and the __next__() method separately.
3. To define a generator, only one yield is needed

2. The concept of coroutine

1. A coroutine is not a process or thread, and its execution is more similar to a subroutine, or a function call without a return value.
2. A program can contain multiple coroutines, and can compare multiple threads with one process, so let's compare coroutines and threads. We know that multiple threads are relatively independent, have their own context, and the switch is controlled by the system; the coroutine is relatively independent and has its own context, but its switching is controlled by itself, and the current coroutine switches to other coroutines from the current coroutine. To control.
3. From the above literal understanding, multi-threaded pause and start is controlled by the operating system, such as gil. The coroutine is single-threaded. In a single thread, there is a function to pause, start, and pass values ​​to the function. We call it a coroutine.
4. In Python, the generator yield has exactly this pause and start function. We can think about using generators as a coroutine.

3. Builder

WithyieldFunction, is a special iterator, containsGenerator functionwithGenerator expression(as an expression of (elem for elem in [1, 2, 3]))

Generator example:

# 
 # Input: 1. 5-->5 2. 3 --->8 3. 2--->10 4. 2---->12
 # Output: 1. 5 2. 4 3. 3.333 4. 3
def avg():
    num = 0
    total = 0.0
         # 
    while 1:
                 # 
        val = yield
                 #Calculation +1
        num += 1
        total += val
                 #  is equal to the total / calculation times
        avg = total/num
                 Print('current average{}'.format(avg))

counter = avg()
counter.send(None)
while True:
         Num = input('Please enter a number:')
    num = float(num)
    counter.send(num)

Code interpretation

• The right side of yield indicates that a value is generated, but in fact, the left side of yield can indicate the value passed by the caller, but we generally don't write it, so it will pass None by default.
• Call the next method to start the generator. After startup, the generator pauses on the first yield and generates a value that is the value to the right of the yield expression.
• Call the send method, the left side of the yield will accept the value, and execute downwards. If there is no yield pause, the stopItertion exception will be thrown out.
• The generator can pause, and accept values, and features with coroutines exist.

View the status of the generator:

from inspect import getgeneratorstate
def simple_gen1():
    print('started')
    x = yield 'running'
    print('receive_x:',x)
    y = yield x
    print('receive_y:', y)
    
test1 = simple_gen1()
    print(getgeneratorstate(test1))
    next(test1)
print(getgeneratorstate(test1))
next(test1)
print(getgeneratorstate(test1))
try:
    next(test1)
except Exception:
    pass
print(getgeneratorstate(test1))

##output:
    GEN_CREATED
started
GEN_SUSPENDED
receive_x: None
GEN_SUSPENDED
receive_y: None
GEN_CLOSED

From the above code, we can see that the generator is stateful -> not activated, paused, has ended