def read_lazy(file_object):
    """Lazy function (generator) to read a file line by line."""
    while True:
        data = file_object.readline()
        if not data:
            break
        yield data

f = open('data')
while True:
    try:
        line = next(f)
        print(line, end='')
    except StopIteration:
        break

def grep(pattern):
    try:
        while True:
            line = (yield)
            if pattern in line:
                print(line)
    except GeneratorExit:
        print('See you again!')
g = grep('Python')
g.send(None)      # 启动协程
g.send("Python Cookbook")
g.close()

from socket import socket, AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
from collections import deque
from select import select
class Scheduler(object):
    def __init__(self):
        self.ready = deque()         # 就绪队列      deque: coroutine 
        self.read_waiting = {}       # 等待读取的队列  dict: socket -> coroutine
        self.write_waiting = {}      # 等待写入的队列  dict: socket -> coroutine
    def add_ready(self, task):
        self.ready.append(task)    
        
    def add_read(self, fileno, task):
        self.read_waiting[fileno] = task
    def add_write(self, fileno, task):
        self.write_waiting[fileno] = task
    def loop(self):
        while any([self.ready, self.read_waiting, self.write_waiting]):
            # 如果就绪队列是空的，就进行I/O轮询，等待事件就绪
            while not self.ready:
                can_read, can_write, _ = select(self.read_waiting,
                                                self.write_waiting,
                                                [])
                for fileno in can_read:
                    self.ready.append(self.read_waiting.pop(fileno))
                for fileno in can_write:
                    self.ready.append(self.write_waiting.pop(fileno))
                
            task = self.ready.popleft()
            try:
                event, fileno = next(task)  # 让协程执行到 yield
                if event == 'read':
                    self.read_waiting[fileno] = task
                elif event == 'write':
                    self.write_waiting[fileno] = task
                else:
                    raise RuntimeError("ERROR!")            
            except StopIteration:
                print('task done')
class AsyncSocket(object):
    def __init__(self, sock):
        self.sock = sock
    def recv(self, maxsize):
        yield 'read', self.sock   # 主动让出，交给调度器调度
        return self.sock.recv(maxsize)
    def send(self, data):
        yield 'write', self.sock  # 主动让出，交给调度器调度
        return self.sock.send(data)
    def accept(self):
        yield 'read', self.sock   # 主动让出，交给调度器调度
        client, addr = self.sock.accept()
        return AsyncSocket(client), addr 
    
    def __getattr__(self, name):
        return getattr(self.sock, name)
def echo_server(scheduler, address, backlog=5):
    sock = AsyncSocket(socket(AF_INET, SOCK_STREAM))
    sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    sock.bind(address)
    sock.listen(backlog)
    while True:
        client_sock, client_addr = yield from sock.accept()  # blocking
        scheduler.add_ready(echo_handler(client_addr, client_sock))
def echo_handler(address, client_sock):
    print('Got connection from {}'.format(address))
    while True:
        msg = yield from client_sock.recv(8192)  # blocking
        if not msg:
            break
        yield from client_sock.send(msg)  # blocking
    client_sock.close()
        
if __name__ == '__main__':
    scheduler = Scheduler()
    server = echo_server(scheduler, ('', 20000))
    scheduler.add_ready(server)
    scheduler.loop()