def test_wait(self): @callbackgoaway def func(): self.assertEqual(self.counter, 0) yield Wait(events=( Never(), Inc(self), Inc(self), ), n=1) self.assertEqual(self.counter, 1) yield Wait(events=( Never(), Inc(self), Inc(self), ), n=3) # A self.counter += 1 yield 'TEST' self.counter += 1 gen = func() # この時点で既にA行の"Inc(self)"は実行されている self.assertEqual(self.counter, 4) self.assertEqual(getgeneratorstate(gen), GEN_SUSPENDED) # A行の後のGeneratorの進め方はこちらに任されている self.assertEqual(self.counter, 4) self.assertEqual(next(gen), 'TEST') self.assertEqual(self.counter, 5) with self.assertRaises(StopIteration): next(gen) self.assertEqual(getgeneratorstate(gen), GEN_CLOSED) self.assertEqual(self.counter, 6)
def gen4(): while True: a = gen3() print(inspect.getgeneratorstate(a)) x = yield from a print(inspect.getgeneratorstate(a)) print(x)
def test_simple_coroutine(self): """ 新建两个协程 """ coroutines = [self.simple_coroutine(i) for i in range(2)] """ 察看协程的状态 """ for coro in coroutines: ret = 0 # 返回 generator 的状态。 print(getgeneratorstate(coro)) ret = next( coro) # SPrimer(预激). tart coroutine and run to the first yield print(getgeneratorstate(coro)) print("Return " + str(ret)) """ 模拟并发。修改一下即可实现事件驱动,例如通过循环检查 coroutine primer 的时候的返回值,来决定何时进一步激活哪个 coroutine。 参考 test_texi.py 的例子 """ for coro in coroutines: ret = 0 try: ret = coro.send(28) # return a + b print("Return " + str(ret)) coro.send( 99 ) # Will have StopIteration exception because coroutine has been finished. except StopIteration: pass finally: print(getgeneratorstate(coro))
def gen(a): print(f'start a={a}') b=yield a print(f'received b={b}') getgeneratorstate(coro) # GEN_RUNNING c=yield a+b print(f'received c={c}')
def test_generator_gi_yieldfrom(self): def a(): self.assertEqual(inspect.getgeneratorstate(gen_b), inspect.GEN_RUNNING) self.assertIsNone(gen_b.gi_yieldfrom) yield self.assertEqual(inspect.getgeneratorstate(gen_b), inspect.GEN_RUNNING) self.assertIsNone(gen_b.gi_yieldfrom) def b(): self.assertIsNone(gen_b.gi_yieldfrom) yield from a() self.assertIsNone(gen_b.gi_yieldfrom) yield self.assertIsNone(gen_b.gi_yieldfrom) gen_b = b() self.assertEqual(inspect.getgeneratorstate(gen_b), inspect.GEN_CREATED) self.assertIsNone(gen_b.gi_yieldfrom) gen_b.send(None) self.assertEqual(inspect.getgeneratorstate(gen_b), inspect.GEN_SUSPENDED) self.assertEqual(gen_b.gi_yieldfrom.gi_code.co_name, 'a') gen_b.send(None) self.assertEqual(inspect.getgeneratorstate(gen_b), inspect.GEN_SUSPENDED) self.assertIsNone(gen_b.gi_yieldfrom) [] = gen_b # Exhaust generator self.assertEqual(inspect.getgeneratorstate(gen_b), inspect.GEN_CLOSED) self.assertIsNone(gen_b.gi_yieldfrom)
def test_and_event(self): root = Builder.load_string( textwrap.dedent(''' BoxLayout: Image: id: image source: 'data/logo/kivy-icon-256.png' Label: id: label text: "Test 'and' Event" font_size: sp(30) ''')) @callbackgoaway def func(): image = root.ids.image label = root.ids.label anim1 = Animation(opacity=0) anim2 = Animation(opacity=0, d=.5) anim1.start(image) anim2.start(label) yield Event(anim1, 'on_complete') & Event(anim2, 'on_complete') self.assertEqual(image.opacity, 0) self.assertEqual(label.opacity, 0) stopTouchApp() gen = func() self.assertEqual(getgeneratorstate(gen), GEN_SUSPENDED) runTouchApp(root) self.assertEqual(getgeneratorstate(gen), GEN_CLOSED)
def generatorStateTest(): """ GEN_CREATED # 等待开始执行 GEN_RUNNING # 解释器正在执行(只有在多线程应用中才能看到这个状态) GEN_SUSPENDED # 在yield表达式处暂停 GEN_CLOSED # 执行结束 """ from inspect import getgeneratorstate def mygen(n): now = 0 while now < n: yield now now += 1 gen = mygen(2) print(getgeneratorstate(gen)) # TODO GEN_RUNNING这个状态,使用多线程获取其状态即可 print(next(gen)) print(getgeneratorstate(gen)) print(next(gen)) gen.close() # 手动关闭/结束生成器 print(getgeneratorstate(gen))
def a(): self.assertEqual(inspect.getgeneratorstate(gen_b), inspect.GEN_RUNNING) self.assertIsNone(gen_b.gi_yieldfrom) yield self.assertEqual(inspect.getgeneratorstate(gen_b), inspect.GEN_RUNNING) self.assertIsNone(gen_b.gi_yieldfrom)
def main(): my_coro2 = simple_coro2(14) getgeneratorstate(my_coro2) x = next(my_coro2) print(x) getgeneratorstate(my_coro2) my_coro2.send(28) my_coro2.send(99)
def sample_16_2(): my_coro2 = simple_coro2(14) print(inspect.getgeneratorstate(my_coro2)) next(my_coro2) print(inspect.getgeneratorstate(my_coro2)) my_coro2.send(28) my_coro2.send(99) print(inspect.getgeneratorstate(my_coro2))
def test_mygen(): gen = mygen(2) print(getgeneratorstate(gen)) print(next(gen)) print(getgeneratorstate(gen)) print(next(gen)) gen.close() # 手动关闭/结束生成器 print(getgeneratorstate(gen))
def demo1(): def test(): yield 1 return "OK" t = test() print(inspect.getgeneratorstate(t)) next(t) print(inspect.getgeneratorstate(t)) try: next(t) except StopIteration: print(inspect.getgeneratorstate(t)) def test2(): # 如果你想实现一种新的迭代模式,使用一个生成器函数来定义它。 # 下面是一个生产某个范围内浮点数的生成器: def frange(start, stop, increment): print(" 自定义迭代器 ".center(30, "-")) x = start while x < stop: # yield x yield round(x, 3) x += increment print([n for n in frange(0, 4, 0.3)]) print(list(frange(0, 1, 0.125))) test2() class Countdown: # a = reversed(range(10)) # print(next(a)) # print(next(a)) # print(list(a)) print(" 反向迭代 ".center(30, "-")) def __init__(self, start): self.start = start # Forward iterator def __iter__(self): n = self.start while n > 0: yield n n -= 1 # Reverse iterator def __reversed__(self): n = 1 while n <= self.start: yield n n += 1 print([rr for rr in reversed(Countdown(30))]) print([rr for rr in Countdown(30)]) """
def Test3(): my_corou = simple_coro2(10) print(getgeneratorstate(my_corou)) first_res = my_corou.send(None) print(getgeneratorstate(my_corou)) print("first response", first_res) second_res = my_corou.send(11) print("second response", second_res) third_res = my_corou.send(12) print("third response", third_res)
def main(): from inspect import getgeneratorstate coro = demo_exc_handling() print(getgeneratorstate(coro)) next(coro) print(getgeneratorstate(coro)) coro.send(1000) print(getgeneratorstate(coro)) coro.throw(DemoException) print(getgeneratorstate(coro)) coro.close() print(getgeneratorstate(coro))
def test_normal_workflow_with_decorator(self): coro_avg = averager() self.assertEqual(getgeneratorstate(coro_avg), 'GEN_SUSPENDED') val = coro_avg.send(10) self.assertEqual(val, 10) self.assertEqual(getgeneratorstate(coro_avg), 'GEN_SUSPENDED') val = coro_avg.send(30) self.assertEqual(val, 20) val = coro_avg.send(5) self.assertEqual(val, 15) coro_avg.close() self.assertEqual(getgeneratorstate(coro_avg), 'GEN_CLOSED')
def main(generator): try: print("生成器初始状态为:{0}".format(getgeneratorstate(g))) next(g) # 激活生成器 print("生成器初始状态为:{0}".format(getgeneratorstate(g))) g.send(100) print("生成器初始状态为:{0}".format(getgeneratorstate(g))) next(g) print("生成器初始状态为:{0}".format(getgeneratorstate(g))) next(g) except StopIteration: print('全部迭代完毕了') print("生成器初始状态为:{0}".format(getgeneratorstate(g)))
def main(): '''Description of the function''' from inspect import getgeneratorstate x = my_coro2 = simple_coro2(14) print(x) print(getgeneratorstate(my_coro2)) x = my_coro2.send(None) print(x) print(getgeneratorstate(my_coro2)) x = my_coro2.send(28) print(x) print(getgeneratorstate(my_coro2)) x = my_coro2.send(99) print(x) print(getgeneratorstate(my_coro2))
def package_center(deliver_man, max_per_day): num = 1 #创建状态- 等待开始自行 print(getgeneratorstate(deliver_man)) deliver_man.send(None) #挂起状态--在yield表达式处暂停 print(getgeneratorstate(deliver_man)) while num <= max_per_day: package_id = 'PKG-%d' % num deliver_man.send(package_id) num += 1 deliver_man.close() print(getgeneratorstate(deliver_man)) print('今天的包裹派送完毕!')
def package_center(deliver_man, max_per_day): num = 1 # 创建状态(GEN_CREATED) - 等待开始执行 print(getgeneratorstate(deliver_man)) deliver_man.send(None) # 挂起状态(GEN_SUSPENDED) - 在yield表达式处暂停 print(getgeneratorstate(deliver_man)) # next(deliver_man) while num <= max_per_day: package_id = 'PKG-%d' % num deliver_man.send(package_id) num += 1 deliver_man.close() # 结束状态(GEN_CLOSED) - 执行完毕 print(getgeneratorstate(deliver_man)) print('今天的包裹派送完毕!')
def test_my_yield(): gen = my_yield(4) print(gen) print(isinstance(gen, Generator)) print(getgeneratorstate(gen)) print(gen.send(None)) print(next(gen)) print(getgeneratorstate(gen)) print(gen.send(None)) print(next(gen)) print(getgeneratorstate(gen)) gen.close() print(getgeneratorstate(gen))
def read_src_workbook(src_path: str, dst_path: str, partition_key: str, partition_values: Iterable): with xlrd.open_workbook(src_path) as xlsfile: time_stamp = time.time() sheet_names = xlsfile.sheet_names() workbooks = build_generators(dst_path, partition_values, sheet_names) # 预激生成器 for partition_value, generator in workbooks.items(): next(generator) print('The status of generator {0} is {1}'.format(partition_value, inspect.getgeneratorstate(generator))) for src_sheet in xlsfile.sheets(): key_index = src_sheet.row_values(0).index(partition_key) for src_row in src_sheet.get_rows(): this_partition_value = src_row[key_index].value if this_partition_value in workbooks: workbooks[src_row[key_index].value].send(src_row) # 结束子生成器 for generator in workbooks.values(): generator.send(None) # 结束派生生成器 for generator in workbooks.values(): try: next(generator) except StopIteration: pass print('Totally use %.1fs' % (time.time() - time_stamp))
def simple_coroutine2(a): print('-> Started : a =', a) b = yield a print('-> Received : b =', b) c = yield a + b print('-> Received : c =', c) print(getgeneratorstate(my_coro2)) #GEN_RUNNING
def iteratorCreationTiming(): def getIterable(x): print("Getting iterable", x) return Iterable(x) class Iterable: def __init__(self, x): self.x = x self.values = list(range(x)) self.count = 0 def __iter__(self): print("Giving iterator now", self.x) return self def __next__(self): print("Next of", self.x, "is", self.count) if len(self.values) > self.count: self.count += 1 return self.values[ self.count - 1 ] else: print("Raising StopIteration for", self.x) raise StopIteration # Python2/3 compatibility. next = __next__ def __del__(self): print("Deleting", self.x) gen = ( (y,z) for y in getIterable(3) for z in getIterable(2) ) print("Using generator", gen) next(gen) res = tuple(gen) print(res) print('*' * 20) try: next(gen) except StopIteration: print("Usage past end gave StopIteration exception as expected.") try: print("Generator state then is", inspect.getgeneratorstate(gen)) # @UndefinedVariable except AttributeError: pass print("Its frame is now", gen.gi_frame) print("Early aborting generator:") gen2 = ( (y,z) for y in getIterable(3) for z in getIterable(2) ) del gen2
def iteratorCreationTiming(): def getIterable(x): print("Getting iterable", x) return Iterable(x) class Iterable: def __init__(self, x): self.x = x self.values = list(range(x)) self.count = 0 def __iter__(self): print("Giving iterator now", self.x) return self def __next__(self): print("Next of", self.x, "is", self.count) if len(self.values) > self.count: self.count += 1 return self.values[self.count - 1] else: print("Raising StopIteration for", self.x) raise StopIteration # Python2/3 compatibility. next = __next__ def __del__(self): print("Deleting", self.x) gen = ((y, z) for y in getIterable(3) for z in getIterable(2)) print("Using generator", gen) next(gen) res = tuple(gen) print(res) print('*' * 20) try: next(gen) except StopIteration: print("Usage past end gave StopIteration exception as expected.") try: print("Generator state then is", inspect.getgeneratorstate(gen)) # @UndefinedVariable except AttributeError: pass print("Its frame is now", gen.gi_frame) print("Early aborting generator:") gen2 = ((y, z) for y in getIterable(3) for z in getIterable(2)) del gen2
def format_execution_point(coro): if asyncio.iscoroutine(coro) or inspect.isasyncgen(coro): if inspect.iscoroutine(coro): t = 'coroutine' s = inspect.getcoroutinestate(coro) c = coro.cr_code f = coro.cr_frame elif inspect.isgenerator(coro): t = 'generator' s = inspect.getgeneratorstate(coro) c = coro.gi_code f = coro.gi_frame elif inspect.isasyncgen(coro): t = 'async_generator' s = getasyncgenstate(coro) f = coro.ag_frame c = coro.ag_code else: return f"(unsupported coroutine type {type(coro)!r})" ref = f'{c.co_filename}:{c.co_firstlineno}:{c.co_name}' if s.endswith('CLOSED'): return f'{t} {ref} just finished' elif s.endswith('SUSPENDED'): return f'{t} {ref} stopped at line {f.f_lineno}' else: assert False, f'Unexpected state {s} for {coro!r})' else: return f"(can't get execution point for {coro!r})"
def package_center(deliver_man, max_per_day): num = 1 # 創建狀態(GEN_CREATED) - 等待開始執行 print(getgeneratorstate(deliver_man)) deliver_man.send(None) # 掛起狀態(GEN_SUSPENDED) - 在yield表達式處暫停 print(getgeneratorstate(deliver_man)) # next(deliver_man) while num <= max_per_day: package_id = 'PKG-%d' % num deliver_man.send(package_id) num += 1 deliver_man.close() # 結束狀態(GEN_CLOSED) - 執行完畢 print(getgeneratorstate(deliver_man)) print('今天的包裹派送完畢!')
def test_operator_or(self): @callbackgoaway def func(): self.assertEqual(self.counter, 0) # orなので片方のincreamentの処理が終わった時点でgeneratorが再開する。 # よって 1 しか増加しない。 yield Inc(self) | Inc(self) self.assertEqual(self.counter, 1) # 同上 yield Inc(self) | Inc(self) | Inc(self) self.assertEqual(self.counter, 2) # 同上 yield Or(Inc(self), Inc(self), Inc(self)) self.assertEqual(self.counter, 3) # 同上 yield Or(self.inc, self.inc, self.inc) self.assertEqual(self.counter, 4) gen = func() self.assertEqual(getgeneratorstate(gen), GEN_CLOSED) # generatorから戻ってきた時には全てのincreamentが実行されている self.assertEqual(self.counter, 11)
def pick_page(name, pages, queue, *a, **kw): """ Picks the highest priority page from the queue. Parameters ---------- name : string Processor name pages : generator object Input data queue : queue object Queue with data to be picked Returns ---------- None """ while True: try: while True: __, page = queue.get(timeout=30) output(page, next_step(queue)) if DEBUG: time=datetime.now().strftime("%Y-%m-%d %H:%M:%S") print('@ %s %s got page %s' % (time, name, page)) gevent.sleep(0) # Set >0 to simulate picker delay except Empty: if DEBUG: print('Queue is empty! %s is on hold...' % name) # Adding time delay in case any more data is generated gevent.sleep(random.randint(4,8)) if queue.empty() and inspect.getgeneratorstate(pages) =='GEN_CLOSED': print('################ %s has quit! ###############' % name) break
def ex_16_2(): my_coro2 = simple_coro2(14) from inspect import getgeneratorstate print(getgeneratorstate(my_coro2)) next(my_coro2) c = getgeneratorstate(my_coro2) print(c) my_coro2.send(28) my_coro2.send(99) getgeneratorstate(my_coro2) """
def stepTraceFunc(event): import inspect if isinstance(event, simpy.Process): xtra = 'Waiting for %s' % (event.target,) generatorName = event._generator.__name__ geninfo = inspect.getgeneratorstate(event._generator) print('TRACE %s: event.Process: gen=%s(locals=%s) (value=%s) %s' % (event.env.now, generatorName, geninfo, event.value, xtra))
def test_handle_demo_exception(self): exc_coro = demo_exc_handling() val = next(exc_coro) self.assertEqual(val, None) val = exc_coro.send(11) self.assertEqual(val, None) exc_coro.throw(DemoException) self.assertEqual(getgeneratorstate(exc_coro), 'GEN_SUSPENDED')
def def_test(): # GEN_CREATE:等待开始执行 # GEN_RUNNING:解释器正在执行,这个状态一般看不到 # GEN_SUSPENDED:在yield表达式处暂停 # GEN_CLOSED:执行结束 my_co = simple_coroutine() # generator object print(getgeneratorstate(my_co)) next(my_co) # 激活协程 print(getgeneratorstate(my_co)) try: my_co.send(1) except StopIteration: pass print(getgeneratorstate(my_co))
def test_property_event(self): root = Factory.Label( text="Test property Event", font_size='30sp', ) @callbackgoaway def func(): Clock.schedule_once(lambda __: setattr(root, 'font_size', 20), .5) yield Event(root, 'font_size') self.assertEqual(root.font_size, 20) stopTouchApp() gen = func() self.assertEqual(getgeneratorstate(gen), GEN_SUSPENDED) runTouchApp(root) self.assertEqual(getgeneratorstate(gen), GEN_CLOSED)
def iteratorCreationTiming(): def getIterable(x): print "Getting iterable", x return Iterable( x ) class Iterable: def __init__(self, x): self.x = x self.values = range( x ) self.count = 0 def __iter__(self): print "Giving iter now", self.x return self def next(self): print "Next of", self.x, "is", self.count if len( self.values ) > self.count: self.count += 1 return self.values[ self.count - 1 ] else: print "Raising StopIteration for", self.x raise StopIteration def __del__(self): print "Deleting", self.x gen = ( (y,z) for y in getIterable( 3 ) for z in getIterable( 2 ) ) print "Using generator", gen gen.next() res = tuple( gen ) print res print "*" * 20 try: gen.next() except StopIteration: print "Use past end gave StopIteration as expected" try: import inspect print "Generator state then is", inspect.getgeneratorstate( gen ) except AttributeError: pass print "Its frame is now", gen.gi_frame print "Early aborting generator" gen2 = ( (y,z) for y in getIterable( 3 ) for z in getIterable( 2 ) ) del gen2
def main(): # create generator object coroutine = coroutine_function() # iterate generator manually with the next() built-in function; # each iteration can raise StopIterate exception try: # get the value the first yield expression: yield 'Hello' so # variable r1 get the string value 'Hello' as the result iteration of # generator object r1 = next(coroutine) print(str.format( '[*] Generator state: {}', inspect.getgeneratorstate(coroutine) )) except StopIteration: # never call because generator has current state is GEN_SUSPENDED not # GEN_CLOSED print(str.format('[#] Generator object iterated')) print(str.format( '[*] The first generator result: {}', r1 )) # the next generator iteration with self.send(value) method; # also try-except and put the string variable 'World' into generator; as # usually generator yield expression try: r2 = coroutine.send('World') print(str.format( '[*] Generator state: {}', inspect.getgeneratorstate(coroutine) )) except StopIteration: print(str.format('[#] Generator object iterated')) print(str.format( '[*] The second generator result: {}', r2 )) # the next generator iteration; ont this stage fall into exception try: r3 = next(coroutine) except StopIteration: print(str.format( '[*] Generator state: {}', inspect.getgeneratorstate(coroutine) ))
def main(): print(str.format( '[*] square_generator является функцией-генератором: {}', inspect.isgeneratorfunction(square_generator) )) print(str.format( '[*] id объекта функции-генератора: {}', id(square_generator) )) # создаем объект-генератор или просто генератор square = square_generator(3) print(str.format( '[*] Вызов функции генератор не запускает код тела функции-генератора' )) print(str.format( '[*] id объекта генератора: {}', id(square) )) print(str.format( '[*] Объект square генератор: {}', inspect.isgenerator(square) )) print(str.format( '[*] Генератор имеет состояние: {}', inspect.getgeneratorstate(square) )) # запускаем генератор на выполнение: итерируем поэлементно for _, item in enumerate(square, start=1): print(str.format('{}-й элемент объекта генератора: {}', _, item)) print(str.format( '[*] Текущее состояние генератора: {}', inspect.getgeneratorstate(square) )) print(str.format( '[*] Текущее состояние генератора: {}', inspect.getgeneratorstate(square) )) # генератор в состоянии GEN_CLOSED не может быть запущен [print(item) for item in square]
def main(): # создаем объект генератор dummy_gen = dummy_generator() print(str.format( '[*] Текущее состояние генератора dummy_gen : {}', inspect.getgeneratorstate(dummy_gen) )) # для запуска генератора необходимо вызвать метод next() или задействовать # его в средствах итерации, такой как for .. in цикл generated_value = next(dummy_gen) print(str.format( '[*] Текущее состояние генератора dummy_gen : {}', inspect.getgeneratorstate(dummy_gen) )) print(str.format( '[*] Сгенерированное генератором значение: {}', generated_value )) try: next(dummy_gen) except StopIteration: print('[#] Генератор проитерирован') print(str.format( '[*] Текущее состояние генератора dummy_gen : {}', inspect.getgeneratorstate(dummy_gen) )) # создаем генератор конечной последовательности четный чисел even_numbers_gen = even_generator_finite(10) [print(str.format( '[*] Четное число: {}', number )) for number in even_numbers_gen] # создаем бесконечный генератор even_numbers_gen_infinitive = even_generator_infinite() for item in even_numbers_gen_infinitive: if item <= 10: print(item, end=', ') else: break
def main(): print('*' * 80) print('[*] create coroutine') # create generator with delimiter splitter = line_splitter(',') print(str.format( '[*] coroutine created and has state: {}', inspect.getgeneratorstate(splitter) )) print('*' * 80) print('[*] prime generator') # prime the generator: can be primed with next(splitter) splitter.send(None) print(str.format( '[*] generator has been primed and has state: {}', inspect.getgeneratorstate(splitter) )) print('*' * 80) print('[*] send the value "A, B, C" in generator and get result') result1 = splitter.send('A, B, C') print(str.format('[*] splitter result #1: {}', result1)) print('*' * 80) print('[*] send the value 123 in generator and get result') result2 = splitter.send(123) print(str.format('[*] splitter result #2: {}', result2)) print('*' * 80) print('[*] send the value "A, B, C" in generator and get result') result3 = splitter.send('A, B, C') print(str.format('[*] splitter result #3: {}', result3)) print('*' * 80) # close generator object explicitly with self.close() method print(str.format( '[*] generator has state: {}', inspect.getgeneratorstate(splitter) )) splitter.close() print('[*] the end') print('*' * 80)
def __next__(self): """ """ genobj = object.__getattribute__(self, "__gen_obj__") try: return genobj.__next__() except : if inspect.getgeneratorstate(genobj) == 'GEN_CLOSED': etype, eval, tb = sys.exc_info() object.__getattribute__(self, "__closed_callback__")(etype, eval, tb) raise
def _kill_state(self): if self._writer: if inspect.getgeneratorstate(self._writer) == "GEN_SUSPENDED": try: self._writer.throw(xml.AbortStream()) except StopIteration: pass else: self._writer = None self._processor = None self._parser = None
def main(): a = 20 b = 110 c = 15 even_check = get_even_number(10, 100) print(str.format( 'generator current state: {}', inspect.getgeneratorstate(even_check) )) # start generator even_check.send(None) print(str.format( 'generator current state: {}', inspect.getgeneratorstate(even_check) )) # send the value in generator object is_even = even_check.send(a) show_result(a, is_even) # send the value in generator object is_even = even_check.send(b) show_result(b, is_even) # send the value in generator object is_even = even_check.send(c) show_result(c, is_even) print(str.format( 'generator current state: {}', inspect.getgeneratorstate(even_check) )) # unbound generator must be closed even_check.close() print(str.format( 'generator current state: {}', inspect.getgeneratorstate(even_check) ))
def main(): # create generator object that will be use as coroutine (two-way data # exchange) dn = double_number() print(str.format( '[*] generator-based coroutine created: {}', inspect.getgeneratorstate(dn) )) # prime coroutine to the nearest yield dn.send(None) print(str.format( '[*] generator-based coroutine primed: {}', inspect.getgeneratorstate(dn) )) # evaluate the value print(str.format('[*] dn.send(5): {}', dn.send(5))) # evaluate the value print(str.format('[*] dn.send(10): {}', dn.send(10))) # close the generator dn.close() print(str.format( '[*] generator-based coroutine closed: {}', inspect.getgeneratorstate(dn) )) # try to iterate generator that has a state GEN_CLOSED try: print(str.format('[*] dn.send(10): {}', dn.send(10))) except StopIteration: print(str.format( '[#] generator-based coroutine has state {} and any iteration on ' 'it raise the exception StopIteration', inspect.getgeneratorstate(dn) ))
def main(): # create generator generator = show_generator_state() print(str.format( '[*] generator current state: {}', inspect.getgeneratorstate(generator) )) # run generator through self.send(None); we can run generator with # self.__next__(): next(generator) generator.send(None) print(str.format( '[*] generator current state: {}', inspect.getgeneratorstate(generator) )) try: # send the value in generator generator.send(generator) except StopIteration: print(str.format( '[*] generator current state: {}', inspect.getgeneratorstate(generator) ))
def main(): ########################################################################## # native coroutine example ########################################################################## print(str.format( 'coroutine_function function is coroutine function => {}', inspect.iscoroutinefunction(coroutine_function) )) print(str.format( 'coroutine_function type => {}', type(coroutine_function) )) # create native python coroutine coroutine = coroutine_function() print(str.format( 'coroutine is coroutine => {}', inspect.iscoroutine(coroutine) )) print(str.format('coroutine type => {}', type(coroutine))) print(str.format( 'coroutine state => {}', inspect.getcoroutinestate(coroutine) )) print(str.format( 'coroutine locals => {}', inspect.getcoroutinelocals(coroutine) )) ########################################################################## # generator example ########################################################################## print(str.format( 'generator_function function is generator function => {}', inspect.isgeneratorfunction(generator_function) )) print(str.format( 'generator_function type => {}', type(generator_function) )) # create generator object generator = generator_function() print(str.format( 'generator is generator object => {}', inspect.isgenerator(generator) )) print(str.format('generator object type => {}', type(generator))) print(str.format( 'generator object state => {}', inspect.getgeneratorstate(generator) )) # iterate generator generator_result1 = next(generator) print(str.format( 'generator object last iterate result => {}', generator_result1 )) print(str.format( 'generator object state => {}', inspect.getgeneratorstate(generator) )) try: generator_result2 = next(generator) print(str.format( 'generator object last iterate result => {}', generator_result2 )) except StopIteration: print(str.format('[#] generator object iterated')) print(str.format( 'generator object state => {}', inspect.getgeneratorstate(generator) )) ########################################################################## # ordinary function example ########################################################################## print(str.format( 'ordinary_function() is ordinary function: {}', inspect.isfunction(ordinary_function) ))
def _generatorstate(self): return inspect.getgeneratorstate(self.generator)
except DemoException: print('*** DemoException handled. Continuing...') else: print('-> coroutine received: {!r}'.format(x)) raise RuntimeError('This line should never run.') #exc_coro = demo_exc_handling() #next(exc_coro) #exc_coro.send(11) #exc_coro.send(22) #exc_coro.close() from inspect import getgeneratorstate #print(getgeneratorstate(exc_coro)) #16-10 #exc_coro = demo_exc_handling() #next(exc_coro) #exc_coro.send(11) #exc_coro.throw(DemoException) #print(getgeneratorstate(exc_coro)) #16-11 exc_coro = demo_exc_handling() next(exc_coro) exc_coro.send(11) exc_coro.throw(ZeroDivisionError) print(getgeneratorstate(exc_coro))
# 生成器是可以暂停的函数 # 用同步的方式编写异步的代码 # 在适当的时候暂停函数并在适当的时候启动函数 # 协程是单线程模式 import inspect # 以下可以理解为协程 def gen_func(): # 返回值给调用方,调用方通过send方式传值给gen value = yield 1 return "ajioy" if __name__ == "__main__": gen = gen_func() print(inspect.getgeneratorstate(gen)) # GEN_CREATED print(next(gen)) print(inspect.getgeneratorstate(gen)) # GEN_SUSPENDED try: next(gen) except StopIteration: pass print(inspect.getgeneratorstate(gen)) # GEN_CLOSED # 获取协程的返回值
#Example 16-2 def simple_coro2(a): print('->Started: a = ', a) b = yield a print('->Received: b = ', b) c = yield a + b print('->Received: c = ', c) my_coro2 = simple_coro2(14) from inspect import getgeneratorstate getgeneratorstate(my_coro2) #'GEN_CREATED' next(my_coro2) #->Started: a = 14 #14 my_coro2.send(28) #->Received: b = 28 #42 my_coro2.send(99) #->Received: c = 99 #Traceback (most recent call last): # File "<stdin>", line 1, in <module> #StopIteration getgeneratorstate(my_coro2) #'GEN_CLOSED' #Example 16-3 @coroutine
def show_generator_state(): generator_object = yield print(str.format( '[~] generator object current state: {}', inspect.getgeneratorstate(generator_object) ))
from functools import wraps from inspect import getgeneratorstate def coroutine(func): """Decorator: primes `func` by advancing to first `yield`""" @wraps(func) def primer(*args, **kwargs): gen = func(*args, **kwargs) next(gen) return gen return primer @coroutine def averager(): total = 0.0 count = 0 average = None while True: term = yield average total += term count += 1 average = total/count coro_avg = averager() print(getgeneratorstate(coro_avg)) print(coro_avg.send(10)) print(coro_avg.send(30)) print(coro_avg.send(5))