Pandas Value Counts: быстрый анализ и подсчет уникальных значений

import pandas as pd

# Создаем простой Series
s = pd.Series(['A', 'B', 'A', 'C', 'B', 'A', None, 'D'])

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

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

# Получение относительных частот (доли вместо абсолютных значений)
s.value_counts(normalize=True)
# A 0.428571
# B 0.285714
# C 0.142857
# D 0.142857
# dtype: float64

# Включение пропущенных значений в подсчет
s.value_counts(dropna=False)
# A 3
# B 2
# C 1
# D 1
# NaN 1
# dtype: int64

# Бинирование числовых данных
numbers = pd.Series([1, 2, 5, 7, 8, 12, 15, 18, 19])
numbers.value_counts(bins=4)
# (0.971, 5.5] 2
# (5.5, 10.0] 3
# (10.0, 14.5] 1
# (14.5, 19.0] 3
# dtype: int64

# Создаем DataFrame с данными о клиентах
df = pd.DataFrame({
'customer_id': [1, 2, 3, 4, 5, 6, 7, 8],
'country': ['USA', 'Canada', 'USA', 'UK', 'USA', 'Canada', 'Germany', 'UK'],
'purchase_amount': [150, 200, 50, 300, 125, 175, 220, 90]
})

# 1. Применение value_counts() к результату запроса
# Найдем количество клиентов по странам, потративших больше 100
high_spenders = df[df['purchase_amount'] > 100]['country'].value_counts()
print(high_spenders)
# USA 2
# Canada 2
# UK 1
# Germany 1
# dtype: int64

# 2. Множественные группировки с pivot_table и value_counts()
# Группируем по странам и подсчитываем средний чек + количество клиентов
country_stats = pd.DataFrame({
'avg_purchase': df.groupby('country')['purchase_amount'].mean(),
'customer_count': df['country'].value_counts()
})
print(country_stats)
# avg_purchase customer_count
# Canada 187.5 2
# Germany 220.0 1
# UK 195.0 2
# USA 108.3 3

# Подсчет с фильтрацией результатов
# Показать только страны с более чем 1 клиентом
popular_countries = df['country'].value_counts()
popular_countries = popular_countries[popular_countries > 1]
print(popular_countries)
# USA 3
# Canada 2
# UK 2
# dtype: int64

# Применение лямбда-функций к value_counts()
# Найти процентное соотношение клиентов по странам
percentage = df['country'].value_counts().apply(lambda x: f"{(x/len(df)*100):.1f}%")
print(percentage)
# USA 37.5%
# Canada 25.0%
# UK 25.0%
# Germany 12.5%
# dtype: object

# Добавим категорию продукта
df['product_category'] = ['Electronics', 'Clothing', 'Electronics', 
'Home', 'Clothing', 'Electronics', 'Home', 'Clothing']

# Многоуровневый анализ: страна + категория продукта
# Сначала создадим мультииндекс
df['combined'] = df['country'] + '_' + df['product_category']

# Затем применим value_counts()
distribution = df['combined'].value_counts()
print(distribution)
# USA_Electronics 2
# Canada_Electronics 1
# USA_Clothing 1
# UK_Home 1
# UK_Clothing 1
# Germany_Home 1
# Canada_Clothing 1
# dtype: int64

import pandas as pd
import matplotlib.pyplot as plt

# Создаем Series с данными
fruits = pd.Series(['apple', 'banana', 'apple', 'orange', 'apple', 
'banana', 'grape', 'apple', 'orange'])

# Визуализируем результаты подсчета
fruits.value_counts().plot(kind='bar')
plt.title('Частота фруктов в датасете')
plt.ylabel('Количество')
plt.xlabel('Фрукты')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Круговая диаграмма для отображения пропорций
fruits.value_counts().plot(kind='pie', autopct='%1.1f%%')
plt.title('Доля каждого фрукта в датасете')
plt.ylabel('') # Убираем метку для оси Y
plt.tight_layout()
plt.show()

import seaborn as sns

