From c66a2c64ac78de66e6f75d5d76b6c5d9cf6005b2 Mon Sep 17 00:00:00 2001 From: pro100ton Date: Sat, 2 Nov 2024 14:13:39 +0300 Subject: [PATCH] Initial migration --- 2_asyncio_base/__init__.py | 0 2_asyncio_base/example_2.py | 23 ++++++++ 3_awaitable_objects/__init__.py | 0 3_awaitable_objects/awaitable_topic.py | 21 +++++++ 3_awaitable_objects/sandbox.py | 26 +++++++++ 3_awaitable_objects/task_3_2_10.py | 8 +++ 3_awaitable_objects/task_3_2_11.py | 17 ++++++ 3_awaitable_objects/task_3_2_12.py | 0 3_awaitable_objects/task_3_2_13.py | 13 +++++ 3_awaitable_objects/task_3_2_14.py | 28 +++++++++ 3_awaitable_objects/task_3_3_10.py | 16 ++++++ 3_awaitable_objects/task_3_3_11.py | 19 +++++++ 3_awaitable_objects/task_3_3_12.py | 20 +++++++ 3_awaitable_objects/task_3_3_9.py | 25 ++++++++ 3_awaitable_objects/task_3_4_10.py | 25 ++++++++ 3_awaitable_objects/task_3_4_11.py | 33 +++++++++++ 3_awaitable_objects/task_3_4_12.py | 46 +++++++++++++++ 3_awaitable_objects/task_3_4_13.py | 22 +++++++ 3_awaitable_objects/task_3_5_10.py | 39 +++++++++++++ 3_awaitable_objects/task_3_5_9.py | 20 +++++++ 3_awaitable_objects/task_3_6_10.py | 19 +++++++ 3_awaitable_objects/task_3_6_11.py | 36 ++++++++++++ 3_awaitable_objects/task_3_6_12.py | 19 +++++++ 3_awaitable_objects/tasks_topic.py | 17 ++++++ 4_polling/polling.py | 30 ++++++++++ 5_asyncio_basis/5_1_8_main_methods.py | 24 ++++++++ 5_asyncio_basis/5_3_10_sleep_task.py | 42 ++++++++++++++ 5_asyncio_basis/5_3_11_sleep_task.py | 57 +++++++++++++++++++ 5_asyncio_basis/5_3_12_sleep_task.py | 43 ++++++++++++++ 5_asyncio_basis/5_3_13_sleep_task.py | 40 +++++++++++++ 5_asyncio_basis/5_3_9_sleep_task.py | 30 ++++++++++ 5_asyncio_basis/5_4_creating_tasks/10_task.py | 29 ++++++++++ 5_asyncio_basis/5_4_creating_tasks/11_task.py | 28 +++++++++ 5_asyncio_basis/5_4_creating_tasks/12_task.py | 34 +++++++++++ 5_asyncio_basis/5_4_creating_tasks/13_task.py | 42 ++++++++++++++ 5_asyncio_basis/5_5_ensure_future/10_task.py | 27 +++++++++ 5_asyncio_basis/5_6_gather/sandbox.py | 23 ++++++++ poetry.lock | 7 +++ pyproject.toml | 14 +++++ 39 files changed, 962 insertions(+) create mode 100644 2_asyncio_base/__init__.py create mode 100644 2_asyncio_base/example_2.py create mode 100644 3_awaitable_objects/__init__.py create mode 100644 3_awaitable_objects/awaitable_topic.py create mode 100644 3_awaitable_objects/sandbox.py create mode 100644 3_awaitable_objects/task_3_2_10.py create mode 100644 3_awaitable_objects/task_3_2_11.py create mode 100644 3_awaitable_objects/task_3_2_12.py create mode 100644 3_awaitable_objects/task_3_2_13.py create mode 100644 3_awaitable_objects/task_3_2_14.py create mode 100644 3_awaitable_objects/task_3_3_10.py create mode 100644 3_awaitable_objects/task_3_3_11.py create mode 100644 3_awaitable_objects/task_3_3_12.py create mode 100644 3_awaitable_objects/task_3_3_9.py create mode 100644 3_awaitable_objects/task_3_4_10.py create mode 100644 3_awaitable_objects/task_3_4_11.py create mode 100644 3_awaitable_objects/task_3_4_12.py create mode 100644 3_awaitable_objects/task_3_4_13.py create mode 100644 3_awaitable_objects/task_3_5_10.py create mode 100644 3_awaitable_objects/task_3_5_9.py create mode 100644 3_awaitable_objects/task_3_6_10.py create mode 100644 3_awaitable_objects/task_3_6_11.py create mode 100644 3_awaitable_objects/task_3_6_12.py create mode 100644 3_awaitable_objects/tasks_topic.py create mode 100644 4_polling/polling.py create mode 100644 5_asyncio_basis/5_1_8_main_methods.py create mode 100644 5_asyncio_basis/5_3_10_sleep_task.py create mode 100644 5_asyncio_basis/5_3_11_sleep_task.py create mode 100644 5_asyncio_basis/5_3_12_sleep_task.py create mode 100644 5_asyncio_basis/5_3_13_sleep_task.py create mode 100644 5_asyncio_basis/5_3_9_sleep_task.py create mode 100644 5_asyncio_basis/5_4_creating_tasks/10_task.py create mode 100644 5_asyncio_basis/5_4_creating_tasks/11_task.py create mode 100644 5_asyncio_basis/5_4_creating_tasks/12_task.py create mode 100644 5_asyncio_basis/5_4_creating_tasks/13_task.py create mode 100644 5_asyncio_basis/5_5_ensure_future/10_task.py create mode 100644 5_asyncio_basis/5_6_gather/sandbox.py create mode 100644 poetry.lock create mode 100644 pyproject.toml diff --git a/2_asyncio_base/__init__.py b/2_asyncio_base/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/2_asyncio_base/example_2.py b/2_asyncio_base/example_2.py new file mode 100644 index 0000000..b805233 --- /dev/null +++ b/2_asyncio_base/example_2.py @@ -0,0 +1,23 @@ +import time +import asyncio + +start = time.time() # Время начала эксперимента!) + + +async def sleeping(n): + # {time.time() - start:.4f} - время от начала работы программы до текущего момента. + # :.4f - ограничение количества знаков после запятой (4). + print(f"Начало выполнения длительной операции № {n}: {time.time() - start:.4f}") + await asyncio.sleep(1) # Имитация длительной операции в 1 секунду длиной. + print(f"Длительная операция № {n} завершена") + + +async def main(): + # Запускаю 30 операций. + task = [sleeping(i) for i in range(1, 31)] + all_results = await asyncio.gather(*task) + print(f"Выполнено {len(all_results)} операций.") + print(f"Программа завершена за {time.time() - start:.4f}") + +# Запуск главной корутины. +asyncio.run(main()) diff --git a/3_awaitable_objects/__init__.py b/3_awaitable_objects/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/3_awaitable_objects/awaitable_topic.py b/3_awaitable_objects/awaitable_topic.py new file mode 100644 index 0000000..75ba6e1 --- /dev/null +++ b/3_awaitable_objects/awaitable_topic.py @@ -0,0 +1,21 @@ +import asyncio + + +async def coro(num, seconds): + print(f"Задача{num} начала свое выполнение") + await asyncio.sleep(seconds) + print(f"Задача{num} выполнена за {seconds} секунду(ы)") + + +async def main(): + # Создание задач из корутины. + task1 = asyncio.create_task(coro(1, 1)) + task2 = asyncio.create_task(coro(2, 2)) + task3 = asyncio.create_task(coro(3, 3)) + task4 = asyncio.create_task(coro(4, 4)) + task5 = asyncio.create_task(coro(5, 5)) + # Запуск и ожидание выполнения задач. + await task5 + + +asyncio.run(main()) diff --git a/3_awaitable_objects/sandbox.py b/3_awaitable_objects/sandbox.py new file mode 100644 index 0000000..b6496ac --- /dev/null +++ b/3_awaitable_objects/sandbox.py @@ -0,0 +1,26 @@ +import asyncio + + +async def test_cor_1(future: asyncio.Future): + print("cor_1 started") + await asyncio.sleep(2) + print("cor_1 set future result to 100") + future.set_result(100) + print("cor_1 continue to sleep") + await asyncio.sleep(2) + print("cor_1 finished") + + +async def test_cor_2(): + print("cor_2 executed") + + +async def main(): + future = asyncio.Future() + tasks = [] + tasks.append(asyncio.create_task(test_cor_1(future))) + tasks.append(asyncio.create_task(test_cor_2())) + await asyncio.gather(*tasks) + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_2_10.py b/3_awaitable_objects/task_3_2_10.py new file mode 100644 index 0000000..36086c9 --- /dev/null +++ b/3_awaitable_objects/task_3_2_10.py @@ -0,0 +1,8 @@ +import asyncio + + +async def main(): + print("Hello, Asyncio!") + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_2_11.py b/3_awaitable_objects/task_3_2_11.py new file mode 100644 index 0000000..d058e0c --- /dev/null +++ b/3_awaitable_objects/task_3_2_11.py @@ -0,0 +1,17 @@ +import asyncio + + +async def coro_1(): + print("coro_1 says, hello coro_2!") + + +async def coro_2(): + print("coro_2 says, hello coro_1!") + + +async def main(): + await coro_1() + await coro_2() + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_2_12.py b/3_awaitable_objects/task_3_2_12.py new file mode 100644 index 0000000..e69de29 diff --git a/3_awaitable_objects/task_3_2_13.py b/3_awaitable_objects/task_3_2_13.py new file mode 100644 index 0000000..8e2d3a5 --- /dev/null +++ b/3_awaitable_objects/task_3_2_13.py @@ -0,0 +1,13 @@ +import asyncio + + +async def generate(number: int): + print(f"Корутина generate с аргументом {number}") + + +async def main(): + for gen in range(0, 10): + await generate(gen) + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_2_14.py b/3_awaitable_objects/task_3_2_14.py new file mode 100644 index 0000000..e6b58a2 --- /dev/null +++ b/3_awaitable_objects/task_3_2_14.py @@ -0,0 +1,28 @@ +import asyncio + + +async def coro_1(): + print("Вызываю корутину 0") + + +async def coro_5(): + print("Вызываю корутину 3") + await coro_3() + + +async def coro_3(): + print("Вызываю корутину 2") + await coro_2() + + +async def coro_4(): + print("Вызываю корутину 1") + await coro_1() + + +async def coro_2(): + print("Вызываю корутину 4") + await coro_4() + + +asyncio.run(coro_5()) diff --git a/3_awaitable_objects/task_3_3_10.py b/3_awaitable_objects/task_3_3_10.py new file mode 100644 index 0000000..76325b7 --- /dev/null +++ b/3_awaitable_objects/task_3_3_10.py @@ -0,0 +1,16 @@ +import asyncio + + +async def print_with_delay(delay: int): + await asyncio.sleep(1) + print(f"Coroutine {delay} is done") + + +async def main(): + tasks = [] + for i in range(10): + tasks.append(print_with_delay(i)) + await asyncio.gather(*tasks) + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_3_11.py b/3_awaitable_objects/task_3_3_11.py new file mode 100644 index 0000000..b97a3f4 --- /dev/null +++ b/3_awaitable_objects/task_3_3_11.py @@ -0,0 +1,19 @@ +import asyncio + +max_counts = {"Counter 1": 13, "Counter 2": 7} + + +async def counter(name: str, max_count: int): + for i in range(1, max_count + 1): + print(f"{name}: {i}") + await asyncio.sleep(1) + + +async def main(): + tasks = [] + for name, value in max_counts.items(): + tasks.append(counter(name, value)) + await asyncio.gather(*tasks) + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_3_12.py b/3_awaitable_objects/task_3_3_12.py new file mode 100644 index 0000000..71a02ad --- /dev/null +++ b/3_awaitable_objects/task_3_3_12.py @@ -0,0 +1,20 @@ +import asyncio + +max_counts = {"Counter 1": 10, "Counter 2": 5, "Counter 3": 15} +delays = {"Counter 1": 1, "Counter 2": 2, "Counter 3": 0.5} + + +async def counter(name: str, max_count: int, delay: int): + for i in range(1, max_count + 1): + print(f"{name}: {i}") + await asyncio.sleep(delay) + + +async def main(): + tasks = [] + for name, value in max_counts.items(): + tasks.append(counter(name, value, delays[name])) + await asyncio.gather(*tasks) + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_3_9.py b/3_awaitable_objects/task_3_3_9.py new file mode 100644 index 0000000..4d40a78 --- /dev/null +++ b/3_awaitable_objects/task_3_3_9.py @@ -0,0 +1,25 @@ +import asyncio + + +async def c_1(): + print("Coroutine 1 is done") + + +async def c_2(): + print("Coroutine 2 is done") + + +async def c_3(): + print("Coroutine 3 is done") + + +async def main(): + tasks = [ + asyncio.create_task(c_1()), + asyncio.create_task(c_2()), + asyncio.create_task(c_3()), + ] + await asyncio.gather(*tasks) + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_4_10.py b/3_awaitable_objects/task_3_4_10.py new file mode 100644 index 0000000..557b546 --- /dev/null +++ b/3_awaitable_objects/task_3_4_10.py @@ -0,0 +1,25 @@ +import asyncio + + +async def set_future_result(value, delay): + print(f"Задача начата. Установка результата '{value}' через {delay} секунд.") + await asyncio.sleep(delay) + print("Результат установлен.") + return value + + +async def create_ans_use_future(): + task = asyncio.create_task(set_future_result("Успех", 2)) + print(f"Состояние Task до выполнения: {'Завершено' if task.done() else 'Ожидание'}") + print("Задача запущена, ожидаем завершения...") + await task + print(f"Состояние Task до выполнения: {'Завершено' if task.done() else 'Ожидание'}") + return task.result() + + +async def main(): + result = await create_ans_use_future() + print("Результат из Task:", result) + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_4_11.py b/3_awaitable_objects/task_3_4_11.py new file mode 100644 index 0000000..c72a665 --- /dev/null +++ b/3_awaitable_objects/task_3_4_11.py @@ -0,0 +1,33 @@ +import asyncio +from asyncio.exceptions import CancelledError + + +async def async_operation(): + print("Начало асинхронной операции.") + try: + await asyncio.sleep(2) + print("Асинхронная операция успешно завершилась.") + except CancelledError: + print("Асинхронная операция была отменена в процессе выполнения.") + raise + + +async def main(): + print("Главная корутина запущена.") + task = asyncio.create_task(async_operation()) + await asyncio.sleep(0.1) + print("Попытка отмены Task.") + task.cancel() + try: + await task + print("Результат Task:", task.result()) + except CancelledError: + print("Обработка исключения: Task был отменен.") + if task.cancelled(): + print("Проверка: Task был отменен.") + else: + print("Проверка: Task не был отменен.") + print("Главная корутина завершена.") + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_4_12.py b/3_awaitable_objects/task_3_4_12.py new file mode 100644 index 0000000..fe09edd --- /dev/null +++ b/3_awaitable_objects/task_3_4_12.py @@ -0,0 +1,46 @@ +import asyncio + + +async def first_function(x): + print(f"Выполняется первая функция с аргументом {x}") + await asyncio.sleep(1) + result = x + 1 + print(f"Первая функция завершилась с результатом {result}") + return result + + +async def second_function(x): + print(f"Выполняется вторая функция с аргументом {x}") + await asyncio.sleep(1) + result = x * 2 + print(f"Вторая функция завершилась с результатом {result}") + return result + + +async def third_function(x): + print(f"Выполняется третья функция с аргументом {x}") + await asyncio.sleep(1) + result = x + 3 + print(f"Третья функция завершилась с результатом {result}") + return result + + +async def fourth_function(x): + print(f"Выполняется четвертая функция с аргументом {x}") + await asyncio.sleep(1) + result = x**2 + print(f"Четвертая функция завершилась с результатом {result}") + return result + + +async def main(): + print("Начало цепочки асинхронных вызовов") + x = 1 + x = await asyncio.create_task(first_function(x)) + x = await asyncio.create_task(second_function(x)) + x = await asyncio.create_task(third_function(x)) + x = await asyncio.create_task(fourth_function(x)) + print(f"Конечный результат цепочки вызовов: {x}") + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_4_13.py b/3_awaitable_objects/task_3_4_13.py new file mode 100644 index 0000000..a9ac13f --- /dev/null +++ b/3_awaitable_objects/task_3_4_13.py @@ -0,0 +1,22 @@ +import asyncio + + +async def waiter(future: asyncio.Future): + await future + print( + f"future выполнен, результат {future.result()}. Корутина waiter() может продолжить работу" + ) + + +async def setter(future: asyncio.Future): + await asyncio.sleep(random.randint(1, 3)) + future.set_result(True) + + +async def main(): + future = asyncio.Future() + tasks = [asyncio.create_task(waiter(future)), asyncio.create_task(setter(future))] + await asyncio.gather(*tasks) + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_5_10.py b/3_awaitable_objects/task_3_5_10.py new file mode 100644 index 0000000..1c15e40 --- /dev/null +++ b/3_awaitable_objects/task_3_5_10.py @@ -0,0 +1,39 @@ +import asyncio + +# Полный словарь students вшит в задачу, вставлять его не нужно +# students = {} +students = { + "Алекс": {"course": "Асинхронный Python", "steps": 515, "speed": 78}, + "Мария": {"course": "Многопоточный Python", "steps": 431, "speed": 62}, + "Иван": {"course": "WEB Парсинг на Python", "steps": 491, "speed": 57}, +} + + +async def study_course(student, course, steps, speed): + print(f"{student} начал проходить курс {course}.") + reading_time = round(steps / speed, 2) + await asyncio.sleep(reading_time) + print(f"{student} прошел курс {course} за {reading_time} ч.") + + +async def main(): + tasks = [] + # Создание задач с помощью asyncio.create_task для каждого студента + for student, student_data in students.items(): + tasks.append( + asyncio.create_task( + study_course( + student, + student_data["course"], + student_data["steps"], + student_data["speed"], + ) + ) + ) + + # Ожидание завершения каждой задачи индивидуально + for task in tasks: + await task + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_5_9.py b/3_awaitable_objects/task_3_5_9.py new file mode 100644 index 0000000..7736dc4 --- /dev/null +++ b/3_awaitable_objects/task_3_5_9.py @@ -0,0 +1,20 @@ +import asyncio + + +async def read_book(student, time): + print(f"{student} начал читать книгу.") + await asyncio.sleep(time) + print(f"{student} закончил читать книгу за {time} секунд.") + + +async def main(): + # Создаем задачи для асинхронного выполнения + task2 = asyncio.create_task(read_book("Алекс", 5)) + task1 = asyncio.create_task(read_book("Мария", 3)) + task3 = asyncio.create_task(read_book("Иван", 4)) + await task1 + await task2 + await task3 + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_6_10.py b/3_awaitable_objects/task_3_6_10.py new file mode 100644 index 0000000..a2b4ea1 --- /dev/null +++ b/3_awaitable_objects/task_3_6_10.py @@ -0,0 +1,19 @@ +import asyncio + + +async def task1(): + await asyncio.sleep(1) + print("Привет из корутины task1") + + +async def task2(): + await asyncio.sleep(1) + print("Привет из корутины task2") + + +async def main(): + await task1() + await task2() + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_6_11.py b/3_awaitable_objects/task_3_6_11.py new file mode 100644 index 0000000..4b6692e --- /dev/null +++ b/3_awaitable_objects/task_3_6_11.py @@ -0,0 +1,36 @@ +import asyncio + + +async def task1(): + print("Начинаем задачу 1") + await asyncio.sleep(1) + print("Привет из корутины task1") + await asyncio.sleep(1) + print("Задача 1 завершилась") + + +async def task2(): + print("Начинаем задачу 2") + await asyncio.sleep(2) + print("Привет из корутины task2") + await asyncio.sleep(2) + print("Задача 2 завершилась") + + +async def task3(): + print("Начинаем задачу 3") + await asyncio.sleep(3) + print("Привет из корутины task3") + await asyncio.sleep(3) + print("Задача 3 завершилась") + + +async def main(): + task_1 = asyncio.create_task(task1()) + task_2 = asyncio.create_task(task2()) + task_3 = asyncio.create_task(task3()) + + await asyncio.gather(task_1, task_2, task_3) + + +asyncio.run(main()) diff --git a/3_awaitable_objects/task_3_6_12.py b/3_awaitable_objects/task_3_6_12.py new file mode 100644 index 0000000..d9d68b3 --- /dev/null +++ b/3_awaitable_objects/task_3_6_12.py @@ -0,0 +1,19 @@ +import asyncio + + +async def compute_square(x): + print(f"Вычисляем квадрат числа: {x}") + await asyncio.sleep(1) # Имитация длительной операции + return x * x + + +async def main(): + # Создаём и запускаем задачи + tasks = [asyncio.create_task(compute_square(i)) for i in range(10)] + # Ожидаем завершения всех задач и собираем результаты + await asyncio.gather(*tasks) + for result in tasks: + print(f"Результат: {result.result()}") + + +asyncio.run(main()) diff --git a/3_awaitable_objects/tasks_topic.py b/3_awaitable_objects/tasks_topic.py new file mode 100644 index 0000000..bc3983f --- /dev/null +++ b/3_awaitable_objects/tasks_topic.py @@ -0,0 +1,17 @@ +import asyncio + + +async def example(): + await asyncio.sleep(1) + print("Hello from awake coroutine") + + +async def main(): + tasks = [] + for _ in range(10): + task = asyncio.create_task(example()) + tasks.append(task) + await asyncio.gather(*tasks) + + +asyncio.run(main()) diff --git a/4_polling/polling.py b/4_polling/polling.py new file mode 100644 index 0000000..d6ab9d3 --- /dev/null +++ b/4_polling/polling.py @@ -0,0 +1,30 @@ +import asyncio + + +async def print_message(): + while True: + print("Имитация работы функции") + await asyncio.sleep(1) + + +async def interrupt_handler(interrupt_flag): + while True: + # Ждем установки флага. + await interrupt_flag.wait() + print("Произошло прерывание! В этом месте может быть установлен любой обработчик") + # Очищаем флаг для следующего использования + interrupt_flag.clear() + + +async def main(): + interrupt_flag = asyncio.Event() + asyncio.create_task(print_message()) + asyncio.create_task(interrupt_handler(interrupt_flag)) + + while True: + await asyncio.sleep(3) + # Устанавливаем флаг для прерывания + interrupt_flag.set() + + +asyncio.run(main()) diff --git a/5_asyncio_basis/5_1_8_main_methods.py b/5_asyncio_basis/5_1_8_main_methods.py new file mode 100644 index 0000000..b99a502 --- /dev/null +++ b/5_asyncio_basis/5_1_8_main_methods.py @@ -0,0 +1,24 @@ +import asyncio + +# Пример данных +log_events = [ + {"event": "Запрос на вход", "delay": 0.5}, + {"event": "Запрос данных пользователя", "delay": 1.0}, + {"event": "Обновление данных пользователя", "delay": 1.5}, + {"event": "Обновление конфигурации сервера", "delay": 5.0}, +] + + +async def fetch_log(event): + await asyncio.sleep(event.get("delay")) + print(f"Событие: '{event['event']}' обработано с задержкой {event['delay']} сек.") + + +async def main(): + tasks = [] + for event in log_events: + tasks.append(asyncio.create_task(fetch_log(event))) + await asyncio.gather(*tasks) + + +asyncio.run(main()) diff --git a/5_asyncio_basis/5_3_10_sleep_task.py b/5_asyncio_basis/5_3_10_sleep_task.py new file mode 100644 index 0000000..b2851fb --- /dev/null +++ b/5_asyncio_basis/5_3_10_sleep_task.py @@ -0,0 +1,42 @@ +import asyncio + + +async def coroutine_1(delay=0.1): + print("Первое сообщение от корутины 1") + await asyncio.sleep(0.03) # Первая задержка + print("Второе сообщение от корутины 1") + await asyncio.sleep(0.14) # Вторая задержка + print("Третье сообщение от корутины 1") + await asyncio.sleep(0.20) # Третья задержка + print("Четвертое сообщение от корутины 1") + + +async def coroutine_2(delay=0.1): + print("Первое сообщение от корутины 2") + await asyncio.sleep(0.02) # Первая задержка + print("Второе сообщение от корутины 2") + await asyncio.sleep(0.10) # Вторая задержка + print("Третье сообщение от корутины 2") + await asyncio.sleep(0.44) # Третья задержка + print("Четвертое сообщение от корутины 2") + + +async def coroutine_3(delay=0.1): + print("Первое сообщение от корутины 3") + await asyncio.sleep(0.01) # Первая задержка + print("Второе сообщение от корутины 3") + await asyncio.sleep(0.12) # Вторая задержка + print("Третье сообщение от корутины 3") + await asyncio.sleep(0.32) # Третья задержка + print("Четвертое сообщение от корутины 3") + + +async def main(): + await asyncio.gather( + coroutine_1(), + coroutine_2(), + coroutine_3(), + ) + + +asyncio.run(main()) diff --git a/5_asyncio_basis/5_3_11_sleep_task.py b/5_asyncio_basis/5_3_11_sleep_task.py new file mode 100644 index 0000000..dac7fc0 --- /dev/null +++ b/5_asyncio_basis/5_3_11_sleep_task.py @@ -0,0 +1,57 @@ +import asyncio + + +async def coroutine_1(): + await asyncio.sleep(1) # Задержка для первого сообщения + print("Сообщение 1 от корутины 1") + await asyncio.sleep(2) # Задержка для второго сообщения + print("Сообщение 2 от корутины 1") + + +async def coroutine_2(): + await asyncio.sleep(1) + print("Сообщение 1 от корутины 2") + await asyncio.sleep(2) + print("Сообщение 2 от корутины 2") + + +async def coroutine_3(): + await asyncio.sleep(1) + print("Сообщение 1 от корутины 3") + await asyncio.sleep(2) + print("Сообщение 2 от корутины 3") + + +async def coroutine_4(): + await asyncio.sleep(1) + print("Сообщение 1 от корутины 4") + await asyncio.sleep(2) + print("Сообщение 2 от корутины 4") + + +async def coroutine_5(): + await asyncio.sleep(1) + print("Сообщение 1 от корутины 5") + await asyncio.sleep(2) + print("Сообщение 2 от корутины 5") + + +async def coroutine_6(): + await asyncio.sleep(1) + print("Сообщение 1 от корутины 6") + await asyncio.sleep(2) + print("Сообщение 2 от корутины 6") + + +async def main(): + await asyncio.gather( + coroutine_1(), + coroutine_2(), + coroutine_3(), + coroutine_4(), + coroutine_5(), + coroutine_6(), + ) + + +asyncio.run(main()) diff --git a/5_asyncio_basis/5_3_12_sleep_task.py b/5_asyncio_basis/5_3_12_sleep_task.py new file mode 100644 index 0000000..f7ae4b4 --- /dev/null +++ b/5_asyncio_basis/5_3_12_sleep_task.py @@ -0,0 +1,43 @@ +import asyncio +import random + +# Не менять. +random.seed(1) + + +class MailServer: + def __init__(self): + self.mailbox = ["Привет!", "Встреча в 15:00", "Важное уведомление", "Реклама"] + + async def check_for_new_mail(self): + if random.random() < 0.1: + return "Ошибка при проверке новых писем." + return random.choice([True, False]) + + async def fetch_new_mail(self): + mail = random.choice(self.mailbox) + return f"Новое письмо: {mail}" + + +# Тут пишите ваш код +async def check_mail(server: MailServer): + while True: + check_result = await server.check_for_new_mail() + if isinstance(check_result, str): + print(check_result) + break + if check_result: + new_mail = await server.fetch_new_mail() + print(new_mail) + else: + print("Новых писем нет.") + await asyncio.sleep(1) + + +async def main(): + # Creating mail server + server = MailServer() + await check_mail(server) + + +asyncio.run(main()) diff --git a/5_asyncio_basis/5_3_13_sleep_task.py b/5_asyncio_basis/5_3_13_sleep_task.py new file mode 100644 index 0000000..9b2f925 --- /dev/null +++ b/5_asyncio_basis/5_3_13_sleep_task.py @@ -0,0 +1,40 @@ +import asyncio +import time + + +async def process_request(request_name, stages, status): + for stage_name in stages: + time.sleep(1) # Симулируем время выполнения этапа + status[request_name] = stage_name + await asyncio.sleep(0) + + +async def update_status(request_name, status): + while True: + print(status) + if status == {request_name: "Отправка уведомлений"}: + break + await asyncio.sleep(0) + + +async def main(): + # Исходные данные по запросу и этапам его обработки + request_name = "Запрос 1" + stages = [ + "Загрузка данных", + "Проверка данных", + "Анализ данных", + "Сохранение результатов", + "Отправка уведомлений", + ] + + status = {request_name: None} + + # Создание задач для каждой корутины + process_task = asyncio.create_task(process_request(request_name, stages, status)) + updater_task = asyncio.create_task(update_status(request_name, status)) + + await asyncio.gather(process_task, updater_task) + + +asyncio.run(main()) diff --git a/5_asyncio_basis/5_3_9_sleep_task.py b/5_asyncio_basis/5_3_9_sleep_task.py new file mode 100644 index 0000000..8093ade --- /dev/null +++ b/5_asyncio_basis/5_3_9_sleep_task.py @@ -0,0 +1,30 @@ +import asyncio + + +async def coroutine_1(): + print("Первое сообщение от корутины 1") + await asyncio.sleep(3) # Подберите необходимую задержку + print("Второе сообщение от корутины 1") + + +async def coroutine_2(): + print("Первое сообщение от корутины 2") + await asyncio.sleep(2) # Подберите необходимую задержку + print("Второе сообщение от корутины 2") + + +async def coroutine_3(): + print("Первое сообщение от корутины 3") + await asyncio.sleep(1) # Подберите необходимую задержку + print("Второе сообщение от корутины 3") + + +async def main(): + await asyncio.gather( + coroutine_1(), + coroutine_2(), + coroutine_3(), + ) + + +asyncio.run(main()) diff --git a/5_asyncio_basis/5_4_creating_tasks/10_task.py b/5_asyncio_basis/5_4_creating_tasks/10_task.py new file mode 100644 index 0000000..95ad108 --- /dev/null +++ b/5_asyncio_basis/5_4_creating_tasks/10_task.py @@ -0,0 +1,29 @@ +import asyncio + +places = [ + "начинает путешествие", + "находит загадочный лес", + "переправляется через реку", + "встречает дружелюбного дракона", + "находит сокровище", +] + +roles = ["Искатель приключений", "Храбрый рыцарь", "Отважный пират"] + + +async def counter(name, delay=0.1): + for place in places: + await asyncio.sleep(delay) + print(f"{name} {place}...") + + +async def main(): + task1 = asyncio.create_task(counter(roles[0])) + task2 = asyncio.create_task(counter(roles[1])) + task3 = asyncio.create_task(counter(roles[2])) + + # Дождитесь выполнения всех созданных задач в главной корутине с помощью await. + await asyncio.gather(task1, task2, task3) + + +asyncio.run(main()) diff --git a/5_asyncio_basis/5_4_creating_tasks/11_task.py b/5_asyncio_basis/5_4_creating_tasks/11_task.py new file mode 100644 index 0000000..979ed24 --- /dev/null +++ b/5_asyncio_basis/5_4_creating_tasks/11_task.py @@ -0,0 +1,28 @@ +import asyncio + +timers = { + "Квест на поиск сокровищ": 10, + "Побег от дракона": 5, +} + + +async def countdown(name, seconds): + while seconds: + if "Квест" in name: + print(f"{name}: Осталось {seconds} сек. Найди скрытые сокровища!") + else: + print(f"{name}: Осталось {seconds} сек. Беги быстрее, дракон на хвосте!") + await asyncio.sleep(1) + seconds -= 1 + print(f"{name}: Задание выполнено! Что дальше?") + + +async def main(): + tasks = [ + asyncio.create_task(countdown(name, seconds)) + for name, seconds in timers.items() + ] + await asyncio.gather(*tasks) + + +asyncio.run(main()) diff --git a/5_asyncio_basis/5_4_creating_tasks/12_task.py b/5_asyncio_basis/5_4_creating_tasks/12_task.py new file mode 100644 index 0000000..8560451 --- /dev/null +++ b/5_asyncio_basis/5_4_creating_tasks/12_task.py @@ -0,0 +1,34 @@ +import asyncio + +news_list = [ + "Новая волна COVID-19 обрушилась на Европу", + "Рынки игр растут на фоне новостей о вакцине", + "Новая волна COVID-19 обрушилась на Европу", + "Новая волна COVID-19 обрушилась на Европу", + "Рынки игр растут на фоне новостей о вакцине", + "Новая волна COVID-19 обрушилась на Европу", + "Новая волна COVID-19 обрушилась на Европу", + "Рынки игр растут на фоне новостей о вакцине", +] + + +async def analyze_news(keyword, news_list, delay): + for news in news_list: + if keyword in news: + print(f"Найдено соответствие для '{keyword}': {news}") + await asyncio.sleep(delay) + + +async def main(): + # Создаем асинхронные задачи для каждой корутины с разными ключевыми словами и задержками + delay = 1 + tasks = [ + asyncio.create_task(analyze_news(keyword, news_list, delay)) + for keyword in ["COVID-19", "игр", "новый вид"] + ] + + # Ожидаем выполнения всех задач + await asyncio.gather(*tasks) + + +asyncio.run(main()) diff --git a/5_asyncio_basis/5_4_creating_tasks/13_task.py b/5_asyncio_basis/5_4_creating_tasks/13_task.py new file mode 100644 index 0000000..cab689e --- /dev/null +++ b/5_asyncio_basis/5_4_creating_tasks/13_task.py @@ -0,0 +1,42 @@ +import asyncio + +status_list = [ + "Отлично", + "Хорошо", + "Удовлетворительно", + "Средне", + "Пониженное", + "Ниже среднего", + "Плохо", + "Очень плохо", + "Критично", + "Катастрофически", +] +CPU_TASK_NAME = "CPU" +MEMORY_TASK_NAME = "Память" +DISK_SPACE_TASK_NAME = "Дисковое пространство" + + +async def monitor_pc(status): + task_name = asyncio.current_task().get_name() + print(f"[{task_name}] Статус проверки: {status}") + if status == "Катастрофически": + print( + f"[{task_name}] Критическое состояние достигнуто. Инициируется остановка..." + ) + + +async def main(): + tasks = [] + for status in status_list: + tasks.append(asyncio.create_task(coro=monitor_pc(status), name=CPU_TASK_NAME)) + tasks.append( + asyncio.create_task(coro=monitor_pc(status), name=MEMORY_TASK_NAME) + ) + tasks.append( + asyncio.create_task(coro=monitor_pc(status), name=DISK_SPACE_TASK_NAME) + ) + await asyncio.gather(*tasks) + + +asyncio.run(main()) diff --git a/5_asyncio_basis/5_5_ensure_future/10_task.py b/5_asyncio_basis/5_5_ensure_future/10_task.py new file mode 100644 index 0000000..2595ee5 --- /dev/null +++ b/5_asyncio_basis/5_5_ensure_future/10_task.py @@ -0,0 +1,27 @@ +import asyncio + + +async def activate_portal(x): + print(f"Активация портала в процессе, требуется времени: {x} единиц") + await asyncio.sleep(x) + return x * 2 + + +async def perform_teleportation(x): + print(f"Телепортация в процессе, требуется времени: {x} единиц") + await asyncio.sleep(x) + return x + 2 + + +async def portal_operator(): + activate_portal_task = asyncio.ensure_future(activate_portal(2)) + await activate_portal_task + pt_task = asyncio.ensure_future( + perform_teleportation(activate_portal_task.result()) + ) + await pt_task + print(f"Результат активации портала: {activate_portal_task.result()} единиц энергии") + print(f"Результат телепортации: {pt_task.result()} единиц времени") + + +asyncio.run(portal_operator()) diff --git a/5_asyncio_basis/5_6_gather/sandbox.py b/5_asyncio_basis/5_6_gather/sandbox.py new file mode 100644 index 0000000..0b37dc3 --- /dev/null +++ b/5_asyncio_basis/5_6_gather/sandbox.py @@ -0,0 +1,23 @@ +import asyncio + + +async def task_1(): + await asyncio.sleep(2) + print("task 1 running after sleep") + return "Result from task 1" + + +async def task_2(): + await asyncio.sleep(1) + raise ValueError("An error occurred in task 2") + + +async def main(): + try: + await asyncio.gather(task_1(), task_2()) + except ValueError: + print("Error occurred in task") + await asyncio.sleep(3) + + +asyncio.run(main()) diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 0000000..022bbde --- /dev/null +++ b/poetry.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Poetry 1.4.2 and should not be changed by hand. +package = [] + +[metadata] +lock-version = "2.0" +python-versions = "^3.10" +content-hash = "53f2eabc9c26446fbcc00d348c47878e118afc2054778c3c803a0a8028af27d9" diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..ee41bb2 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,14 @@ +[tool.poetry] +name = "python-asyncio-course" +version = "0.1.0" +description = "" +authors = ["t0xa"] +readme = "README.md" + +[tool.poetry.dependencies] +python = "^3.10" + + +[build-system] +requires = ["poetry-core"] +build-backend = "poetry.core.masonry.api"