Функция Mode в Питоне: как находить часто встречающиеся значения

from statistics import mode

# Пример с числовыми данными
numbers = [1, 2, 3, 3, 4, 5, 3, 2]
most_common = mode(numbers)
print(f"Мода: {most_common}") # Выведет: Мода: 3

# Пример с текстовыми данными
fruits = ["apple", "banana", "apple", "orange", "apple", "grape"]
most_common_fruit = mode(fruits)
print(f"Самый популярный фрукт: {most_common_fruit}") # Выведет: Самый популярный фрукт: apple

from statistics import multimode

data = [1, 1, 2, 2, 3, 4, 5]
modes = multimode(data)
print(f"Моды: {modes}") # Выведет: Моды: [1, 2]

from statistics import mode

# Python 3.8+ поддерживает параметр для контроля поведения с равными частотами
try:
# Возвращает наименьшее значение при равных частотах
result = mode([1, 1, 2, 2], method='min')
print(f"Мода (метод 'min'): {result}") # Выведет: Мода (метод 'min'): 1

# Возвращает наибольшее значение при равных частотах
result = mode([1, 1, 2, 2], method='max')
print(f"Мода (метод 'max'): {result}") # Выведет: Мода (метод 'max'): 2
except TypeError:
# Для версии Python < 3.8
print("Ваша версия Python не поддерживает параметр method.")

from statistics import mode, multimode, StatisticsError
import numpy as np

# Целые числа
integer_data = [1, 2, 3, 3, 4, 5, 3, 2, 6]
try:
print(f"Мода целых чисел: {mode(integer_data)}") # 3
except StatisticsError as e:
print(f"Ошибка: {e}")

# Вещественные числа 
float_data = [1\.1, 2.2, 3.3, 1.1, 4.4, 1.1]
try:
print(f"Мода вещественных чисел: {mode(float_data)}") # 1.1
except StatisticsError as e:
print(f"Ошибка: {e}")

# Работа с numpy-массивами
numpy_array = np.array([5, 2, 7, 2, 2, 5, 1])
try:
print(f"Мода numpy-массива: {mode(numpy_array)}") # 2
except StatisticsError as e:
print(f"Ошибка: {e}")

# Проверка на несколько мод
multiple_modes_data = [1, 1, 2, 2, 3, 4]
all_modes = multimode(multiple_modes_data)
print(f"Все моды: {all_modes}") # [1, 2]

from statistics import mode, multimode, StatisticsError

# Строки
text_data = ["python", "java", "python", "javascript", "python", "c++", "java"]
try:
print(f"Самый популярный язык: {mode(text_data)}") # python
except StatisticsError as e:
print(f"Ошибка: {e}")

# Символы в строке
text = "programming"
char_list = list(text)
try:
most_common_char = mode(char_list)
print(f"Самый частый символ: '{most_common_char}'") # g
except StatisticsError as e:
print(f"Ошибка: {e}")

# Обработка регистра
case_sensitive_data = ["Python", "python", "PYTHON", "python", "Java"]
try:
print(f"С учетом регистра: {mode(case_sensitive_data)}") # python

# Приведение к одному регистру для игнорирования
normalized_data = [item.lower() for item in case_sensitive_data]
print(f"Без учета регистра: {mode(normalized_data)}") # python
except StatisticsError as e:
print(f"Ошибка: {e}")

# Обработка категориальных данных
categories = ["A", "B", "A", "C", "A", "B", "D"]
try:
print(f"Наиболее частая категория: {mode(categories)}") # A
all_frequent = multimode(categories)
print(f"Все частые категории: {all_frequent}") # ['A']
except StatisticsError as e:
print(f"Ошибка: {e}")

import pandas as pd
from statistics import mode, multimode, StatisticsError

# Создаем DataFrame с различными типами данных
df = pd.DataFrame({
'числа': [1, 2, 3, 3, None, 4, 3],
'категории': ['A', 'B', 'A', None, 'C', 'A', 'b'],
'оценки': [4\.1, 3.9, 4.0, 4.0, 3.8, None, 4.0]
})

# Обработка числовых данных с пропусками
clean_numbers = [x for x in df['числа'] if pd.notna(x)]
try:
print(f"Мода числовых данных: {mode(clean_numbers)}") # 3
except StatisticsError as e:
print(f"Ошибка: {e}")

# Обработка категориальных данных с нормализацией
clean_categories = [str(x).lower() for x in df['категории'] if pd.notna(x)]
try:
print(f"Мода категорий: {mode(clean_categories)}") # a
except StatisticsError as e:
print(f"Ошибка: {e}")

