Quickly identifying the winning variant in an A/B test is crucial for maximizing marketing performance and minimizing wasted spend. By automating the winner selection process, you can rapidly respond to changes in customer behavior and ensure that your campaigns are always optimized for the best results. This approach removes guesswork, allowing you to focus resources on what works and improve your marketing ROI.


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

class TestTask(unittest.TestCase):
    def test_correct_winner_and_rate(self):
        importlib.reload(user_code)
        data = {
            "variant": ["A", "B", "C"],
            "visitors": [1000, 950, 980],
            "conversions": [120, 150, 110]
        }
        df = pd.DataFrame(data)
        result = user_code.select_ab_test_winner(df)
        expected_variant = "B"
        expected_rate = 150 / 950
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and result[0] == expected_variant and abs(result[1] - expected_rate) < 1e-8,
            f"Correctly returns winner 'B' and conversion rate {expected_rate}",
            f"Expected ('B', {expected_rate}), got {result}"
        )

    def test_accurate_conversion_rates(self):
        importlib.reload(user_code)
        data = {
            "variant": ["X", "Y"],
            "visitors": [500, 200],
            "conversions": [100, 80]
        }
        df = pd.DataFrame(data)
        result = user_code.select_ab_test_winner(df)
        expected_variant = "Y"
        expected_rate = 80 / 200
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and result[0] == expected_variant and abs(result[1] - expected_rate) < 1e-8,
            f"Correctly calculates conversion rates and selects 'Y'",
            f"Expected ('Y', {expected_rate}), got {result}"
        )

    def test_returns_tuple(self):
        importlib.reload(user_code)
        data = {
            "variant": ["X"],
            "visitors": [10],
            "conversions": [2]
        }
        df = pd.DataFrame(data)
        result = user_code.select_ab_test_winner(df)
        _dynamic_test(
            self,
            isinstance(result, tuple) and len(result) == 2,
            "Function returns a tuple with two elements",
            f"Expected tuple of length 2, got {result}"
        )

    def test_tied_conversion_rates_returns_first(self):
        importlib.reload(user_code)
        data = {
            "variant": ["A", "B", "C"],
            "visitors": [100, 200, 300],
            "conversions": [50, 100, 150]  # All conversion rates = 0.5
        }
        df = pd.DataFrame(data)
        result = user_code.select_ab_test_winner(df)
        expected_variant = "A"
        expected_rate = 0.5
        _dynamic_test(
            self,
            result is not None and isinstance(result, tuple) and result[0] == expected_variant and abs(result[1] - expected_rate) < 1e-8,
            "Returns first variant in case of tied conversion rates",
            f"Expected ('A', {expected_rate}), 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

Unlock the power of Python to solve real-world marketing problems. This course guides marketers through practical Python applications, from analyzing campaign data to visualizing trends and automating repetitive tasks. Each section blends engaging theory with hands-on challenges tailored to marketing scenarios.

Learn to harness Python for analyzing marketing data, uncovering trends, and making data-driven decisions.

Explore how Python can automate repetitive marketing tasks, saving time and reducing errors.

Delve into advanced analytics techniques to uncover deeper insights and optimize marketing strategies.

Challenge: Automate A/B Test Winner Selection

Oplossing

Challenge: Automate A/B Test Winner Selection

Oplossing