As you have seen in earlier chapters, analyzing marketing campaigns is fundamental for understanding which strategies drive growth and customer engagement. Dashboards play a crucial role in this process by providing a clear, concise view of key metrics, allowing you to make informed decisions quickly. By automating the collection and analysis of campaign data, you gain the ability to spot trends, compare performance, and allocate resources more effectively. This chapter challenges you to put these concepts into practice by building a simple Python dashboard that summarizes campaign performance and highlights actionable insights.


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 setUp(self):
        # Always reload user_code before each test
        import sys
        if "user_code" in sys.modules:
            del sys.modules["user_code"]

    def test_conversion_rate_calculation(self):
        import user_code
        import pandas as pd
        # Reconstruct the DataFrame for testing
        data = {
            "campaign": ["Spring Launch", "Summer Sale", "Holiday Promo", "Referral Boost"],
            "impressions": [10000, 8000, 15000, 5000],
            "clicks": [500, 400, 900, 300],
            "conversions": [50, 32, 110, 25],
        }
        expected_rates = [0.005, 0.004, 0.007333333333333334, 0.005]
        df = pd.DataFrame(data)
        df["conversion_rate"] = df["conversions"] / df["impressions"]
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue()
        # Check that each conversion rate appears in the output in percent format
        for rate in expected_rates:
            percent_str = f"{rate:.2%}"
            _dynamic_test(
                self,
                percent_str in output,
                f"Conversion rate {percent_str} appears in output",
                f"Expected conversion rate {percent_str} not found in output: {output}",
            )

    def test_best_performing_campaign_identified(self):
        import user_code
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue()
        # The best campaign is Holiday Promo (0.007333...)
        expected_name = "Holiday Promo"
        expected_rate = 0.007333333333333334
        expected_line = f"Best-Performing Campaign: {expected_name} ({expected_rate:.2%} conversion rate)"
        _dynamic_test(
            self,
            expected_line in output,
            f"Best-performing campaign '{expected_name}' with {expected_rate:.2%} is indicated in output",
            f"Expected best-performing campaign line not found: {expected_line} in output: {output}",
        )

    def test_dashboard_includes_all_metrics(self):
        import user_code
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue()
        campaigns = ["Spring Launch", "Summer Sale", "Holiday Promo", "Referral Boost"]
        impressions = ["10000", "8000", "15000", "5000"]
        clicks = ["500", "400", "900", "300"]
        conversions = ["50", "32", "110", "25"]
        for c, i, cl, co in zip(campaigns, impressions, clicks, conversions):
            _dynamic_test(
                self,
                c in output and i in output and cl in output and co in output,
                f"Dashboard output includes metrics for campaign {c}",
                f"Dashboard missing metrics for campaign {c}: impressions={i}, clicks={cl}, conversions={co}",
            )

    def test_dashboard_format_and_header(self):
        import user_code
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue()
        header = "Campaign Performance Dashboard"
        divider = "-" * 35
        _dynamic_test(
            self,
            header in output and divider in output,
            "Dashboard includes header and divider",
            f"Dashboard missing header or divider: {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

A practical Python course tailored for startup founders, focusing on leveraging Python to solve real-world business problems, automate tasks, analyze data, and make data-driven decisions. Each section is packed with engaging theory and hands-on challenges inspired by startup scenarios.

Learn how Python can automate and streamline everyday startup operations, from handling customer data to tracking growth metrics.

Harness the power of Python for data analysis and visualization to make informed decisions that drive startup growth.

Apply Python to solve growth, marketing, and customer insight challenges faced by startup founders.

Challenge: Campaign Performance Dashboard

Soluzione