Identifying **high-value customers** is a crucial step in designing effective marketing strategies. By understanding which customers contribute the most to revenue, you can focus your marketing efforts and resources on nurturing these relationships, creating personalized offers, and increasing overall customer loyalty. Segmenting your customer base also helps you tailor campaigns to different groups, ensuring that each segment receives relevant messaging and incentives. This approach leads to improved engagement, better return on investment, and a deeper understanding of your market.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.df = pd.DataFrame({
            "CustomerID": [1, 2, 3, 4, 5, 6],
            "TotalPurchaseAmount": [1200, 800, 300, 1500, 450, 700]
        })
        self.df_edge = pd.DataFrame({
            "CustomerID": [10,11,12],
            "TotalPurchaseAmount": [1000, 500, 499]
        })

    def test_high_value_assignment(self):
        import user_code
        importlib.reload(user_code)
        summary = user_code.segment_customers(self.df)
        # Recreate segmentation
        df = self.df.copy()
        df["Segment"] = df["TotalPurchaseAmount"].apply(lambda x: "High Value" if x >= 1000 else ("Medium Value" if x >= 500 else "Low Value"))
        count_high = (df["Segment"] == "High Value").sum()
        actual_high = summary.loc[summary["Segment"] == "High Value", "CustomerCount"].values
        _dynamic_test(
            self,
            len(actual_high) == 1 and actual_high[0] == count_high,
            "Correct count for 'High Value' customers.",
            f"Expected {count_high} 'High Value', got {actual_high}"
        )

    def test_medium_value_assignment(self):
        import user_code
        importlib.reload(user_code)
        summary = user_code.segment_customers(self.df)
        df = self.df.copy()
        df["Segment"] = df["TotalPurchaseAmount"].apply(lambda x: "High Value" if x >= 1000 else ("Medium Value" if x >= 500 else "Low Value"))
        count_medium = (df["Segment"] == "Medium Value").sum()
        actual_medium = summary.loc[summary["Segment"] == "Medium Value", "CustomerCount"].values
        _dynamic_test(
            self,
            len(actual_medium) == 1 and actual_medium[0] == count_medium,
            "Correct count for 'Medium Value' customers.",
            f"Expected {count_medium} 'Medium Value', got {actual_medium}"
        )

    def test_low_value_assignment(self):
        import user_code
        importlib.reload(user_code)
        summary = user_code.segment_customers(self.df)
        df = self.df.copy()
        df["Segment"] = df["TotalPurchaseAmount"].apply(lambda x: "High Value" if x >= 1000 else ("Medium Value" if x >= 500 else "Low Value"))
        count_low = (df["Segment"] == "Low Value").sum()
        actual_low = summary.loc[summary["Segment"] == "Low Value", "CustomerCount"].values
        _dynamic_test(
            self,
            len(actual_low) == 1 and actual_low[0] == count_low,
            "Correct count for 'Low Value' customers.",
            f"Expected {count_low} 'Low Value', got {actual_low}"
        )

    def test_summary_column_names(self):
        import user_code
        importlib.reload(user_code)
        summary = user_code.segment_customers(self.df)
        expected_cols = ["Segment", "CustomerCount"]
        _dynamic_test(
            self,
            list(summary.columns) == expected_cols,
            "Summary DataFrame columns are correct.",
            f"Expected columns {expected_cols}, got {list(summary.columns)}"
        )

    def test_edge_case_boundaries(self):
        import user_code
        importlib.reload(user_code)
        summary = user_code.segment_customers(self.df_edge)
        df = self.df_edge.copy()
        df["Segment"] = df["TotalPurchaseAmount"].apply(lambda x: "High Value" if x >= 1000 else ("Medium Value" if x >= 500 else "Low Value"))
        for segment in ["High Value", "Medium Value", "Low Value"]:
            expected_count = (df["Segment"] == segment).sum()
            actual = summary.loc[summary["Segment"] == segment, "CustomerCount"].values
            if expected_count > 0:
                _dynamic_test(
                    self,
                    len(actual) == 1 and actual[0] == expected_count,
                    f"Correct count for '{segment}' at boundaries.",
                    f"Expected {expected_count} '{segment}', got {actual}"
                )
            else:
                _dynamic_test(
                    self,
                    not (summary["Segment"] == segment).any(),
                    f"No '{segment}' segment present if count is zero.",
                    f"Unexpected '{segment}' present in summary."
                )

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: Segment Customers by Purchase Behavior

Ratkaisu

Challenge: Segment Customers by Purchase Behavior

Ratkaisu