In digital marketing, summarizing campaign performance is crucial for understanding the effectiveness of your strategies and communicating results to stakeholders. The most important metrics to include in a campaign performance summary are **total impressions**, which show how many times your ads were displayed; **average click-through rate (CTR)**, which measures the percentage of impressions that resulted in clicks and reflects audience engagement; and the **conversion rate**, which indicates the proportion of clicks that led to a desired action such as a purchase or signup. Identifying the campaign with the highest conversion rate helps you recognize what resonates best with your audience and informs future optimizations.


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 sys
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'campaign': ['Spring Sale', 'Summer Splash', 'Fall Fest', 'Winter Warmup'],
            'impressions': [10000, 15000, 8000, 12000],
            'clicks': [500, 600, 320, 480],
            'conversions': [50, 90, 40, 60]
        }
        self.df = pd.DataFrame(self.data)
        self.expected_total_impressions = 10000 + 15000 + 8000 + 12000  # 45000
        ctrs = [500/10000, 600/15000, 320/8000, 480/12000]
        self.expected_average_ctr = sum(ctrs) / 4
        conversion_rates = [50/500, 90/600, 40/320, 60/480]
        self.expected_top_campaign = self.data['campaign'][conversion_rates.index(max(conversion_rates))]

    def _run_function_and_capture(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.summarize_campaign_performance(self.df)
        output = f.getvalue().strip().split('\\n')
        return output

    def test_total_impressions(self):
        output = self._run_function_and_capture()
        _dynamic_test(
            self,
            any(str(self.expected_total_impressions) == line.strip() for line in output),
            f"Correct total impressions ({self.expected_total_impressions}) printed",
            f"Expected total impressions {self.expected_total_impressions} in output, got: {output}",
        )

    def test_average_ctr(self):
        output = self._run_function_and_capture()
        found = False
        for line in output:
            try:
                val = float(line)
                # Acceptable error threshold for float comparison
                if abs(val - self.expected_average_ctr) < 1e-6:
                    found = True
                    break
            except Exception:
                continue
        _dynamic_test(
            self,
            found,
            f"Correct average CTR ({self.expected_average_ctr}) printed",
            f"Expected average CTR {self.expected_average_ctr} in output, got: {output}",
        )

    def test_top_campaign(self):
        output = self._run_function_and_capture()
        _dynamic_test(
            self,
            any(self.expected_top_campaign == line.strip() for line in output),
            f"Correct top campaign ('{self.expected_top_campaign}') printed",
            f"Expected top campaign '{self.expected_top_campaign}' in output, got: {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: Campaign Performance Summary

Oplossing