Python NumPy: How to Calculate Array Statistics

Statistical analysis is the backbone of data science and scientific computing. In Python, while standard lists can store numbers, they lack the performance and built-in functions required for efficient statistical analysis. The NumPy library bridges this gap, providing high-performance array objects and a suite of statistical tools.

This guide explores how to create arrays, calculate core descriptive statistics (like mean and variance), handle multi-dimensional data, and perform advanced analysis like normalization.

Creating and Understanding NumPy Arrays

Before calculating statistics, you need to structure your data into NumPy arrays. These arrays are more memory-efficient and faster than Python lists for numerical operations.

Basic Array Creation

You can convert lists to arrays or generate data using built-in methods.

import numpy as np

data_list = [10, 20, 30, 40, 50]
arr = np.array(data_list)

range_arr = np.arange(0, 10, 2) 

linear_arr = np.linspace(0, 1, 5)

print(f"Manual Array: {arr}")
print(f"Range Array:  {range_arr}")
print(f"Linear Array: {linear_arr}")

Output:

Manual Array: [10 20 30 40 50]
Range Array:  [0 2 4 6 8]
Linear Array: [0.   0.25 0.5  0.75 1.  ]

Calculating Basic Descriptive Statistics

NumPy provides functions to calculate Central Tendency (where the data is centered) and Dispersion (how spread out the data is).

import numpy as np

data = np.array([15, 20, 35, 40, 50, 12, 45, 55])

mean_val = np.mean(data)
median_val = np.median(data)

std_dev = np.std(data)       # Standard Deviation
variance = np.var(data)      # Variance
min_val = np.min(data)
max_val = np.max(data)

print(f"Mean:     {mean_val:.2f}")
print(f"Median:   {median_val:.2f}")
print(f"Std Dev:  {std_dev:.2f}")
print(f"Range:    {min_val} - {max_val}")

Output:

Mean:     34.00
Median:   37.50
Std Dev:  15.39
Range:    12 - 55

Working with Multi-Dimensional Arrays (Axes)

When working with matrices (2D arrays), you often need to calculate statistics for the entire dataset, or specifically for rows/columns. In NumPy, this is controlled by the axis parameter.

• axis=0: Calculate down the columns.
• axis=1: Calculate across the rows.

import numpy as np

matrix = np.array([
    [10, 20, 30],
    [5,  15, 25],
    [2,  4,  6]
])

print(f"Global Mean: {np.mean(matrix):.2f}")

print(f"Column Means: {np.mean(matrix, axis=0)}")

print(f"Row Means:    {np.mean(matrix, axis=1)}")

Output:

Global Mean: 13.00
Column Means: [ 5.66666667 13.         20.33333333]
Row Means:    [20. 15.  4.]

Advanced Analysis: Percentiles and Correlation

Beyond averages, you often need to understand the distribution of data or how variables relate to one another.

Percentiles

Percentiles help identify where a value stands relative to the rest of the data.

import numpy as np

data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

q1 = np.percentile(data, 25)
q2 = np.percentile(data, 50)
q3 = np.percentile(data, 75)

print(f"25th Percentile: {q1}")
print(f"50th Percentile: {q2}")
print(f"75th Percentile: {q3}")

Output:

25th Percentile: 3.25
50th Percentile: 5.5
75th Percentile: 7.75

Correlation

Use np.corrcoef to see if two datasets move in the same direction.

import numpy as np

x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 6, 8, 10]) # Perfect positive correlation

corr_matrix = np.corrcoef(x, y)
print(f"Correlation Matrix:\n{corr_matrix}")

Output:

Correlation Matrix:
[[1. 1.]
 [1. 1.]]

Handling Missing Data and Normalization

Real-world data is often messy or requires scaling before it can be used in Machine Learning algorithms.

Handling NaN (Not a Number)

Standard functions return nan if the array contains missing values. Use nan-safe functions instead.

import numpy as np

dirty_data = np.array([10, 20, np.nan, 40, 50])

print(f"Standard Mean: {np.mean(dirty_data)}")

print(f"Safe Mean:     {np.nanmean(dirty_data)}")

Output:

Standard Mean: nan
Safe Mean:     30.0

Z-Score Normalization

Standardizing data (mean of 0, standard deviation of 1) is a common preprocessing step.

import numpy as np

data = np.array([10, 20, 30, 40, 50])

def normalize_z_score(arr):
    return (arr - np.mean(arr)) / np.std(arr)

normalized = normalize_z_score(data)
print(f"Normalized Data:\n{normalized}")

Output:

Normalized Data:
[-1.41421356 -0.70710678  0.          0.70710678  1.41421356]

Conclusion

Calculating statistics in Python using NumPy is both concise and performant.

1. Initialize your data using np.array.
2. Analyze basics using np.mean, np.median, and np.std.
3. Control Dimensions using the axis parameter for matrices.
4. Handle Errors using np.nanmean functions to account for missing data.