# Преобразуем результаты value_counts() в DataFrame для seaborn
count_df = pd.DataFrame({'fruit': fruits.value_counts().index, 
'count': fruits.value_counts().values})

# Создаем горизонтальную гистограмму с цветовым градиентом
plt.figure(figsize=(10, 6))
ax = sns.barplot(x='count', y='fruit', data=count_df, 
palette='viridis')

# Добавляем значения на график
for i, v in enumerate(count_df['count']):
ax.text(v + 0.1, i, str(v), va='center')

plt.title('Частота фруктов (Seaborn)', fontsize=15)
plt.tight_layout()
plt.show()

# Используем catplot для более сложных отношений
# Сначала создадим более богатый датасет
df = pd.DataFrame({
'fruit': fruits,
'quality': ['high', 'low', 'medium', 'high', 'medium', 
'high', 'low', 'medium', 'high'],
'price': [5, 3, 4, 6, 5, 3, 2, 4, 5]
})

# Подсчитываем частоту комбинаций фрукт-качество
fruit_quality_counts = df.groupby(['fruit', 'quality']).size().reset_index(name='count')

# Создаем сгруппированную гистограмму
sns.catplot(x='fruit', y='count', hue='quality', data=fruit_quality_counts, 
kind='bar', height=6, aspect=1.5)
plt.title('Распределение фруктов по качеству')
plt.tight_layout()
plt.show()

import plotly.express as px
import plotly.graph_objects as go

# Создаем базовую интерактивную гистограмму
fig = px.bar(x=fruits.value_counts().index, 
y=fruits.value_counts().values,
labels={'x': 'Фрукты', 'y': 'Количество'},
title='Интерактивная визуализация результатов value_counts()')

# Добавляем интерактивные элементы
fig.update_traces(hovertemplate='Фрукт: %{x}<br>Количество: %{y}')
fig.update_layout(hovermode='closest')

# Для HTML/Jupyter
fig.show()

# Создаем интерактивную тепловую карту для многомерных данных
# Сначала создадим сводную таблицу
pivot = pd.crosstab(df['fruit'], df['quality'])

# Создаем тепловую карту
fig = px.imshow(pivot, 
labels=dict(x="Качество", y="Фрукт", color="Количество"),
title="Тепловая карта распределения фруктов по качеству")

# Добавляем текстовые аннотации с точными значениями
fig.update_traces(text=pivot.values, texttemplate="%{text}")
fig.show()

# Объединение редких категорий
def plot_with_others(series, threshold=0.05):
"""Визуализирует результаты value_counts(), объединяя редкие категории в 'Другое'"""
counts = series.value_counts(normalize=True)
mask = counts >= threshold

# Создаем новую серию с объединенными редкими категориями
plot_data = pd.Series(
list(counts[mask]) + [counts[~mask].sum()],
index=list(counts[mask].index) + ['Другое']
)

# Визуализируем
plot_data.plot(kind='pie', autopct='%1.1f%%', figsize=(10, 6))
plt.title(f'Распределение с порогом {threshold*100}%')
plt.show()

# Применение функции
plot_with_others(fruits, threshold=0.2)

# Использование категориальных данных для оптимизации памяти
# Преобразование столбца в категориальный тип перед применением value_counts()
import pandas as pd
import numpy as np

# Создаем большой датасет (1 миллион строк)
data = pd.DataFrame({
'category': np.random.choice(['A', 'B', 'C', 'D', 'E'], size=1000000),
'numeric': np.random.normal(0, 1, size=1000000)
})

# Замеряем время выполнения на стандартных строковых данных
%time regular_counts = data['category'].value_counts()

# Преобразуем в категориальный тип
data['category'] = data['category'].astype('category')

# Замеряем время на категориальных данных
%time optimized_counts = data['category'].value_counts()

# Разница может быть существенной на больших датасетах
# Особенно при многократном вызове value_counts()

# Создаем функцию для автоматического анализа категориальных переменных
def categorical_analysis(df, threshold=0.01):
"""
Автоматически анализирует все категориальные столбцы в датафрейме:
- Подсчитывает частоты
- Отображает редкие категории (меньше threshold)
- Вычисляет энтропию (меру неопределенности)
"""
results = {}

