Начали писать курс по Data Science в Python 😎. Пока базовый курс 🧦. Тема на самом деле сложная, но очень интересная 😋 Python лидирует в области анализа данных. Его типы данных и библиотеки являются одними из самых удобных и одновременно простых для начала работы в области Data Science, но кстати, они не самые производительные. Существует, например, Julia, который значительно быстрее на больших наборах данных. В конце концов, никто не отменял C ➕ CUDA. Но мы все знаем, что удобство и возможность быстро начать работать побеждают потенциальную производительность. Примером тому является Excel, который также используется для Data Science, возможно даже чаще, чем Python 🙂

Подпишись 👉🏻 @KodduuPython 🤖

Вот пример кода на Python для выполнения статистического анализа с использованием библиотеки SciPy, включающий различные статистические тесты и функции, которые демонстрируют возможности библиотеки:

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

# Генерация случайных данных для двух групп
np.random.seed(42)
group1 = np.random.normal(loc=50, scale=10, size=100)  # Первая группа: нормальное распределение
group2 = np.random.normal(loc=55, scale=15, size=100)  # Вторая группа: другое распределение

# 1. Проверка нормальности распределения (тест Шапиро-Уилка)
stat1, p_value1 = stats.shapiro(group1)
stat2, p_value2 = stats.shapiro(group2)

print(f"Тест Шапиро-Уилка для группы 1: W={stat1}, p-value={p_value1}")
print(f"Тест Шапиро-Уилка для группы 2: W={stat2}, p-value={p_value2}")

# 2. Тест на равенство дисперсий (тест Левена)
levene_stat, levene_p_value = stats.levene(group1, group2)
print(f"Тест Левена: stat={levene_stat}, p-value={levene_p_value}")

# 3. Проверка гипотезы о равенстве средних значений (t-тест)
t_stat, t_p_value = stats.ttest_ind(group1, group2)
print(f"T-тест: stat={t_stat}, p-value={t_p_value}")

# 4. Построение гистограмм для визуализации распределения
plt.hist(group1, alpha=0.5, label='Group 1', bins=15)
plt.hist(group2, alpha=0.5, label='Group 2', bins=15)
plt.title('Распределение значений в двух группах')
plt.legend()
plt.show()

# 5. Корреляционный анализ (коэффициент Пирсона)
x = np.random.rand(100)
y = 2 * x + np.random.normal(0, 0.1, 100)
pearson_corr, pearson_p_value = stats.pearsonr(x, y)
print(f"Коэффициент корреляции Пирсона: r={pearson_corr}, p-value={pearson_p_value}")

# 6. Проверка независимости категориальных переменных (хи-квадрат тест)
observed = np.array([[20, 15], [10, 25]])
chi2_stat, chi2_p_value, dof, expected = stats.chi2_contingency(observed)
print(f"Хи-квадрат тест: chi2={chi2_stat}, p-value={chi2_p_value}, degrees of freedom={dof}")
print("Ожидаемые значения:")
print(expected)

### Описание и особенности анализа

1. Тест Шапиро-Уилка — проверяет гипотезу о нормальности распределения данных. Если p-value меньше 0.05, мы отвергаем гипотезу о нормальности.
2. Тест Левена — проверяет гипотезу о равенстве дисперсий между двумя группами. Низкий p-value говорит о том, что дисперсии значимо различаются.
3. t-тест — тестирует гипотезу о равенстве средних значений двух групп. Используется, если дисперсии равны и данные имеют нормальное распределение.
4. Коэффициент корреляции Пирсона — оценивает степень линейной зависимости между двумя переменными. Значение коэффициента находится в диапазоне от -1 до 1.
5. Хи-квадрат тест — используется для проверки зависимости между категориальными переменными.

### Преимущества и особенности использования SciPy:
- Разнообразие тестов: библиотека SciPy предоставляет широкий выбор статистических тестов и функций для анализа данных, от простых t-тестов до более сложных непараметрических тестов.
- Гибкость: SciPy позволяет анализировать как непрерывные, так и категориальные данные, что делает ее полезной для различных типов задач.
- Легкость интеграции: SciPy легко интегрируется с другими библиотеками Python, такими как NumPy и Matplotlib, что позволяет проводить как численные расчеты, так и визуализацию данных.

Эти особенности делают библиотеку SciPy мощным инструментом для проведения статистического анализа в Python.

Подпишись 👉🏻 @KodduuPython 🤖

Продолжаем писать курс по Data Science в Python 😎 Написали про NumPy 36 уоков и задач 👍 Переходим к Pandas 🧐

