Today we're learning the art of doing everything all at once in Python. Well — not you exactly, but the Python script you write.
Because sometimes, one task at a time just doesn't cut it. Imagine downloading files, resizing images, and saving them all in the same second. Welcome to the chaotic, beautiful world of multithreading.
We saved the weird, powerful, slightly intimidating functions for last. Two things to cover:
map(),filter(),reduce()Multithreading
Quick Recap: Why Learn These?
If you've ever thought "can't I just use loops instead of all this complicated stuff?" — you're right. But also kind of wrong.
In small programs, loops are fine. But in real-world applications, when performance, memory and scalability start to matter, Pythonic solutions like map(), filter(), reduce() and multithreading become your secret weapons.
Let's break them down. One function, one concept, one vibe at a time.
map(): The Smart Looper
Your teacher gives you 10 test papers and asks you to increase everyone's marks by 5. You could go one by one and manually add 5. Or you could apply the rule to all of them at once.
That's map().
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, numbers))
print(squared) # Output: [1, 4, 9, 16]map() applies a function to each element of a list. Think of it as .apply() from Excel, but Pythonified.
filter(): The Selective Friend
You're planning a party. You only want to invite people who bring snacks. So you make a guest list by checking: does this person bring food? If yes, they're in.
That's filter().
ages = [12, 17, 18, 24, 15]
adults = list(filter(lambda x: x >= 18, ages))
print(adults) # Output: [18, 24]filter() keeps only the values that return True in a given function.
reduce(): The Ultimate Compressor
To use reduce(), you need to import it first:
from functools import reduceImagine you're collecting money from friends to pay for pizza. One person collects the total, one by one, from each person, keeping a running total.
That's reduce().
from functools import reduce
numbers = [1, 2, 3, 4]
total = reduce(lambda x, y: x + y, numbers)
print(total) # Output: 10reduce() combines all elements of a list into a single value. Use it when you need to collapse a list: sum, product, longest word, and so on.
Multithreading: Because One Brain Isn't Enough
You're downloading files, resizing images, and saving them to disk. Doing it one by one is slow. But what if your code could do all three at the same time?
Hello, multithreading.
import threading
def print_numbers():
for i in range(5):
print("Number:", i)
def print_letters():
for letter in 'abcde':
print("Letter:", letter)
t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_letters)
t1.start()
t2.start()
t1.join()
t2.join()Your terminal might show numbers and letters intermixed — that's threads working side by side.
But Why Bother With Multithreading?
Because in the real world:
Web apps handle thousands of users clicking buttons.
Games update graphics, play sounds, and listen to controls — all at once.
Data pipelines clean, process, and store huge files simultaneously.
You can't do all that in one slow, single-threaded line of code.
Thread Synchronization: When Threads Fight
But what if two threads access the same resource at the same time? Things break, badly.
The solution is a lock.
import threading
lock = threading.Lock()
def safe_task():
with lock:
# This section is thread-safe
print("Running safely")
t1 = threading.Thread(target=safe_task)
t2 = threading.Thread(target=safe_task)
t1.start()
t2.start()with lock: ensures only one thread can enter that block at a time. Like a washroom key at a petrol pump — one person at a time, please.
When Threads Go Rogue: The GIL Dilemma
Alright, you've created multiple threads. You're feeling like a tech wizard. Until you realise Python isn't actually running them all at the same time.
Welcome to the GIL: the Global Interpreter Lock, the bouncer at the Python party.
Imagine a restaurant kitchen with five chefs (your threads), but only one stove (the CPU core). The GIL says: only one chef can cook at a time, even if all of them are ready. So your threads end up taking turns rather than cooking simultaneously.
Sounds counterproductive? A bit. But the GIL exists to keep memory safe and avoid wild bugs. It's a CPython thing specifically.
So Does Multithreading Even Work in Python?
Yes — especially for I/O-bound tasks like downloading files, making web requests, or reading from disk. It's not so great for CPU-bound tasks like complex maths or data crunching. For those, we bring out the big guns: multiprocessing.
Pythonic Pro Tips
Don't overuse
reduce()just to look smart. Sometimes a simpleforloop is clearer.Use
filter()when you need clean data.Use
map()when you want transformed data.Use multithreading for I/O-bound tasks (file operations, web requests).
For CPU-heavy tasks, use multiprocessing instead.
Coding Challenge
Given a list of numbers, return the sum of the squares of all even numbers. Try solving it using filter() to grab the evens, map() to square them, and reduce() to sum them.
Final Thoughts
This is the end of our Python series — but not the end for you. Keep learning. Keep building. Keep breaking. Keep fixing.
Keep building things that make you go: "Damn. I wrote that."
This article was originally published on Medium by the My Equation team.
