När du genomför ett A/B-test är målet att avgöra om en ny variant (B) verkligen skiljer sig från kontrollen (A) baserat på den insamlade datan. Din slutsats kan dock vara felaktig av två huvudsakliga skäl: du kan upptäcka en skillnad när det inte finns någon (**typ I-fel**, eller "falskt positivt"), eller så kan du missa en verklig skillnad (**typ II-fel**, eller "falskt negativt"). För att identifiera vilket fel – om något – som har inträffat, måste du jämföra den verkliga sanningen (om en verklig effekt finns) med resultatet av ditt statistiska test (om du har påvisat en signifikant effekt).

Om ditt test visar ett signifikant resultat när ingen verklig effekt finns, har du gjort ett **typ I-fel**. Om ditt test inte hittar ett signifikant resultat när en verklig effekt faktiskt finns, har du gjort ett **typ II-fel**. Om din slutsats stämmer överens med verkligheten (antingen genom att korrekt upptäcka en verklig effekt eller korrekt dra slutsatsen att ingen finns), har du gjort ett **korrekt beslut**. Att förstå dessa scenarier är avgörande för att tolka de praktiska konsekvenserna av dina tester och för att fatta välgrundade affärsbeslut baserat på dina resultat.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_correct_decision_true_effect_significant(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.classify_ab_test_outcome(True, True)
        _dynamic_test(
            self,
            result == "Correct Decision",
            'Returns "Correct Decision" for (True, True)',
            f'Expected "Correct Decision" for (True, True), got {result}'
        )

    def test_correct_decision_no_effect_not_significant(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.classify_ab_test_outcome(False, False)
        _dynamic_test(
            self,
            result == "Correct Decision",
            'Returns "Correct Decision" for (False, False)',
            f'Expected "Correct Decision" for (False, False), got {result}'
        )

    def test_type_i_error(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.classify_ab_test_outcome(False, True)
        _dynamic_test(
            self,
            result == "Type I Error",
            'Returns "Type I Error" for (False, True)',
            f'Expected "Type I Error" for (False, True), got {result}'
        )

    def test_type_ii_error(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.classify_ab_test_outcome(True, False)
        _dynamic_test(
            self,
            result == "Type II Error",
            'Returns "Type II Error" for (True, False)',
            f'Expected "Type II Error" for (True, False), got {result}'
        )

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 normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    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 nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    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 '\\n'.join(lines) if changed else code

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


test_main.py

Behärska konsten och vetenskapen bakom A/B-testning med Python. Denna kurs täcker de statistiska grunderna, experimentdesign och praktisk implementering av A/B-tester, med stark tonvikt på praktiska övningar och verkliga scenarier. Lär dig att analysera resultat, undvika vanliga fallgropar och kommunicera fynd på ett effektivt sätt.

Utforska grunderna i A/B-testning – från grundläggande terminologi och den vetenskapliga metoden till praktiska arbetsflöden som används inom teknik och marknadsföring. Detta avsnitt ger en omfattande grund, inklusive historisk kontext, motiven bakom experimentering och den viktiga vokabulär som krävs för effektiv kommunikation i datadrivna miljöer.

Behärska de färdigheter som krävs för att utforma robusta A/B-tester: från hypotesformulering och randomisering till beräkning av stickprovsstorlek och val av mätvärden. Denna sektion täcker hypotesformulering, randomisering, bestämning av stickprovsstorlek och val av mätvärden i detalj, med praktiska exempel och övningar.

Fördjupa dig i de statistiska koncept som ligger till grund för A/B-testning, inklusive signifikans, p-värden, feltyper och konfidensintervall. Denna sektion erbjuder detaljerade förklaringar, praktiska kodexempel och interaktiva övningar för att stärka din förståelse.

Fördjupa dig i grunderna för praktisk A/B-testanalys – simulera data, tolka resultat, skapa övertygande visualiseringar och kommunicera resultat till intressenter. Lär dig att effektivt kommunicera resultat, skapa övertygande visualiseringar och undvika vanliga fallgropar vid tolkning.

Challenge: Identifiering av Feltyp

Lösning