Скачать или смотреть Understanding the Async/Await Behavior in Python: Why Is There No Difference in Result?

Discover why your `async/await` code in Python behaves like synchronous code and learn how to execute coroutines concurrently for expected results.
---
This video is based on the question https://stackoverflow.com/q/63105445/ asked by the user 'Laika_Boss' ( https://stackoverflow.com/u/6117702/ ) and on the answer https://stackoverflow.com/a/63105515/ provided by the user 'kingkupps' ( https://stackoverflow.com/u/6476496/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: No difference in result between async/await and synchronous way in Python

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Async/Await Behavior in Python: Why Is There No Difference in Result?

When delving into Python's asynchronous programming, many developers encounter an interesting concept: async/await. You might be expecting a difference in the result when using async/await versus traditional synchronous programming. However, as you might have experienced, you can end up with a sequence of outputs that resembles synchronous execution. In this post, we will explore this behavior and demonstrate how to achieve concurrent execution using Python’s asyncio library.

The Starting Point: Your Code

Let’s take a look at the initial code that you wrote:

[[See Video to Reveal this Text or Code Snippet]]

Expected Output

You might have expected the output to look like this:

[[See Video to Reveal this Text or Code Snippet]]

However, the actual output you received was:

[[See Video to Reveal this Text or Code Snippet]]

Understanding the Execution Flow

To understand why you experienced this behavior, we must look closer at how async/await operates:

Sequential Execution: In your original main function, you're calling await on each coroutine one after the other. This means that it waits for the first coroutine (write_after(1, 'Hello...')) to complete before starting the next one (write_after(2, '...world')).

Pauses: The pauses occur after each begin print statement since the code is not running concurrently – it waits for the execution of the first task to finish completely before moving to the second one.

The Solution: Running Coroutines Concurrently

To achieve the expected concurrent behavior, you can use the asyncio.gather() method. This allows you to run multiple coroutines at the same time, making better use of the asynchronous capabilities of Python.

Updated Code Example

Here's how you should structure your main function:

[[See Video to Reveal this Text or Code Snippet]]

Expected Output with asyncio.gather()

With this updated approach, you will now see the following output:

[[See Video to Reveal this Text or Code Snippet]]

Conclusion: Embracing Asynchronous Programming

By utilizing asyncio.gather(), you can run your coroutines concurrently, achieving the well-timed, non-blocking behavior that async/await promises to deliver. This understanding is crucial for any developer wanting to harness the full power of asynchronous programming in Python.

Next time you write asynchronous code, remember that concurrency is not just about using async and await – it's about the structure you define in your main function! Happy coding!