Что такое NumPy - это Numerical Python, то есть библиотека для работы с числами. Основа тут N-мерные массивы, которые можно перемножать, искать max, min, среднее. Искать корреляции между строками массивов и т.д. Работает очень быстро, по сравнению со стандартными типами данных Python. Очень круто для научных и прочих технических задач с циферами. Ну прям летает оно, потому что массивы immutable и хранятся в памяти подряд.

А вот Pandas многим понравиться еще больше, потому что это Ваши любымие таблицы (прям как в Excel). Тут можно будет впихнуть любые типы данных, включая пустые значения, которые NumPy по умолчанию не поддерживает 🤨Можно прям взять вашу любимубю табличку Excel, и сразу сюда подгрузить, можно и из CSV затянуть данные. Но придется заплатить производительностью - все будет медленее, чем в NumPy. Зато индексацию по вашим любимым столбикам можно будет сделать. Сам люблю, когда большой уже Excel файл тормозит, его втянуть в Pandas и выжать из него все данные которые мне нужны 😀

Подпишись 👉🏻 @KodduuPython 🤖

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

### Пример кода на Python с PyMC3:

import numpy as np
import matplotlib.pyplot as plt
import pymc3 as pm
import arviz as az

# Генерация синтетических данных
np.random.seed(42)
size = 100
X = np.random.randn(size)  # случайные входные данные
true_intercept = 1.0  # истинное значение интерцепта
true_slope = 2.5  # истинное значение коэффициента наклона
true_sigma = 0.5  # истинное значение стандартного отклонения ошибки
Y = true_intercept + true_slope * X + np.random.normal(scale=true_sigma, size=size)

# Построение модели в PyMC3
with pm.Model() as model:
    # Определяем априорные распределения для параметров
    intercept = pm.Normal("intercept", mu=0, sigma=10)
    slope = pm.Normal("slope", mu=0, sigma=10)
    sigma = pm.HalfNormal("sigma", sigma=1)
    
    # Линейная модель
    mu = intercept + slope * X
    
    # Наблюдения с ошибками
    Y_obs = pm.Normal("Y_obs", mu=mu, sigma=sigma, observed=Y)
    
    # Запуск выборки с помощью метода NUTS (No-U-Turn Sampler)
    trace = pm.sample(2000, tune=1000, return_inferencedata=True)
    
# Визуализация результатов
az.plot_trace(trace)
plt.show()

# Визуализация апостериорных предсказаний
with model:
    pm.plot_posterior_predictive_glm(trace, samples=100, 
                                     label='Posterior predictive regression lines',
                                     eval=np.linspace(-3, 3, 100))
plt.scatter(X, Y, c='r', label='Observed data')
plt.legend()
plt.show()

# Вывод статистик выборки
print(az.summary(trace))

### Описание анализа

#### Шаги:
1. Генерация данных: Мы создаем синтетические данные, которые моделируют линейную зависимость между независимой переменной \(X\) и зависимой переменной \(Y\) с добавлением случайного шума.
2. Модель в PyMC3:
- Задаем априорные распределения для параметров нашей модели: интерцепта, коэффициента наклона и стандартного отклонения ошибки (sigma).
- Выражаем зависимость через линейную модель.
- Определяем наблюдения как нормально распределенные вокруг линейной модели с неизвестной дисперсией (sigma).
3. Запуск выборки: Используем метод NUTS для выполнения байесовского вывода. Этот метод является адаптивной версией метода Гамильтоновой Монте-Карло (HMC), который эффективно исследует пространство параметров.
4. Визуализация результатов: Мы визуализируем траектории выборки и построенные регрессионные линии с учетом апостериорных распределений.

#### Особенности использования PyMC3:
1. Байесовский подход: В отличие от частотных методов, PyMC3 реализует байесовский подход к статистическому анализу, что позволяет работать с неопределенностями и априорными предположениями. Это особенно полезно в случаях, когда данные ограничены или сложно структурированы.
2. Гибкость моделей: PyMC3 позволяет строить сложные иерархические модели с нелинейными зависимостями и легко работать с различными типами распределений для параметров. Модель может быть расширена для работы с любыми вероятностными зависимостями.
3. Мощные алгоритмы выборки: PyMC3 использует современные алгоритмы выборки, такие как NUTS, который помогает эффективно исследовать сложные пространства параметров, особенно когда обычные методы, такие как MCMC, не справляются.
4. Визуализация неопределенности: Визуализация результатов выборки, особенно апостериорных предсказаний, дает представление не только о средних значениях, но и о вариациях и неопределенности оценок, что является мощным инструментом для принятия решений в условиях неопределенности.

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

Подпишись 👉🏻 @KodduuPython 🤖

Пример кода для проведения статистического анализа с использованием библиотеки PyStan (интерфейс Python для языка моделирования Stan), демонстрирующий выполнение байесовской линейной регрессии.

