You can call the asyncio.run() function to execute your async function and get the result. This is a simple and convenient way to run a single coroutine and get its result.

The following example uses the aiohttp library to fetch data from a REST API. You can install aiohttp with pip like this:

pip install aiohttp

Or:

pip3 install aiohttp

The code:

# SlingAcademy.com
# This code uses Python 3.11.4

import asyncio
import aiohttp

# create a coroutine to fetch data from the API
async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.json()

# get the result from the coroutine
result = asyncio.run(fetch_data("https://api.slingacademy.com/"))

# use the result as you wish
print(result)

Output:

{'success': True, 'message': 'Welcome to Sling Academy Public API'}

Await the async function in another async function

This approach uses the await keyword to wait for the async function to finish and get its return value. This can only be done inside another async function.

The example below defines an async function get_data that simulates fetching some data from a remote server and returning it as a dictionary. It also defines another async function process_data that calls get_data using await and prints its return value:

# SlingAcademy.com
# This code uses Python 3.11.4

import asyncio
import random


# Define an async function that returns a value
async def get_data():
    # Simulate some network delay
    await asyncio.sleep(random.random() * 5)
    # Return some data as a string
    return {"status": "success", "message": "Welcome to Sling Academy!"}


# Define another async function that calls the first one using await
async def process_data():
    # Call get_data using await and assign its return value to a variable
    data = await get_data()
    # Use the variable to perform further operations
    print(f"The data is: {data}")

asyncio.run(process_data())

Output:

The data is: {'status': 'success', 'message': 'Welcome to Sling Academy!'}

Using loop.run_until_complete()

You can use the loop.run_until_complete() method to run an async function until it is done and get the result. This is useful if you already have an event loop object and want to run one or more coroutines on it.

Example:

# SlingAcademy.com
# This code uses Python 3.11.4

import asyncio

# mimic a long running task
async def square(number: int) -> int:
    await asyncio.sleep(3)
    return number * number

# create an event loop
loop = asyncio.get_event_loop()

# get the result
result = loop.run_until_complete(square(2023))

# use the result
print(result)  

# close the loop to free up resources
loop.close()

This code will print a number after 3 seconds:

Using the asyncio.gather() function

The asyncio.gather() function can help you run multiple async functions in parallel and get their results as a list. This is useful if you want to perform concurrent tasks and collect their results at once.

Example:

# SlingAcademy.com
# This code uses Python 3.11.4

import asyncio
import random


# This function will be called by asyncio.gather()
async def square(number: int) -> int:
    await asyncio.sleep(random.randint(1, 5))
    return number * number


# This function will call square() four times
async def do_multiple_tasks():
    return await asyncio.gather(square(10), square(20), square(30), square(40))

# Get the results as a list
result = asyncio.run(do_multiple_tasks())

# Use the results the way you want
print(result)

Output (appears after one or a few seconds):