Это слишком сложно.

аюсь обернуть голову вокруг асинхронного / ожидания в Python.

Я на правильном пути?

async а также@coroutine функции возвращают сопрограмму / генератор, а не возвращаемое значение.

await извлекает фактическое возвращаемое значение сопрограммы / генератора.
 

async Результат функции (сопрограммы) предназначен для добавления в цикл обработки событий.

await создает «мост» между циклом обработки событий и ожидаемой сопрограммой (включение следующей точки).

@coroutine«syield напрямую связывается с обработкой событий (пропуск прямого звонка, который ждет результата)
 

await может использоваться только внутри асинхронных функций.

yield можно использовать только внутри@coroutine.

(@coroutine = @types.coroutine)

Ответы на вопрос(2)

(иллюстрирует весь поток управления междуasync а такжеtypes.coroutine и цикл событий)

import types


class EL:
    """Fake An event loop."""

    def __init__(self, outer_async):
        self.outer_async = outer_async

    def loop(self):
        print('    EL.loop : outer_async.send(None)')
        send_result = self.outer_async.send(None) # seed outer_async.
        print('    EL.loop : outer_async.send(None) -> outer_async_send_result = {}'.format(send_result))

        do_loop = True
        loop_counter = 0

        while do_loop:
            print()
            loop_counter += 1
            try:
                arg = send_result + '-loop(send-{})'.format(loop_counter)
                print('    EL.loop.while : task.outer_async.send({})'.format(arg))
                send_result = self.outer_async.send(arg) # raises StopIteration.
                print('    EL.loop.while : task.outer_async.send({}) -> send_result = {}'.format(arg, send_result))
            except StopIteration as e:
                print('    EL.loop.while : except StopIteration -> {}'.format(e.value))
                do_loop = False
        return loop_counter


async def outer_async(label):
    inner_coro_arg = label + '-A1'
    print('        outer_async({}) : await inner_coro({})'.format(label, inner_coro_arg))
    await_result = await inner_coro(inner_coro_arg)
    print('        outer_async({}) : await inner_coro({}) -> await_result = {}'.format(label, inner_coro_arg, await_result))

    inner_coro_arg = label + '-A2'
    print('        outer_async({}) : await inner_coro({})'.format(label, inner_coro_arg))
    await_result = await inner_coro(inner_coro_arg)
    print('        outer_async({}) : await inner_coro({}) -> await_result = {}'.format(label, inner_coro_arg, await_result))
    return 555555


@types.coroutine
def inner_coro(inner_coro_label):
    yld_arg = inner_coro_label + '-C(yield)'
    print('            inner_coro({}) : yield({})'.format(inner_coro_label, yld_arg))
    yield_result = yield yld_arg
    print('            inner_coro({}) : yield({}) -> yield_result = {}'.format(inner_coro_label, yld_arg, yield_result))
    return_value = yield_result + '-C(return)'
    print('            inner_coro({}) : return -> {}'.format(inner_coro_label, return_value))
    return return_value


def main():
    loop = EL(outer_async('$'))
    print('main() : loop.loop')
    loop_outer_async = loop.loop()
    print('main() : loop.loop -> {}'.format(loop_outer_async))


if __name__ == '__main__':
    main()

Результат:

main() : loop.loop
    EL.loop : outer_async.send(None)
        outer_async($) : await inner_coro($-A1)
            inner_coro($-A1) : yield($-A1-C(yield))
    EL.loop : outer_async.send(None) -> outer_async_send_result = $-A1-C(yield)

    EL.loop.while : task.outer_async.send($-A1-C(yield)-loop(send-1))
            inner_coro($-A1) : yield($-A1-C(yield)) -> yield_result = $-A1-C(yield)-loop(send-1)
            inner_coro($-A1) : return -> $-A1-C(yield)-loop(send-1)-C(return)
        outer_async($) : await inner_coro($-A1) -> await_result = $-A1-C(yield)-loop(send-1)-C(return)
        outer_async($) : await inner_coro($-A2)
            inner_coro($-A2) : yield($-A2-C(yield))
    EL.loop.while : task.outer_async.send($-A1-C(yield)-loop(send-1)) -> send_result = $-A2-C(yield)

    EL.loop.while : task.outer_async.send($-A2-C(yield)-loop(send-2))
            inner_coro($-A2) :, yield($-A2-C(yield)) -> yield_result = $-A2-C(yield)-loop(send-2)
            inner_coro($-A2) : return -> $-A2-C(yield)-loop(send-2)-C(return)
        outer_async($) : await inner_coro($-A2) -> await_result = $-A2-C(yield)-loop(send-2)-C(return)
    EL.loop.while : except StopIteration -> 555555
main() : loop.loop -> 2
 Tushortz25 июл. 2018 г., 08:51
Это слишком сложно.

async а также@coroutine функции возвращают сопрограмму / генератор, а не возвращаемое значение

Быть техническим,types.coroutine возвращает сопрограмму на основе генератора, которая отличается от генераторов и отличается от сопрограмм.

await извлекает фактическое возвращаемое значение сопрограммы / генератора.

await, похожий наyield from, приостанавливает выполнение сопрограммы до тех пор, пока ожидаемое выполнение не завершится и не вернет результат.

Результат асинхронной функции (сопрограммы) предназначен для добавления в цикл обработки событий.

Да.

await создает «мост» между циклом обработки событий и ожидаемой сопрограммой (включение следующей точки).

await создает точку приостановки, которая указывает в цикле событий, что будет выполняться некоторая операция ввода-вывода, что позволяет ей переключаться на другую задачу.

Выход @ coroutine напрямую связывается с циклом обработки событий. (пропуск прямого звонка, который ждет результата)

Нет, генераторы сопрограмм используютyield from аналогичноawaitнеyield.

await может использоваться только внутри асинхронных функций.

Да.

Выход можно использовать только внутри сопрограммы.

yield from может использоваться внутри сопрограмм на основе генератора (генераторы украшеныtypes.coroutine) и, начиная с Python 3.6, вasync функции, которые приводят к асинхронному генератору.

 industryworker359511228 сент. 2017 г., 08:51
Я исследовал дальше. В ответstackoverflow.com/a/46462604/3595112, когдаinner_coro делаетyieldпоток управления переходит в цикл обработки событий, пропуская начальный вызывающийouter_async, Учитывая этот пример, вы бы согласились, что здесьyield способ для сопрограммы общаться напрямую с циклом событий?

Ваш ответ на вопрос