2026-01-168 min read

Futures (Python Programming)

Learn Futures (Python Programming) step by step with clear examples and exercises.

Title: Futures (Python Programming)

Why This Matters

In this Python lesson, we delve into a powerful tool called Futures, which helps manage asynchronous tasks efficiently. As you progress through your coding journey, you'll encounter situations where you need to perform multiple tasks simultaneously, such as network requests, database operations, or CPU-intensive computations. Using Futures can help improve the performance of your applications and prevent blocking issues. This skill is crucial for real-world programming scenarios, interviews, and debugging complex codebases.

Prerequisites

Before diving into Futures, you should have a solid understanding of:

Python basics (variables, functions, loops, conditionals)
Asynchronous programming concepts (event loop, coroutines, tasks)
Basic network requests using libraries like requests or httpx
Understanding the difference between synchronous and asynchronous code
Familiarity with web scraping using libraries such as BeautifulSoup
Basic understanding of exception handling in Python
Understanding the Global Interpreter Lock (GIL) and its implications on threading and multiprocessing performance
Knowledge of how to create and manage threads and processes in Python

Core Concept

What are Futures?

In Python, a Future is an object that represents the eventual result of an asynchronous operation, such as a network request or CPU-intensive computation. It allows you to write asynchronous code in a synchronous style, making it easier to manage and reason about your concurrent tasks.

How do Futures work?

When you create a Future, Python's asyncio library starts an asynchronous task that will eventually produce a result. You can then use the await keyword to pause the execution of your synchronous code until the Future's result is available. If the asynchronous operation encounters an error, the Future will raise it when its result is returned.

Creating and using Futures

To create a Future, you can use the asyncio.Future() constructor. You can then pass a callback function to the Future's set_result() method, which will be called when the asynchronous operation completes. Here's an example:

import asyncio

def long_running_task(result):

Simulate a CPU-intensive task

async def mock_long_running_task():

await asyncio.sleep(3)

return result * 2

return mock_long_running_task()

async def main():

future = asyncio.Future()

asyncio.create_task(long_running_task(future))

The following line will pause the execution until long_running_task completes

result = await future

print("Result:", result)

if __name__ == "__main__":

asyncio.run(main())


In this example, we create an asynchronous task using `asyncio.create_task()` and pass it to a mock function that simulates a long-running CPU-intensive task. We also create a Future and set its result callback to the same function. When the task completes, it sets the result of the Future, which allows us to use `await` in the main function to pause its execution until the result is available.

### Managing multiple Futures with asyncio.gather()

You can manage multiple Futures using the `asyncio.gather()` function, which waits for all provided Futures to complete and returns their results in the order they were created. Here's an example:

import asyncio

def long_running_task(result):

await asyncio.sleep(3)

return result * 2

async def main():

futures = [asyncio.create_task(long_running_task(i)) for i in range(5)]

results = await asyncio.gather(*futures)

for result in results:

print("Result:", result)

if __name__ == "__main__":

asyncio.run(main())


In this example, we create five asynchronous tasks using `asyncio.create_task()` and pass them to the `long_running_task()` function. We then use `asyncio.gather()` to wait for all tasks to complete simultaneously and collect their results. This allows us to perform multiple CPU-intensive computations concurrently without blocking the main thread.

Worked Example

Let's build an asynchronous web scraper using Futures, the requests library, and BeautifulSoup:

import asyncio
import aiohttp
from bs4 import BeautifulSoup

async def fetch(url):
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
soup = BeautifulSoup(await response.text(), "html.parser")
return soup

async def main():
urls = ["https://www.example1.com", "https://www.example2.com"]
futures = [fetch(url) for url in urls]

soups = await asyncio.gather(*futures)
for soup in soups:
print("URL:", soup.title.string)
print("Links:", len([link for link in soup.find_all("a")]))
print("\n")

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

In this example, we create a list of URLs and use fetch() to start an asynchronous task for each one. We then use asyncio.gather() to wait for all tasks to complete simultaneously and collect their results. This allows us to scrape multiple websites concurrently without blocking the main thread.

Common Mistakes

Not awaiting Futures: When using Futures, it's essential to use the await keyword before them in your synchronous code. Failing to do so will result in a non-blocking Future and could lead to unexpected behavior.

Not setting the Future's result: If you don't set the Future's result using its set_result() method, it will never complete, and your asynchronous code will not progress.

Not handling errors: If an error occurs during the execution of an asynchronous task, it will be raised when the Future's result is returned. Make sure to handle these errors appropriately in your code.

