Использование метода value_counts() в Pandas: подсчет уникальных значений

import pandas as pd

# Создаем Series с данными о фруктах
fruits = pd.Series(['apple', 'banana', 'apple', 'orange', 'apple', 'banana', 'kiwi'])

# Применяем метод value_counts()
fruit_counts = fruits.value_counts()
print(fruit_counts)

# Результат:
# apple 3
# banana 2
# orange 1
# kiwi 1
# dtype: int64

Series.value_counts(
normalize=False,
sort=True,
ascending=False,
bins=None,
dropna=True
)

import pandas as pd
import numpy as np

# Создаём Series с некоторыми пропущенными значениями
data = pd.Series(['A', 'B', 'A', 'B', 'C', np.nan, 'A', np.nan])

# Базовый подсчёт
print("Базовый подсчёт:")
print(data.value_counts())

# С нормализацией (относительные частоты)
print("\nОтносительные частоты:")
print(data.value_counts(normalize=True))

# В порядке возрастания
print("\nСортировка по возрастанию:")
print(data.value_counts(ascending=True))

# С включением NaN значений
print("\nС включением пропущенных значений:")
print(data.value_counts(dropna=False))

Базовый подсчёт:
A 3
B 2
C 1
dtype: int64

Относительные частоты:
A 0.5
B 0.333333
C 0.166667
dtype: float64

Сортировка по возрастанию:
C 1
B 2
A 3
dtype: int64

С включением пропущенных значений:
A 3
B 2
NaN 2
C 1
dtype: int64

# Создаём числовую Series
numeric_data = pd.Series([1, 2, 5, 8, 10, 12, 15, 18, 20, 25, 30])

# Разделяем на интервалы по 10 единиц
print(numeric_data.value_counts(bins=3))

# Результат:
# (19.667, 30.0] 4
# (9.333, 19.667] 4
# (0.999, 9.333] 3
# dtype: int64

# Создаём простой DataFrame
df = pd.DataFrame({
'Category': ['A', 'B', 'A', 'C', 'B', 'A'],
'Value': [10, 20, 15, 30, 25, 15]
})

# Подсчёт уникальных значений в столбце Category
print(df['Category'].value_counts())

# Результат:
# A 3
# B 2
# C 1
# Name: Category, dtype: int64

import pandas as pd

# Создаём DataFrame с данными о продажах
sales_data = pd.DataFrame({
'Product': ['Laptop', 'Phone', 'Tablet', 'Laptop', 'Phone', 'Laptop'],
'Region': ['North', 'South', 'North', 'South', 'North', 'North'],
'Sales': [1200, 800, 500, 1500, 750, 1000]
})

# Подсчитываем комбинации Product и Region
combo_counts = sales_data.groupby(['Product', 'Region']).size()
print(combo_counts)
print("\nФорматирование как Series с value_counts():")
print(pd.Series(zip(sales_data['Product'], sales_data['Region'])).value_counts())

# Создаём данные с более разнообразными категориями
categories = pd.Series(['A', 'B', 'A', 'C', 'B', 'D', 'A', 'E', 'F', 'A', 'B', 'G'])

# Получаем подсчёт всех категорий
all_counts = categories.value_counts()
print("Все категории:")
print(all_counts)

# Фильтруем только популярные категории (встречаются 2+ раз)
popular_categories = all_counts[all_counts >= 2]
print("\nПопулярные категории (2+ вхождения):")
print(popular_categories)

# Фильтруем редкие категории (встречаются только 1 раз)
rare_categories = all_counts[all_counts == 1]
print("\nРедкие категории (только 1 вхождение):")
print(rare_categories)

# Создаём маску для фильтрации DataFrame на основе частоты
mask = categories.isin(popular_categories.index)
print("\nДанные только с популярными категориями:")
print(categories[mask])

# Определяем топ-10 продуктов
top_products = df['Product'].value_counts().nlargest(10).index
# Создаём новый столбец с группировкой
df['ProductCategory'] = df['Product'].apply(lambda x: x if x in top_products else 'Other')

# Создаём Series с данными о категориях продуктов
products = pd.Series(['Electronics', 'Clothing', 'Electronics', 'Books', 
'Electronics', 'Clothing', 'Food', 'Electronics'])

# Получаем процентное распределение
percent_distribution = products.value_counts(normalize=True)
print("Процентное распределение:")
print(percent_distribution)