import pystan
import numpy as np
import matplotlib.pyplot as plt

# Генерация синтетических данных
np.random.seed(42)
size = 100
X = np.random.randn(size)
true_intercept = 1.0
true_slope = 2.5
true_sigma = 0.5
Y = true_intercept + true_slope * X + np.random.normal(0, true_sigma, size)

# Определяем модель на языке Stan
stan_model_code = """
data {
    int<lower=0> N;        // Количество наблюдений
    vector[N] x;           // Независимая переменная
    vector[N] y;           // Зависимая переменная
}
parameters {
    real alpha;            // Интерцепт
    real beta;             // Коэффициент наклона
    real<lower=0> sigma;   // Стандартное отклонение
}
model {
    y ~ normal(alpha + beta * x, sigma);  // Линейная модель с нормальным шумом
}
"""

# Подготовка данных для передачи в Stan
stan_data = {
    'N': size,
    'x': X,
    'y': Y
}

# Компиляция и запуск модели в Stan
stan_model = pystan.StanModel(model_code=stan_model_code)
fit = stan_model.sampling(data=stan_data, iter=2000, chains=4)

# Вывод результатов выборки
print(fit)

# Получение результатов выборки для параметров модели
fit_results = fit.extract()

# Визуализация апостериорных предсказаний
alpha_samples = fit_results['alpha']
beta_samples = fit_results['beta']

x_pred = np.linspace(-3, 3, 100)
y_pred = np.zeros((len(alpha_samples), len(x_pred)))

for i in range(len(alpha_samples)):
    y_pred[i, :] = alpha_samples[i] + beta_samples[i] * x_pred

# Построение графика с доверительными интервалами
plt.plot(x_pred, np.mean(y_pred, axis=0), label='Posterior mean', color='blue')
plt.fill_between(x_pred, np.percentile(y_pred, 2.5, axis=0), np.percentile(y_pred, 97.5, axis=0), color='blue', alpha=0.3)
plt.scatter(X, Y, c='r', label='Observed data')
plt.title('Байесовская линейная регрессия с PyStan')
plt.legend()
plt.show()

### Описание анализа

#### Шаги:
1. Генерация данных: Мы создаем синтетические данные с линейной зависимостью между независимой переменной \(X\) и зависимой переменной \(Y\) с добавлением случайного шума.
2. Модель на языке Stan: Мы описываем байесовскую линейную регрессию с нормальным распределением шума в модели. В этой модели есть три параметра: интерцепт (alpha), коэффициент наклона (beta) и стандартное отклонение ошибки (sigma).
3. Подготовка данных для Stan: Мы передаем данные, такие как количество наблюдений и сами данные, в формате, понятном Stan.
4. Запуск выборки: Мы используем алгоритм HMC (Гамильтонова Монте-Карло) для выполнения байесовского вывода с использованием выборки параметров модели. Параметры выборки будут использованы для построения апостериорных распределений.
5. Визуализация результатов: Мы визуализируем предсказания модели, построенные на основе апостериорных распределений, с доверительными интервалами. Это позволяет оценить неопределенность предсказаний.

### Особенности PyStan:
1. Высокая производительность: PyStan является оберткой над Stan, который использует высокоэффективные алгоритмы Гамильтоновой Монте-Карло для проведения выборки из апостериорных распределений. Это делает его особенно полезным для сложных и вычислительно тяжелых моделей.
2. Явное описание модели: Stan использует свой язык для определения моделей, что делает описания вероятностных моделей более строгими и легко читаемыми. Это позволяет четко задавать как априорные распределения, так и зависимость между переменными.
3. Поддержка сложных иерархических моделей: PyStan может использоваться для моделирования сложных иерархических моделей, что делает его подходящим для задач с большим количеством параметров и зависимостей.
4. Мощные методы байесовского вывода: Используя такие алгоритмы, как NUTS и HMC, PyStan обеспечивает эффективный байесовский анализ, особенно в пространствах параметров высокой размерности.

Подпишись 👉🏻 @KodduuPython 🤖

Начальные требования для курса Data Science в Python пришлось немного поднять, не можем же мы повторять здесь все что есть в других курсах для новчиков 🤷‍♀️ Вся база по Python уже ведь есть тут.

Подпишись 👉🏻 @KodduuPython 🤖

Ниже пример кода на Python для проведения статистического анализа с использованием библиотеки Statsmodels. Мы проведем линейную регрессию и некоторые дополнительные статистические тесты.

import numpy as np
import statsmodels.api as sm
import statsmodels.formula.api as smf
import matplotlib.pyplot as plt

