Introduction to python generator generator

When I followed Liao Xuefeng’s blog to learn Python, when I saw the chapter about generators, I first mentioned generator and yield, and then when searching for information, I found the concept of coroutines. , this article summarizes these concepts.

　generator Literally understood, it is a generator. There are two ways to implement it:

1. Different For list generators ([]), it is represented by (). (It turns out that this is called a generator expression, haha)

Access method, you can use for loop to access, you can also use .next to access.

N = ['Hello', 'World', 18, 'Apple', 'None']
hh = (s.lower() for s in N if isinstance(s,str) ==True)print hh#for item in hh:#    print item#print hh.next()#print hh.next()#print hh.next()#print hh.next()

Output result

at 0x7f543a074690>
hello
world
apple
none

hh is the value returned by the generator, similar to an array. Supports for loop access and .next() access. One thing to note is that hh.next() cannot be executed after the for loop is executed, similar to when the pointer reaches the end, or the iterator in C++ points to the end, and then accesses An error will occur.

2. Use yield to generate (called generator function)

No matter it is called with next() or for loop, after yield is executed, n value is returned, and then the current The state is pending and then returns.

def create_counter(n):print "create counter"#while True:while False:yield nprint 'increment n'n += 1cnt = create_counter(2)#print cntfor item in cnt:print item#print next(cnt)#print next(cnt)#print cnt.next()#print cnt.next()

For example, in this example, when printing cnt,

indicates that this is a generator.
When is False, only create counter will be printed

When it is True, an infinite loop will occur when using a for loop.

Coroutine:

I know that there are concepts of processes and threads, but I really don’t know what a coroutine is

From a technical point of view Say, "A coroutine is a function that you can pause execution of." If you understand it as "just like a generator", then you're right. Saw this in an article.

The reason why python has high execution efficiency

1. Switching subroutines is not thread switching, but is controlled by the program itself. Therefore, there is no overhead of thread switching, compared with multi-threading , the greater the number of threads, the more obvious the performance advantages of coroutines.

2. There is no locking mechanism involved in the execution process.

Attached is a simple example of producer and consumer:

def consumer():
    r = ''while True:
        n = yield rif not n:returnprint('[CONSUMER] Consuming %s...' % n)
        time.sleep(1)
        r = '200 OK'def produce(c):
    c.next()
    n = 0while n < 5:
        n = n + 1print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)print('[PRODUCER] Consumer return: %s' % r)
    c.close()if __name__=='__main__':
    c = consumer()
    produce(c)

1. The consumer function is a generator.
2. c.send(None) is actually equivalent to next(c). When executed for the first time, it only executes until n = yield r and then stops, and then returns the value of r to the caller.
3. yield r is an expression that is assigned a value through send(msg), and send(msg) has a return value. The return value is: the parameter of the next yield r expression, which is r .
4. Once produce produces something, switch to consumer execution through c.send(n). The consumer gets the message through yield, processes it, and sends the result back through yield. In other words, c.send(1) will not only send a data to c, but it will also wait for the next yield to return a data from c. It has a return value. It is completed after one go. Only the returned data (200 OK) will continue to execute below.
5. The entire process is lock-free and executed by one thread. Producer and consumer cooperate to complete the task, so it is called "coroutine" rather than preemptive multi-tasking of threads.

In summary, yield r is an expression, which is assigned by c.send, and then The return value is the next parameter of the yield r expression.

##

The above is the detailed content of Introduction to python generator generator. For more information, please follow other related articles on the PHP Chinese website!