# Добавляем кумулятивную сумму
cumulative_percent = percent_distribution.cumsum()
print("\nКумулятивный процент:")
print(cumulative_percent)

# Создаём DataFrame для комбинированного представления
analysis_df = pd.DataFrame({
'Count': products.value_counts(),
'Percent': percent_distribution,
'Cumulative': cumulative_percent
})
print("\nКомбинированный анализ:")
print(analysis_df)

# Создаём данные с потенциальными ошибками ввода
cities = pd.Series(['New York', 'Los Angeles', 'New York', 'Chicago', 'New York',
'Nw York', 'Chicago', 'Los Angls', 'New York', 'Chicago'])

# Используем value_counts для выявления редких значений (потенциальных опечаток)
city_counts = cities.value_counts()
print("Все города:")
print(city_counts)

# Выявляем потенциальные опечатки (встречаются только 1 раз)
potential_typos = city_counts[city_counts == 1]
print("\nПотенциальные опечатки:")
print(potential_typos)

# Исправляем опечатки, используя словарь соответствия
corrections = {
'Nw York': 'New York',
'Los Angls': 'Los Angeles'
}
corrected_cities = cities.replace(corrections)

# Проверяем результат после исправления
print("\nРезультат после исправления:")
print(corrected_cities.value_counts())

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Создаём серию данных
categories = pd.Series(['A', 'B', 'A', 'C', 'B', 'D', 'A', 'A', 'B', 'E', 'C'])

# Получаем частоты с помощью value_counts()
category_counts = categories.value_counts()

# Базовый столбчатый график с помощью pandas
plt.figure(figsize=(10, 6))
category_counts.plot(kind='bar', color='skyblue')
plt.title('Распределение категорий')
plt.xlabel('Категория')
plt.ylabel('Количество')
plt.xticks(rotation=0) # Горизонтальные подписи для лучшей читаемости
plt.tight_layout()
plt.show()

# Круговая диаграмма для отображения пропорций
plt.figure(figsize=(8, 8))
category_counts.plot(kind='pie', autopct='%1.1f%%', startangle=90, figsize=(8, 8))
plt.title('Процентное распределение категорий')
plt.ylabel('') # Удаляем метку оси y для круговой диаграммы
plt.tight_layout()
plt.show()

# Создаём DataFrame с более сложными данными для демонстрации
df = pd.DataFrame({
'Category': ['Electronics', 'Clothing', 'Food', 'Books', 'Electronics', 
'Clothing', 'Electronics', 'Books', 'Food', 'Electronics'],
'Region': ['North', 'South', 'North', 'South', 'East', 
'West', 'North', 'East', 'West', 'South'],
'Sales': [1200, 800, 350, 600, 1500, 950, 1300, 400, 250, 1100]
})

# Горизонтальный барплот с помощью seaborn
plt.figure(figsize=(10, 6))
sns.countplot(y='Category', data=df, order=df['Category'].value_counts().index)
plt.title('Распределение продаж по категориям')
plt.xlabel('Количество')
plt.ylabel('Категория')
plt.tight_layout()
plt.show()

# Многоуровневая визуализация: категория и регион
# Получаем counts для комбинации категория-регион
category_region_counts = df.groupby(['Category', 'Region']).size().unstack(fill_value=0)

# Строим сгруппированную гистограмму
category_region_counts.plot(kind='bar', figsize=(12, 6))
plt.title('Распределение продаж по категориям и регионам')
plt.xlabel('Категория')
plt.ylabel('Количество')
plt.legend(title='Регион')
plt.tight_layout()
plt.show()

import plotly.express as px
import plotly.graph_objs as go

# Создаём базовый интерактивный барплот
fig = px.bar(
x=category_counts.index, 
y=category_counts.values,
labels={'x': 'Категория', 'y': 'Количество'},
title='Интерактивное распределение категорий'
)
fig.show()

# Интерактивная круговая диаграмма
fig = px.pie(
values=category_counts.values,
names=category_counts.index,
title='Интерактивное процентное распределение'
)
fig.show()

# Комбинированная визуализация с value_counts и средними значениями
# Получаем средние продажи по категориям
category_avg_sales = df.groupby('Category')['Sales'].mean().reset_index()
category_counts = df['Category'].value_counts().reset_index()
category_counts.columns = ['Category', 'Count']

# Объединяем данные
merged_data = pd.merge(category_counts, category_avg_sales, on='Category')