# Генерация синтетических данных
np.random.seed(42)
size = 100
X = np.random.normal(0, 1, size)
true_intercept = 2.0
true_slope = 3.5
Y = true_intercept + true_slope * X + np.random.normal(0, 1, size)

# Добавление константы (интерцепта) в данные
X_with_const = sm.add_constant(X)

# Создание модели линейной регрессии
model = sm.OLS(Y, X_with_const)
results = model.fit()

# Вывод результатов регрессии
print(results.summary())

# Построение графика
plt.scatter(X, Y, label='Observed data')
plt.plot(X, results.fittedvalues, color='red', label='Fitted line')
plt.title('Линейная регрессия с использованием Statsmodels')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.show()

# Проверка остатков на нормальность (тест Джарка-Бера)
jb_test_stat, jb_p_value, skew, kurtosis = sm.stats.jarque_bera(results.resid)
print(f"Тест Джарка-Бера: stat={jb_test_stat}, p-value={jb_p_value}")

# Тест на гетероскедастичность (тест Бреуша-Пагана)
_, bp_p_value, _, _ = sm.stats.het_breuschpagan(results.resid, results.model.exog)
print(f"Тест Бреуша-Пагана: p-value={bp_p_value}")

### Описание анализа

#### Шаги:

1. Генерация данных: Мы создаем синтетические данные, которые моделируют линейную зависимость между независимой переменной \(X\) и зависимой переменной \(Y\) с добавлением случайного шума. Эти данные мы будем использовать для построения регрессионной модели.
2. Добавление константы: В Statsmodels для линейной регрессии нужно явно добавить константу (интерцепт) в данные с помощью функции sm.add_constant().
3. Построение модели линейной регрессии: Мы используем метод наименьших квадратов (OLS) для построения модели. sm.OLS() создает объект модели, а метод fit() выполняет оценку параметров модели.
4. Вывод результатов: Результаты регрессии включают оценки параметров модели (интерцепта и коэффициента наклона), а также различные статистические показатели, такие как \(R^2\), t-статистика, F-статистика и p-значения.
5. Визуализация: Мы строим график исходных данных и линии регрессии, чтобы увидеть, как хорошо модель описывает данные.
6. Тест Джарка-Бера: Этот тест проверяет, следуют ли остатки нормальному распределению. Это важно, так как одно из предположений линейной регрессии — нормальность ошибок.
7. Тест Бреуша-Пагана: Этот тест проверяет наличие гетероскедастичности (изменяющейся дисперсии остатков). Если гетероскедастичность присутствует, то стандартные ошибки оценок могут быть неверными.

### Особенности использования Statsmodels:

1. Мощный инструмент для линейных и нелинейных моделей: Statsmodels предоставляет широкие возможности для создания как простых линейных регрессионных моделей, так и более сложных статистических моделей, таких как логистическая регрессия, временные ряды, иерархические модели и другие.

2. Поддержка формул: В дополнение к традиционному API, Statsmodels поддерживает API на основе формул через модуль statsmodels.formula.api. Это позволяет удобно задавать модели в стиле R, например: model = smf.ols('Y ~ X', data=data).

3. Расширенные статистические тесты: В дополнение к стандартным оценкам модели (таким как коэффициенты регрессии и стандартные ошибки), Statsmodels включает разнообразные статистические тесты для проверки предположений моделей (например, тесты на нормальность остатков, гетероскедастичность, автокорреляцию).

4. Информативные отчеты: Результаты модели в Statsmodels включают детализированные таблицы с основными статистиками, такими как коэффициенты, доверительные интервалы, статистики t и F, p-значения, \(R^2\), и многое другое. Это делает Statsmodels особенно полезной для выполнения регрессионного анализа с акцентом на интерпретацию результатов.

Подпишись 👉🏻 @KodduuPython 🤖

Вот пример кода на Python для проведения анализа выживаемости с использованием библиотеки Lifelines. В этом примере мы применим Каплан-Майеровскую оценку и регрессию пропорциональных рисков Кокса, которые являются ключевыми методами анализа выживаемости.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from lifelines import KaplanMeierFitter, CoxPHFitter

# Генерация синтетических данных
np.random.seed(42)
n = 100  # количество наблюдений
data = pd.DataFrame({
    'duration': np.random.exponential(10, size=n),  # продолжительность времени до события
    'event': np.random.binomial(1, 0.8, size=n),    # индикатор события (1 - событие произошло, 0 - цензурировано)
    'age': np.random.normal(50, 10, size=n),        # возраст как ковариата
    'treatment': np.random.binomial(1, 0.5, size=n) # лечение (0 или 1)
})

# Каплан-Майеровская оценка
kmf = KaplanMeierFitter()
kmf.fit(durations=data['duration'], event_observed=data['event'])

