Clear visual comparisons are essential when presenting campaign results to clients. Being able to quickly and effectively illustrate the differences between two campaigns helps clients understand which strategies are performing better and where improvements can be made. Side-by-side bar charts are especially useful for this purpose, allowing you to highlight key metrics such as **impressions**, **clicks**, and **conversions** in an easy-to-interpret format. This approach ensures that your insights are both memorable and actionable during client meetings.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import user_code

class TestTask(unittest.TestCase):
    def setUp(self):
        importlib.reload(user_code)

    def test_bar_chart_created(self):
        # Clear all figures
        plt.close('all')
        # Capture number of figures before
        figs_before = len(plt.get_fignums())
        importlib.reload(user_code)
        figs_after = len(plt.get_fignums())
        _dynamic_test(
            self,
            figs_after > figs_before,
            "A bar chart is created and displayed.",
            "No bar chart was created or displayed."
        )

    def test_axes_labels_and_title(self):
        plt.close('all')
        importlib.reload(user_code)
        fig = plt.gcf()
        ax = fig.axes[0]
        xlabel = ax.get_xlabel()
        ylabel = ax.get_ylabel()
        title = ax.get_title()
        _dynamic_test(
            self,
            normalize_text(xlabel) == 'metrics',
            "x-axis is labeled 'Metrics' correctly.",
            f"Expected x-axis label 'Metrics', got '{xlabel}'."
        )
        _dynamic_test(
            self,
            normalize_text(ylabel) == 'count',
            "y-axis is labeled 'Count' correctly.",
            f"Expected y-axis label 'Count', got '{ylabel}'."
        )
        _dynamic_test(
            self,
            'impressions' in normalize_text(title) and 'clicks' in normalize_text(title) and 'conversions' in normalize_text(title),
            "Chart title describes all metrics.",
            f"Expected chart title to mention all metrics, got '{title}'."
        )

    def test_xtick_labels(self):
        plt.close('all')
        importlib.reload(user_code)
        fig = plt.gcf()
        ax = fig.axes[0]
        xtick_labels = [lbl.get_text() for lbl in ax.get_xticklabels()]
        expected_labels = ['Impressions', 'Clicks', 'Conversions']
        _dynamic_test(
            self,
            all(label in xtick_labels for label in expected_labels),
            "x-axis shows all metric names correctly.",
            f"Expected x-axis labels {expected_labels}, got {xtick_labels}."
        )

    def test_legend_present(self):
        plt.close('all')
        importlib.reload(user_code)
        fig = plt.gcf()
        ax = fig.axes[0]
        legend = ax.get_legend()
        _dynamic_test(
            self,
            legend is not None,
            "Legend is present on the chart.",
            "No legend found on the chart."
        )
        legend_texts = [t.get_text() for t in legend.get_texts()]
        expected_legend = ['Campaign A', 'Campaign B']
        _dynamic_test(
            self,
            all(lbl in legend_texts for lbl in expected_legend),
            "Legend correctly identifies both campaigns.",
            f"Expected legend labels {expected_legend}, got {legend_texts}."
        )

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 Comparison Visualizer

解答