Python - 重载异步方法

Question

我正在为 API 构建一个包装器。目前，它有效。但是，它是同步的，使用请求模块进行 HTTP 调用。

我想实现一种方法来异步调用这些方法，而不必使用不同的名称或 lib 版本。我立刻想到了重载，但是看到python中的重载与其他语言有点不同，看起来不太可能。

基本上，我想构建一个看起来像这样的类（从想法上讲，我知道它在 Python 中不起作用）：

class Foo:
    def foo(self):
        # Requests code...
        print("foo sync")

    async def foo(self):
        # aiohttp code...
        print("foo async")

并以这种方式使用它：

f = Foo()
f.foo()
await f.foo()

输出：

>> "foo sync"
>> "foo async"

基本上，在这段代码中，异步函数会完全覆盖前一个函数，这并没有真正的帮助。

通过谷歌搜索，这看起来不太可能，但是，Python 总是设法让我感到惊讶。

提前致谢：D

Answer 1

问题：重载异步方法

考虑以下class 定义，将Inheritance 与Overloading 一起使用！

你有一个基础class Foo:，从它继承class Foo_async(Foo):。
因此，您可以在 sync 和 async 模式下重用大部分实现。
class Foo_async主要只实现async/await的要求。

注意：我使用的是asyncio。例如：

import asyncio

class Foo():
    def __init__(self):
        self.mode = "sync"

    def __repr__(self):
        return "{}::foo() {}".format(self.__class__.__name__, self.mode)

    def foo(self):
        print("{}".format(self.__repr__()))
        print("\t\tworkload {}".format(1))
        print("\t\tworkload {}".format(2))

class Foo_async(Foo):
    def __init__(self):
        self.mode = "async awaited"

    async def foo(self):
        super().foo()

用法：

async def run(foo):
    await foo.foo()

if __name__ == '__main__':
    Foo().foo()

    loop = asyncio.get_event_loop()
    loop.run_until_complete(run(Foo_async()))
    loop.close()

输出：

Foo::foo() sync
        workload 1
        workload 2
Foo_async::foo() async awaited
        workload 1
        workload 2

---

如果您想要更细化，请将 def foo(...) 中的工作负载拆分为单独的工作负载函数。
现在您可以使用await 调用此函数。

例如：（显示，只改代码！）

class Foo():
    ...

    def foo(self):
        print("{}".format(self.__repr__()))
        self.workload_1()
        self.workload_2()

    def workload_1(self):
        print("\t\t{} workload {}".format(self.mode, 1))

    def workload_2(self):
        print("\t\t{} workload {}".format(self.mode, 2))

class Foo_async(Foo):
    ...       

    async def foo(self):
        print("{}".format(self.__repr__()))
        await self.workload_1()
        await self.workload_2()

    async def workload_1(self):
        super().workload_1()

    async def workload_2(self):
        super().workload_2()

输出：

Foo::foo() sync
        sync workload 1
        sync workload 2
Foo_async::foo() async awaited
        async awaited workload 1
        async awaited workload 2

用 Python：3.5.3 测试