🔧 Как работает async/await в Python для выполнения асинхронного кода

Async/await в Python

Async/await - это механизм в Python, который обеспечивает асинхронное выполнение кода.

Ключевое слово async

Оно используется для объявления асинхронной функции. Функция, помеченная как async, позволяет выполнение других задач во время ожидания долгих операций.

async def some_async_function():
    # Ждем выполнение долгой операции
    await long_operation()
    # Выполняем другие задачи
    do_other_tasks()
    # Возвращаем результат
    return result
    

Ключевое слово await

Ожидание наступления события (ждем выполнения долгой операции). Функция с ключевым словом await может быть использована только внутри асинхронной функции.

async def long_operation():
    # Долгая операция, выполняющаяся асинхронно
    await some_async_task()
    return result
    

Пример использования async/await

Код ниже показывает пример, как использовать async/await для выполнения нескольких задач параллельно:

import asyncio

async def task1():
    await asyncio.sleep(1)
    print("Задача 1 выполнена!")

async def task2():
    await asyncio.sleep(2)
    print("Задача 2 выполнена!")

async def main():
    await asyncio.gather(task1(), task2())

asyncio.run(main())
    

В этом примере асинхронные задачи task1 и task2 выполняются параллельно с помощью asyncio.gather.

Как работает async await в Python?

Программирование с использованием асинхронных операций становится все более популярным в современном мире разработки программного обеспечения. В Python мы можем использовать ключевые слова async и await для создания асинхронных функций и ожидания результатов выполнения асинхронных задач.

Async является ключевым словом, которое позволяет определить асинхронную функцию. Асинхронные функции в Python могут содержать другие асинхронные операции и блокирующие операции без проблем. Они выполняются в особых объектах, называемых корутины, которые возвращаются из асинхронных функций и могут быть запланированы на выполнение другими видами асинхронных операций.

async def calculate_square(number):
    print(f"Вычисление квадрата для числа {number}...")
    await asyncio.sleep(1)
    result = number ** 2
    return result

async def main():
    tasks = []
    for i in range(1, 6):
        task = asyncio.create_task(calculate_square(i))
        tasks.append(task)
        
    completed_tasks = await asyncio.gather(*tasks)
    print("Результаты вычислений:")
    for result in completed_tasks:
        print(result)

asyncio.run(main())
    

В представленном примере мы имеем две асинхронные функции. Функция calculate_square вычисляет квадрат переданного числа с небольшой задержкой. В функции main мы создаем список задач, каждая из которых вызывает функцию calculate_square. Затем мы ожидаем выполнения всех этих задач с помощью функции asyncio.gather и выводим результаты.

Ключевое слово await используется для ожидания завершения асинхронных операций, таких как asyncio.sleep в нашем примере. Когда встречается await, выполнение текущей асинхронной функции приостанавливается и передается в другую асинхронную операцию. Как только эта операция завершится, выполнение возвращается к месту, где был вызван await.

Важно отметить, что асинхронные функции поддерживают создание корутин с использованием yield и yield from, но в современных версиях Python рекомендуется использовать async и await. Ключевые слова async и await делают код более понятным и легким для чтения.

Асинхронные операции позволяют выполнять несколько задач параллельно, без необходимости блокировки исполнения всей программы. Это особенно ценно при работе с сетевыми запросами или вводом/выводом, где задачи могут блокироваться и ожидать завершения внешних операций. Асинхронный код может быть более эффективным и быстрым, поскольку во время ожидания выполнения одной операции можно выполнять другие задачи.

В заключение, использование async и await в Python позволяет создавать асинхронные программы с легкостью и удобством. Вместо блокировки выполнения программы на задачах, которые занимают много времени, мы можем ожидать их результаты асинхронно и продолжать параллельное выполнение других задач. Это помогает повысить эффективность и отзывчивость программы, особенно при обработке задач, связанных с сетью или вводом/выводом.