Beim A/B-Testing ist es entscheidend, Benutzer auf Kontroll- und Varianten-Gruppen ausgewogen und unbeeinflusst zuzuweisen, um verlässliche Ergebnisse zu erzielen. Wenn sich die Gruppen systematisch in Nutzermerkmalen wie Alter, Standort oder Verhalten unterscheiden, könnte jeder beobachtete Effekt auf diese Unterschiede und nicht auf die getestete Änderung zurückzuführen sein. **Randomisierung** stellt sicher, dass jeder Benutzer die gleiche Chance hat, einer beliebigen Gruppe zugeordnet zu werden, wodurch Verzerrungen minimiert und vergleichbare Gruppen geschaffen werden.

Um die Ausgewogenheit zu überprüfen, können die Verteilungen der Nutzermerkmale zwischen den Gruppen nach der Zuweisung verglichen werden. Idealerweise sollten beide Gruppen ähnliche Mittelwerte und Anteile bei wichtigen Variablen aufweisen. Falls keine Ausgewogenheit besteht, kann dies auf einen Fehler im Randomisierungsprozess oder auf das Vorhandensein von Störvariablen hinweisen. Sorgfältige Zuweisung und Überprüfung der Ausgewogenheit gewährleisten die Validität der A/B-Test-Ergebnisse.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import pandas as pd
import numpy as np
import importlib
import sys

class TestTask(unittest.TestCase):
    def setUp(self):
        self.users = pd.DataFrame({
            'user_id': [101, 102, 103, 104, 105, 106, 107, 108],
            'age': [23, 45, 31, 29, 40, 22, 30, 27],
            'location': ['NY', 'CA', 'TX', 'NY', 'CA', 'TX', 'NY', 'CA']
        })

    def test_group_column_exists_and_valid(self):
        import user_code
        importlib.reload(user_code)
        df = user_code.assign_groups(self.users)
        _dynamic_test(
            self,
            'group' in df.columns,
            "Returned DataFrame includes a 'group' column.",
            "Returned DataFrame does not have a 'group' column."
        )
        valid = set(df['group'].unique()) <= {'control', 'variant'}
        _dynamic_test(
            self,
            valid,
            "All group assignments are either 'control' or 'variant'.",
            f"Group assignments must be only 'control' or 'variant', got: {set(df['group'].unique())}"
        )

    def test_each_user_one_group(self):
        import user_code
        importlib.reload(user_code)
        df = user_code.assign_groups(self.users)
        counts = df.groupby('user_id')['group'].nunique().values
        _dynamic_test(
            self,
            all(c == 1 for c in counts),
            "Each user is assigned to exactly one group.",
            f"Some users assigned to multiple groups: group counts: {counts}"
        )

    def test_assignment_is_random_and_balanced(self):
        import user_code
        # Run multiple times to check for randomness
        group_counts = []
        for _ in range(20):
            importlib.reload(user_code)
            df = user_code.assign_groups(self.users)
            counts = df['group'].value_counts()
            group_counts.append(counts)
        # Check that both groups appear in all runs
        for counts in group_counts:
            _dynamic_test(
                self,
                'control' in counts and 'variant' in counts,
                "Both groups are assigned in each run.",
                f"One of the groups is missing in assignment: {counts.to_dict()}"
            )
        # Check that distribution is approximately even
        diffs = [abs(counts.get('control',0) - counts.get('variant',0)) for counts in group_counts]
        _dynamic_test(
            self,
            all(d <= 4 for d in diffs),
            "Assignment is approximately balanced for 8 users.",
            f"Assignment is not balanced enough: diffs={diffs}"
        )

    def test_original_dataframe_not_modified(self):
        import user_code
        importlib.reload(user_code)
        orig = self.users.copy()
        _ = user_code.assign_groups(self.users)
        _dynamic_test(
            self,
            self.users.equals(orig),
            "Original DataFrame is not modified.",
            "Original DataFrame was changed after function call."
        )

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: Zuweisung von Nutzern zu Gruppen

Lösung