async/await в Python: асинхронное программирование

1# Синхронный: каждая операция блокирует поток
2import time
3
4def sync_fetch(url):
5    time.sleep(2)  # Блокировка на 2 секунды
6    return f"Data from {url}"
7
8# 3 запроса = 6 секунд
9for url in urls:
10    result = sync_fetch(url)
11
12# Асинхронный: операции выполняются параллельно
13import asyncio
14import aiohttp
15
16async def async_fetch(url):
17    async with aiohttp.ClientSession() as session:
18        async with session.get(url) as response:
19            return await response.text()
20
21# 3 запроса = ~2 секунды
22async def main():
23    tasks = [async_fetch(url) for url in urls]
24    results = await asyncio.gather(*tasks)

1import asyncio
2
3# Определение корутины
4async def greet(name):
5    print(f"Hello, {name}")
6    await asyncio.sleep(1)  # Асинхронная пауза
7    print(f"Goodbye, {name}")
8
9# Запуск корутины
10asyncio.run(greet("World"))

1import asyncio
2
3async def fetch_data(url, delay):
4    print(f"Starting fetch from {url}")
5    await asyncio.sleep(delay)
6    return f"Data from {url}"
7
8async def main():
9    # Запуск параллельно
10    task1 = asyncio.create_task(fetch_data("api1.com", 2))
11    task2 = asyncio.create_task(fetch_data("api2.com", 1))
12
13    # Ожидание результата
14    result1 = await task1
15    result2 = await task2
16
17    print(f"Results: {result1}, {result2}")
18
19asyncio.run(main())

1import asyncio
2
3async def main():
4    # gather — запуск нескольких корутин
5    results = await asyncio.gather(
6        fetch_data("url1"),
7        fetch_data("url2"),
8        fetch_data("url3")
9    )
10
11    # wait — ожидание с опцией timeout
12    done, pending = await asyncio.wait(
13        [task1, task2],
14        timeout=5.0,
15        return_when=asyncio.FIRST_COMPLETED
16    )
17
18    # wait_for — таймаут для одной задачи
19    try:
20        result = await asyncio.wait_for(fetch_data("url"), timeout=3.0)
21    except asyncio.TimeoutError:
22        print("Request timed out")
23
24asyncio.run(main())

1import asyncio
2
3async def worker(name, delay):
4    await asyncio.sleep(delay)
5    return f"{name} done"
6
7async def main():
8    tasks = [
9        asyncio.create_task(worker(f"Worker {i}", i))
10        for i in range(5)
11    ]
12
13    # Сбор результатов
14    for task in asyncio.as_completed(tasks):
15        result = await task
16        print(result)
17
18asyncio.run(main())

1import aiohttp
2import asyncio
3
4async def fetch(session, url):
5    async with session.get(url) as response:
6        return await response.json()
7
8async def main():
9    async with aiohttp.ClientSession() as session:
10        tasks = [fetch(session, url) for url in urls]
11        results = await asyncio.gather(*tasks)

1import aiofiles
2import asyncio
3
4async def read_file(path):
5    async with aiofiles.open(path, 'r') as f:
6        content = await f.read()
7        return content
8
9async def write_file(path, content):
10    async with aiofiles.open(path, 'w') as f:
11        await f.write(content)

1import asyncpg
2import asyncio
3
4async def main():
5    conn = await asyncpg.connect('postgresql://user:pass@localhost/db')
6
7    # Выполнение запроса
8    rows = await conn.fetch('SELECT * FROM users WHERE active = $1', True)
9
10    # Вставка
11    await conn.execute(
12        'INSERT INTO users(name, email) VALUES($1, $2)',
13        'John', 'john@example.com'
14    )
15
16    await conn.close()

1import asyncio
2
3async def producer(queue):
4    for i in range(10):
5        await queue.put(f"Task {i}")
6        await asyncio.sleep(0.5)
7
8async def consumer(queue):
9    while True:
10        task = await queue.get()
11        print(f"Processing: {task}")
12        await asyncio.sleep(1)
13        queue.task_done()
14
15async def main():
16    queue = asyncio.Queue()
17
18    # Запуск производителя и потребителей
19    producer_task = asyncio.create_task(producer(queue))
20    consumers = [asyncio.create_task(consumer(queue)) for _ in range(3)]
21
22    await producer_task
23    await queue.join()
24
25    for consumer_task in consumers:
26        consumer_task.cancel()

1import asyncio
2
3async def fetch_with_limit(semaphore, url):
4    async with semaphore:
5        print(f"Fetching {url}")
6        await asyncio.sleep(1)
7        return f"Data from {url}"
8
9async def main():
10    semaphore = asyncio.Semaphore(5)  # Максимум 5 параллельных запросов
11
12    tasks = [
13        fetch_with_limit(semaphore, url)
14        for url in urls
15    ]
16
17    results = await asyncio.gather(*tasks)

1import asyncio
2
3async def risky_operation():
4    await asyncio.sleep(1)
5    raise ValueError("Something went wrong")
6
7async def main():
8    # Обработка ошибок в gather
9    results = await asyncio.gather(
10        risky_operation(),
11        fetch_data("url"),
12        return_exceptions=True  # Исключения как результаты
13    )
14
15    for result in results:
16        if isinstance(result, Exception):
17            print(f"Error: {result}")
18        else:
19            print(f"Success: {result}")