# Округление и обработка оценок
clean_scores = [round(x, 0) for x in df['оценки'] if pd.notna(x)]
try:
print(f"Мода округленных оценок: {mode(clean_scores)}") # 4.0
except StatisticsError as e:
print(f"Ошибка: {e}")

def custom_mode(data):
frequency = {}

# Подсчет частот
for value in data:
if value in frequency:
frequency[value] += 1
else:
frequency[value] = 1

# Нахождение наиболее частого значения
max_count = 0
modes = []

for value, count in frequency.items():
if count > max_count:
modes = [value]
max_count = count
elif count == max_count:
modes.append(value)

# Если все элементы встречаются одинаковое число раз
if max_count == 1:
raise Exception("No mode found – all values appear exactly once")

return modes if len(modes) > 1 else modes[0]

# Пример использования
data = [1, 3, 5, 3, 7, 9, 3, 5]
result = custom_mode(data)
print(f"Мода: {result}") # Мода: 3

from collections import Counter

def counter_mode(data):
# Подсчет частот с помощью Counter
count = Counter(data)

# Наиболее частые элементы
max_frequency = max(count.values())

# Возвращаем все моды
return [item for item, freq in count.items() if freq == max_frequency]

# Пример использования
data = ["red", "blue", "red", "green", "blue", "red"]
result = counter_mode(data)
print(f"Моды: {result}") # Моды: ['red']

import numpy as np

def numpy_mode(data):
values, counts = np.unique(data, return_counts=True)
max_count_index = np.argmax(counts)
return values[max_count_index]

# Пример использования
data = np.array([1, 2, 3, 1, 2, 3, 3, 4, 5])
result = numpy_mode(data)
print(f"Мода: {result}") # Мода: 3

from scipy import stats

def scipy_mode(data):
mode_result = stats.mode(data)
# В SciPy 1.8.0+ возвращается объект ModeResult
# В более старых версиях возвращается кортеж (mode, count)
try:
# Для новых версий SciPy
return mode_result.mode[0]
except AttributeError:
# Для старых версий SciPy
return mode_result[0][0]

# Пример использования
data = [1, 2, 2, 3, 3, 3, 4, 5]
result = scipy_mode(data)
print(f"Мода (SciPy): {result}") # Мода (SciPy): 3

import pandas as pd

def pandas_mode(data):
series = pd.Series(data)
return series.mode().tolist()

# Пример использования
data = ["apple", "orange", "apple", "pear", "orange", "apple"]
result = pandas_mode(data)
print(f"Моды (Pandas): {result}") # Моды (Pandas): ['apple']

from collections import Counter

def most_common_word(text):
# Удаляем знаки препинания и приводим к нижнему регистру
clean_text = ''.join(c if c.isalnum() or c.isspace() else ' ' for c in text.lower())

# Разбиваем на слова и фильтруем пустые строки
words = [word for word in clean_text.split() if word]

# Используем Counter для подсчета частоты
word_counts = Counter(words)

# Находим слово с максимальной частотой
most_common = word_counts.most_common(1)

return most_common[0] if most_common else None

# Пример использования
sample_text = "Python это мощный язык программирования. Python прост в изучении, Python имеет обширные библиотеки."
result = most_common_word(sample_text)
print(f"Самое частое слово: {result[0]}, появилось {result[1]} раз(а)")
# Вывод: Самое частое слово: python, появилось 3 раз(а)

from statistics import multimode
import random

def analyze_weather_data(daily_temps, weekly_temps):
# Находим моду дневных температур
daily_mode = multimode(daily_temps)

# Находим моду недельных средних температур
weekly_mode = multimode(weekly_temps)

# Анализ разброса температур
daily_range = max(daily_temps) – min(daily_temps)
weekly_range = max(weekly_temps) – min(weekly_temps)

return {
'daily_mode': daily_mode,
'weekly_mode': weekly_mode,
'daily_range': daily_range,
'weekly_range': weekly_range
}

# Симуляция данных о температуре
daily_temps = [random.randint(15, 30) for _ in range(30)] # 30 дней
weekly_temps = [round(sum(daily_temps[i:i+7])/7, 1) for i in range(0, len(daily_temps)-6, 7)]

results = analyze_weather_data(daily_temps, weekly_temps)
print(f"Наиболее частые дневные температуры: {results['daily_mode']}")
print(f"Наиболее частые средненедельные температуры: {results['weekly_mode']}")
print(f"Диапазон дневных температур: {results['daily_range']}")
print(f"Диапазон средненедельных температур: {results['weekly_range']}")