# Создаём комбинированный график
fig = go.Figure()

# Добавляем столбцы для количества
fig.add_trace(go.Bar(
x=merged_data['Category'],
y=merged_data['Count'],
name='Количество',
marker_color='royalblue'
))

# Добавляем линию для средних продаж
fig.add_trace(go.Scatter(
x=merged_data['Category'],
y=merged_data['Sales'],
name='Средние продажи',
mode='lines+markers',
marker=dict(size=10, color='red'),
yaxis='y2'
))

# Настраиваем макет с двумя осями Y
fig.update_layout(
title='Количество и средние продажи по категориям',
yaxis=dict(title='Количество', side='left'),
yaxis2=dict(title='Средние продажи', side='right', overlaying='y', showgrid=False),
legend=dict(x=0, y=1.1, orientation='h')
)

fig.show()

# Предположим, у нас много категорий
many_categories = pd.Series(np.random.choice(list('ABCDEFGHIJKLMNOPQRSTUVWXYZ'), size=1000))
many_counts = many_categories.value_counts()

# 1. Отображаем только top-N категорий
top_n = 8
plt.figure(figsize=(10, 6))
many_counts.nlargest(top_n).plot(kind='bar', color='skyblue')
plt.title(f'Топ-{top_n} самых частых категорий')
plt.tight_layout()
plt.show()

# 2. Группируем остальные категории как "Другие"
top_categories = many_counts.nlargest(top_n)
others_sum = many_counts.sum() – top_categories.sum()

# Создаём новую Series с категорией "Другие"
plot_data = pd.concat([top_categories, pd.Series({'Другие': others_sum})])

plt.figure(figsize=(10, 6))
plot_data.plot(kind='bar', color=['skyblue']*top_n + ['lightgray'])
plt.title(f'Топ-{top_n} категорий и группа "Другие"')
plt.tight_layout()
plt.show()

# 3. Используем логарифмический масштаб для значений с большим разбросом
plt.figure(figsize=(12, 6))
plt.bar(range(len(many_counts.nlargest(15))), 
many_counts.nlargest(15), 
tick_label=many_counts.nlargest(15).index)
plt.yscale('log') # Логарифмический масштаб
plt.title('Распределение категорий (логарифмический масштаб)')
plt.tight_layout()
plt.show()

import pandas as pd
import numpy as np
import time
import matplotlib.pyplot as plt
from memory_profiler import memory_usage

