Преобразование оператора "yield from" в код Python 2.7

Я только что столкнулся с этой проблемой, и мое использование было немного сложнее, так как мне нужен возвращаемое значение на yield from:

result = yield from other_gen()

это не может быть представлено как простой for цикл, но может быть воспроизведен с помощью этого:

_iter = iter(other_gen())
try:
    while True: #broken by StopIteration
        yield next(_iter)
except StopIteration as e:
    if e.args:
        result = e.args[0]
    else:
        result = None

надеюсь, это поможет людям, которые столкнулись с той же проблемой. :)

замените их на for-loops:

yield from range(L[start] + 1, L[end])

==>

for i in range(L[start] + 1, L[end]):
    yield i

то же самое про элементы:

yield from missing_elements(L, index, end)

==>

for el in missing_elements(L, index, end):
    yield el

Я думаю, что нашел способ эмулировать Python 3.x yield from построить в Python 2.х. Это не эффективно и это немного hacky, но вот это:

import types

def inline_generators(fn):
    def inline(value):
        if isinstance(value, InlineGenerator):
            for x in value.wrapped:
                for y in inline(x):
                    yield y
        else:
            yield value
    def wrapped(*args, **kwargs):
        result = fn(*args, **kwargs)
        if isinstance(result, types.GeneratorType):
            result = inline(_from(result))
        return result
    return wrapped

class InlineGenerator(object):
    def __init__(self, wrapped):
        self.wrapped = wrapped

def _from(value):
    assert isinstance(value, types.GeneratorType)
    return InlineGenerator(value)

использование:

@inline_generators
def outer(x):
    def inner_inner(x):
        for x in range(1, x + 1):
            yield x
    def inner(x):
        for x in range(1, x + 1):
            yield _from(inner_inner(x))
    for x in range(1, x + 1):
        yield _from(inner(x))

for x in outer(3):
    print x,

результат:

1 1 1 2 1 1 2 1 2 3

может быть, кто-то находит это полезным.

известные проблемы: отсутствует поддержка send () и различных угловых случаев, описанных в PEP 380. Они могут быть добавлены, и я буду редактировать свою запись, как только я ее получу рабочий.

как насчет использования определения от pep-380 чтобы построить версию синтаксиса Python 2:

инструкции:

RESULT = yield from EXPR

семантически эквивалентно:

_i = iter(EXPR)
try:
    _y = next(_i)
except StopIteration as _e:
    _r = _e.value
else:
    while 1:
        try:
            _s = yield _y
        except GeneratorExit as _e:
            try:
                _m = _i.close
            except AttributeError:
                pass
            else:
                _m()
            raise _e
        except BaseException as _e:
            _x = sys.exc_info()
            try:
                _m = _i.throw
            except AttributeError:
                raise _e
            else:
                try:
                    _y = _m(*_x)
                except StopIteration as _e:
                    _r = _e.value
                    break
        else:
            try:
                if _s is None:
                    _y = next(_i)
                else:
                    _y = _i.send(_s)
            except StopIteration as _e:
                _r = _e.value
                break
RESULT = _r

в генераторе, заявлении:

return value

семантически эквивалентно

raise StopIteration(value)

за исключением того, что, как и в настоящее время, исключение не может быть поймано except предложения в возвращающем генераторе.

В StopIteration исключение ведет себя так, как будто определено таким образом:

class StopIteration(Exception):

    def __init__(self, *args):
        if len(args) > 0:
            self.value = args[0]
        else:
            self.value = None
        Exception.__init__(self, *args)

Я нашел использование контекстов ресурсов (используя python-resources модуль), чтобы быть элегантным механизмом для реализации подгенераторов в Python 2.7. К счастью, я уже использовал контексты ресурсов в любом случае.

Если в Python 3.3 вы бы:

@resources.register_func
def get_a_thing(type_of_thing):
    if type_of_thing is "A":
        yield from complicated_logic_for_handling_a()
    else:
        yield from complicated_logic_for_handling_b()

def complicated_logic_for_handling_a():
    a = expensive_setup_for_a()
    yield a
    expensive_tear_down_for_a()

def complicated_logic_for_handling_b():
    b = expensive_setup_for_b()
    yield b
    expensive_tear_down_for_b()

в Python 2.7 у вас будет:

@resources.register_func
def get_a_thing(type_of_thing):
    if type_of_thing is "A":
        with resources.complicated_logic_for_handling_a_ctx() as a:
            yield a
    else:
        with resources.complicated_logic_for_handling_b_ctx() as b:
            yield b

@resources.register_func
def complicated_logic_for_handling_a():
    a = expensive_setup_for_a()
    yield a
    expensive_tear_down_for_a()

@resources.register_func
def complicated_logic_for_handling_b():
    b = expensive_setup_for_b()
    yield b
    expensive_tear_down_for_b()

обратите внимание, что сложные логические операции требуют только регистрации в качестве ресурса.