Dans les tests A/B, il est essentiel d’assigner les utilisateurs aux groupes témoin et variante de manière équilibrée et impartiale pour obtenir des résultats fiables. Si les groupes diffèrent systématiquement selon les caractéristiques des utilisateurs — telles que l’âge, la localisation ou le comportement — tout effet observé pourrait être dû à ces différences plutôt qu’au changement testé. **La randomisation** permet de garantir que chaque utilisateur a une chance égale d’être assigné à n’importe quel groupe, ce qui minimise les biais et aide à créer des groupes comparables.

Pour vérifier l’équilibre, il est possible de comparer les distributions des caractéristiques des utilisateurs entre les groupes après l’assignation. Idéalement, les deux groupes devraient présenter des moyennes et des proportions similaires pour les variables importantes. Si ce n’est pas le cas, cela peut indiquer une faille dans le processus de randomisation ou la présence de variables confondantes. Une assignation rigoureuse et une vérification de l’équilibre contribuent à assurer la validité des conclusions de votre test A/B.


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

Maîtrisez l'art et la science des tests A/B avec Python. Ce cours couvre les bases statistiques, la conception d'expériences et la mise en œuvre pratique des tests A/B, avec un fort accent sur la pratique et des scénarios réels. Apprenez à analyser les résultats, à éviter les pièges courants et à communiquer efficacement les conclusions.

Explorez les éléments essentiels des tests A/B — de la terminologie de base et de la méthode scientifique aux flux de travail pratiques utilisés dans la technologie et le marketing. Cette section offre une base complète, incluant le contexte historique, la justification de l'expérimentation et le vocabulaire essentiel nécessaire pour une communication efficace dans des environnements axés sur les données.

Maîtrisez les compétences nécessaires pour concevoir des tests A/B robustes : de la formulation d'hypothèses et la randomisation au calcul de la taille de l'échantillon et à la sélection des métriques. Cette section couvre en détail la création d'hypothèses, la randomisation, la détermination de la taille de l'échantillon et la sélection des métriques, avec des exemples pratiques et des exercices interactifs.

Plongez dans les concepts statistiques qui sous-tendent les tests A/B, y compris la signification, les valeurs p, les types d'erreurs et les intervalles de confiance. Cette section propose des explications détaillées, des exemples de code pratiques et des exercices interactifs pour consolider votre compréhension.

Plongez dans les fondamentaux de l'analyse pratique des tests A/B — simulez des données, interprétez les résultats, créez des visualisations percutantes et communiquez les conclusions aux parties prenantes. Apprenez à communiquer efficacement les résultats, à créer des visualisations convaincantes et à éviter les pièges courants lors de l'interprétation.

Défi : Assigner les utilisateurs aux groupes

Solution