Как эффективно посчитать количество одинаковых элементов в массиве NumPy?

05.10.2025
20848

7 мин
60

Подсчет частоты встречаемости элементов в массивах данных является фундаментальной задачей во многих областях анализа данных и машинного обучения. NumPy, как основная библиотека для научных вычислений в Python, предоставляет мощные и оптимизированные инструменты для решения этой задачи.

Зачем подсчитывать одинаковые элементы: примеры из практики

Понимание распределения значений в массиве критически важно:

Анализ данных: Определение наиболее частых категорий, пользовательских действий, ID товаров в логах или транзакциях.
Обработка естественного языка (NLP): Подсчет частоты слов или токенов для построения моделей TF-IDF или мешка слов.
Обнаружение аномалий: Выявление слишком редких или, наоборот, доминирующих значений, которые могут указывать на ошибки или особенности данных.
Feature Engineering: Создание признаков на основе частоты встречаемости категориальных переменных.

Краткий обзор массивов NumPy и их особенностей

NumPy (ndarray) предоставляет многомерные массивы фиксированного размера и типа данных. Ключевые особенности:

Производительность: Операции выполняются на уровне C, что значительно быстрее стандартных списков Python.
Векторизация: Позволяет выполнять операции над целыми массивами без явных циклов в Python.
Широкий набор функций: Включает математические, статистические, линейную алгебру и другие операции.

Основные методы подсчета одинаковых элементов

Рассмотрим наиболее распространенные и эффективные подходы к подсчету элементов в NumPy.

Использование `numpy.unique` для подсчета уникальных элементов

Функция numpy.unique является универсальным инструментом. При установке параметра return_counts=True она возвращает два массива: уникальные элементы и их количество.

import numpy as np
from typing import Tuple