# Построение графика Каплан-Майеровской кривой
kmf.plot_survival_function()
plt.title('Каплан-Майеровская оценка')
plt.xlabel('Время')
plt.ylabel('Вероятность выживания')
plt.show()

# Каплан-Майеровская оценка для двух групп (лечение vs без лечения)
kmf_treatment = KaplanMeierFitter()
kmf_no_treatment = KaplanMeierFitter()

# Разделение данных по группам
treatment_group = data['treatment'] == 1
no_treatment_group = data['treatment'] == 0

# Построение кривых выживания для обеих групп
kmf_treatment.fit(durations=data['duration'][treatment_group], event_observed=data['event'][treatment_group], label='Лечение')
kmf_no_treatment.fit(durations=data['duration'][no_treatment_group], event_observed=data['event'][no_treatment_group], label='Без лечения')

# Визуализация
kmf_treatment.plot_survival_function()
kmf_no_treatment.plot_survival_function()
plt.title('Каплан-Майеровская оценка (лечение vs без лечения)')
plt.xlabel('Время')
plt.ylabel('Вероятность выживания')
plt.show()

# Регрессия пропорциональных рисков Кокса
cph = CoxPHFitter()
cph.fit(data, duration_col='duration', event_col='event')
cph.print_summary()

# Визуализация коэффициентов модели Кокса
cph.plot()
plt.title('Коэффициенты регрессии Кокса')
plt.show()

### Описание анализа

#### Шаги:
1. Генерация данных: Мы создаем синтетические данные, которые включают время до события (например, смерть или отказ оборудования), индикатор события (1 — событие произошло, 0 — цензурирование), возраст участников и индикатор лечения.
2. Каплан-Майеровская оценка:
- Каплан-Майеровский метод — это популярный непараметрический метод для оценки функции выживания. Мы применяем его к нашим данным, чтобы оценить вероятность выживания на каждом этапе времени.
- Мы также сравниваем выживаемость между двумя группами: тех, кто получал лечение, и тех, кто не получал лечение.
3. Регрессия пропорциональных рисков Кокса:
- Регрессия Кокса является полупараметрическим методом, который используется для оценки зависимости времени до события от ковариат (например, возраста или лечения). В модели Кокса не предполагается форма базовой функции интенсивности.
- Мы выполняем регрессию Кокса, чтобы понять, как лечение и возраст влияют на вероятность наступления события.

#### Особенности использования Lifelines:
1. Простота использования: Lifelines предлагает простые и интуитивные инструменты для выполнения анализа выживаемости. Это делает его отличным выбором для задач анализа выживаемости, как с реальными, так и с синтетическими данными.

2. Каплан-Майеровская оценка: Этот метод позволяет оценивать функцию выживания и сравнивать выживаемость между различными группами. Визуализация с помощью Lifelines позволяет легко интерпретировать результаты.

3. Регрессия пропорциональных рисков Кокса: Модель Кокса — один из самых популярных методов анализа выживаемости, и Lifelines предоставляет удобный интерфейс для создания и интерпретации таких моделей. Она помогает понять влияние ковариат на выживаемость.

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

5. Поддержка цензурированных данных: Lifelines учитывает цензурированные данные, что является ключевым аспектом анализа выживаемости. Это позволяет корректно учитывать данные о тех наблюдениях, где событие не произошло до конца периода наблюдения.

Lifelines — это мощный инструмент для анализа данных выживаемости, который предлагает удобные функции для выполнения Каплан-Майеровской оценки, регрессии Кокса и других методов анализа событий.

Подпишись 👉🏻 @KodduuPython 🤖

Пишем Data Science в Python дальше. В Pandas главное выбрать правильный формат создания данных - построчный 👆Единственный вариант когда вам может подойти создание по стоблцам - это статические данные, которые вы грузите из внешнки, уже хранящиеся в таком формате (че это за данные такие? 🤨), и у вас этих данных очень дофига, то есть для вас критична скорость создания самого Date Set, и вы будете данные просто анализировать без изменений. Ну и если памяти у Вас мало, потому что вы оказались заперты с 90х в лаборотрии с Pentium 1 с 32MB RAM и кнопкой Turbo 😆

Подпишись 👉🏻 @KodduuPython 🤖

Вот пример кода на Python для проведения статистического анализа с использованием библиотеки Pingouin, которая является мощным инструментом для выполнения различных статистических тестов и анализа данных.

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

# Генерация синтетических данных
np.random.seed(42)
data = pd.DataFrame({
    'group1': np.random.normal(50, 10, 30),  # Группа 1
    'group2': np.random.normal(55, 15, 30),  # Группа 2
    'group3': np.random.normal(60, 5, 30)    # Группа 3
})

