Arrays & Vectorisation: Explain Why Loops Are Slow in Analytics Interviews
Why does adding one million prices one by one feel slow, while one NumPy line seems to finish almost instantly? The surprise is not that computers are fast - it is that Python loops make the computer wait at the wrong layer.
- An array is a fixed-shape collection of same-type values stored for fast numerical operations.
- Vectorisation means applying one operation to many values at once, without writing an explicit Python loop.
- Python loops are slow mainly because each iteration carries interpreter overhead: type checks, object handling and bytecode execution.
- NumPy arrays are fast because the heavy work runs in compiled C/Fortran-style loops over contiguous memory.
- Use vectorisation when the same calculation applies across rows, columns, observations, products or customers.
- Do not blindly vectorise everything: large temporary arrays can waste memory and sometimes make code slower.
- In interviews, explain loops versus vectorisation through interpreter overhead, memory layout, compiled execution and readability.
Big Picture: The Same Logic, Two Very Different Execution Paths
At the business level, the task may be simple: calculate discounts, margins, risk scores or customer segments. At the computer level, the question is: do you ask Python to handle each item separately, or do you hand the whole numeric block to an optimized array engine?
Core Explanation: Arrays, Loops and Vectorisation
The key idea is simple: loops describe work item by item; vectorisation describes work as one batch operation. For analytics, this matters because business datasets are naturally columnar - prices, quantities, ages, clicks, ratings, balances and delivery times.
1. What an Array Really Is
An array stores values in a structured grid: one dimension for a list, two dimensions for a table, more dimensions for tensors such as images or model inputs. In numerical libraries such as NumPy, arrays usually hold one data type, which lets the computer process values efficiently.
2. Why Python Loops Are Slow
A Python for loop is not slow because repetition is bad. It is slow because Python is a high-level interpreted language. Each iteration may involve fetching objects, checking types, executing bytecode and managing references. That overhead becomes painful when repeated thousands or millions of times.
In contrast, a NumPy operation such as revenue = units * price sends a whole array operation to optimized low-level code. The loop still exists somewhere - but it runs closer to the machine, with less per-item overhead and better memory access.
3. Loop Thinking versus Array Thinking
Loop thinking says: “For every product, compute margin.” Array thinking says: “Take the whole price column and subtract the whole cost column.” The business logic is identical; the execution model is not.
4. Worked Example: Revenue Without a Loop
Suppose an ecommerce analyst has three SKUs:
- Units sold =
[100, 40, 20] - Selling price =
[199, 499, 999]
Loop logic calculates each product revenue and adds it:
- SKU 1:
100 × 199 = 19,900 - SKU 2:
40 × 499 = 19,960 - SKU 3:
20 × 999 = 19,980 - Total revenue =
59,840
Vectorised logic writes this as one dot product: total_revenue = units · price = 59,840. Same arithmetic, cleaner expression, better execution path for large arrays.
5. Broadcasting: The Trick That Makes Array Code Concise
Broadcasting lets arrays of compatible shapes work together without manually copying values. Example: if price is a column of product prices and GST is 0.18, then price * 1.18 applies the same multiplier to the whole array.
Definitions You Should Be Able to Say Cleanly
- Array: A fixed-shape collection of values, usually same-type, stored for efficient indexed and numerical operations.
- Vectorisation: Applying one operation to many values at once without writing an explicit loop in high-level code.
- Broadcasting: Automatically aligning compatible array shapes so arithmetic can happen without manually copying smaller arrays.
- Interpreter overhead: Extra work a language runtime performs while executing each high-level instruction.
- Contiguous memory: Storing values next to each other, making sequential access faster for the processor.
How to Evaluate Whether Vectorisation Helped
Do not say “vectorised is faster” without evidence. A good analyst measures speed, memory and correctness against a baseline.
Case Study: Meesho and Marketplace-Scale Feature Calculations
Meesho illustrates why array thinking matters in Indian ecommerce: marketplace decisions depend on scoring many users, sellers and products repeatedly.
Meesho operates in a highly price-sensitive Indian ecommerce market, with a large long-tail catalogue and many small sellers. The analytics problem is not “calculate one product score.” It is closer to “calculate millions of product-user-seller signals repeatedly, then rank, recommend, flag or summarize them.”
The move: Instead of treating every row as a separate Python object, an analytics team should represent features as arrays or matrices: product price, discount, rating count, delivery estimate, seller reliability, click behaviour and conversion labels. Standard transformations - normalization, margin calculation, eligibility filters, similarity scoring - can then run as vectorised operations.
The outcome or lesson: The primary driver is not “NumPy is magic.” The primary driver is regular numeric work moved into optimized array operations. Supporting drivers include clean feature design, consistent data types, batch processing, memory-aware pipelines and careful validation. The strategic so what: at marketplace scale, speed is not only an engineering concern - it determines how fast analysts can test pricing, ranking and growth hypotheses.
The case proves the core concept: vectorisation wins when the business problem naturally becomes repeated numeric operations over large structured data.
How AI Changes Arrays & Vectorisation
AI makes arrays even more important because modern AI systems are built on tensors - arrays with more dimensions. Text, images, clicks and transactions are converted into numerical representations before models can learn from them.
Use ChatGPT or Claude like a code reviewer: paste a small loop-based calculation and ask, “Rewrite this using NumPy vectorisation, explain the shape of each array, and list any memory risks.” Then test both versions on a small sample before trusting the refactor.
Interview Relevance
“You have written a Python loop to calculate a metric for every customer in a large dataset. Why might it be slow, and how would you improve it?”
A strong answer uses this sentence: “The loop is not slow because arithmetic is slow; it is slow because Python manages each iteration at the interpreter level, while vectorised array operations push repeated numeric work into optimized compiled code.”
Common Mistake
The mistake is saying “vectorisation is always faster!” That costs candidates because it ignores memory overhead, irregular logic and correctness checks. The one-line fix: say vectorisation is usually best for large, regular numeric operations - then benchmark speed and memory against the loop baseline.
What to Revise Next
Now that arrays and vectorisation make sense, move to the tools that MBA analytics roles actually test on datasets: loading data, selecting columns, filtering rows and cleaning messy business tables.