Identifying high-performing audience segments is crucial for optimizing your digital marketing campaigns. By focusing on the segments that yield the highest conversion rates, you can allocate resources more efficiently and maximize campaign ROI. Analyzing segment performance also helps you understand audience behaviors and refine your targeting strategies for future campaigns.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout
import pandas as pd

class TestTask(unittest.TestCase):
    def test_top_segment_and_average(self):
        import user_code
        importlib.reload(user_code)
        data = {
            'segment': ['A', 'B', 'C', 'D'],
            'conversion_rate': [0.12, 0.18, 0.09, 0.15]
        }
        df = pd.DataFrame(data)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_segments(df)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            'top segment: b with conversion rate 0.18' in output,
            "Correct top segment and conversion rate printed for standard data.",
            f"Output does not include correct top segment: {output}",
        )
        _dynamic_test(
            self,
            'average conversion rate: 0.135' in output,
            "Correct average conversion rate printed for standard data.",
            f"Output does not include correct average conversion rate: {output}",
        )

    def test_different_number_of_segments(self):
        import user_code
        importlib.reload(user_code)
        data = {
            'segment': ['X', 'Y'],
            'conversion_rate': [0.5, 0.7]
        }
        df = pd.DataFrame(data)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_segments(df)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            'top segment: y with conversion rate 0.7' in output,
            "Correct top segment and conversion rate printed for two segments.",
            f"Output does not include correct top segment for two segments: {output}",
        )
        _dynamic_test(
            self,
            'average conversion rate: 0.6' in output,
            "Correct average conversion rate printed for two segments.",
            f"Output does not include correct average conversion rate for two segments: {output}",
        )

    def test_negative_and_zero_conversion_rates(self):
        import user_code
        importlib.reload(user_code)
        data = {
            'segment': ['A', 'B', 'C'],
            'conversion_rate': [0.0, -0.1, 0.05]
        }
        df = pd.DataFrame(data)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_segments(df)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            'top segment: c with conversion rate 0.05' in output,
            "Correct top segment and conversion rate printed with zero/negative rates.",
            f"Output does not include correct top segment for negative/zero rates: {output}",
        )
        _dynamic_test(
            self,
            'average conversion rate: -0.016666' in output or 'average conversion rate: -0.01667' in output or 'average conversion rate: -0.0167' in output,
            "Correct average conversion rate printed with zero/negative rates.",
            f"Output does not include correct average conversion rate for negative/zero rates: {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

Learn how to leverage Python to solve real-world problems faced by digital agencies. This course covers automation, data analysis, and reporting techniques tailored for marketing, content, and analytics teams. Through engaging theory and hands-on challenges, you'll gain practical skills to streamline workflows, analyze campaign data, and generate actionable insights.

Discover how Python can automate repetitive tasks in digital agencies, from campaign scheduling to content management and client communication.

Learn how to use Python for analyzing campaign data, extracting insights, and making data-driven decisions in digital agencies.

Master the art of generating clear, insightful reports and visualizations for clients using Python.

Challenge: Segment Analysis

Oplossing