# 1. Проверка нормальности распределения (тест Шапиро-Уилка)
normality_test_group1 = pg.normality(data['group1'])
normality_test_group2 = pg.normality(data['group2'])
normality_test_group3 = pg.normality(data['group3'])

print("Тест Шапиро-Уилка для группы 1:", normality_test_group1)
print("Тест Шапиро-Уилка для группы 2:", normality_test_group2)
print("Тест Шапиро-Уилка для группы 3:", normality_test_group3)

# 2. Проверка равенства дисперсий (тест Левена)
levene_test = pg.homoscedasticity(data)
print("\nТест Левена на равенство дисперсий между группами:\n", levene_test)

# 3. Однофакторный ANOVA
anova_results = pg.anova(dv='group1', between='group2', data=data)
print("\nРезультаты однофакторного ANOVA:\n", anova_results)

# 4. Парный t-тест (сравнение двух групп)
ttest_results = pg.ttest(data['group1'], data['group2'])
print("\nРезультаты парного t-теста:\n", ttest_results)

# 5. Корреляционный анализ (коэффициент Пирсона)
correlation = pg.corr(data['group1'], data['group3'])
print("\nКоэффициент корреляции Пирсона между группой 1 и группой 3:\n", correlation)

# 6. Визуализация данных и результатов анализа
plt.hist(data['group1'], alpha=0.5, label='Group 1', bins=10)
plt.hist(data['group2'], alpha=0.5, label='Group 2', bins=10)
plt.hist(data['group3'], alpha=0.5, label='Group 3', bins=10)
plt.title('Распределение значений в группах')
plt.legend()
plt.show()

### Описание анализа

#### Шаги:

1. Проверка нормальности распределения (тест Шапиро-Уилка):
- Тест Шапиро-Уилка проверяет гипотезу о том, что данные имеют нормальное распределение. Если p-value < 0.05, то гипотеза о нормальности отвергается.

2. Проверка равенства дисперсий (тест Левена):
- Тест Левена используется для проверки гомогенности дисперсий между несколькими группами. Он особенно полезен перед проведением ANOVA, так как одно из предположений ANOVA заключается в равенстве дисперсий.

3. Однофакторный ANOVA:
- Однофакторный дисперсионный анализ (ANOVA) проверяет, различаются ли средние значения между несколькими группами. Если p-value < 0.05, то существует значимое различие между группами.

4. Парный t-тест:
- t-тест используется для проверки, есть ли значимое различие между средними значениями двух групп. В Pingouin можно легко выполнить парный t-тест для сравнения двух выборок.

5. Корреляционный анализ (коэффициент Пирсона):
- Корреляция Пирсона измеряет линейную зависимость между двумя переменными. Значение коэффициента корреляции находится в диапазоне от -1 до 1, где значения, близкие к 1 или -1, указывают на сильную линейную зависимость.

#### Особенности использования Pingouin:

1. Простота использования: Pingouin разработан как удобный инструмент для выполнения статистического анализа с минимальным количеством кода. Он интуитивен и легко интегрируется с pandas, что делает его очень удобным для пользователей Python.

2. Широкий набор статистических тестов: Pingouin поддерживает широкий спектр статистических тестов, включая t-тесты, ANOVA, корреляцию, регрессию, многомерные методы и многое другое. Это делает его универсальным инструментом для выполнения большинства стандартных статистических анализов.

3. Дополнительные метрики и эффекты: Многие тесты в Pingouin автоматически предоставляют полезные метрики, такие как размеры эффекта, доверительные интервалы и другие важные статистические параметры. Это особенно полезно для интерпретации результатов анализа.

4. Поддержка повторных измерений: Pingouin отлично справляется с задачами, включающими повторные измерения, такие как парные t-тесты, тесты Фридмана и другие методы анализа для связанных данных.

5. Легкость интеграции с визуализацией: Результаты Pingouin легко визуализировать с помощью библиотек, таких как Matplotlib и Seaborn, что позволяет эффективно комбинировать аналитическую мощь с наглядностью.

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

Подпишись 👉🏻 @KodduuPython 🤖

Средний курс на Stepik имеет 200-300 уроков/тестов/задач. Мы делаем упор на задачах, чтобы писать код. Вот уже в Data Science в Python около 100 уроков/тестов/задач 🧐

Подпишись 👉🏻 @KodduuPython 🤖

Scrapy — это мощный и быстрый фреймворк для веб-скрейпинга на Python. Он позволяет эффективно собирать данные с веб-сайтов и структурировать их в нужном формате.

Ниже представлен пример простого паука, который собирает заголовки и ссылки статей с главной страницы новостного сайта:

import scrapy

