Bij het uitvoeren van een A/B-test is het doel om te bepalen of een nieuwe variant (B) daadwerkelijk verschilt van de controle (A) op basis van de verzamelde gegevens. De conclusie kan echter om twee hoofdredenen onjuist zijn: er kan een verschil worden vastgesteld terwijl dat er niet is (**Type I-fout**, of "vals positief"), of een daadwerkelijk verschil kan worden gemist (**Type II-fout**, of "vals negatief"). Om te bepalen welk type fout - indien van toepassing - is opgetreden, moet de werkelijkheid (of er daadwerkelijk een effect bestaat) worden vergeleken met de uitkomst van de statistische test (of er een significant effect is vastgesteld).

Als de test een significant resultaat oplevert terwijl er geen echt effect bestaat, is er sprake van een **Type I-fout**. Als de test er niet in slaagt een significant resultaat te vinden terwijl er wel een echt effect bestaat, is er sprake van een **Type II-fout**. Als de conclusie overeenkomt met de werkelijkheid (het correct detecteren van een echt effect of het correct concluderen dat er geen effect is), is er sprake van een **juiste beslissing**. Inzicht in deze scenario's is essentieel voor het interpreteren van de praktische implicaties van de tests en voor het nemen van onderbouwde zakelijke beslissingen op basis van de bevindingen.


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

Beheers de kunst en wetenschap van A/B-testen met Python. Deze cursus behandelt de statistische basisprincipes, het ontwerpen van experimenten en de praktische uitvoering van A/B-tests, met een sterke nadruk op praktische oefeningen en realistische scenario's. Leer resultaten analyseren, veelvoorkomende valkuilen vermijden en bevindingen effectief communiceren.

Ontdek de essentie van A/B-testen — van kernterminologie en de wetenschappelijke methode tot praktische workflows die worden gebruikt in technologie en marketing. Deze sectie biedt een uitgebreide basis, inclusief de historische context, de achterliggende redenen voor experimentatie en de essentiële woordenschat die nodig is voor effectieve communicatie in data-gedreven omgevingen.

Beheers de vaardigheden die nodig zijn om robuuste A/B-tests te ontwerpen: van het formuleren van hypothesen en randomisatie tot het berekenen van de steekproefgrootte en het selecteren van metrics. Deze sectie behandelt het opstellen van hypothesen, randomisatie, het bepalen van de steekproefgrootte en het selecteren van metrics in detail, met praktische voorbeelden en hands-on oefeningen.

Duik in de statistische concepten die ten grondslag liggen aan A/B-testen, waaronder significantie, p-waarden, fouttypes en betrouwbaarheidsintervallen. Deze sectie biedt gedetailleerde uitleg, praktische codevoorbeelden en hands-on oefeningen om je begrip te versterken.

Duik in de basisprincipes van praktische A/B-testanalyse — simuleer gegevens, interpreteer resultaten, maak overtuigende visualisaties en communiceer bevindingen aan belanghebbenden. Leer bevindingen effectief te communiceren, overtuigende visualisaties te maken en veelvoorkomende valkuilen bij interpretatie te vermijden.

Challenge: Identificatie van Fouttypen

Oplossing