def count_elements_unique(arr: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
    """Подсчитывает количество каждого уникального элемента в массиве.

    Args:
        arr (np.ndarray): Входной массив NumPy.

    Returns:
        Tuple[np.ndarray, np.ndarray]: Кортеж из двух массивов:
                                         - Уникальные элементы.
                                         - Соответствующее количество каждого элемента.
    """
    unique_elements, counts = np.unique(arr, return_counts=True)
    return unique_elements, counts

# Пример: Анализ ID рекламных кампаний
campaign_ids = np.array([101, 102, 101, 103, 102, 101, 104, 101])
unique_campaigns, campaign_counts = count_elements_unique(campaign_ids)

print(f"Уникальные ID кампаний: {unique_campaigns}")
print(f"Количество каждой кампании: {campaign_counts}")
# Вывод:
# Уникальные ID кампаний: [101 102 103 104]
# Количество каждой кампании: [4 2 1 1]

Этот метод работает для массивов любых типов данных и размерностей (массив будет автоматически «сплющен» перед подсчетом).

Подсчет с использованием `numpy.bincount` для целочисленных массивов

Функция numpy.bincount чрезвычайно эффективна, но имеет ограничение: она работает только с неотрицательными целыми числами. Она создает массив (бины), где индекс соответствует значению элемента, а значение по этому индексу — его количество.

import numpy as np

def count_elements_bincount(arr: np.ndarray) -> np.ndarray:
    """Подсчитывает количество каждого неотрицательного целого числа в массиве.

    Args:
        arr (np.ndarray): Входной массив NumPy (только неотрицательные целые числа).

    Returns:
        np.ndarray: Массив, где индекс i содержит количество вхождений числа i.
                   Размер массива равен max(arr) + 1.
    """
    if not np.issubdtype(arr.dtype, np.integer) or np.any(arr < 0):
        raise ValueError("Массив должен содержать только неотрицательные целые числа для bincount.")
    return np.bincount(arr)

# Пример: Анализ оценок пользователей (0-5)
user_ratings = np.array([4, 5, 4, 3, 5, 5, 2, 4, 3, 4])
rating_counts = count_elements_bincount(user_ratings)

print(f"Распределение оценок (индекс=оценка, значение=количество): {rating_counts}")
# Вывод: Распределение оценок (индекс=оценка, значение=количество): [0 0 1 2 4 3]
# (0 нулей, 0 единиц, 1 двойка, 2 тройки, 4 четверки, 3 пятерки)

# Получение уникальных элементов и их ненулевых количеств:
non_zero_indices = np.nonzero(rating_counts)[0]
print(f"Оценки: {non_zero_indices}")
print(f"Количество: {rating_counts[non_zero_indices]}")

np.bincount часто является самым быстрым методом для подходящих данных.

Реализация подсчета через `numpy.where` и булевы маски

Этот подход менее универсален для подсчета всех уникальных элементов, но удобен, если нужно посчитать количество конкретного значения или значений, удовлетворяющих условию.

import numpy as np

def count_specific_value(arr: np.ndarray, value: any) -> int:
    """Подсчитывает количество вхождений конкретного значения в массиве.

    Args:
        arr (np.ndarray): Входной массив NumPy.
        value (any): Значение для подсчета.

    Returns:
        int: Количество вхождений значения.
    """
    # np.where возвращает индексы, size дает их количество
    count = np.where(arr == value)[0].size
    # Альтернативный, часто более эффективный способ:
    # count = np.sum(arr == value)
    return count

# Пример: Подсчет количества переходов с определенного UTM-источника
utm_sources = np.array(['google', 'yandex', 'vk', 'google', 'google', 'yandex'])
specific_source = 'google'
google_count = count_specific_value(utm_sources, specific_source)

print(f"Количество переходов с '{specific_source}': {google_count}")
# Вывод: Количество переходов с 'google': 3

Хотя можно организовать цикл по уникальным значениям и применять np.where или np.sum, это будет значительно менее эффективно, чем np.unique или np.bincount из-за многократного прохода по массиву.

Сравнение производительности различных методов

np.bincount: Самый быстрый для неотрицательных целых чисел, особенно если диапазон значений невелик. O(N + K), где N — размер массива, K — максимальное значение.
np.unique: Универсален, хорошо оптимизирован. Производительность зависит от количества уникальных элементов и необходимости сортировки. Обычно основан на сортировке, O(N log N).
np.where/np.sum в цикле: Наименее производительный для подсчета всех уникальных элементов из-за многократных проходов по данным. O(M * N), где M — количество уникальных элементов.

Выбор зависит от типа данных и требований к производительности.

Продвинутые техники и оптимизация подсчета

Подсчет элементов с использованием `numpy.histogram`

Хотя numpy.histogram предназначен для построения гистограмм непрерывных данных, его можно адаптировать для подсчета дискретных (целочисленных) значений, если правильно определить границы бинов.

import numpy as np

def count_elements_histogram(arr: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
    """Подсчитывает количество целых чисел с помощью гистограммы.

    Args:
        arr (np.ndarray): Входной массив NumPy (предпочтительно целочисленный).

    Returns:
        Tuple[np.ndarray, np.ndarray]: Кортеж из двух массивов:
                                         - Центры бинов (значения).
                                         - Количество в каждом бине.
    """
    # Определяем бины так, чтобы каждое целое число попало в свой бин
    min_val, max_val = int(arr.min()), int(arr.max())
    # Границы: min-0.5, min+0.5, min+1.5, ..., max+0.5
    bins = np.arange(min_val - 0.5, max_val + 1.5, 1)
    counts, _ = np.histogram(arr, bins=bins)
    # Значения - это центры бинов (или просто исходные целые числа)
    values = np.arange(min_val, max_val + 1)
    # Возвращаем только те значения, для которых count > 0
    mask = counts > 0
    return values[mask], counts[mask]

# Пример с ID кампаний
unique_vals, hist_counts = count_elements_histogram(campaign_ids)
print(f"Значения (гистограмма): {unique_vals}")
print(f"Количество (гистограмма): {hist_counts}")

Этот метод может быть полезен в специфических случаях, но обычно np.unique или np.bincount предпочтительнее для прямого подсчета.

Работа с многомерными массивами: подсчет по осям

Стандартные np.unique и np.bincount работают с «сплющенным» массивом. Для подсчета уникальных строк или столбцов (или срезов по другим осям) требуется иной подход.

np.unique с параметром axis позволяет найти уникальные строки или столбцы:

import numpy as np

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

# Подсчет уникальных строк
unique_rows, counts = np.unique(data, axis=0, return_counts=True)

print("Уникальные строки:")
print(unique_rows)
print(f"Количество строк: {counts}")
# Вывод:
# Уникальные строки:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
# Количество строк: [2 2 1]

Подсчет уникальных элементов вдоль оси (например, сколько раз каждое значение встречается в каждом столбце) требует итерации или более сложных приемов, часто с использованием np.apply_along_axis и одной из базовых функций подсчета.

Оптимизация скорости подсчета для больших массивов

Выбор метода: Как обсуждалось, np.bincount — король скорости для неотрицательных целых чисел.
Типы данных: Используйте наиболее подходящий и экономичный тип данных (например, np.int32 вместо np.int64, если значения помещаются).
Предварительная обработка: Если данные не целочисленные, но их можно эффективно отобразить в целые числа (например, через словарь или np.unique без подсчета), можно затем применить np.bincount к индексам.
Избегание Python циклов: Векторизованные операции NumPy почти всегда быстрее.
Библиотеки: Для очень больших данных, не помещающихся в память, рассмотрите Dask или Spark, которые предоставляют схожий API, но для распределенных вычислений.

Примеры использования и практические советы

Подсчет частоты слов в текстовом корпусе с помощью NumPy

Предположим, у нас есть массив токенизированных слов после предварительной обработки текста.

import numpy as np

# Пример массива слов (токенов) после лемматизации и удаления стоп-слов
corpus_tokens = np.array(['анализ', 'данные', 'numpy', 'массив', 'данные',
                          'подсчет', 'numpy', 'эффективно', 'данные'])

# Используем np.unique для подсчета
unique_words, word_counts = np.unique(corpus_tokens, return_counts=True)

# Создаем словарь для удобства просмотра
word_freq = dict(zip(unique_words, word_counts))

print("Частота слов:")
# Сортируем по частоте для наглядности
for word, count in sorted(word_freq.items(), key=lambda item: item[1], reverse=True):
    print(f"'{word}': {count}")

# Вывод:
# Частота слов:
# 'данные': 3
# 'numpy': 2
# 'анализ': 1
# 'массив': 1
# 'подсчет': 1
# 'эффективно': 1

Анализ распределения данных в массиве

Подсчет уникальных значений — первый шаг к пониманию распределения. Например, анализируя клики по баннерам.

import numpy as np

# ID баннеров, по которым кликнули пользователи
banner_clicks = np.array([10, 25, 10, 30, 10, 25, 40, 10, 25, 30])

# Используем bincount, так как ID - неотрицательные целые
click_counts = np.bincount(banner_clicks)

active_banners = np.nonzero(click_counts)[0]
print("Анализ кликов по баннерам:")
for banner_id in active_banners:
    print(f"Баннер ID {banner_id}: {click_counts[banner_id]} кликов")

# Определение самого популярного баннера
most_popular_banner = active_banners[np.argmax(click_counts[active_banners])]
print(f"\nСамый популярный баннер: ID {most_popular_banner}")

# Вывод:
# Анализ кликов по баннерам:
# Баннер ID 10: 4 кликов
# Баннер ID 25: 3 кликов
# Баннер ID 30: 2 кликов
# Баннер ID 40: 1 кликов
# 
# Самый популярный баннер: ID 10

Советы по выбору оптимального метода подсчета

Данные — неотрицательные целые: Используйте np.bincount для максимальной производительности.
Данные — любые (числа, строки, булевы): Используйте np.unique(arr, return_counts=True). Это наиболее универсальный метод.
Нужно посчитать только одно или несколько конкретных значений: Используйте булево индексирование и np.sum(arr == value) или np.where.
Работа с многомерными массивами (уникальные строки/столбцы): Используйте np.unique(arr, axis=..., return_counts=True).
Очень большие данные: Рассмотрите np.bincount после маппинга в целые числа или используйте Dask.

Заключение

Краткое резюме рассмотренных методов

Мы рассмотрели основные подходы к подсчету одинаковых элементов в NumPy: np.unique как универсальное решение, np.bincount как высокопроизводительный инструмент для целых чисел, и использование np.where или булевых масок для подсчета конкретных значений. Также затронули работу с многомерными массивами и методы оптимизации.

Дальнейшие направления для изучения и применения

Для более сложных задач анализа частотности стоит обратить внимание на:

Pandas: Объект pd.Series имеет метод .value_counts(), который является удобной высокоуровневой оберткой над подобными техниками.
collections.Counter: Стандартная библиотека Python предлагает класс Counter для подсчета хэшируемых объектов, что может быть удобнее для нечисловых данных или когда не требуется производительность NumPy.
Разреженные матрицы: Если массив очень большой и разреженный (много нулей), использование форматов разреженных матриц (например, из scipy.sparse) может сэкономить память и ускорить некоторые операции.

Эффективный подсчет элементов — ключевой навык при работе с данными в NumPy, позволяющий быстро извлекать важную информацию о структуре и распределении данных.