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

σ = √(Σ(x – μ)² / N)

где:
σ — стандартное отклонение
x — значение элемента датасета
μ — среднее арифметическое всех значений
N — количество элементов в наборе данных

s = √(Σ(x – x̄)² / (n – 1))

где:
s — выборочное стандартное отклонение
x̄ — среднее арифметическое выборки
n — размер выборки

def calculate_mean(data):
return sum(data) / len(data)

def calculate_std_dev(data, sample=True):
# Рассчитываем среднее
mean = calculate_mean(data)

# Суммируем квадраты отклонений от среднего
squared_diff_sum = sum((x – mean) ** 2 for x in data)

# Делим на (n-1) для выборки или на n для генеральной совокупности
divisor = len(data) – 1 if sample else len(data)

# Возвращаем квадратный корень из результата
return (squared_diff_sum / divisor) ** 0.5

# Пример использования
data = [12, 15, 18, 22, 25, 27, 30, 32]
sample_std = calculate_std_dev(data)
population_std = calculate_std_dev(data, sample=False)

print(f"Выборочное стандартное отклонение: {sample_std:.2f}")
print(f"Стандартное отклонение генеральной совокупности: {population_std:.2f}")

import statistics

data = [12, 15, 18, 22, 25, 27, 30, 32]

# Стандартное отклонение выборки (с поправкой Бесселя)
sample_std = statistics.stdev(data)

# Стандартное отклонение генеральной совокупности
population_std = statistics.pstdev(data)

print(f"statistics.stdev(): {sample_std:.2f}")
print(f"statistics.pstdev(): {population_std:.2f}")

import numpy as np

# Пример улучшенного алгоритма Велфорда для онлайн-расчета
def welford_std(data):
n = 0
mean = 0
M2 = 0

for x in data:
n += 1
delta = x – mean
mean += delta / n
M2 += delta * (x – mean)

if n < 2:
return float('nan')
else:
return np.sqrt(M2 / (n – 1))

data = [12, 15, 18, 22, 25, 27, 30, 32]
print(f"Стандартное отклонение (алгоритм Велфорда): {welford_std(data):.2f}")

import numpy as np

# Создаем тестовый массив
data = np.array([12, 15, 18, 22, 25, 27, 30, 32])

# Стандартное отклонение выборки (с поправкой Бесселя)
sample_std = np.std(data, ddof=1) # ddof=1 даёт несмещенную оценку

# Стандартное отклонение генеральной совокупности
population_std = np.std(data, ddof=0) # ddof=0 по умолчанию

print(f"NumPy sample std: {sample_std:.2f}")
print(f"NumPy population std: {population_std:.2f}")

# Для многомерных массивов можно указать ось вычислений
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
row_std = np.std(matrix, axis=1, ddof=1)
col_std = np.std(matrix, axis=0, ddof=1)

print(f"Стандартное отклонение по строкам: {row_std}")
print(f"Стандартное отклонение по столбцам: {col_std}")

import pandas as pd

# Создаем датафрейм
df = pd.DataFrame({
'Group': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C'],
'Value': [12, 15, 18, 22, 25, 27, 30, 32]
})

# Общее стандартное отклонение
total_std = df['Value'].std()

# Группировка и расчет по группам
group_std = df.groupby('Group')['Value'].std()

print(f"Общее стандартное отклонение: {total_std:.2f}")
print("Стандартное отклонение по группам:")
print(group_std)

# Rolling standard deviation (скользящее стандартное отклонение)
time_series = pd.Series([1, 2, 5, 7, 9, 12, 15, 14, 13, 11])
rolling_std = time_series.rolling(window=3).std()
print("\nСкользящее стандартное отклонение (окно 3):")
print(rolling_std)

from scipy import stats

data = [12, 15, 18, 22, 25, 27, 30, 32]

# Дескриптивная статистика, включая стандартное отклонение
desc = stats.describe(data)
print(f"SciPy stats.describe(): {desc}")

# Тест на нормальность (проверка, подчиняются ли данные нормальному распределению)
normality_test = stats.shapiro(data)
print(f"Тест Шапиро-Уилка на нормальность: {normality_test}")

