Die Synthese statistischer und visueller Informationen ist eine entscheidende Fähigkeit zur Interpretation von A/B-Testergebnissen und zur Ableitung umsetzbarer Empfehlungen. Beim Überprüfen einer Übersicht von A/B-Testergebnissen sollten **p-Werte**, **Konfidenzintervalle** und visuelle Darstellungen wie **Balkendiagramme** oder **Fehlerbalken** kombiniert betrachtet werden. Zunächst sollte der `p-value` geprüft werden: Ein Wert unterhalb des festgelegten Schwellenwerts (in der Regel `0.05`) weist auf statistische Signifikanz hin, ist jedoch allein nicht ausreichend. Anschließend sollte das **Konfidenzintervall** für den geschätzten Effekt betrachtet werden – überschreitet es nicht den Wert Null, unterstützt dies das Ergebnis einer statistisch signifikanten Differenz, und der Bereich gibt Aufschluss über die mögliche Effektgröße. **Visualisierungen** ermöglichen es, Muster, Ausreißer oder Überlappungen zwischen Gruppen schnell zu erkennen und die numerischen Ergebnisse zu bestätigen oder zu hinterfragen. Durch die Integration dieser Elemente lässt sich sicher interpretieren, ob der beobachtete Unterschied bedeutsam ist und welche praktischen Maßnahmen daraus folgen sollten – wie die Einführung einer neuen Funktion, die Durchführung weiterer Tests oder die Beibehaltung des Status quo.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import pandas as pd
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_code = importlib.import_module("user_code")

    def test_recommendation_column_added(self):
        results_data = {
            "test_scenario": ["A", "B"],
            "p_value": [0.01, 0.2],
            "confidence_interval": [(0.05, 0.10), (-0.01, 0.03)],
            "mean_difference": [0.08, 0.01]
        }
        df = pd.DataFrame(results_data)
        df_out = self.user_code.interpret_ab_results(df)
        has_column = "recommendation" in df_out.columns
        correct_length = len(df_out["recommendation"]) == len(df_out)
        _dynamic_test(self,
            has_column and correct_length,
            "Adds 'recommendation' column with one entry per scenario.",
            f"Recommendation column missing or wrong length. Columns: {df_out.columns}, length: {len(df_out['recommendation']) if has_column else 'N/A'}"
        )

    def test_recommend_rollout(self):
        results_data = {
            "test_scenario": ["C"],
            "p_value": [0.01],
            "confidence_interval": [(0.01, 0.05)],
            "mean_difference": [0.03]
        }
        df = pd.DataFrame(results_data)
        df_out = self.user_code.interpret_ab_results(df)
        rec = df_out["recommendation"][0]
        _dynamic_test(self,
            "rollout" in rec.lower() and "improvement" in rec.lower(),
            "Recommends rollout when p < 0.05 and CI above zero.",
            f"Expected rollout recommendation, got: {rec}"
        )

    def test_recommend_do_not_rollout(self):
        results_data = {
            "test_scenario": ["D"],
            "p_value": [0.01],
            "confidence_interval": [(-0.08, -0.01)],
            "mean_difference": [-0.05]
        }
        df = pd.DataFrame(results_data)
        df_out = self.user_code.interpret_ab_results(df)
        rec = df_out["recommendation"][0]
        _dynamic_test(self,
            "do not rollout" in rec.lower() or ("not rollout" in rec.lower()),
            "Recommends not rolling out when p < 0.05 and CI below zero.",
            f"Expected do not rollout recommendation, got: {rec}"
        )

    def test_recommend_investigate_further(self):
        results_data = {
            "test_scenario": ["E"],
            "p_value": [0.01],
            "confidence_interval": [(-0.02, 0.03)],
            "mean_difference": [0.00]
        }
        df = pd.DataFrame(results_data)
        df_out = self.user_code.interpret_ab_results(df)
        rec = df_out["recommendation"][0]
        _dynamic_test(self,
            "investigate" in rec.lower(),
            "Recommends to investigate further when p < 0.05 and CI crosses zero.",
            f"Expected investigate further recommendation, got: {rec}"
        )

    def test_recommend_maintain(self):
        results_data = {
            "test_scenario": ["F"],
            "p_value": [0.2],
            "confidence_interval": [(-0.01, 0.03)],
            "mean_difference": [0.01]
        }
        df = pd.DataFrame(results_data)
        df_out = self.user_code.interpret_ab_results(df)
        rec = df_out["recommendation"][0]
        _dynamic_test(self,
            "maintain" in rec.lower() or "no statistically significant difference" in rec.lower(),
            "Recommends maintaining current version when p >= 0.05.",
            f"Expected maintain recommendation, got: {rec}"
        )

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: Interpreting A/B-Test-Ergebnisse

Lösung