Simulating A/B tests is a practical way to understand how different variants perform in growth experiments. By writing a Python function that models an A/B test, you can quickly analyze which version leads to better user conversion. This approach is essential for making data-driven decisions in growth hacking, as it helps you evaluate experiment outcomes with clear, reproducible calculations.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_conversion_rates_and_comparison(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.ab_test_simulator(1000, 120, 980, 150)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "group a: 120/1000 converted (12.00%)" in output,
            "Correct conversion rate for Group A displayed.",
            f"Expected conversion rate for Group A not found. Output: {output}"
        )
        _dynamic_test(
            self,
            "group b: 150/980 converted (15.31%)" in output,
            "Correct conversion rate for Group B displayed.",
            f"Expected conversion rate for Group B not found. Output: {output}"
        )
        _dynamic_test(
            self,
            "group b performed better." in output,
            "Correct group comparison output (Group B better).",
            f"Expected 'Group B performed better.' not found. Output: {output}"
        )

    def test_group_a_better(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.ab_test_simulator(100, 30, 200, 20)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "group a performed better." in output,
            "Correct group comparison output (Group A better).",
            f"Expected 'Group A performed better.' not found. Output: {output}"
        )

    def test_groups_equal(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.ab_test_simulator(100, 20, 200, 40)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "both groups performed equally." in output,
            "Correct output when both groups are equal.",
            f"Expected 'Both groups performed equally.' not found. Output: {output}"
        )

    def test_zero_users(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.ab_test_simulator(0, 0, 100, 10)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "group a: 0/0 converted (0.00%)" in output,
            "Correctly handles zero users in Group A.",
            f"Expected output for zero users in Group A not found. Output: {output}"
        )
        _dynamic_test(
            self,
            "group b: 10/100 converted (10.00%)" in output,
            "Correctly calculates Group B conversion rate.",
            f"Expected output for Group B not found. Output: {output}"
        )
        _dynamic_test(
            self,
            "group b performed better." in output,
            "Correct group comparison when Group A has zero users.",
            f"Expected 'Group B performed better.' not found. Output: {output}"
        )

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

Unlock the power of Python to automate, analyze, and optimize growth strategies. This course is designed for growth hackers who want to leverage Python for data-driven marketing, user acquisition, and rapid experimentation. Learn to automate repetitive tasks, analyze user behavior, and extract actionable insights—all without prior data science experience.

Learn how to use Python to automate repetitive growth hacking tasks, from data cleaning to campaign reporting.

Use Python to analyze user engagement, retention, and behavior patterns to inform growth strategies.

Apply Python to design, analyze, and optimize growth experiments such as A/B tests and campaign performance evaluations.

Challenge: A/B Test Simulator

Solution