Forecasting campaign results is essential for marketers who want to maximize the impact of their budgets. By predicting how many conversions a campaign might generate based on factors like spend and impressions, you can make more informed decisions about where to allocate resources. This approach helps you set realistic expectations, avoid overspending, and optimize your strategy for better returns. Predictive analytics, such as linear regression, allows you to model relationships between variables and anticipate future outcomes, making your marketing efforts more data-driven and effective.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import numpy as np
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        self.df = pd.DataFrame({
            "spend": [1000, 1500, 2000, 2500, 3000],
            "impressions": [10000, 15000, 20000, 25000, 30000],
            "conversions": [120, 180, 240, 300, 360]
        })
        self.future_campaigns = [
            {"spend": 1800, "impressions": 18000},
            {"spend": 2200, "impressions": 22000}
        ]

    def test_model_fits_and_predicts_correctly(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'fit_and_predict_conversions', None)
        _dynamic_test(
            self,
            callable(func),
            "fit_and_predict_conversions function is defined",
            "fit_and_predict_conversions function is not defined or not callable"
        )
        preds = func(self.df, self.future_campaigns)
        _dynamic_test(
            self,
            preds is not None and hasattr(preds, 'shape'),
            "Function returns an array-like object with shape",
            f"Function did not return a shape-aware object, got: {preds}"
        )
        # Fit the model here to get expected predictions
        from sklearn.linear_model import LinearRegression
        model = LinearRegression()
        X = self.df[["spend", "impressions"]]
        y = self.df["conversions"]
        model.fit(X, y)
        X_new = pd.DataFrame(self.future_campaigns)
        expected = model.predict(X_new)
        _dynamic_test(
            self,
            np.allclose(preds, expected),
            "Predictions are correct for provided data",
            f"Expected predictions {expected}, got {preds}"
        )

    def test_returns_numpy_array(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'fit_and_predict_conversions', None)
        preds = func(self.df, self.future_campaigns)
        _dynamic_test(
            self,
            hasattr(preds, 'shape') and hasattr(preds, '__getitem__'),
            "Returned predictions are array-like (NumPy array or similar)",
            f"Returned predictions are not array-like: {type(preds)}"
        )

    def test_empty_new_data(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'fit_and_predict_conversions', None)
        preds = func(self.df, [])
        _dynamic_test(
            self,
            hasattr(preds, 'shape') and preds.shape[0] == 0,
            "Function returns empty array when new_data is empty",
            f"Expected empty predictions, got {preds}"
        )

    def test_any_length_new_data(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'fit_and_predict_conversions', None)
        test_data = [
            {"spend": 1100, "impressions": 12000},
            {"spend": 1400, "impressions": 14000},
            {"spend": 1700, "impressions": 16000},
            {"spend": 2100, "impressions": 21000},
            {"spend": 2900, "impressions": 29000}
        ]
        preds = func(self.df, test_data)
        _dynamic_test(
            self,
            hasattr(preds, 'shape') and preds.shape[0] == len(test_data),
            "Function predicts for all entries in new_data",
            f"Expected {len(test_data)} predictions, got shape {preds.shape}"
        )

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: Predict Future Campaign Performance

解答