Принципы работы с async/await в Python: практическое руководство с примерами

import asyncio

async def fetch_data(url):
    await asyncio.sleep(1)
    return f"Данные с {url}"

async def main():
    # Параллельное создание задач
    task1 = asyncio.create_task(fetch_data("site1.com"))
    task2 = asyncio.create_task(fetch_data("site2.com"))
    
    # Ждём результатов обоих задач одновременно
    result1, result2 = await asyncio.gather(task1, task2)
    
    print(result1)
    print(result2)

# Запуск
# asyncio.run(main())

import asyncio

async def fetch_data(url):
    await asyncio.sleep(1)
    return f"Данные с {url}"

async def main():
    # Параллельное создание задач
    task1 = asyncio.create_task(fetch_data("site1.com"))
    task2 = asyncio.create_task(fetch_data("site2.com"))
    
    # Ждём результатов обоих задач одновременно
    result1, result2 = await asyncio.gather(task1, task2)
    
    print(result1)
    print(result2)

# Запуск
# asyncio.run(main())

import asyncio

async def task(name, delay):
    await asyncio.sleep(delay)
    return f"Задача {name} завершена"

async def main():
    # Создание задач
    task1 = asyncio.create_task(task("Первая", 1))
    task2 = asyncio.create_task(task("Вторая", 2))
    
    # Получение результатов
    results = await asyncio.gather(task1, task2)
    print(results)

asyncio.run(main())

import asyncio

async def task1():
    await asyncio.sleep(1)
    return "Задача 1"

async def task2():
    await asyncio.sleep(2)
    return "Задача 2"

async def main():
    tasks = [task1(), task2()]
    done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
    print(f"Завершено: {[t.result() for t in done]}")
    print(f"В процессе: {len(pending)}")

asyncio.run(main())

import asyncio

async def producer(queue):
    for i in range(3):
        await queue.put(i)
        print(f"Произведено: {i}")
        await asyncio.sleep(0.1)

async def consumer(queue):
    while True:
        item = await queue.get()
        print(f"Потреблено: {item}")
        queue.task_done()

async def main():
    queue = asyncio.Queue()
    
    # Создание производителя и потребителя
    producer_task = asyncio.create_task(producer(queue))
    consumer_task = asyncio.create_task(consumer(queue))
    
    # Ожидание завершения производителя
    await producer_task
    await queue.join()  # Ожидание обработки всех элементов
    
    consumer_task.cancel()

asyncio.run(main())

import asyncio

async def fetch_data(sem, url):
    async with sem:
        await asyncio.sleep(1)
        return f"Данные с {url}"

async def main():
    sem = asyncio.Semaphore(2)  # Ограничение до 2 параллельных операций
    
    tasks = [
        fetch_data(sem, f"site{i}.com")
        for i in range(5)
    ]
    
    results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main())

import asyncio
import logging

# Настройка логирования
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

async def main():
    try:
        # Инициализация ресурсов
        await setup_resources()
        
        # Запуск основных задач
        await asyncio.gather(
            task1(),
            task2(),
            return_exceptions=True
        )
        
    except Exception as e:
        logger.error(f"Ошибка в основном цикле: {e}")
    finally:
        # Очистка ресурсов
        await cleanup_resources()

if __name__ == "__main__":
    asyncio.run(main())

async def create_and_manage_tasks():
    # Создание задач с именами для лучшей отладки
    task1 = asyncio.create_task(
        fetch_data("site1.com"),
        name="fetch_site1"
    )
    
    task2 = asyncio.create_task(
        fetch_data("site2.com"),
        name="fetch_site2"
    )
    
    # Параллельное выполнение с таймаутом
    try:
        results = await asyncio.gather(
            task1,
            task2,
            return_exceptions=True,
            timeout=5.0
        )
    except asyncio.TimeoutError:
        logger.warning("Таймаут при выполнении задач")
        # Отмена задач, если они всё ещё выполняются
        task1.cancel()
        task2.cancel()
        raise

class ResourceManager:
    def __init__(self):
        self._lock = asyncio.Lock()
        self._resources = {}
    
    async def acquire_resource(self, resource_id):
        async with self._lock:
            if resource_id not in self._resources:
                self._resources[resource_id] = await self._create_resource(resource_id)
            return self._resources[resource_id]
    
    async def _create_resource(self, resource_id):
        try:
            # Здесь создание ресурса
            return Resource(resource_id)
        except Exception as e:
            logger.error(f"Ошибка при создании ресурса {resource_id}: {e}")
            raise

# ПЛОХО
task = asyncio.create_task(fetch_data())
# ХОРОШО
task = asyncio.create_task(fetch_data(), name="fetch_data_task")

# ПЛОХО
try:
    await asyncio.gather(task1, task2)
except Exception:
    pass
# ХОРОШО
try:
    await asyncio.gather(task1, task2, return_exceptions=True)
except Exception as e:
    logger.error(f"Ошибка: {e}")

# ПЛОХО
async with session.get(url) as response:
    data = await response.text()
    # Возврат без очистки
    return data
# ХОРОШО
async with session.get(url) as response:
    try:
        data = await response.text()
        return data
    finally:
        await response.release()