关于使用asyncio和wait/async-def关键字进行python异步编程的问题

我目前正在通过查看示例代码来研究Python中的同步编程和使用asyncio的异步编程之间的区别。在这样做的时候,我有一个问题。

由于我目前的工作是一名机器学习工程师,我使用为机器学习服务的服务器逻辑的类比来编写示例代码。以下是我想描述的场景:

首先,存在一个称为预处理的函数,该函数必须始终首先执行。这是因为它为后面的两个函数(predict和apply_business_logic)预处理输入数据。

其次,预处理函数的输出将用作predict和apply_business_logic函数的输入。预测函数简单地生成根据机器学习模型计算的预测,而apply_business_logic函数应用任意的业务逻辑。关键是这两个函数相互独立,使得异步执行比同步执行更有效率。

最后,该逻辑包括计算预测和apply_business_logic函数输出的加权平均值,以确定最终结果,并返回该结果。

如果我们假设逻辑结构为如上所述的三个步骤,那么同步执行它是非常简单的。

1.同步运行

import time


def preprocess(x: list[int]):
    """
    dummy preprocess
    """
    return x


def predict(x: list[int]) -> float:
    time.sleep(3)
    pred = sum(x) / len(x)
    print(">> finish `predict` function!")
    return pred


def apply_business_logic(x: list[int]) -> int:
    res = sum(x) ** 2
    print(">> finish `apply_business_logic` function!")
    return res


def main(x: list[int]) -> float:
    # sync function because it must be done before running `predict` and `apply_business_logic` function
    x = preprocess(x)

    # asynchronously running(..?)
    pred_result = predict(x)
    logic_result = apply_business_logic(x)

    # final response
    alpha = 0.7
    response = (alpha * pred_result) + ((1 - alpha) * logic_result)
    return response

if __name__ == "__main__":
    x = list(range(100))

    res = main(x)
    print('>> final result:', res)

2.异步运行(1)

我无法确保以下代码将异步运行。。

import asyncio


def preprocess(x: list[int]):
    """
    dummy preprocess
    """
    return x


async def predict(x: list[int]) -> float:
    await asyncio.sleep(delay=3)
    pred = sum(x) / len(x)
    print(">> finish `predict` function!")
    return pred


async def apply_business_logic(x: list[int]) -> int:
    res = sum(x) ** 2
    print(">> finish `apply_business_logic` function!")
    return res


async def main(x: list[int]) -> float:
    # sync function because it must be done before running `predict` and `apply_business_logic` function
    x = preprocess(x)

    # asynchronously running(..?)
    pred_result = await predict(x)
    logic_result = await apply_business_logic(x)

    # final response
    alpha = 0.7
    response = (alpha * pred_result) + ((1 - alpha) * logic_result)
    return response

if __name__ == "__main__":
    x = list(range(100))

    loop = asyncio.get_event_loop()
    res = loop.run_until_complete(main(x))
    loop.close()
    print('>> final result:', res)

3.异步运行(2)

这段代码必须异步运行,我检查了它。

import asyncio

def preprocess(x: list[int]):
    """
    dummy preprocess
    """
    return x


async def predict(x: list[int]) -> float:
    await asyncio.sleep(delay=3)  
    pred = sum(x) / len(x)
    print(">> finish `predict` function!")
    return pred


async def apply_business_logic(x: list[int]) -> int:
    res = sum(x) ** 2
    print(">> finish `apply_business_logic` function!")
    return res


async def main(x: list[int]) -> float:
    # sync function because it must be done before running `predict` and `apply_business_logic` function
    x = preprocess(x)

    tasks = await asyncio.gather(
        predict(x),
        apply_business_logic(x)
    )
    pred_result, logic_result = tasks[0], tasks[1]

    # final response
    alpha = 0.7
    response = (alpha * pred_result) + ((1-alpha) * logic_result)
    return response

if __name__ == "__main__":
    x = list(range(100))
    resp = asyncio.run(main(x))
    print("resp >>", resp)

我不知道这两种方法之间的区别( 1.synchronous running 和 2.asynchronous running(1) ). 尤其是第二种方法( 2.异步运行(1) )是第一次打印 print(">> finish 预测 function!") 尽管使用异步语法( await, async def 关键字..)。所以,第二种方法不是异步的??