Trending September 2023 # Complete Guide To Python Async # Suggested October 2023 # Top 16 Popular

You are reading the article Complete Guide To Python Async updated in September 2023 on the website Phuhoabeautyspa.com. We hope that the information we have shared is helpful to you. If you find the content interesting and meaningful, please share it with your friends and continue to follow and support us for the latest updates. Suggested October 2023 Complete Guide To Python Async

Introduction to Python Async

Python async is an asynchronous function or also known as coroutine in Python changes the behavior of the function call. Async in Python is a feature for many modern programming languages that allows the functioning of multiple operations without waiting time. This is a smart way to handle multiple network tasks or I/O tasks where the actual program’s time is spent waiting for other tasks to finish. We shall look into async implementation in Python. Moving to async functions not only required knowledge of Syntax but also a way of thinking for the logic needs to be changed.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Asynchronous functions/ Coroutines use async keyword OR @asyncio.coroutine.

Either function would work as a coroutine which returns coroutine objects. Calling either function would not actually run, but a coroutine object is returned.

In some cases, if needed to determine whether the function is a coroutine or not, asyncio has a method asyncio.iscoroutinefunction(func). If the user wants to determine whether the object returned from the function is a coroutine object, they can utilize the asyncio method asyncio.iscoroutine(obj).

Defining async def makes a coroutine

Python Async provided single-threaded concurrent code by using coroutines, running network I/O, and other related I/O over sockets. Python async has an event loop that waits for another event to happen and acts on the event.

Async provides a set of Low Level and High-Level API’s

To create and maintain event loops providing asynchronous API’s for handling OS signals, networking, running subprocesses, etc.

Perform network I/O and distribute tasks in the mode of queues.

Implement protocols using transport and synchronize concurrent code.

Bridges call back-based libraries and code with async or await

Runs coroutines concurrently with full control of their execution.

Examples of Python Async

Lets us discuss the examples of Python Async.

Example #1

Code:

import queue def task(name, sample_queue): if sample_queue.empty(): print(f'Task {name} has nothing to do') else: while not sample_queue.empty(): cnt = sample_queue.get() total = 0 for x in range(cnt): print(f'Task {name} is running now') total += 1 print(f'Task {name} is running with a total of: {total}') def sample_async(): sample_queue = queue.Queue() for work in [2, 5, 10, 15, 20]: sample_queue.put(work) tasks = [ (task, 'Async1', sample_queue), (task, 'Async2', sample_queue), (task, 'Async3', sample_queue) ] for t, n, q in tasks: t(n, q) if __name__ == '__main__': sample_async()

Output:

‘task’ in the above example accepts string and queue.

Example #2 import asyncio import functools def event_handler(loop, stop=False): print('Calling event handler') if stop: print('Loop is being stopped') loop.stop() if __name__ == '__main__': loop = asyncio.get_event_loop() try: loop.call_soon(functools.partial(event_handler, loop)) print('Loop is being started') loop.call_soon(functools.partial(event_handler, loop, stop=True)) loop.run_forever() finally: print('Loop is being closed') loop.close()

Output:

Example #3

Code:

import asyncio async def sample_task(task_seconds): print('Task takes {} seconds to complete'.format(task_seconds)) await asyncio.sleep(task_seconds) return 'task has been completed' if __name__ == '__main__': sample_event = asyncio.get_event_loop() try: print('Creation of tasks started') task_object_loop = sample_event.create_task(sample_task(task_seconds=3)) sample_event.run_until_complete(task_object_loop) finally: sample_event.close() print("Task status: {}".format(task_object_loop.result()))

Output:

On running the Program,

As the task takes 3 seconds to complete, so after completion of the task,

Example #4

Code:

Output:

Event loop countdown() coroutine calls, executes until yield from, and asyncio.sleep() function. The future loop watches the future object until the other one is over. Once the second one is on, the event loop gets the paused countdown coroutine(), which gives the event loop the future object and sends future objects to result back to the coroutine with countdown() starting running back.

Asyncio was added to the standard library to prevent looping. Running event loops provides a few features, like,

Registering, executing, and canceling delayed calls i.e. Asynchronous functions.

Creation of subprocesses and transports for communication between tasks.

Creations of client and server transport for communication between tasks.

Delegating function calls to thread pools.

The reason behind using async is to improve the throughput of the program by reducing idle time when performing I/O. Programs in this juggle use an abstraction event loop. Resemble multi-threading, but event loop generally lives in a single thread.

With this, we conclude ‘Python Async.’ Async I/O is a language-agnostic model and lets coroutines communicate with each other. Asyncio, a Python function, provides API to run and manage coroutines. API of asyncio was declared stable rather being provisional. In Python, async has evolved with minor changes in the versions. Using Python async tool, asynchronous programming is powerful. Based on users’ requirements, Python async achieves concurrency, code flow, architecture design, and data manipulation. However, if a user tries to implement a program or a server that implements significant I/O operations, async makes a huge difference.

Thanks! Happy Learning!!