In multi-channel marketing, customers often interact with several touchpoints before converting. **Linear attribution** addresses the challenge of fairly distributing credit by assigning equal value to each channel involved in a customer's journey. This approach ensures that no single channel is over- or under-valued, making it easier for you to understand the collective impact of your marketing efforts. By using linear attribution, you can more accurately assess the performance of each channel, optimize your budget allocation, and foster collaboration between different marketing teams.


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

class TestTask(unittest.TestCase):
    def test_output_columns(self):
        import user_code
        importlib.reload(user_code)
        df = pd.DataFrame({
            'customer_id': [1, 2, 3],
            'channels': [
                ['Email', 'Social'],
                ['Search'],
                ['Email', 'Search', 'Social']
            ],
            'conversion': [True, True, False]
        })
        result = user_code.linear_attribution(df)
        _dynamic_test(
            self,
            isinstance(result, pd.DataFrame) and set(result.columns) == {'channel', 'total_conversions'},
            'Returned DataFrame has correct columns',
            f"Returned DataFrame columns incorrect: {getattr(result, 'columns', None)}"
        )

    def test_equal_fractional_credit(self):
        import user_code
        importlib.reload(user_code)
        df = pd.DataFrame({
            'customer_id': [1],
            'channels': [['Email', 'Social', 'Search']],
            'conversion': [True]
        })
        result = user_code.linear_attribution(df)
        if result is None:
            _dynamic_test(self, False, '', 'Function returned None')
            return
        res = dict(zip(result['channel'], result['total_conversions']))
        expected = {'Email': 1/3, 'Social': 1/3, 'Search': 1/3}
        cond = all(abs(res.get(k, 0) - v) < 1e-8 for k, v in expected.items()) and len(res) == 3
        _dynamic_test(
            self,
            cond,
            'Each channel receives equal fractional credit for one conversion',
            f"Expected {expected}, got {res}"
        )

    def test_skip_no_conversion(self):
        import user_code
        importlib.reload(user_code)
        df = pd.DataFrame({
            'customer_id': [1, 2],
            'channels': [['Email', 'Social'], ['Search']],
            'conversion': [False, False]
        })
        result = user_code.linear_attribution(df)
        if result is None:
            _dynamic_test(self, False, '', 'Function returned None')
            return
        _dynamic_test(
            self,
            result.empty,
            'Function skips journeys without a conversion',
            f"Expected empty DataFrame, got {result}"
        )

    def test_sum_credits_multiple_journeys(self):
        import user_code
        importlib.reload(user_code)
        df = pd.DataFrame({
            'customer_id': [1, 2, 3],
            'channels': [
                ['Email', 'Social'],
                ['Social', 'Search'],
                ['Email', 'Search']
            ],
            'conversion': [True, True, True]
        })
        result = user_code.linear_attribution(df)
        if result is None:
            _dynamic_test(self, False, '', 'Function returned None')
            return
        res = dict(zip(result['channel'], result['total_conversions']))
        expected = {
            'Email': 1 + 0.5,
            'Social': 0.5 + 0.5,
            'Search': 0.5 + 0.5
        }
        cond = (
            abs(res.get('Email', 0) - 1.0) < 1e-8 and
            abs(res.get('Social', 0) - 1.0) < 1e-8 and
            abs(res.get('Search', 0) - 1.0) < 1e-8
        )
        _dynamic_test(
            self,
            cond,
            'Credits are summed for channels appearing in multiple journeys',
            f"Expected {expected}, got {res}"
        )

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: Implement a Linear Attribution Model

Ratkaisu

Challenge: Implement a Linear Attribution Model

Ratkaisu