When you want to identify peak signup periods and analyze user growth, you often need to look at the number of signups occurring each day. By doing this, you can spot trends, such as which days see the most activity, and use that insight to optimize your marketing efforts. In this challenge, you will write a Python script using `pandas` to create a DataFrame with hardcoded user signup dates, then calculate the number of signups per day and find the day with the highest number of signups.

import pandas as pd

# Create a DataFrame with hardcoded signup dates
data = {
    "user_id": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    "signup_date": [
        "2024-06-01", "2024-06-01", "2024-06-02", "2024-06-02", "2024-06-02",
        "2024-06-03", "2024-06-03", "2024-06-03", "2024-06-03", "2024-06-04"
    ]
}
df = pd.DataFrame(data)

# Count signups per day
signups_per_day = df["signup_date"].value_counts().sort_index()
print("Signups per day:")
print(signups_per_day)

# Find the day with the highest number of signups
peak_day = signups_per_day.idxmax()
peak_count = signups_per_day.max()
print(f"\nDay with the highest signups: {peak_day} ({peak_count} signups)")

You can use this approach with real signup data by loading it from a CSV or database instead of hardcoding values. This lets you analyze trends over longer periods and across larger user bases.

Note


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io

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

    def test_dataframe_structure(self):
        import user_code
        importlib.reload(user_code)
        df = getattr(user_code, 'df', None)
        _dynamic_test(
            self,
            df is not None and hasattr(df, 'shape') and df.shape[0] >= 12 and 'signup_date' in df.columns and 'user_id' in df.columns,
            "DataFrame has at least 12 rows and required columns.",
            f"Expected DataFrame with at least 12 rows and columns 'user_id', 'signup_date'. Got: {getattr(df, 'shape', None)}, columns: {getattr(df, 'columns', None)}",
        )

    def test_at_least_four_unique_dates(self):
        import user_code
        importlib.reload(user_code)
        df = getattr(user_code, 'df', None)
        unique_dates = df['signup_date'].unique() if df is not None and 'signup_date' in df.columns else []
        _dynamic_test(
            self,
            len(unique_dates) >= 4,
            "At least 4 unique signup dates present.",
            f"Expected at least 4 unique signup dates, got {len(unique_dates)}: {unique_dates}",
        )

    def test_signups_per_day_printed(self):
        import user_code
        import importlib
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        importlib.reload(user_code)
        sys.stdout = sys_stdout
        output = normalize_text(f.getvalue())
        df = getattr(user_code, 'df', None)
        if df is not None and 'signup_date' in df.columns:
            counts = df['signup_date'].value_counts().sort_index()
            for date, count in counts.items():
                expected_line = f"{date}    {count}"
                _dynamic_test(
                    self,
                    normalize_text(date) in output and str(count) in output,
                    f"Output contains signup count for {date}.",
                    f"Expected signup count for {date}: {count} not found in output: {output}",
                )
        else:
            _dynamic_test(self, False, "df exists", "df does not exist or missing 'signup_date' column.")

    def test_peak_day_printed(self):
        import user_code
        import importlib
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        importlib.reload(user_code)
        sys.stdout = sys_stdout
        output = normalize_text(f.getvalue())
        df = getattr(user_code, 'df', None)
        if df is not None and 'signup_date' in df.columns:
            counts = df['signup_date'].value_counts().sort_index()
            peak_day = counts.idxmax()
            peak_count = counts.max()
            expected = f"day with the highest signups: {peak_day} ({peak_count} signups)"
            _dynamic_test(
                self,
                normalize_text(expected) in output,
                f"Peak signup day and count printed as expected.",
                f"Expected: '{expected}' in output: {output}",
            )
        else:
            _dynamic_test(self, False, "df exists", "df does not exist or missing 'signup_date' column.")

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 automate, analyze, and optimize growth strategies. This course is designed for growth hackers who want to leverage Python for data-driven marketing, user acquisition, and rapid experimentation. Learn to automate repetitive tasks, analyze user behavior, and extract actionable insights—all without prior data science experience.

Learn how to use Python to automate repetitive growth hacking tasks, from data cleaning to campaign reporting.

Use Python to analyze user engagement, retention, and behavior patterns to inform growth strategies.

Apply Python to design, analyze, and optimize growth experiments such as A/B tests and campaign performance evaluations.

Challenge: Signup Trend Analyzer

Solution