相关疑难解决方法(0)

有什么作用asyncio.create_task()？我看过文档，似乎无法理解。一些让我困惑的代码是这样的：

import asyncio

async def counter_loop(x, n):
    for i in range(1, n + 1):
        print(f"Counter {x}: {i}")
        await asyncio.sleep(0.5)
    return f"Finished {x} in {n}"

async def main():
    slow_task = asyncio.create_task(counter_loop("Slow", 4))
    fast_coro = counter_loop("Fast", 2)

    print("Awaiting Fast")
    fast_val = await fast_coro
    print("Finished Fast")

    print("Awaiting Slow")
    slow_val = await slow_task
    print("Finished Slow")

    print(f"{fast_val}, {slow_val}")

asyncio.run(main())

这给出了以下输出：

001 | Awaiting Fast
002 | Counter Fast: 1
003 | Counter Slow: 1
004 | Counter Fast: 2
005 | Counter Slow: …

在Python中，我们await在每个协程对象之前需要一个关键字，以便事件循环调用它。但是当我们放置 时await，它会使调用阻塞。因此，我们最终会做与阻塞方式相同的事情。这样的用途有什么意义呢？

https://www.aeracode.org/2018/02/19/python-async-simplified/

https://stackabuse.com/python-async-await-tutorial/

有这个简单的代码：

import asyncio

async def main():
    f = asyncio.Future()
    await f

asyncio.run(main())

协程（此处main）可以等待 Future 对象。它基本上会被阻止，直到f有结果或设置异常，或者直到它们被取消。

出于好奇，我想知道“这种等待是如何发生的”？我具体检查了Task.py的 Python 实现def __step()。

在最简单的形式中，快乐的情况下，当返回的result是 Future 时，它​​是：

.
.
result = coro.send(None)
.
.
blocking = getattr(result, '_asyncio_future_blocking', None)
.
.
if blocking:   # So `result` is a Future with `_asyncio_future_blocking == True`
    result._asyncio_future_blocking = False
    result.add_done_callback(self.__wakeup, context=self._context)
    self._fut_waiter = result
    if self._must_cancel:
        if self._fut_waiter.cancel(msg=self._cancel_message):
            self._must_cancel = False

我从本节中得到了所有其他答案（例如当它result是裸露的yield或CancellationError发生时等等），除了这个！ …

在这个页面上我读到了这样的内容：

asyncio 模块中的协程不受全局解释器锁或 GIL 的限制。

asyncio但是，如果事件循环和threading线程都在带有 GIL 的单个 Python 进程中运行，这怎么可能呢？

据我了解， GIL 对 的影响asyncio不会像对 那样强烈threading，因为在 的情况下threading，解释器会切换到无用的操作，例如time.sleep()。因此，在使用时asyncio，建议使用asyncio.sleep().

据我所知，这些工具的设计目的略有不同，threading更常用于执行 IO 绑定操作的“遗留”阻塞代码，以及asyncio非阻塞代码。

我想知道当事件循环切换任务时，python 提供了什么保证。

据我所知async/await从线程显著不同之处在于基于时间分片事件循环不切换任务，这意味着除非任务收益率（await），它会无限期地进行。这实际上很有用，因为在 asyncio 下管理临界区比使用线程更容易。

我不太清楚的是以下内容：

async def caller():
    while True:
        await callee()


async def callee():
    pass

在这个例子中caller是重复的await。所以从技术上讲，它正在屈服。但是我不清楚这是否会允许事件循环上的其他任务执行，因为它只callee屈服于并且永远不会屈服。

也就是说，如果我callee在“关键部分”内等待，即使我知道它不会阻塞，我是否有发生其他意外事件的风险？

我有这个 Cython 代码（简化）：

class Callback:
    async def foo(self):
        print('called')

cdef void call_foo(void* callback):
    print('call_foo')
    asyncio.wait_for(<object>callback.foo())

async def py_call_foo():
    call_foo(Callback())

async def example():
    loop.run_until_complete(py_call_foo())

但是会发生什么：我得到RuntimeWarning: coroutine Callback.foo was never awaited. 而且，事实上，它从未被调用过。然而，call_foo被称为。

知道发生了什么/如何让它真正等待Callback.foo完成吗？

扩大的视野

在上面的示例中，缺少一些重要的细节：特别是，从call_foo. 真正的项目设置是这样的：

1. 有规则的 Bison 解析器。规则引用了特制的结构，我们称之为ParserState. 此结构包含对回调的引用，当规则匹配时，解析器会调用回调。

2. 在 Cython 代码中，有一个类，我们称之为Parser，包的用户应该扩展它以制作他们的自定义解析器。这个类有一些方法，然后需要从ParserState.

3. 解析应该是这样发生的：

   async def parse_file(file, parser):
       cdef ParserState state = allocate_parser_state(
           rule_callbacks,
           parser,
           file,
       )
       parse_with_bison(state)
   

   Run Code Online (Sandbox Code Playgroud)

回调具有一般形状：

ctypedef void(callback*)(char* text, void* parser)

我不得不承认我不知道具体是如何asyncio实现的await …

您好，我是 Python 新手，正在尝试使用 Detrous 制作的 Dark Sky Python API。当我运行演示代码时，出现错误：

forecast = await darksky.get_forecast(
              ^
SyntaxError: 'await' outside function

此错误源于：

forecast = await darksky.get_forecast(
    latitude, longitude,
    extend=False, # default `False`
    lang=languages.ENGLISH, # default `ENGLISH`
    units=units.AUTO, # default `auto`
    exclude=[weather.MINUTELY, weather.ALERTS] # default `[]`
)

我不太确定如何解决这个问题，我正在使用 python 3。

谢谢

据我了解，目的是同时asyncio.gather运行其参数，并且当协程执行等待表达式时，它为事件循环提供了安排其他任务的机会。考虑到这一点，我惊讶地发现以下代码片段忽略了.asyncio.gather

import asyncio                                                             
  
async def aprint(s):
    print(s)

async def forever(s):
    while True:
        await aprint(s)

async def main():
    await asyncio.gather(forever('a'), forever('b'))

asyncio.run(main())

async def forever(s):
    while True:
        await aprint(s)
        await asyncio.sleep(1.)

async def forever(s):
    while True:
        await aprint(s)
        await asyncio.sleep(0.)