如何按顺序运行2个异步调用？

# 第一个异步调用
def async_call1(callback):
    # 异步操作
    result = perform_async_operation1()
    # 执行回调函数
    callback(result)

# 第二个异步调用
def async_call2(callback):
    # 异步操作
    result = perform_async_operation2()
    # 执行回调函数
    callback(result)

# 按顺序运行异步调用
def run_async_calls():
    async_call1(lambda result1: async_call2(lambda result2: process_results(result1, result2)))

// 第一个异步调用
function asyncCall1() {
  return new Promise((resolve, reject) => {
    // 异步操作
    performAsyncOperation1((result) => {
      resolve(result);
    });
  });
}

// 第二个异步调用
function asyncCall2(result1) {
  return new Promise((resolve, reject) => {
    // 异步操作，可以使用result1
    performAsyncOperation2(result1, (result) => {
      resolve(result);
    });
  });
}

// 按顺序运行异步调用
async function runAsyncCalls() {
  const result1 = await asyncCall1();
  const result2 = await asyncCall2(result1);
  processResults(result1, result2);
}

# 第一个异步调用
async def async_call1():
    # 异步操作
    result = await perform_async_operation1()
    return result

# 第二个异步调用
async def async_call2(result1):
    # 异步操作，可以使用result1
    result = await perform_async_operation2(result1)
    return result

# 按顺序运行异步调用
async def run_async_calls():
    result1 = await async_call1()
    result2 = await async_call2(result1)
    process_results(result1, result2)