import statsmodels.api as sm

# Создаем искусственный набор данных
x = sm.add_constant([1, 2, 3, 4, 5])
y = [2, 4, 5, 4, 6]

# Линейная регрессия
model = sm.OLS(y, x).fit()

# Стандартная ошибка коэффициентов использует стандартное отклонение
print(model.summary())

import numpy as np
import matplotlib.pyplot as plt

# Генерируем случайные данные из нормального распределения
np.random.seed(42)
data = np.random.normal(loc=50, scale=5, size=1000) # среднее=50, std=5

# Гистограмма с отображением среднего и стандартного отклонения
plt.figure(figsize=(10, 6))
plt.hist(data, bins=30, alpha=0.7, color='skyblue', density=True)

# Добавляем вертикальные линии для среднего и стандартных отклонений
mean = np.mean(data)
std = np.std(data)

# Среднее значение
plt.axvline(mean, color='red', linestyle='dashed', linewidth=2, label=f'Среднее = {mean:.2f}')

# Стандартные отклонения
for i in range(1, 4):
plt.axvline(mean + i*std, color='green', linestyle='dashed', linewidth=1, 
label=f'Среднее + {i}σ = {mean + i*std:.2f}')
plt.axvline(mean – i*std, color='green', linestyle='dashed', linewidth=1)

plt.title('Распределение данных с отображением стандартных отклонений')
plt.xlabel('Значение')
plt.ylabel('Плотность')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

import seaborn as sns

# Настраиваем стиль
sns.set(style="whitegrid")

# Генерируем различные наборы данных
np.random.seed(42)
data1 = np.random.normal(loc=0, scale=1, size=100)
data2 = np.random.normal(loc=0, scale=2, size=100)
data3 = np.random.normal(loc=0, scale=0.5, size=100)

# Создаем DataFrame для удобства
df = pd.DataFrame({
'Низкий разброс (σ=0.5)': data3,
'Средний разброс (σ=1)': data1,
'Высокий разброс (σ=2)': data2
})

# Box plot для сравнения разброса
plt.figure(figsize=(12, 6))
sns.boxplot(data=df)
plt.title('Сравнение распределений с разными стандартными отклонениями')
plt.ylabel('Значение')
plt.show()

# Violin plot с отображением распределения
plt.figure(figsize=(12, 6))
sns.violinplot(data=df)
plt.title('Violin plot распределений с разными стандартными отклонениями')
plt.ylabel('Значение')
plt.show()

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

# Генерируем данные временного ряда с разной волатильностью
np.random.seed(42)
dates = pd.date_range(start='2023-01-01', periods=100, freq='D')
base_value = 100
volatility_periods = {
'Низкая волатильность (σ=2)': np.random.normal(0, 2, 30),
'Средняя волатильность (σ=5)': np.random.normal(0, 5, 40),
'Высокая волатильность (σ=10)': np.random.normal(0, 10, 30)
}

values = []
current_value = base_value
for period_name, period_changes in volatility_periods.items():
for change in period_changes:
current_value += change
values.append(current_value)

# Создаем DataFrame временного ряда
time_df = pd.DataFrame({
'Date': dates,
'Value': values
})

# Интерактивный график с скользящим стандартным отклонением
time_df['Rolling_Std'] = time_df['Value'].rolling(window=10).std()

fig = go.Figure()
fig.add_trace(go.Scatter(
x=time_df['Date'], 
y=time_df['Value'],
mode='lines',
name='Значение'
))
fig.add_trace(go.Scatter(
x=time_df['Date'], 
y=time_df['Rolling_Std'],
mode='lines',
name='Скользящее стандартное отклонение (окно=10)',
line=dict(dash='dash')
))

fig.update_layout(
title='Временной ряд со скользящим стандартным отклонением',
xaxis_title='Дата',
yaxis_title='Значение',
hovermode='x unified'
)

fig.show()

import numpy as np
import matplotlib.pyplot as plt

# Генерируем данные
x = np.linspace(0, 10, 100)
y_true = 2 * x + 1
np.random.seed(42)
y_noise = np.random.normal(0, x, size=len(x)) # Шум, увеличивающийся с x
y_observed = y_true + y_noise

