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 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 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)
))
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)
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))
