A thousand miles begins with a single step

def firstn(n):
    num = 0
    while num < n:
        yield num
        num += 1

for num in firstn(10):
    print(num)

def grep_word(match):
    print("Print sentence match word: {}".format(match))
    while True:
        sentence = (yield)
        if match in sentence:
            print(sentence)

corou = grep_word("Hello")

# grep_word 会执行到 sentence = (yield) 处暂停
next(corou)

corou.send("First Sentence")
corou.send("Hello world")

import select
import socket
from queue import Queue


class Task:
    '''所有任务的基类'''
    taskid = 0

    def __init__(self, target) -> None:
        Task.taskid += 1
        self.tid = Task.taskid
        self.target = target
        self.sendval = None

    def run(self):
        return self.target.send(self.sendval)


class SystemCall:
    '''如果 Task.run 返回了 SystemCall, 
       Scheduler 会调用 SystemCall.handle 来执行需要的操作'''

    def handle(self):
        pass


class Scheduler:
    '''运行 event loop, 调度 Task 运行'''

    def __init__(self) -> None:
        self.ready = Queue()
        self.taskmap = {}
        self.read_waiting = {}
        self.write_waiting = {}

    def wait_for_read(self, task, fd):
        self.read_waiting[fd] = task

    def wait_for_write(self, task, fd):
        self.write_waiting[fd] = task

    def new(self, target):
        newtask = Task(target)
        self.taskmap[newtask.tid] = newtask
        self.schedule(newtask)
        return newtask.tid

    def iotask(self):
        while True:
            if self.ready.empty():
                self.iopoll(None)
            else:
                self.iopoll(0)
            yield

    def iopoll(self, timeout):
        if self.read_waiting or self.write_waiting:
            r, w, e = select.select(
                self.read_waiting, self.write_waiting, [], timeout)
            for fd in r:
                self.schedule(self.read_waiting.pop(fd))
            for fd in w:
                self.schedule(self.write_waiting.pop(fd))

    def schedule(self, task):
        self.ready.put(task)

    def exit(self, task):
        print("Task %d terminated" % task.tid)
        del self.taskmap[task.tid]

    def mainloop(self):
        '''主循环，调度运行所有的 Task'''
        self.new(self.iotask())
        while self.taskmap:
            task = self.ready.get()
            try:
                result = task.run()
                if isinstance(result, SystemCall):
                    result.task = task
                    result.sched = self
                    result.handle()
                    continue
            except StopIteration:
                self.exit(task)
                continue
            self.schedule(task)


class ReadWait(SystemCall):
    def __init__(self, f) -> None:
        self.f = f

    def handle(self):
        fd = self.f.fileno()
        self.sched.wait_for_read(self.task, fd)


class WriteWait(SystemCall):
    def __init__(self, f) -> None:
        self.f = f

    def handle(self):
        fd = self.f.fileno()
        self.sched.wait_for_write(self.task, fd)


class NewTask(SystemCall):
    '''创建一个新的 Task'''

    def __init__(self, target) -> None:
        self.target = target

    def handle(self):
        tid = self.sched.new(self.target)
        self.task.sendval = tid
        # 触发自己的 Task 继续执行
        self.sched.schedule(self.task)


def handle_client(client, addr):
    print(f"Connection from {addr}")
    while True:
        # 等待可读
        yield ReadWait(client)
        data = client.recv(65535)
        if not data:
            break
        # 等待可写
        yield WriteWait(client)
        client.send(data)

    client.close()
    print(f"Client closed {addr}")


def server(port):
    print(f'Server starting port: {port}')
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(("", port))
    sock.listen(5)
    while True:
        # 等待新的连接到达
        yield ReadWait(sock)
        client, addr = sock.accept()
        # 使用 handle_client 创建一个新的 Task, 处理客户端的请求
        yield NewTask(handle_client(client, addr))


sched = Scheduler()
sched.new(server(9998))
sched.mainloop()

import asyncio

async def main():
    print('Hello ...')
    await asyncio.sleep(1)
    print('... World!')

asyncio.run(main())

import asyncio


async def handle_tcp_echo(reader, writer):
    address = writer.get_extra_info('peername')
    print(f'connection accept from {address}')

    while True:
        data = await reader.read(65535)
        if not data:
            print(f'connection closed {address}')
            writer.close()
            return

        writer.write(data)
        await writer.drain()


async def run_server():
    server = await asyncio.start_server(handle_tcp_echo, "", 9998)
    async with server:
        await server.serve_forever()

asyncio.run(run_server())