# Рассчитываем скользящее среднее и стандартное отклонение
window_size = 10
y_smoothed = np.zeros_like(y_observed)
std_dev = np.zeros_like(y_observed)

for i in range(len(x)):
# Определяем окно с учетом границ массива
start = max(0, i – window_size // 2)
end = min(len(x), i + window_size // 2)
window = y_observed[start:end]
y_smoothed[i] = np.mean(window)
std_dev[i] = np.std(window)

# Визуализация с областью стандартного отклонения
plt.figure(figsize=(12, 6))
plt.plot(x, y_observed, 'o', alpha=0.5, label='Наблюдения')
plt.plot(x, y_smoothed, 'r-', label='Сглаженная линия')
plt.fill_between(x, y_smoothed – std_dev, y_smoothed + std_dev, 
alpha=0.2, color='r', label='±1σ')

plt.plot(x, y_true, 'g--', label='Истинная линия')
plt.title('Визуализация данных с областью стандартного отклонения')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Генерируем данные с искусственными выбросами
np.random.seed(42)
normal_data = np.random.normal(loc=100, scale=15, size=95)
outliers = np.array([30, 40, 200, 210, 220])
data = np.concatenate([normal_data, outliers])
np.random.shuffle(data)

# Функция для обнаружения выбросов на основе Z-score
def detect_outliers_zscore(data, threshold=3):
mean = np.mean(data)
std = np.std(data)
z_scores = [(y – mean) / std for y in data]
return np.where(np.abs(z_scores) > threshold)[0], z_scores

# Обнаружение выбросов
outlier_indices, z_scores = detect_outliers_zscore(data)
outlier_values = data[outlier_indices]

# Визуализация
plt.figure(figsize=(12, 6))
plt.scatter(range(len(data)), data, alpha=0.7)
plt.scatter(outlier_indices, outlier_values, color='red', label='Выбросы (|Z| > 3)')
plt.axhline(np.mean(data), color='green', linestyle='-', label='Среднее')
plt.axhline(np.mean(data) + 3*np.std(data), color='orange', linestyle='--', label='+3σ')
plt.axhline(np.mean(data) – 3*np.std(data), color='orange', linestyle='--', label='-3σ')

plt.title('Обнаружение выбросов с помощью Z-score (порог = 3σ)')
plt.xlabel('Индекс')
plt.ylabel('Значение')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

print(f"Обнаружено {len(outlier_indices)} выбросов: {outlier_values}")

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import yfinance as yf

# Получаем исторические данные нескольких акций
tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN']
start_date = '2022-01-01'
end_date = '2023-01-01'

stock_data = {}
for ticker in tickers:
stock_data[ticker] = yf.download(ticker, start=start_date, end=end_date)

# Рассчитываем дневную доходность и волатильность (стандартное отклонение)
returns_data = {}
volatility = {}
for ticker, data in stock_data.items():
# Рассчитываем дневную доходность
returns_data[ticker] = data['Adj Close'].pct_change().dropna()
# Рассчитываем годовую волатильность (аннуализированное стандартное отклонение)
volatility[ticker] = returns_data[ticker].std() * np.sqrt(252) # 252 торговых дня в году

# Создаем DataFrame с результатами
volatility_df = pd.DataFrame(volatility.items(), columns=['Тикер', 'Годовая волатильность'])
volatility_df['Годовая волатильность'] = volatility_df['Годовая волатильность'] * 100 # Переводим в проценты

# Визуализация
plt.figure(figsize=(10, 6))
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
for i, ticker in enumerate(tickers):
plt.plot(returns_data[ticker].cumsum() * 100, label=ticker, color=colors[i])

plt.title('Кумулятивная доходность акций')
plt.xlabel('Дата')
plt.ylabel('Кумулятивная доходность (%)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# Сравнительная таблица волатильности
print("Сравнение годовой волатильности:")
print(volatility_df.sort_values(by='Годовая волатильность'))

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

# Создаем синтетический сигнал с шумом
np.random.seed(42)
t = np.linspace(0, 1, 1000)
clean_signal = np.sin(2 * np.pi * 5 * t) + 0.5 * np.sin(2 * np.pi * 20 * t)
noise = np.random.normal(0, 0.5, len(t))
noisy_signal = clean_signal + noise

# Реализуем адаптивный фильтр на основе локального стандартного отклонения
def adaptive_filter(signal, window_size=20, threshold_multiplier=2.0):
filtered = np.copy(signal)
for i in range(len(signal)):
# Определяем границы окна
start = max(0, i – window_size // 2)
end = min(len(signal), i + window_size // 2)
window = signal[start:end]

# Рассчитываем локальное стандартное отклонение
window_std = np.std(window)
window_mean = np.mean(window)

# Если текущее значение отклоняется слишком сильно, заменяем его средним
if abs(signal[i] – window_mean) > threshold_multiplier * window_std:
filtered[i] = window_mean

return filtered

# Применяем фильтр
filtered_signal = adaptive_filter(noisy_signal, window_size=30, threshold_multiplier=2.0)

# Визуализация
plt.figure(figsize=(12, 8))

plt.subplot(3, 1, 1)
plt.plot(t, clean_signal)
plt.title('Оригинальный чистый сигнал')
plt.grid(True, alpha=0.3)

plt.subplot(3, 1, 2)
plt.plot(t, noisy_signal)
plt.title('Сигнал с шумом')
plt.grid(True, alpha=0.3)

plt.subplot(3, 1, 3)
plt.plot(t, filtered_signal)
plt.title('Отфильтрованный сигнал (адаптивный фильтр на основе стандартного отклонения)')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Симулируем калибровочные измерения с известными эталонными значениями
reference_values = np.array([0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100])

# Каждое эталонное значение измеряется несколько раз
n_measurements = 5
np.random.seed(42)

# Создаем модель датчика с нелинейностью и увеличивающейся дисперсией с ростом значения
def sensor_model(x, a, b, c):
return a * x**2 + b * x + c

# Истинные параметры модели
true_params = [0\.001, 0.95, 2]

# Генерируем измерения
measurements = []
all_reference = []

for ref in reference_values:
# Истинное показание датчика
true_reading = sensor_model(ref, *true_params)

# Шум растет с увеличением значения
noise_std = 1 + ref * 0.05

# Генерируем измерения
readings = true_reading + np.random.normal(0, noise_std, n_measurements)

measurements.extend(readings)
all_reference.extend([ref] * n_measurements)

measurements = np.array(measurements)
all_reference = np.array(all_reference)

# Оцениваем параметры модели
params, cov = curve_fit(sensor_model, all_reference, measurements)

# Рассчитываем стандартное отклонение для каждого эталонного значения
measurement_std = []
for ref in reference_values:
mask = all_reference == ref
std = np.std(measurements[mask])
measurement_std.append(std)

# Визуализация результатов калибровки
plt.figure(figsize=(12, 8))

plt.subplot(2, 1, 1)
plt.scatter(all_reference, measurements, alpha=0.7, label='Измерения')

# Генерируем кривую калибровки
x_smooth = np.linspace(0, 100, 500)
y_smooth = sensor_model(x_smooth, *params)
plt.plot(x_smooth, y_smooth, 'r-', label='Калибровочная кривая')

# Добавляем идеальную линию y=x для сравнения
plt.plot([0, 100], [0, 100], 'g--', label='Идеальная линия (y=x)')

plt.title('Калибровка датчика')
plt.xlabel('Эталонное значение')
plt.ylabel('Показание датчика')
plt.legend()
plt.grid(True, alpha=0.3)

# График стандартного отклонения
plt.subplot(2, 1, 2)
plt.bar(reference_values, measurement_std, width=5, alpha=0.7)
plt.title('Стандартное отклонение измерений по эталонным значениям')
plt.xlabel('Эталонное значение')
plt.ylabel('Стандартное отклонение')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Вывод результатов калибровки
print(f"Параметры калибровочной модели: a={params[0]:.6f}, b={params[1]:.6f}, c={params[2]:.6f}")
print("\nСтандартное отклонение по эталонным точкам:")
for ref, std in zip(reference_values, measurement_std):
print(f"Эталон {ref}: σ = {std:.3f}")