Visualizing your marketing data is essential for uncovering trends and making informed decisions. By plotting daily campaign results, you can quickly identify spikes, dips, and patterns, making it easier to compare performance across different days. This approach allows you to spot successful strategies and areas that need adjustment, ultimately helping you optimize your campaigns for better results.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'date': ['2024-06-01', '2024-06-02', '2024-06-03', '2024-06-04'],
            'impressions': [1000, 1200, 1100, 1300],
            'clicks': [100, 150, 120, 170],
            'conversions': [10, 20, 15, 25]
        }
        self.df = pd.DataFrame(self.data)
        # Patch plt.show to not block
        self._original_show = plt.show
        plt.show = lambda *a, **k: None

    def tearDown(self):
        plt.show = self._original_show

    def test_lineplot_clicks_labels(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_campaign_performance(self.df)
        figs = [plt.figure(num) for num in plt.get_fignums()]
        _dynamic_test(
            self,
            len(figs) >= 2,
            "Function generates two plots.",
            f"Expected two plots to be generated, found {len(figs)}."
        )
        # Check first plot for lineplot
        ax = figs[0].axes[0] if figs[0].axes else None
        _dynamic_test(
            self,
            ax is not None,
            "First figure has axes.",
            "First plot has no axes."
        )
        # Check x and y labels
        xlabel = ax.get_xlabel()
        ylabel = ax.get_ylabel()
        title = ax.get_title()
        _dynamic_test(
            self,
            normalize_text(xlabel) == 'date',
            "Line plot x-axis labeled 'Date'.",
            f"Line plot x-axis label incorrect: '{xlabel}'."
        )
        _dynamic_test(
            self,
            normalize_text(ylabel) == 'clicks',
            "Line plot y-axis labeled 'Clicks'.",
            f"Line plot y-axis label incorrect: '{ylabel}'."
        )
        _dynamic_test(
            self,
            'clicks' in normalize_text(title),
            "Line plot contains 'clicks' in title.",
            f"Line plot title does not reference 'clicks': '{title}'."
        )
        # Check data
        lines = ax.get_lines()
        _dynamic_test(
            self,
            len(lines) > 0,
            "Line plot contains line data.",
            "Line plot appears empty."
        )
        ydata = lines[0].get_ydata()
        _dynamic_test(
            self,
            list(ydata) == self.data['clicks'],
            "Line plot displays correct clicks data.",
            f"Expected clicks data {self.data['clicks']}, got {list(ydata)}."
        )

    def test_barplot_conversions_labels(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_campaign_performance(self.df)
        figs = [plt.figure(num) for num in plt.get_fignums()]
        _dynamic_test(
            self,
            len(figs) >= 2,
            "Function generates two plots.",
            f"Expected two plots to be generated, found {len(figs)}."
        )
        # Check second plot for barplot
        ax = figs[1].axes[0] if figs[1].axes else None
        _dynamic_test(
            self,
            ax is not None,
            "Second figure has axes.",
            "Second plot has no axes."
        )
        xlabel = ax.get_xlabel()
        ylabel = ax.get_ylabel()
        title = ax.get_title()
        _dynamic_test(
            self,
            normalize_text(xlabel) == 'date',
            "Bar chart x-axis labeled 'Date'.",
            f"Bar chart x-axis label incorrect: '{xlabel}'."
        )
        _dynamic_test(
            self,
            normalize_text(ylabel) == 'conversions',
            "Bar chart y-axis labeled 'Conversions'.",
            f"Bar chart y-axis label incorrect: '{ylabel}'."
        )
        _dynamic_test(
            self,
            'conversion' in normalize_text(title),
            "Bar chart contains 'conversion' in title.",
            f"Bar chart title does not reference 'conversion': '{title}'."
        )
        # Check data
        bars = ax.patches
        bar_heights = [bar.get_height() for bar in bars]
        _dynamic_test(
            self,
            bar_heights == self.data['conversions'],
            "Bar chart displays correct conversions data.",
            f"Expected conversions data {self.data['conversions']}, got {bar_heights}."
        )

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: Visualize Campaign Results

Ratkaisu