Beim Durchführen eines A/B-Tests besteht das Ziel darin, festzustellen, ob eine neue Variante (B) sich tatsächlich von der Kontrollgruppe (A) unterscheidet, basierend auf den gesammelten Daten. Das Ergebnis kann jedoch aus zwei Hauptgründen falsch sein: Es kann ein Unterschied festgestellt werden, obwohl keiner existiert (**Fehler 1. Art**, oder "falsch positiv"), oder ein tatsächlicher Unterschied wird übersehen (**Fehler 2. Art**, oder "falsch negativ"). Um zu erkennen, welcher Fehler – falls überhaupt – aufgetreten ist, muss die reale Situation (ob tatsächlich ein Effekt vorliegt) mit dem Ergebnis des statistischen Tests (ob ein signifikanter Effekt festgestellt wurde) verglichen werden.

Wird ein signifikantes Ergebnis festgestellt, obwohl kein realer Effekt existiert, liegt ein **Fehler 1. Art** vor. Wird kein signifikanter Effekt festgestellt, obwohl ein realer Effekt existiert, liegt ein **Fehler 2. Art** vor. Entspricht das Testergebnis der Realität (entweder durch korrektes Erkennen eines Effekts oder durch korrektes Feststellen, dass kein Effekt vorliegt), wurde eine **korrekte Entscheidung** getroffen. Das Verständnis dieser Szenarien ist entscheidend, um die praktischen Auswirkungen der Tests zu interpretieren und fundierte geschäftliche Entscheidungen auf Basis der Ergebnisse zu treffen.


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

Beherrschen Sie die Kunst und Wissenschaft des A/B-Testings mit Python. Dieser Kurs behandelt die statistischen Grundlagen, das Design von Experimenten und die praktische Umsetzung von A/B-Tests, mit einem starken Fokus auf praxisnahe Übungen und reale Szenarien. Lernen Sie, Ergebnisse zu analysieren, häufige Fehler zu vermeiden und Erkenntnisse effektiv zu kommunizieren.

Erkunden Sie die Grundlagen des A/B-Testings – von zentraler Terminologie und der wissenschaftlichen Methode bis hin zu praxisnahen Workflows, die in Technologie und Marketing eingesetzt werden. Dieser Abschnitt bietet eine umfassende Grundlage, einschließlich des historischen Kontexts, der Begründung für Experimente und des wesentlichen Vokabulars, das für eine effektive Kommunikation in datengetriebenen Umgebungen erforderlich ist.

Beherrschen Sie die Fähigkeiten, die für die Gestaltung robuster A/B-Tests erforderlich sind: von der Hypothesenformulierung und Randomisierung bis zur Berechnung der Stichprobengröße und Auswahl der Metriken. Dieser Abschnitt behandelt die Erstellung von Hypothesen, Randomisierung, Bestimmung der Stichprobengröße und Auswahl der Metriken im Detail, mit praxisnahen Beispielen und praktischen Übungen.

Tauchen Sie ein in die statistischen Konzepte, die A/B-Tests zugrunde liegen, einschließlich Signifikanz, p-Werten, Fehlertypen und Konfidenzintervallen. Dieser Abschnitt bietet ausführliche Erklärungen, praxisnahe Codebeispiele und praktische Übungen, um Ihr Verständnis zu festigen.

Tauchen Sie ein in die Grundlagen der praktischen A/B-Test-Analyse – simulieren Sie Daten, interpretieren Sie Ergebnisse, erstellen Sie überzeugende Visualisierungen und kommunizieren Sie Erkenntnisse an Stakeholder. Erlernen Sie die effektive Kommunikation von Ergebnissen, die Erstellung überzeugender Visualisierungen und das Vermeiden häufiger Fehler bei der Interpretation.

Challenge: Identifikation von Fehlertypen

Lösung