Skip to main content

Python NumPy: How to Find the Most Frequent Value (Mode) in a NumPy Array

The mode-the most frequently occurring value in a dataset-is a fundamental statistical measure for categorical data, frequency analysis, and outlier detection. Unlike mean and median, NumPy doesn't provide a direct mode function, but several efficient approaches exist depending on your data type and requirements.

This guide covers methods ranging from high-performance integer counting to general-purpose solutions for any data type.

Using bincount for Integer Arrays (Fastest)​

For non-negative integer arrays, np.bincount() offers the fastest performance by directly counting occurrences at each index:

import numpy as np

# Array of non-negative integers
data = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])

# Count occurrences of each value
counts = np.bincount(data)

# Find the value with maximum count
mode = counts.argmax()
frequency = counts[mode]

print(f"Mode: {mode}")
print(f"Frequency: {frequency}")

Output:

Mode: 5
Frequency: 3
Integer Requirement

np.bincount() only works with non-negative integers. Negative numbers raise an error, and floats must be converted. The function's speed comes from using array indices directly as counters.

For general-purpose mode finding with any data type, np.unique() with return_counts=True provides the most flexible solution:

import numpy as np

# Works with any comparable data type
data = np.array([-1.5, 2.0, -1.5, 3.5, 2.0, -1.5, 7.0])

# Get unique values and their counts
values, counts = np.unique(data, return_counts=True)

# Find index of maximum count
max_index = counts.argmax()

mode = values[max_index]
frequency = counts[max_index]

print(f"Mode: {mode}")
print(f"Frequency: {frequency}")

Output:

Mode: -1.5
Frequency: 3

This approach works with floats, negative numbers, and even strings:

import numpy as np

# String array example
categories = np.array(['apple', 'banana', 'apple', 'cherry', 'apple', 'banana'])
values, counts = np.unique(categories, return_counts=True)
mode = values[counts.argmax()]
print(f"Most common: {mode}")

Output:

Most common: apple

Using scipy.stats.mode​

SciPy provides a dedicated mode function with additional features:

from scipy import stats
import numpy as np

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

result = stats.mode(data, keepdims=False)

print(f"Mode: {result.mode}")
print(f"Count: {result.count}")

Output:

Mode: 10
Count: 3

For 2D arrays, calculate mode along specific axes:

import numpy as np
from scipy import stats

# 2D array
matrix = np.array([
    [1, 2, 3],
    [1, 2, 2],
    [1, 3, 2]
])

# Mode along columns (axis=0)
col_modes = stats.mode(matrix, axis=0, keepdims=False)
print(f"Column modes: {col_modes.mode}")  # [1, 2, 2]

# Mode along rows (axis=1)
row_modes = stats.mode(matrix, axis=1, keepdims=False)
print(f"Row modes: {row_modes.mode}")     # [1, 2, 1] or similar

Output:

Column modes: [1 2 2]
Row modes: [1 2 1]
Tie Breaking

When multiple values share the highest frequency, scipy.stats.mode returns the smallest value. Use the multi-mode approach below to find all modes.

Finding Multiple Modes (Multimodal Data)​

When data has multiple values with the same maximum frequency:

import numpy as np

def find_all_modes(data):
    """Find all modes in an array (handles ties)."""
    values, counts = np.unique(data, return_counts=True)
    max_count = counts.max()
    
    # Get all values with maximum count
    modes = values[counts == max_count]
    
    return modes, max_count


# Bimodal data
data = np.array([1, 1, 2, 2, 3, 4])
modes, count = find_all_modes(data)

print(f"Modes: {modes}")
print(f"Each appears: {count} times")

Output:

Modes: [1 2]
Each appears: 2 times

Complete Mode Analysis Function​

A comprehensive utility for mode analysis:

import numpy as np

def analyze_mode(data):
    """
    Perform complete mode analysis on an array.
    
    Returns:
        dict with mode information
    """
    values, counts = np.unique(data, return_counts=True)
    max_count = counts.max()
    modes = values[counts == max_count]
    
    return {
        'mode': modes[0] if len(modes) == 1 else modes,
        'frequency': max_count,
        'is_multimodal': len(modes) > 1,
        'all_modes': modes,
        'total_elements': len(data),
        'unique_values': len(values),
        'mode_percentage': (max_count / len(data)) * 100
    }


# Usage
data = np.array([4, 1, 2, 2, 3, 2, 4, 4, 5])
result = analyze_mode(data)

print(f"Mode(s): {result['mode']}")
print(f"Frequency: {result['frequency']}")
print(f"Multimodal: {result['is_multimodal']}")
print(f"Mode percentage: {result['mode_percentage']:.1f}%")

Output:

Mode(s): [2 4]
Frequency: 3
Multimodal: True
Mode percentage: 33.3%

Method Comparison​

MethodData TypesSpeedDependenciesMulti-mode
np.bincountNon-negative integersFastestNumPyManual
np.uniqueAny comparable typeFastNumPyManual
scipy.stats.modeAny typeModerateSciPyNo (returns smallest)

Handling Large Arrays Efficiently​

For very large arrays, memory-efficient approaches matter:

import numpy as np
from collections import Counter

def mode_memory_efficient(data, chunk_size=1_000_000):
    """
    Find mode for very large arrays using chunked processing.
    """
    counter = Counter()
    
    for i in range(0, len(data), chunk_size):
        chunk = data[i:i + chunk_size]
        counter.update(chunk)
    
    mode, count = counter.most_common(1)[0]
    return mode, count


# Works with large arrays
large_data = np.random.randint(0, 100, size=10_000_000)
mode, count = mode_memory_efficient(large_data)
print(f"Mode: {mode}, Count: {count}")

Output (may vary since picked 10.000.000 random numbers):

Mode: 27, Count: 100861
Choosing the Right Method
  • Integer data (0+): Use np.bincount() for maximum speed
  • Mixed/float data: Use np.unique() with return_counts=True
  • Statistical workflows: Use scipy.stats.mode
  • Need all modes: Implement custom filtering on counts

By selecting the appropriate method for your data type and requirements, you can efficiently find mode values in NumPy arrays of any size.

Table of Contents