from statistics import mode, multimode
import random

def analyze_survey(responses, question_types):
results = {}

for question, responses_list in zip(question_types, responses):
if question == 'single_choice':
# Для вопросов с одним вариантом ответа находим моду
try:
results[question] = mode(responses_list)
except:
results[question] = multimode(responses_list)
elif question == 'multiple_choice':
# Для вопросов с несколькими вариантами разбиваем и находим моды
flattened = [item for sublist in responses_list for item in sublist]
results[question] = multimode(flattened)
elif question == 'rating':
# Для рейтинговых вопросов вычисляем среднее и моду
results[question] = {
'average': sum(responses_list) / len(responses_list),
'mode': multimode(responses_list)
}

return results

# Симуляция данных опроса
question_types = ['single_choice', 'multiple_choice', 'rating']
responses = [
['A', 'B', 'A', 'C', 'A', 'B', 'A'], # single_choice
[['X', 'Y'], ['X', 'Z'], ['Y', 'Z'], ['X', 'Y'], ['X']], # multiple_choice
[5, 4, 5, 3, 5, 4, 5] # rating
]

survey_results = analyze_survey(responses, question_types)
print("Результаты анализа опроса:")
for question_type, result in survey_results.items():
print(f"{question_type}: {result}")

import matplotlib.pyplot as plt
import numpy as np
from statistics import mode, multimode
from scipy.stats import binom

def binomial_mode_experiment(n, p, num_experiments):
# Генерируем выборки из биномиального распределения
samples = [np.random.binomial(n, p) for _ in range(num_experiments)]

# Находим моду эмпирически
empirical_mode = multimode(samples)

# Теоретическая мода биномиального распределения
theoretical_mode = int(p * (n + 1)) # Приближение для целых чисел

# Построение графика распределения
count_dict = {}
for sample in samples:
if sample in count_dict:
count_dict[sample] += 1
else:
count_dict[sample] = 1

x = sorted(count_dict.keys())
y = [count_dict[k] for k in x]

plt.figure(figsize=(10, 6))
plt.bar(x, y, alpha=0.7, color='skyblue')

for mode_val in empirical_mode:
plt.axvline(x=mode_val, color='red', linestyle='--', 
label=f'Эмпирическая мода: {mode_val}')

plt.axvline(x=theoretical_mode, color='green', linestyle='-', 
label=f'Теоретическая мода: {theoretical_mode}')

plt.title(f'Биномиальное распределение B({n}, {p})')
plt.xlabel('Значение')
plt.ylabel('Частота')
plt.legend()
plt.grid(alpha=0.3)

return {
'empirical_mode': empirical_mode,
'theoretical_mode': theoretical_mode
}

# Параметры эксперимента
n = 20 # число испытаний
p = 0.3 # вероятность успеха
num_experiments = 1000 # размер выборки

results = binomial_mode_experiment(n, p, num_experiments)
print(f"Эмпирическая мода: {results['empirical_mode']}")
print(f"Теоретическая мода: {results['theoretical_mode']}")

# Для отображения графика в Jupyter Notebook или другой среде
# plt.show()

from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from statistics import multimode
import numpy as np

def analyze_clusters_mode(n_samples=300, n_clusters=3):
# Генерируем синтетические данные с заданными кластерами
X, y_true = make_blobs(n_samples=n_samples, centers=n_clusters, 
cluster_std=0.7, random_state=42)

# Применяем K-means для кластеризации
kmeans = KMeans(n_clusters=n_clusters)
y_pred = kmeans.fit_predict(X)

# Анализируем моды в каждом кластере
cluster_modes = {}

for i in range(n_clusters):
# Получаем точки текущего кластера
cluster_points = X[y_pred == i]

# Для анализа моды преобразуем координаты в дискретные значения
# Округляем до 1 знака после запятой
x_discrete = np.round(cluster_points[:, 0], 1)
y_discrete = np.round(cluster_points[:, 1], 1)

# Находим моды для x и y координат
x_modes = multimode(x_discrete)
y_modes = multimode(y_discrete)

cluster_modes[i] = {
'x_modes': x_modes,
'y_modes': y_modes,
'size': len(cluster_points)
}

return cluster_modes

# Анализируем моды в кластерах
cluster_analysis = analyze_clusters_mode()

print("Анализ мод в кластерах:")
for cluster_id, data in cluster_analysis.items():
print(f"Кластер {cluster_id}:")
print(f" Размер кластера: {data['size']}")
print(f" Моды по X: {data['x_modes']}")
print(f" Моды по Y: {data['y_modes']}")
print()