Explore advanced Python concepts and tools used by experienced Python developers.

Python for Programmers

In this module, we’ll explore advanced Python concepts and tools used by experienced Python developers. We'll begin by exploring Python modules and then move on to topics such as unicode, generators, and iterators. Lastly, we'll go over web-related tasks with Python, methods of testing code, and other useful skills.

Advanced Concepts in Python

# Pitfalls of the `concurrent.futures` module
One of the pitfalls of the `concurrent.futures` module is that you can accidentally create deadlocks when the caller to associate with a Future is also waiting on the results of another future.


This sounds
kind of confusing, so let's look at an example:

from concurrent.futures import ThreadPoolExecutor


def wait_forever():
    """
    This function will wait forever if there's only one
    thread assigned to the pool
    """
    my_future = executor.submit(zip, [1, 2, 3], [4, 5, 6])
    result = my_future.result()
    print(result)

if __name__ == '__main__':
    executor = ThreadPoolExecutor(max_workers=1)
    executor.submit(wait_forever)


Here we import the `ThreadPoolExecutor` class and create an instance of
it (line 1). Take note that we set its maximum number of workers to one thread.
Then we submit our function, `wait_forever`.  Inside of our function, we submit another job to the thread pool that is supposed to zip two lists together, get the result of that operation and print it out (lines 4 - 11). 
However we've just created a deadlock. The reason is that we are having
one Future wait for another Future to finish. Basically we want a
pending operation to wait on another pending operation which doesn't
work very well.
# How `ThreadPoolExecutor` can make it work

Let's rewrite the code a bit to make it work:

Let's look into the scenarios when deadlocks occur.

Deadlocks

Pitfalls of the concurrent.futures module

Pitfalls of the `concurrent.futures` module