def simple_coroutine():
  print('-> start')
  x = yield
  print('-> recived', x)

sc = simple_coroutine()

next(sc)
sc.send('zhexiao')

import inspect

def simple_coroutine(a):
  print('-> start')

  b = yield a
  print('-> recived', a, b)

  c = yield a + b
  print('-> recived', a, b, c)

# run 
sc = simple_coroutine(5)

next(sc)
sc.send(6) # 5, 6
sc.send(7) # 5, 6, 7

def averager():
  total = 0.0
  count = 0
  avg = None

  while True:
    num = yield avg
    total += num
    count += 1
    avg = total/count

# run
ag = averager()
# 預(yù)激協(xié)程
print(next(ag))   # None

print(ag.send(10)) # 10
print(ag.send(20)) # 15

generator.throw(exc_type[, exc_value[, traceback]])

class DemoException(Exception):
  """
  custom exception
  """

def handle_exception():
  print('-> start')

  while True:
    try:
      x = yield
    except DemoException:
      print('-> run demo exception')
    else:
      print('-> recived x:', x)

  raise RuntimeError('this line should never run')

he = handle_exception()
next(he)
he.send(10) # recived x: 10
he.send(20) # recived x: 20

he.throw(DemoException) # run demo exception

he.send(40) # recived x: 40
he.close()

he.throw(Exception) # run demo exception

def gen():
  for c in 'AB':
    yield c

print(list(gen()))

def gen_new():
  yield from 'AB'

print(list(gen_new()))

from collections import namedtuple

ResClass = namedtuple('Res', 'count average')

# 子生成器
def averager():
  total = 0.0
  count = 0
  average = None

  while True:
    term = yield
    if term is None:
      break
    total += term
    count += 1
    average = total / count

  return ResClass(count, average)


# 委派生成器
def grouper(storages, key):
  while True:
    # 獲取averager()返回的值
    storages[key] = yield from averager()


# 客戶端代碼
def client():
  process_data = {
    'boys_2': [39.0, 40.8, 43.2, 40.8, 43.1, 38.6, 41.4, 40.6, 36.3],
    'boys_1': [1.38, 1.5, 1.32, 1.25, 1.37, 1.48, 1.25, 1.49, 1.46]
  }

  storages = {}
  for k, v in process_data.items():
    # 獲得協(xié)程
    coroutine = grouper(storages, k)

    # 預(yù)激協(xié)程
    next(coroutine)

    # 發(fā)送數(shù)據(jù)到協(xié)程
    for dt in v:
      coroutine.send(dt)

    # 終止協(xié)程
    coroutine.send(None)
  print(storages)

# run
client()

import collections

# time 字段是事件發(fā)生時的仿真時間，
# proc 字段是出租車進程實例的編號，
# action 字段是描述活動的字符串。
Event = collections.namedtuple('Event', 'time proc action')


def taxi_process(proc_num, trips_num, start_time=0):
  """
  每次改變狀態(tài)時創(chuàng)建事件，把控制權(quán)讓給仿真器
  :param proc_num:
  :param trips_num:
  :param start_time:
  :return:
  """
  time = yield Event(start_time, proc_num, 'leave garage')

  for i in range(trips_num):
    time = yield Event(time, proc_num, 'pick up people')
    time = yield Event(time, proc_num, 'drop off people')

  yield Event(time, proc_num, 'go home')

# run
t1 = taxi_process(1, 1)
a = next(t1)  
print(a)  # Event(time=0, proc=1, action='leave garage')
b = t1.send(a.time + 6)
print(b)  # Event(time=6, proc=1, action='pick up people')
c = t1.send(b.time + 12)
print(c)  # Event(time=18, proc=1, action='drop off people')
d = t1.send(c.time + 1)
print(d)  # Event(time=19, proc=1, action='go home')

import collections
import queue
import random

# time 字段是事件發(fā)生時的仿真時間，
# proc 字段是出租車進程實例的編號，
# action 字段是描述活動的字符串。
Event = collections.namedtuple('Event', 'time proc action')


def taxi_process(proc_num, trips_num, start_time=0):
  """
  每次改變狀態(tài)時創(chuàng)建事件，把控制權(quán)讓給仿真器
  :param proc_num:
  :param trips_num:
  :param start_time:
  :return:
  """
  time = yield Event(start_time, proc_num, 'leave garage')

  for i in range(trips_num):
    time = yield Event(time, proc_num, 'pick up people')
    time = yield Event(time, proc_num, 'drop off people')

  yield Event(time, proc_num, 'go home')


class SimulateTaxi(object):
  """
  模擬出租車控制臺
  """

  def __init__(self, proc_map):
    # 保存排定事件的 PriorityQueue 對象，
    # 如果進來的是tuple類型，則默認使用tuple[0]做排序
    self.events = queue.PriorityQueue()
    # procs_map 參數(shù)是一個字典,使用dict構(gòu)建本地副本
    self.procs = dict(proc_map)

  def run(self, end_time):
    """
    排定并顯示事件，直到時間結(jié)束
    :param end_time:
    :return:
    """
    for _, taxi_gen in self.procs.items():
      leave_evt = next(taxi_gen)
      self.events.put(leave_evt)

    # 仿真系統(tǒng)的主循環(huán)
    simulate_time = 0
    while simulate_time < end_time:
      if self.events.empty():
        print('*** end of events ***')
        break

      # 第一個事件的發(fā)生
      current_evt = self.events.get()
      simulate_time, proc_num, action = current_evt
      print('taxi:', proc_num, ', at time:', simulate_time, ', ', action)

      # 準備下個事件的發(fā)生
      proc_gen = self.procs[proc_num]
      next_simulate_time = simulate_time + self.compute_duration()

      try:
        next_evt = proc_gen.send(next_simulate_time)
      except StopIteration:
        del self.procs[proc_num]
      else:
        self.events.put(next_evt)
    else:
      msg = '*** end of simulation time: {} events pending ***'
      print(msg.format(self.events.qsize()))

  @staticmethod
  def compute_duration():
    """
    隨機產(chǎn)生下個事件發(fā)生的時間
    :return:
    """
    duration_time = random.randint(1, 20)
    return duration_time


# 生成3個出租車，現(xiàn)在全部都沒有離開garage
taxis = {i: taxi_process(i, (i + 1) * 2, i * 5)
     for i in range(3)}

# 模擬運行
st = SimulateTaxi(taxis)
st.run(100)