When you are first handed a massive dataset—whether it's millions of telescope images, a decade of financial records, or a database of user clicks—the sheer volume of numbers is completely incomprehensible to the human brain.
Before you can build a predictive machine learning model, you have to understand what your data actually looks like. The very first step of Exploratory Data Analysis (EDA) is computing summary statistics. You need to boil down massive arrays into single, representative numbers: the "typical" value (mean, median), the spread of the data (standard deviation, variance), and the extremes (minimum, maximum).
In our previous deep-dives, we explored how NumPy uses compiled C code and UFuncs to perform blindingly fast array operations. Now, we are going to apply that exact same architecture to Aggregations.
In this masterclass, we will explore the extreme performance differences between Python and NumPy aggregations, decode the notoriously confusing multidimensional axis parameter, and learn how to safely navigate missing data.
Let's start with the simplest aggregation possible: calculating the sum of an array.
Python has a built-in sum() function. If you have a small list of numbers, it works perfectly. However, just like we saw with for loops, native Python functions are completely unequipped to handle big data.
Let's generate an array of one million random numbers and compare Python's sum() to NumPy's np.sum():
import numpy as np
# Generate an array of 1,000,000 random floats
big_array = np.random.rand(1000000)
# 1. Timing Python's built-in sum()
%timeit sum(big_array)
# Output: 10 loops, best of 3: 104 ms per loop
# 2. Timing NumPy's compiled np.sum()
%timeit np.sum(big_array)
# Output: 1000 loops, best of 3: 442 µs per loop
The Breakdown: NumPy's np.sum() executes in $442$ microseconds. Python's sum() takes $104$ milliseconds. NumPy is roughly 250 times faster.
Why? Because np.sum() is aware of the array's contiguous memory layout and fixed data type. It pushes the addition operation down into highly optimized, compiled C code, completely bypassing Python's sluggish type-checking.
⚠️ A Critical Warning: Because they share a name, it is incredibly easy to accidentally use Python's built-in sum(), min(), or max() on a NumPy array. While they will technically work, they will silently strangle your program's performance. Always explicitly use the np. prefix, or use the object-oriented method (discussed below). Furthermore, Python's built-ins do not understand multidimensional arrays, which will cause your code to crash if you try to sum a 2D matrix!
2. Minimum, Maximum, and Object-Oriented Syntax
Just as there is np.sum(), NumPy has corresponding functions for finding the extreme values in a dataset: np.min() and np.max().
# Finding the extremes of our million-element array
print(np.min(big_array))
print(np.max(big_array))
# Output:
# 1.1717128136634614e-06
# 0.9999976784968716
The Shorthand: Object Methods
For the most common aggregations, NumPy provides a cleaner, object-oriented syntax. Instead of passing the array into a function, you can call the method directly on the array object itself:
# This is functionally identical and equally fast:
print(big_array.min())
print(big_array.max())
print(big_array.sum())
Advanced data scientists heavily favor this shorthand syntax because it allows for clean "method chaining" (e.g., my_array.reshape(3,3).sum()).
3. Multidimensional Aggregates: Conquering the axis Keyword
So far, we have looked at 1D arrays. But machine learning operates on multidimensional grids (like a CSV file where rows are patients and columns are medical readings).
By default, if you call an aggregation function on a 2D matrix, NumPy will treat it like a flattened 1D array and return a single aggregate value over the entire array:
# Create a 3x4 matrix
M = np.random.random((3, 4))
print(M)
# [[ 0.8967576 0.03783739 0.75952519 0.06682827]
# [ 0.8354065 0.99196818 0.19544769 0.43447084]
# [ 0.66859307 0.15038721 0.37911423 0.6687194 ]]
# Default behavior: Sums EVERY number in the grid
print(M.sum())
# Output: 6.0850555667307118
But what if you want to find the minimum value of each column (e.g., the lowest reading for each distinct medical test)? To do this, you must pass the axis argument.
The axis Trap (And How to Understand It)
The way the axis argument works confuses almost everyone coming from other languages.
The Golden Rule: The axis keyword does not specify the dimension that will be returned. It specifies the dimension of the array that will be collapsed (or reduced).
axis=0 (Collapse the Rows): This tells NumPy to crush the row dimension. It searches down the rows. Therefore, it returns the aggregate for each column.
axis=1 (Collapse the Columns): This tells NumPy to crush the column dimension. It searches across the columns. Therefore, it returns the aggregate for each row.
# Find the minimum value in each COLUMN (Collapse the rows / axis=0)
print(M.min(axis=0))
# Output: [ 0.66859307 0.03783739 0.19544769 0.06682827]
# (Notice we get 4 values back, matching our 4 columns)
# Find the maximum value in each ROW (Collapse the columns / axis=1)
print(M.max(axis=1))
# Output: [ 0.8967576 0.99196818 0.6687194 ]
# (Notice we get 3 values back, matching our 3 rows)
4. The Silent Killer: NaN Data and Safe Aggregations
In real-world data science, your data is never perfect. Sensors fail, humans leave forms blank, and network packets drop. In Python, missing numerical data is represented by the special IEEE floating-point value NaN (Not a Number).
NaN acts like a virus. If you perform any mathematical operation that includes a NaN value, the result will immediately become NaN.
dirty_data = np.array([1, 2, 3, np.nan, 5])
# Standard aggregations will be infected!
print(dirty_data.sum()) # Output: nan
print(dirty_data.mean()) # Output: nan
To combat this, NumPy (since version 1.8) includes NaN-safe counterparts for almost every aggregation function. These functions compute the result while completely ignoring any missing values.
# Using the NaN-safe versions
print(np.nansum(dirty_data)) # Output: 11.0 (1+2+3+5)
print(np.nanmean(dirty_data)) # Output: 2.75
The Complete NumPy Aggregation Arsenal
Here is your master reference table for the most crucial aggregation functions:
| Function Name |
NaN-safe Version |
Description |
np.sum |
np.nansum |
Compute sum of elements |
np.prod |
np.nanprod |
Compute product of elements |
np.mean |
np.nanmean |
Compute the arithmetic mean (average) |
np.median |
np.nanmedian |
Compute the median (middle value) |
np.std |
np.nanstd |
Compute standard deviation (spread of data) |
np.var |
np.nanvar |
Compute variance |
np.min |
np.nanmin |
Find minimum value |
np.max |
np.nanmax |
Find maximum value |
np.argmin |
np.nanargmin |
Find the index of the minimum value |
np.argmax |
np.nanargmax |
Find the index of the maximum value |
np.percentile |
np.nanpercentile |
Compute rank-based statistics (e.g., 25th percentile) |
np.any |
N/A |
Evaluate whether any elements are True |
np.all |
N/A |
Evaluate whether all elements are True |
(Pro-Tip on argmin / argmax:** These are secretly two of the most powerful functions on this list. In machine learning, you rarely just want to know "What is the highest probability?" You want to know "WHICH category has the highest probability?" argmax gives you the exact index position of that maximum value so you can identify the winning class).
5. Real-World EDA Example: US President Heights
Let's pull all of this together with a real-world example. Imagine we have a CSV file (president_heights.csv) containing the heights (in centimeters) of US Presidents.
First, we use Pandas (a library built entirely on NumPy arrays) to extract the data into a raw NumPy array:
import pandas as pd
import numpy as np
# Read the CSV and extract the 'height(cm)' column as a NumPy array
data = pd.read_csv('data/president_heights.csv')
heights = np.array(data['height(cm)'])
print(heights)
# Output: [189 170 189 163 183 171 185 168 ... 185]
Now that we have our heights array, we can use our aggregation toolkit to instantly understand the "shape" of this dataset without having to scan 40+ raw numbers with our eyes:
print("Mean height: ", heights.mean())
print("Standard deviation:", heights.std())
print("Minimum height: ", heights.min())
print("Maximum height: ", heights.max())
# Output:
# Mean height: 179.738095238
# Standard deviation: 6.93184344275
# Minimum height: 163
# Maximum height: 193
This tells us the average president is nearly 180cm, but the standard deviation of ~6.9cm shows there is a decent amount of variety. We can dig deeper into the distribution using quantiles:
print("25th percentile: ", np.percentile(heights, 25))
print("Median: ", np.median(heights))
print("75th percentile: ", np.percentile(heights, 75))
# Output:
# 25th percentile: 174.25
# Median: 182.0
# 75th percentile: 183.0
We see that the median height is $182$ cm (just shy of six feet), which is slightly higher than the mean, hinting that the data might be skewed by a few shorter presidents.
To confirm this, data scientists will often pass these NumPy arrays directly into a visualization library like Matplotlib or Seaborn to generate a histogram, allowing us to visually verify the mathematical aggregations we just computed.
import matplotlib.pyplot as plt
import seaborn; seaborn.set() # Set visual style
plt.hist(heights)
plt.title('Height Distribution of US Presidents')
plt.xlabel('height (cm)')
plt.ylabel('number');
And just like that, you have completed your first cycle of Exploratory Data Analysis!
Free Resources to Dive Deeper
To truly master aggregations, you need to practice. Here are the best free resources to sharpen your EDA skills:
Official NumPy Aggregation Documentation: The complete index of every statistical function built into NumPy, including correlations and histograms.
Kaggle Datasets: The best way to practice is on real data. Download a free, messy CSV file from Kaggle and practice using np.nansum, axis=0, and np.percentile to summarize it.
Matplotlib Pyplot Tutorial: Learn how to turn your NumPy arrays into beautiful histograms and scatter plots for visual EDA.
Ig We Completed Half Of Numpy :)