class NewsSpider(scrapy.Spider):
    name = "news"

    start_urls = [
        'https://example-news-website.com/',
    ]

    def parse(self, response):
        for article in response.css('div.article'):
            yield {
                'title': article.css('h2.title::text').get(),
                'link': article.css('a::attr(href)').get(),
            }

        next_page = response.css('a.next::attr(href)').get()
        if next_page is not None:
            yield response.follow(next_page, self.parse)

Особенности данного примера:

1. Класс Spider: Создаем класс NewsSpider, наследуемый от scrapy.Spider, и задаем уникальное имя паука name = "news".

2. Начальные URL: Список start_urls содержит страницы, с которых паук начнет обход.

3. Метод `parse`: Основной метод, который обрабатывает ответ от каждого запроса. Здесь мы используем CSS-селекторы для извлечения данных.

4. Извлечение данных: В цикле for мы проходим по каждому элементу статьи и используем yield для возвращения словаря с данными.

5. Пагинация: Проверяем наличие ссылки на следующую страницу и используем response.follow() для перехода, что обеспечивает рекурсивный обход.

Как запустить паука:

Сохраните код в файл news_spider.py и выполните команду в терминале:

scrapy runspider news_spider.py -o articles.json

Это запустит паука и сохранит собранные данные в файл articles.json.

Особенности Scrapy:

- Асинхронность: Scrapy основан на асинхронной модели, что позволяет выполнять множество запросов одновременно и ускоряет процесс сбора данных.

- Легкость масштабирования: Фреймворк позволяет легко настраивать количество параллельных запросов и другие параметры производительности.

- Встроенные инструменты: Имеет мощные средства для обработки ошибок, повторных попыток, управления сессиями и кук.

- Расширяемость: Поддерживает Middleware, Pipelines и расширения, позволяющие добавлять дополнительную функциональность.

- Сообщество и документация: Обширная документация и активное сообщество упрощают решение возникающих вопросов.

Заключение

Scrapy предоставляет удобный и эффективный способ сбора данных с веб-сайтов. Его особенности, такие как асинхронность и расширяемость, делают его отличным выбором для проектов любой сложности.

Подпишись 👉🏻 @KodduuPython 🤖

Selenium — это инструмент для автоматизации веб-браузеров, широко используемый для веб-скрейпинга сайтов с динамическим контентом, генерируемым с помощью JavaScript. Он позволяет программно взаимодействовать с веб-страницами так же, как это делает пользователь: кликать по элементам, заполнять формы, прокручивать страницу и т.д.

Ниже приведен пример кода на Python, который использует Selenium для извлечения названий и цен продуктов с динамического сайта:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options

# Настройка опций браузера
chrome_options = Options()
chrome_options.add_argument('--headless')  # Режим без GUI (необязательно)

# Инициализация веб-драйвера для Chrome
driver = webdriver.Chrome(options=chrome_options)

try:
    # Открываем веб-сайт
    driver.get('https://example-ecommerce-site.com')

    # Явное ожидание загрузки элементов (например, 10 секунд)
    driver.implicitly_wait(10)

    # Находим все элементы с продуктами
    products = driver.find_elements(By.CLASS_NAME, 'product-item')

    # Извлекаем данные о каждом продукте
    for product in products:
        title = product.find_element(By.CLASS_NAME, 'product-title').text
        price = product.find_element(By.CLASS_NAME, 'product-price').text
        print(f'Название: {title}, Цена: {price}')

finally:
    # Закрываем браузер
    driver.quit()

Особенности данного примера:

1. Инициализация WebDriver: Используем webdriver.Chrome() для запуска браузера Chrome. С помощью Options можно задать дополнительные параметры, например, запуск в фоновом режиме без интерфейса (`--headless`).

2. Открытие веб-сайта: Метод get() загружает страницу по указанному URL.

3. Ожидание загрузки элементов: Используем implicitly_wait(10), чтобы подождать до 10 секунд загрузки необходимых элементов на странице.

4. Поиск элементов: Метод find_elements() находит все элементы, соответствующие заданному селектору. В данном случае ищем продукты по классу product-item.

5. Извлечение информации: Для каждого продукта находим элементы с названием и ценой по соответствующим классам и извлекаем текст с помощью .text.

6. Обработка исключений: Используем блок try...finally для гарантированного закрытия браузера, даже если в процессе возникнет ошибка.

Особенности использования Selenium для веб-скрейпинга:

- Работа с динамическим контентом: Selenium может обрабатывать страницы, контент которых загружается или обновляется с помощью JavaScript после первоначальной загрузки страницы.

- Интерактивное взаимодействие: Возможность симулировать действия пользователя — клики, ввод текста, наведение курсора и другие события.

