Скачать или смотреть Mixing tornado.gen.coroutine with async/await: A Guide for Python Developers

Learn how to transition from `tornado.gen.coroutine` to `async/await` in your Tornado applications effectively. Discover the differences and best practices for refactoring your code.
---
This video is based on the question https://stackoverflow.com/q/64654541/ asked by the user 'ca9163d9' ( https://stackoverflow.com/u/825920/ ) and on the answer https://stackoverflow.com/a/64656783/ provided by the user 'xyres' ( https://stackoverflow.com/u/1925257/ ) 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: Mix tornado.gen.coroutine with async/await?

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.
---
Mixing tornado.gen.coroutine with async/await: A Guide for Python Developers

As developers, we often face the challenge of updating our code to keep up with the latest advancements in Python programming. One such challenge arises when dealing with the Tornado web framework, specifically when transitioning from the older tornado.gen.coroutine to the more modern async/await syntax. This guide will delve into the question: Can you mix tornado.gen.coroutine with async/await, and how can you refactor your code accordingly?

Understanding the Problem

You may find yourself with legacy code that uses @ gen.coroutine for asynchronous operations, like this:

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

Now, you want to call an asynchronous function defined with async def, such as:

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

Given this scenario, the key questions arise:

Can these two syntax forms coexist?

How should you refactor the existing code to adopt async/await?

The Solution: Refactoring for Modern Asynchrony

The good news is that @ gen.coroutine and async/await serve similar purposes in providing asynchronous programming, but they are not the same and should not be mixed inappropriately.

Differences Between @ gen.coroutine and async/await

Historical Context:

@ gen.coroutine was introduced before Python added native support for asynchronous programming through async/await in version 3.5.

It allows functions to yield values and be executed asynchronously.

Preferred Syntax:

Since the introduction of async/await, it is recommended to use this newer syntax for better clarity and compatibility with modern Python practices.

Key Refactoring Guidelines

When converting your legacy Tornado code to use async/await, keep in mind the following important guidelines:

Remove the Coroutine Decorator:

Do not decorate async def functions with @ gen.coroutine. Here's an example of the revised function:

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

Use await Instead of yield:

Replace any instances of yield with await as follows:

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

Handling None Values:

While yield None works, you should avoid using await None as it doesn’t function the same way.

Executing Multiple Asynchronous Calls:

For calling multiple asynchronous functions, you can use:

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

This method replaces the older yield [f1(), f2()] pattern when using @ gen.coroutine.

Conclusion

Refactoring your Tornado code to adopt the async/await syntax not only modernizes your application but also makes your code easier to read and maintain. By following the guidelines mentioned above, you can smoothly transition from @ gen.coroutine to async/await, ensuring your code remains efficient and up-to-date.

Now that you're equipped with this knowledge, it's time to refactor your code and take full advantage of Python’s asynchronous capabilities!