# Создаём большой набор данных
n = 10_000_000
categories = ['A', 'B', 'C', 'D', 'E'] * (n // 5 + 1)
categories = categories[:n]

# Сравним производительность для различных типов данных
def compare_dtypes_performance():
# Стандартная строка
start_time = time.time()
df_str = pd.Series(categories)
counts_str = df_str.value_counts()
str_time = time.time() – start_time
str_memory = memory_usage((df_str.value_counts,))

# С категориальным типом
start_time = time.time()
df_cat = pd.Series(categories, dtype='category')
counts_cat = df_cat.value_counts()
cat_time = time.time() – start_time
cat_memory = memory_usage((df_cat.value_counts,))

print(f"Стандартная строка: {str_time:.2f} сек, {str_memory[0]:.2f} МБ")
print(f"Категориальный тип: {cat_time:.2f} сек, {cat_memory[0]:.2f} МБ")
print(f"Ускорение: {str_time/cat_time:.2f}x, Экономия памяти: {str_memory[0]/cat_memory[0]:.2f}x")

compare_dtypes_performance()

# Создаём DataFrame с несколькими столбцами
df = pd.DataFrame({
'Category': np.random.choice(['A', 'B', 'C', 'D', 'E'], size=n),
'Region': np.random.choice(['North', 'South', 'East', 'West'], size=n),
'Value': np.random.randint(1, 1000, size=n)
})

# Неэффективный подход: сначала value_counts(), потом фильтрация
def inefficient_approach():
start_time = time.time()
# Получаем все подсчёты, затем фильтруем
all_counts = df['Category'].value_counts()
filtered_counts = all_counts[all_counts > 1_000_000]
inefficient_time = time.time() – start_time
return inefficient_time

# Эффективный подход: сначала фильтрация, потом value_counts()
def efficient_approach():
start_time = time.time()
# Сначала фильтруем датафрейм
mask = df['Value'] > 500
filtered_df = df[mask]
# Затем выполняем value_counts() на меньшем наборе данных
filtered_counts = filtered_df['Category'].value_counts()
efficient_time = time.time() – start_time
return efficient_time

inefficient_time = inefficient_approach()
efficient_time = efficient_approach()
print(f"Неэффективный подход: {inefficient_time:.2f} сек")
print(f"Эффективный подход: {efficient_time:.2f} сек")
print(f"Ускорение: {inefficient_time/efficient_time:.2f}x")

import multiprocessing
from joblib import Parallel, delayed

# Функция для параллельного применения value_counts()
def parallel_value_counts(df, groups):
results = {}
for group in groups:
results[group] = df[group].value_counts()
return results

# Разбиваем задачу на параллельные процессы
def parallel_process_value_counts(df, columns, n_jobs=-1):
# Разделяем столбцы на группы для параллельной обработки
n_jobs = multiprocessing.cpu_count() if n_jobs == -1 else n_jobs
column_splits = [columns[i::n_jobs] for i in range(n_jobs)]

# Выполняем параллельную обработку
results = Parallel(n_jobs=n_jobs)(
delayed(parallel_value_counts)(df, split) for split in column_splits
)

# Объединяем результаты
final_results = {}
for res in results:
final_results.update(res)

return final_results

# Пример использования с большим количеством столбцов
large_df = pd.DataFrame({
f'col_{i}': np.random.choice(['A', 'B', 'C', 'D', 'E'], size=1_000_000)
for i in range(20)
})

start_time = time.time()
serial_results = {col: large_df[col].value_counts() for col in large_df.columns}
serial_time = time.time() – start_time
print(f"Последовательная обработка: {serial_time:.2f} сек")

start_time = time.time()
parallel_results = parallel_process_value_counts(large_df, large_df.columns.tolist())
parallel_time = time.time() – start_time
print(f"Параллельная обработка: {parallel_time:.2f} сек")
print(f"Ускорение: {serial_time/parallel_time:.2f}x")

from functools import lru_cache

# Создаём класс, кэширующий результаты value_counts()
class CachedValueCounter:
def __init__(self, data):
self.data = data
self.cache = {}

@lru_cache(maxsize=128)
def get_counts(self, column, normalize=False, sort=True, ascending=False, dropna=True):
"""Кэширующая обёртка для value_counts()"""
cache_key = (column, normalize, sort, ascending, dropna)
if cache_key not in self.cache:
self.cache[cache_key] = self.data[column].value_counts(
normalize=normalize, sort=sort, ascending=ascending, dropna=dropna
)
return self.cache[cache_key]

def clear_cache(self):
"""Очистить кэш при необходимости"""
self.cache = {}

# Пример использования кэшированных подсчётов
counter = CachedValueCounter(df)

# Первый вызов (вычисляет и кэширует)
start_time = time.time()
counts1 = counter.get_counts('Category')
first_call_time = time.time() – start_time
print(f"Первый вызов: {first_call_time:.4f} сек")

# Второй вызов (берёт из кэша)
start_time = time.time()
counts2 = counter.get_counts('Category')
second_call_time = time.time() – start_time
print(f"Второй вызов: {second_call_time:.4f} сек")
print(f"Ускорение при повторном вызове: {first_call_time/second_call_time:.2f}x")

# Использование паттерна "итерация по чанкам" для больших файлов
def process_large_file_in_chunks(filename, column, chunk_size=1000000):
"""Обрабатывает большой CSV файл по частям и агрегирует результаты value_counts()"""
# Словарь для агрегации подсчётов
total_counts = {}

# Обработка файла чанками
for chunk in pd.read_csv(filename, chunksize=chunk_size):
# Получаем value_counts() для текущего чанка
chunk_counts = chunk[column].value_counts()

# Агрегируем результаты
for value, count in chunk_counts.items():
if value in total_counts:
total_counts[value] += count
else:
total_counts[value] = count

# Преобразуем в Series
result = pd.Series(total_counts)

# Сортируем результат (по умолчанию value_counts() сортирует по убыванию)
return result.sort_values(ascending=False)

# Пример использования:
# counts = process_large_file_in_chunks('huge_data.csv', 'category_column')

# Пример использования Dask для масштабируемого value_counts()
import dask.dataframe as dd

# Загружаем данные через Dask
dask_df = dd.read_csv('huge_data.csv')

# Выполняем value_counts() распределённо
counts = dask_df['category_column'].value_counts().compute()