### Subheading: Cancelling Futures

To cancel a Future and its associated asynchronous task, you can use the cancel() method. If the task has not started yet, it will be prevented from running. If it's already running, it might take some time to cancel, depending on the nature of the task.

### Subheading: Waiting for a single Future to complete

If you only want to wait for a single Future to complete, you can use the await keyword directly with the Future object, like so:

future = asyncio.create_task(long_running_task())
await future
result = future.result()

### Subheading: Error handling in Futures

To handle exceptions during the execution of an asynchronous task, you can use a try-except block around the Future's set_result() callback function. Here's an example:

def long_running_task(result):
try:

Simulate an error during CPU-intensive task

raise ValueError("Simulated error")

except Exception as e:

future.set_exception(e)


In this example, if an exception occurs during the execution of `long_running_task()`, it sets the Future's exception attribute instead of its result attribute. You can then handle the exception in your synchronous code by using a try-except block around the `await` statement:

try:

result = await future

except Exception as e:

print("Error:", e)


7. ### Subheading: Cancelling a Future after a certain timeout
- To cancel a Future if it takes too long to complete (e.g., after 10 seconds), you can use the `task.cancel()` method and wait for the cancellation to propagate using a loop with a timeout:

import time

def long_running_task(result):

Simulate a CPU-intensive task

await asyncio.sleep(15) # This task takes too long

return result * 2

async def main():

future = asyncio.create_task(long_running_task(future))

start_time = time.monotonic()

while not future.done():

if time.monotonic() - start_time > 10:

future.cancel()

await future

print("Task cancelled due to timeout.")

break

await asyncio.sleep(1)

if future.result():

print("Result:", future.result())

else:

print("Error:", future.exception())


In this example, we create a Future and start an asynchronous task that takes too long to complete (15 seconds). We then use a loop with a timeout of 10 seconds to check if the task is still running. If it's taking too long, we cancel the task using `future.cancel()` and wait for the cancellation to propagate before printing an error message.

Practice Questions

Write an asynchronous function that performs n-factorial using Futures and the asyncio library.
Modify the web scraper example to also print the number of images on each page.
Implement a simple asynchronous chat server using Futures, sockets, and the asyncio library.
### Subheading: Error handling in Futures

How would you modify the long-running task function to handle exceptions during its execution?

### Subheading: Cancelling a Future after a certain timeout

How can you cancel a Future if it takes too long to complete (e.g., after 10 seconds)?

### Subheading: Waiting for multiple Futures to complete in order

How would you modify the asyncio.gather() function to wait for multiple Futures to complete in the order they were created?

### Subheading: Cancelling a group of Futures

How can you cancel all Futures within a group when one of them encounters an error?

FAQ

Why should I use Futures instead of threading or multiprocessing?

Futures are designed to work seamlessly with Python's asyncio library, allowing you to write cleaner and more efficient asynchronous code. Threading and multiprocessing can lead to issues like the Global Interpreter Lock (GIL) and increased complexity in managing shared resources.

Can I use Futures for I/O-bound tasks only?

While Futures are particularly useful for I/O-bound tasks, they can also be used for CPU-intensive computations by breaking them into smaller chunks that can run concurrently. However, for purely CPU-bound tasks, using threading or multiprocessing might still offer better performance due to the GIL.

How do I cancel a Future if an asynchronous task takes too long?

To cancel a Future and its associated asynchronous task, you can use the cancel() method. If the task has not started yet, it will be prevented from running. If it's already running, it might take some time to cancel, depending on the nature of the task.

How do I wait for a single Future to complete?

To wait for a single Future to complete, you can use the await keyword directly with the Future object, like so:

future = asyncio.create_task(long_running_task())
await future
result = future.result()

How do I handle errors in Futures?

To handle exceptions during the execution of an asynchronous task, you can use a try-except block around the Future's set_result() callback function. Here's an example:

def long_running_task(result):
try:

Simulate an error during CPU-intensive task

raise ValueError("Simulated error")

except Exception as e:

future.set_exception(e)


In this example, if an exception occurs during the execution of `long_running_task()`, it sets the Future's exception attribute instead of its result attribute. You can then handle the exception in your synchronous code by using a try-except block around the `await` statement:

try:

result = await future

except Exception as e:

print("Error:", e)


6. **How do I wait for multiple Futures to complete in order?**
- To wait for multiple Futures to complete in the order they were created, you can use a loop and check each Future's `done()` attribute:

futures = [asyncio.create_task(long_running