# Получаем список категориальных столбцов
categorical_cols = df.select_dtypes(include=['object', 'category']).columns

for col in categorical_cols:
# Подсчитываем частоты
counts = df[col].value_counts(normalize=True)

# Находим редкие категории
rare_values = counts[counts < threshold].index.tolist()

# Вычисляем энтропию (-sum(p*log(p)))
entropy = -np.sum(counts * np.log(counts))

results[col] = {
'total_categories': len(counts),
'top_category': counts.index[0],
'top_category_percentage': f"{counts.values[0]*100:.2f}%",
'rare_categories': rare_values,
'rare_categories_count': len(rare_values),
'entropy': entropy,
'distribution': counts
}

return results

# Применяем функцию к датафрейму
analysis_results = categorical_analysis(df, threshold=0.05)

# Выводим результаты в виде структурированного отчета
for column, stats in analysis_results.items():
print(f"\n=== Анализ столбца: {column} ===")
print(f"Всего категорий: {stats['total_categories']}")
print(f"Самая частая категория: {stats['top_category']} ({stats['top_category_percentage']})")
print(f"Количество редких категорий: {stats['rare_categories_count']}")
print(f"Энтропия распределения: {stats['entropy']:.4f}")

# Визуализируем топ-5 категорий
stats['distribution'].head(5).plot(kind='bar')
plt.title(f'Топ-5 категорий в {column}')
plt.tight_layout()
plt.show()

# Создание бинарных признаков для редких категорий
def encode_rare_categories(df, column, threshold=0.05):
"""
Заменяет редкие категории на 'OTHER' и создает бинарный признак
"""
# Находим редкие категории
counts = df[column].value_counts(normalize=True)
rare_mask = counts < threshold
rare_categories = counts[rare_mask].index.tolist()

# Создаем новый столбец с замененными редкими категориями
df[f"{column}_processed"] = df[column].apply(
lambda x: 'OTHER' if x in rare_categories else x
)

# Создаем бинарный признак
df[f"{column}_is_rare"] = df[column].apply(
lambda x: 1 if x in rare_categories else 0
)

return df

# Пример использования
df = encode_rare_categories(df, 'product_category', threshold=0.1)

# Для числовых переменных можно создать бины на основе распределения
def create_quantile_bins(df, column, n_bins=5):
"""
Создает новый категориальный признак на основе квантилей числовой переменной
"""
df[f"{column}_bin"] = pd.qcut(df[column], q=n_bins, labels=False)

# Анализируем распределение по бинам
bin_counts = df[f"{column}_bin"].value_counts().sort_index()

print(f"Распределение по бинам для {column}:")
print(bin_counts)

return df

# Пример использования
df = create_quantile_bins(df, 'price', n_bins=4)

# Пример анализа несбалансированности классов
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# Подготовка данных
X = df[['feature1', 'feature2', 'feature3']]
y = df['target'] # Целевая переменная

# Анализируем распределение целевой переменной
class_distribution = y.value_counts(normalize=True)
print("Распределение классов:")
print(class_distribution)

# Определяем, нужна ли коррекция несбалансированности
is_imbalanced = any(class_distribution < 0.2) # Произвольный порог

if is_imbalanced:
# Устанавливаем веса классов обратно пропорционально их частоте
class_weights = {i: 1.0/count for i, count in enumerate(class_distribution)}
print("Применяем веса классов:", class_weights)
else:
class_weights = None

# Разделяем данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Обучаем модель с учетом весов классов
model = RandomForestClassifier(class_weight=class_weights)
model.fit(X_train, y_train)

# Оцениваем результаты
y_pred = model.predict(X_test)

# Сравниваем распределения предсказанных и фактических классов
print("Распределение фактических классов в тестовой выборке:")
print(y_test.value_counts(normalize=True))

print("Распределение предсказанных классов:")
print(pd.Series(y_pred).value_counts(normalize=True))

# Подробный отчет по метрикам
print(classification_report(y_test, y_pred))