The Project | About Us | Contribute | Donations | License

HOME

Asynchronous programming is a form of parallel programming that allows a unit of work to run separately from the main application thread and notifies the main thread when the work is complete. Python's asyncio library provides a framework for writing asynchronous code using the async and await keywords.

Key Concepts

Event Loop

The core of asyncio is the event loop, which runs asynchronous tasks and callbacks, performs network IO operations, and runs subprocesses.
The event loop is responsible for managing the execution of asynchronous tasks.

Coroutines

Coroutines are special functions defined with async def that can pause and resume their execution.
They use the await keyword to yield control back to the event loop.

Tasks

Tasks are used to schedule coroutines concurrently.
They are created using asyncio.create_task().

Futures

Futures represent a result that may not be available yet.
They are used for low-level APIs and are not commonly used directly in high-level code.

Practical Examples

Example 1: Basic Coroutine

import asyncio

async def say_hello():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

# Running the coroutine
asyncio.run(say_hello())

Explanation:

say_hello is a coroutine that prints "Hello", waits for 1 second, and then prints "World".
asyncio.run(say_hello()) runs the coroutine in the event loop.

Example 2: Running Multiple Coroutines Concurrently

import asyncio

async def task1():
    print("Task 1 started")
    await asyncio.sleep(2)
    print("Task 1 finished")

async def task2():
    print("Task 2 started")
    await asyncio.sleep(1)
    print("Task 2 finished")

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

# Running the main coroutine
asyncio.run(main())

Explanation:

task1 and task2 are two coroutines that run concurrently.
asyncio.gather(task1(), task2()) schedules both coroutines to run concurrently.
The main coroutine is responsible for gathering and running the tasks.

Example 3: Using Tasks for Concurrency

import asyncio

async def task(name, duration):
    print(f"Task {name} started")
    await asyncio.sleep(duration)
    print(f"Task {name} finished")

async def main():
    task1 = asyncio.create_task(task("A", 2))
    task2 = asyncio.create_task(task("B", 1))

    await task1
    await task2

# Running the main coroutine
asyncio.run(main())

Explanation:

asyncio.create_task() schedules the coroutines to run concurrently.
The main coroutine waits for both tasks to complete using await.

Practical Exercises

Exercise 1: Simple Asynchronous Function

Task: Write an asynchronous function that prints "Start", waits for 3 seconds, and then prints "End".

Solution:

import asyncio

async def simple_task():
    print("Start")
    await asyncio.sleep(3)
    print("End")

# Running the coroutine
asyncio.run(simple_task())

Exercise 2: Concurrent Tasks

Task: Create two asynchronous functions that each print their start and end messages, with different sleep durations. Run them concurrently.

Solution:

import asyncio

async def task1():
    print("Task 1 started")
    await asyncio.sleep(2)
    print("Task 1 finished")

async def task2():
    print("Task 2 started")
    await asyncio.sleep(1)
    print("Task 2 finished")

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

# Running the main coroutine
asyncio.run(main())

Common Mistakes and Tips

Blocking Code: Avoid using blocking code (e.g., time.sleep()) in asynchronous functions. Use await asyncio.sleep() instead.
Not Using await: Ensure that you use await when calling coroutines; otherwise, they won't run as expected.
Event Loop Management: Use asyncio.run() to manage the event loop. Avoid manually creating and closing the event loop unless necessary.

Conclusion

In this section, we explored the basics of asynchronous programming using Python's asyncio library. We covered key concepts such as the event loop, coroutines, tasks, and futures. Through practical examples and exercises, you learned how to write and run asynchronous code, manage concurrency, and avoid common pitfalls. This knowledge prepares you for more advanced asynchronous programming topics and real-world applications.

Asyncio for Asynchronous Programming

Key Concepts

Event Loop

Coroutines

Tasks

Futures

Practical Examples

Example 1: Basic Coroutine

Example 2: Running Multiple Coroutines Concurrently

Example 3: Using Tasks for Concurrency

Practical Exercises

Exercise 1: Simple Asynchronous Function

Exercise 2: Concurrent Tasks

Common Mistakes and Tips

Conclusion

Python Programming Course

Module 1: Introduction to Python

Module 2: Control Structures

Module 3: Functions and Modules

Module 4: Data Structures

Module 5: Object-Oriented Programming

Module 6: File Handling

Module 7: Error Handling and Exceptions

Module 8: Advanced Topics

Module 9: Testing and Debugging

Module 10: Web Development with Python

Module 11: Data Science with Python

Module 12: Final Project