Discover challenging Python brain teasers that test your skills and stretch your thinking. Gain insights into advanced concepts and enhance your understanding of this versatile language.

Forget Scrabble, Boggle, or Wordle. Tease your mind and test your skills with these fun brain teasers designed to stretch your thinking and expand your understanding of one of the most widely used languages out there. 

Python is simple. These puzzles are not. Good luck!

Python Brain Teasers

# Try it yourself
Try executing the code below to verify the results:

from concurrent.futures import ProcessPoolExecutor
from itertools import repeat

guilty = 0

def juror():
    global guilty

    guilty += 1

with ProcessPoolExecutor() as pool:
    for _ in repeat(None, 12):
        pool.submit(juror)

print(guilty)

# Explanation

Both **threads** and **processes** are concurrent units of work. The main difference is that threads share the same memory space and processes don’t.
This means that if we have a global variable (like `guilty`), all threads in the same process will be able to access and modify it. Whereas in processes, we’ll need to communicate the data between the processes in some way (like through a socket).

This teaser uses a `ProcessPoolExecutor`, meaning the code is executed in a different process. Every `juror` changes its own copy of `guilty`.

Threads allow faster access to shared data, but they are more dangerous. None of the built-in types in Python (such as `list` or `dict`) are thread safe. If we change (or mutate) a `list` from two threads at the same time, the behavior is undefined. We’ll need to use `threading.Lock` to ensure that only one thread changes the list at a time.
Making all built-in types thread-safe will make them run much slower, and most of the Python code out there still runs in a single thread. This is why the built-in types will not be thread-safe in the near (or distant) future.

So, when should we use threads, and when should we use processes? A good, general rule is if we have CPU-bound code, we should use processes, and if we have an I/O-bound code, we should use threads.
Before using threads or processes, remember that there’s a limit on how much parallelization will help. It’s also much harder to write using threads and processes than it is to write sequential code.


Let’s find out how threads and processes work in Python.

Before We Begin

Python Puzzles

Wrapping Up

Puzzle 24: Explanation

Try it yourself

Explanation