- Ожидания: Поддержка явных (`WebDriverWait`) и неявных (`implicitly_wait`) ожиданий для синхронизации с динамическим контентом.

- Скриншоты: Возможность делать скриншоты страниц для отладки с помощью метода save_screenshot().

- Настройка браузера: Поддержка различных браузеров (Chrome, Firefox, Edge и др.) и возможность настройки параметров запуска.

Важно учитывать при использовании Selenium:

- Производительность: Запуск полноценного браузера требует больше ресурсов и времени по сравнению с библиотеками, работающими напрямую с HTTP-запросами (например, Requests).

- Правовые аспекты: Необходимо соблюдать правила использования сайтов и учитывать законодательство о защите данных. Рекомендуется проверять файл robots.txt и условия обслуживания сайта.

- Обнаружение скриптов: Сайты могут распознавать автоматизированные запросы. Для обхода этого можно настраивать заголовки запроса, использовать прокси или имитировать действия реального пользователя.

- Сложность установки: Требуется установка веб-драйверов (например, ChromeDriver для Chrome), что может добавить сложности при разворачивании на сервере или в контейнере Docker.

Подпишись 👉🏻 @KodduuPython 🤖

NumPy и Pandas в "Data Science в Python" закончен 👍👍👍

Подпишись 👉🏻 @KodduuPython 🤖

Beautiful Soup — это популярная библиотека Python для парсинга HTML и XML документов. Она позволяет легко извлекать данные из веб-страниц, работая поверх библиотек для получения страниц, таких как requests.

Ниже приведен пример кода, который извлекает заголовки статей и ссылки с главной страницы блога:

import requests
from bs4 import BeautifulSoup

# URL страницы, которую будем парсить
url = 'https://example-blog-website.com/'

# Отправляем GET-запрос к странице
response = requests.get(url)

# Проверяем статус ответа
if response.status_code == 200:
    # Создаем объект BeautifulSoup
    soup = BeautifulSoup(response.content, 'html.parser')
    
    # Находим все элементы с классом 'post'
    posts = soup.find_all('div', class_='post')
    
    # Извлекаем заголовки и ссылки
    for post in posts:
        title = post.find('h2').get_text()
        link = post.find('a')['href']
        print(f'Заголовок: {title}')
        print(f'Ссылка: {link}\n')
else:
    print('Не удалось получить страницу')

Особенности данного примера:

1. Получение страницы: Используем библиотеку requests для отправки HTTP-запроса к целевому URL. Проверяем статус ответа, чтобы убедиться в успешном получении страницы.

2. Парсинг HTML: Создаем объект BeautifulSoup, передавая в него содержимое страницы и используемый парсер (`'html.parser'`).

3. Поиск элементов: Используем метод find_all() для поиска всех div с классом 'post'. Это возвращает список элементов, соответствующих заданным критериям.

4. Извлечение данных: В цикле проходим по каждому элементу post, извлекаем заголовок статьи с помощью find('h2').get_text() и ссылку с помощью find('a')['href'].

5. Вывод результатов: Печатаем заголовки и ссылки в удобочитаемом формате.

Особенности Beautiful Soup:

- Простота использования: Интуитивно понятный синтаксис для навигации и поиска элементов в дереве HTML.

- Поддержка разных парсеров: Можно использовать разные парсеры, такие как 'html.parser', lxml или html5lib, в зависимости от потребностей и установленных библиотек.

- Обработка невалидного HTML: Beautiful Soup хорошо справляется с разбором некорректно сформированного HTML, что часто встречается на реальных веб-сайтах.

- Мощные инструменты поиска: Методы find(), find_all(), select() позволяют искать элементы по тегам, классам, идентификаторам и CSS-селекторам.

- Извлечение текста и атрибутов: Легко получать текст внутри элементов с помощью .get_text() и значения атрибутов через доступ как к словарю (`element['attribute']`).

Важно учитывать:

- Уважение к правилам сайта: Перед парсингом убедитесь, что вы имеете право собирать данные с сайта. Проверьте файл robots.txt и условия использования ресурса.

- Эффективность: Для небольших проектов или единоразового сбора данных Beautiful Soup подходит идеально. Однако для больших объемов данных или сложных сайтов стоит рассмотреть использование Scrapy.

- Обработка динамического контента: Beautiful Soup не выполняет JavaScript. Для сайтов с динамическим контентом потребуется использовать Selenium или запросы к API.

Заключение

Beautiful Soup — отличный инструмент для быстрого и простого веб-скрейпинга. Он особенно полезен, когда нужно извлечь данные из статических веб-страниц с минимальными усилиями.

Подпишись 👉🏻 @KodduuPython 🤖