Asynchronous programming is implemented in Python through asyncio, allowing programs to perform other tasks while waiting for the I/O operation to complete. Use async def to define coroutines and call other coroutines through await, avoiding the performance problems of traditional blocking programming. 1. asyncio.run() simplifies event loop management, automatically creates and cleanses event loops; 2. Use asyncio.gather() to run multiple tasks concurrently to improve efficiency; 3. In embedded environments such as Jupyter, asyncio.get_event_loop() is required to obtain the current event loop. Mastering these basics can you write efficient asynchronous Python code.

Asynchronous programming in Python might sound complex at first, but once you get the hang of it, it's a powerful way to write faster and more efficient code — especially for I/O-bound tasks like handling network requests or waiting for file operations.

If you're new to async programming, the main thing to understand is that asyncio lets your program do other work while waiting for something else to finish. That's different from traditional "blocking" code, where each step has to wait for the previous one to complete.

What Is async/await and Why Use It?

At the core of asyncio are two keywords: async and await . An async def function is called a coroutine, which doesn't run immediately when called — instead, it returns a coroutine object that needs to be awaited or scheduled.

You use await inside an async function to call another coroutine and wait for its result. This setup allows Python to pause the execution of that function and switch to doing something else while it waits.

Why bother? Because this model avoids creating multiple threads or processes, which can be heavy and complicated. Instead, everything runs within a single thread, managed by an event loop.

Here's a basic example:

 import asyncio

async def says_hello():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

asyncio.run(say_hello())

This script prints “Hello”, waits for one second without blocking the whole program, then prints “World”.

How to Run Async Code with asyncio.run()

Before Python 3.7, managing event loops was a bit messy — you had to create and manage them manually. But now, asyncio.run() handles all that for you. Just pass it your top-level coroutine, and it will set up the loop, run your code, and clean things up afterward.

It's the recommended way to start asynchronous programs unless you have specific reasons not to.

A few key points about asyncio.run() :

• It creates a new event loop every time it's called.
• It closes any resources properly after execution.
• Don't use it inside already running event loops — you'll get an error.

If you're using Jupyter notebooks or embedding async code inside another system, you may need to use await directly or access the current event loop via asyncio.get_event_loop() instead.

Structuring Concurrent Tasks with asyncio.gather()

Running one coroutine at a time isn't much faster than regular code. The real benefit comes when you run multiple coroutines concurrently.

To do that, asyncio.gather() is your go-to tool. It schedules multiple awaitable objects (like coroutines) and waits for all of them to finish.

Here's how you can run three tasks at once:

 async def task(name):
    print(f"{name} started")
    await asyncio.sleep(2)
    print(f"{name} finished")

async def main():
    await asyncio.gather(
        task("Task A"),
        task("Task B"),
        task("Task C")
    )

asyncio.run(main())

In this example, all three tasks start together. After about two seconds, they all finish. You'll see the "started" messages first, then a pause, then the "finished" ones.

A couple of tips:

• Make sure you await the result of gather() , otherwise nothing will actually run.
• If you're passing in coroutine objects, don't add parentses — task() starts it; task refers to the function itself.
• You can also gather results by capturing return values ??from your coroutines.

Wrapping Up

Getting started with asyncio doesn't have to be overwhelming. Start small with async def , await , and asyncio.run() , then move on to structuring concurrent workflows with asyncio.gather() .

Once you're comfortable with these basics, you can explore more advanced topics like async context managers, queues, or HTTP clients like aiohttp .

But for most beginners, the above covers what you need to start writing useful async Python code.

Basically that's it.

The above is the detailed content of Getting Started with Asynchronous Programming in Python (asyncio). For more information, please follow other related articles on the PHP Chinese website!