Summary  
This chapter explains how to perform independent and paired t-tests in Python using SciPy, including checking assumptions (normality, equal variances) and interpreting t-statistics and p-values to assess whether two group means differ significantly.

General domain of usage  
Clinical research

**Video: A Practical Guide to t-tests in Python**

This video walks you through the essentials of t-tests, focusing on both independent and paired t-tests. You will learn when to use each test, the assumptions underlying them (such as normality and variance equality), and how to interpret the results. The guide highlights practical examples and demonstrates how these tests help you determine whether two groups differ significantly in their means.

When you want to determine if two groups differ significantly in their means, t-tests are a fundamental tool. There are two primary types of t-tests: the **independent t-test** (also known as the two-sample t-test) and the **paired t-test**. 

The **independent t-test** is used when you are comparing the means of two unrelated groups, such as test scores from students in two different classes. The **paired t-test** is used when the two groups are related or matched in some way, such as measurements taken from the same individuals before and after an intervention.

Before performing a t-test, you should check several assumptions:
- The data should be approximately normally distributed in each group;
- The data should be measured at the interval or ratio level;
- For the independent t-test, the variances of the two groups should be equal (homogeneity of variance).

In Python, you can use functions from the `scipy.stats` module to perform these tests. The `ttest_ind` function performs the independent t-test, and `ttest_rel` is used for the paired t-test. When interpreting the results, pay close attention to the **p-value**: if it is less than your chosen significance level (commonly 0.05), you can conclude that there is a statistically significant difference between the group means.

A low p-value suggests that the observed difference is unlikely to have occurred by random chance, while a high p-value indicates insufficient evidence to claim a difference.

import numpy as np
from scipy.stats import ttest_ind, ttest_rel

# Independent t-test example
group_a = np.array([23, 21, 19, 24, 20])
group_b = np.array([30, 29, 33, 35, 31])
t_stat_ind, p_value_ind = ttest_ind(group_a, group_b, equal_var=True)
print("Independent t-test statistic:", t_stat_ind)
print("Independent t-test p-value:", p_value_ind)

# Paired t-test example
before = np.array([5.1, 5.5, 6.0, 5.8, 5.3])
after = np.array([5.7, 6.0, 6.5, 6.2, 5.9])
t_stat_rel, p_value_rel = ttest_rel(before, after)
print("Paired t-test statistic:", t_stat_rel)
print("Paired t-test p-value:", p_value_rel)

import unittest
import ast
import re
import io
import sys
import numpy as np
from scipy.stats import ttest_ind, ttest_rel

class TestTask(unittest.TestCase):
    def test_independent_ttest_default(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        ns = {}
        try:
            exec(code, ns)
            p_val_ind = ns.get('p_val_ind')
            
            data1 = np.array([12, 15, 14, 10, 13])
            data2 = np.array([18, 17, 16, 20, 19])
            _, expected = ttest_ind(data1, data2)
            
            is_correct = p_val_ind is not None and abs(float(p_val_ind) - expected) < 1e-5
        except Exception:
            is_correct = False
            p_val_ind = None
            
        _dynamic_test(
            self,
            is_correct,
            "Correct p-value calculated for independent t-test.",
            f"Expected p-value close to 0.001603, got {p_val_ind}. Ensure you used ttest_ind for data_a and data_b.",
        )

    def test_paired_ttest_default(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        ns = {}
        try:
            exec(code, ns)
            p_val_paired = ns.get('p_val_paired')
            
            data_before = np.array([8.2, 7.9, 8.5, 8.0, 8.3])
            data_after = np.array([8.7, 8.4, 8.9, 8.5, 8.8])
            _, expected = ttest_rel(data_before, data_after)
            
            is_correct = p_val_paired is not None and abs(float(p_val_paired) - expected) < 1e-5
        except Exception:
            is_correct = False
            p_val_paired = None
            
        _dynamic_test(
            self,
            is_correct,
            "Correct p-value calculated for paired t-test.",
            f"Expected p-value close to 0.0000178, got {p_val_paired}. Ensure you used ttest_rel for data_before and data_after.",
        )

    def test_dynamic_values(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        # Підміна масивів для перевірки динамічності
        code = change_var(code, 'data_a', 'np.array([10, 20, 30])')
        code = change_var(code, 'data_b', 'np.array([15, 25, 35])')
        code = change_var(code, 'data_before', 'np.array([1, 2, 3])')
        code = change_var(code, 'data_after', 'np.array([2, 3, 4])')
        
        ns = {}
        try:
            exec(code, ns)
            p_val_ind = ns.get('p_val_ind')
            p_val_paired = ns.get('p_val_paired')
            
            _, exp_ind = ttest_ind([10, 20, 30], [15, 25, 35])
            _, exp_paired = ttest_rel([1, 2, 3], [2, 3, 4])
            
            is_correct = (p_val_ind is not None and abs(float(p_val_ind) - exp_ind) < 1e-5 and
                          p_val_paired is not None and abs(float(p_val_paired) - exp_paired) < 1e-5)
        except Exception:
            is_correct = False
            
        _dynamic_test(
            self,
            is_correct,
            "T-tests compute dynamically based on the input arrays.",
            "Failed to evaluate dynamically. Ensure you are passing the variables directly into the functions.",
        )

    def test_printed_output(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        f_io = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f_io
        try:
            exec(code, {})
        except Exception:
            pass
        finally:
            sys.stdout = sys_stdout
            
        output = f_io.getvalue()
        
        found = '0.00160' in output and '1.78' in output and 'e-05' in output
        
        _dynamic_test(
            self,
            found,
            "Both p-values are printed successfully.",
            "The results were not printed properly. Make sure the print statements remain intact.",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def gsub_spaces(text):
    text = re.sub(r"\s+", "", text)
    text = text.replace("'", "")
    text = text.replace('"', "")
    return text

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]
    if not assign_nodes:
        return code
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True
        
    return chr(10).join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()

test_main.py

This course provides a comprehensive introduction to statistical methods using Python. You will learn how to apply core statistical concepts, perform hypothesis testing, analyze data distributions, and interpret results using Python's scientific libraries. The course emphasizes practical application through real-world examples and hands-on exercises.

A comprehensive section covering the core concepts and practical applications of statistical methods using Python.

Comparing Two Groups: t-tests

Oplossing