Image by Author | Canva
# Introduction
When you’re new to Python, you usually use “for” loops whenever you have to process a collection of data. Need to square a list of numbers? Loop through them. Need to filter or sum them? Loop again. This is more intuitive for us as humans because our brain thinks and works sequentially (one thing at a time).
But that doesn’t mean computers have to. They can take advantage of something called vectorized thinking. Basically, instead of looping through every element to perform an operation, you give the entire list to Python like, “Hey, here is the list. Perform all the operations at once.”
In this tutorial, I’ll give you a gentle introduction to how it works, why it matters, and we’ll also cover a few examples to see how beneficial it can be. So, let’s get started.
# What is Vectorized Thinking & Why It Matters?
As discussed previously, vectorized thinking means that instead of handling operations sequentially, we want to perform them collectively. This idea is actually inspired by matrix and vector operations in mathematics, and it makes your code much faster and more readable. Libraries like NumPy allow you to implement vectorized thinking in Python.
For example, if you have to multiply a list of numbers by 2, then instead of accessing every element and doing the operation one by one, you multiply the entire list simultaneously. This has major benefits, like reducing much of Python’s overhead. Every time you iterate through a Python loop, the interpreter has to do a lot of work like checking the types, managing objects, and handling loop mechanics. With a vectorized approach, you reduce that by processing in bulk. It’s also much faster. We’ll see that later with an example for performance impact. I’ve visualized what I just said in the form of an image so you can get an idea of what I’m referring to.
Now that you have the idea of what it is, let’s see how you can implement it and how it can be useful.
# A Simple Example: Temperature Conversion
There are different temperature conventions used in different countries. For example, if you’re familiar with the Fahrenheit scale and the data is given in Celsius, here’s how you can convert it using both approaches.
// The Loop Approach
celsius_temps = [0, 10, 20, 30, 40, 50]
fahrenheit_temps = []
for temp in celsius_temps:
fahrenheit = (temp * 9/5) + 32
fahrenheit_temps.append(fahrenheit)
print(fahrenheit_temps)
Output:
[32.0, 50.0, 68.0, 86.0, 104.0, 122.0]
// The Vectorized Approach
import numpy as np
celsius_temps = np.array([0, 10, 20, 30, 40, 50])
fahrenheit_temps = (celsius_temps * 9/5) + 32
print(fahrenheit_temps) # [32. 50. 68. 86. 104. 122.]
Output:
[ 32. 50. 68. 86. 104. 122.]
Instead of dealing with each item one at a time, we turn the list into a NumPy array and apply the formula to all elements at once. Both of them process the data and give the same result. Apart from the NumPy code being more concise, you might not notice the time difference right now. But we’ll cover that shortly.
# Advanced Example: Mathematical Operations on Multiple Arrays
Let’s take another example where we have multiple arrays and we have to calculate profit. Here’s how you can do it with both approaches.
// The Loop Approach
revenues = [1000, 1500, 800, 2000, 1200]
costs = [600, 900, 500, 1100, 700]
tax_rates = [0.15, 0.18, 0.12, 0.20, 0.16]
profits = []
for i in range(len(revenues)):
gross_profit = revenues[i] - costs[i]
net_profit = gross_profit * (1 - tax_rates[i])
profits.append(net_profit)
print(profits)
Output:
[340.0, 492.00000000000006, 264.0, 720.0, 420.0]
Here, we’re calculating profit for each entry manually:
- Subtract cost from revenue (gross profit)
- Apply tax
- Append result to a new list
Works fine, but it’s a lot of manual indexing.
// The Vectorized Approach
import numpy as np
revenues = np.array([1000, 1500, 800, 2000, 1200])
costs = np.array([600, 900, 500, 1100, 700])
tax_rates = np.array([0.15, 0.18, 0.12, 0.20, 0.16])
gross_profits = revenues - costs
net_profits = gross_profits * (1 - tax_rates)
print(net_profits)
Output:
[340. 492. 264. 720. 420.]
The vectorized version is also more readable, and it performs element-wise operations across all three arrays simultaneously. Now, I don’t just want to keep repeating “It’s faster” without solid proof. And you might be thinking, “What is Kanwal even talking about?” But now that you’ve seen how to implement it, let’s look at the performance difference between the two.
# Performance: The Numbers Don’t Lie
The difference I’m talking about isn’t just hype or some theoretical thing. It’s measurable and proven. Let’s look at a practical benchmark to understand how much improvement you can expect. We’ll create a very large dataset of 1,000,000 instances and perform the operation \( x^2 + 3x + 1 \) on each element using both approaches and compare the time.
import numpy as np
import time
# Create a large dataset
size = 1000000
data = list(range(size))
np_data = np.array(data)
# Test loop-based approach
start_time = time.time()
result_loop = []
for x in data:
result_loop.append(x ** 2 + 3 * x + 1)
loop_time = time.time() - start_time
# Test vectorized approach
start_time = time.time()
result_vector = np_data ** 2 + 3 * np_data + 1
vector_time = time.time() - start_time
print(f"Loop time: {loop_time:.4f} seconds")
print(f"Vector time: {vector_time:.4f} seconds")
print(f"Speedup: {loop_time / vector_time:.1f}x faster")
Output:
Loop time: 0.4615 seconds
Vector time: 0.0086 seconds
Speedup: 53.9x faster
That’s more than 50 times faster!!!
This isn’t a small optimization, it will make your data processing tasks (I’m talking about BIG datasets) much more feasible. I’m using NumPy for this tutorial, but Pandas is another library built on top of NumPy. You can use that too.
# When NOT to Vectorize
Just because something works for most cases doesn’t mean it’s the approach. In programming, your “best” approach always depends on the problem at hand. Vectorization is great when you’re performing the same operation on all elements of a dataset. But if your logic involves complex conditionals, early termination, or operations that depend on previous results, then stick to the loop-based approach.
Similarly, when working with very small datasets, the overhead of setting up vectorized operations might outweigh the benefits. So just use it where it makes sense, and don’t force it where it doesn’t.
# Wrapping Up
As you continue to work with Python, challenge yourself to spot opportunities for vectorization. When you find yourself reaching for a `for` loop, pause and ask whether there’s a way to express the same operation using NumPy or Pandas. More often than not, there is, and the result will be code that’s not only faster but also more elegant and easier to understand.
Remember, the goal isn’t to eliminate all loops from your code. It’s to use the right tool for the job.
Kanwal Mehreen Kanwal is a machine learning engineer and a technical writer with a profound passion for data science and the intersection of AI with medicine. She co-authored the ebook “Maximizing Productivity with ChatGPT”. As a Google Generation Scholar 2022 for APAC, she champions diversity and academic excellence. She’s also recognized as a Teradata Diversity in Tech Scholar, Mitacs Globalink Research Scholar, and Harvard WeCode Scholar. Kanwal is an ardent advocate for change, having founded FEMCodes to empower women in STEM fields.
