Visualizing before-and-after metrics is a powerful way to communicate the impact of a product feature launch. By presenting both sets of data on a single chart, you can clearly show stakeholders how a key metric has changed due to your intervention. Adding clear titles, axis labels, and a legend ensures that your audience immediately understands the story your data tells, making your insights actionable and persuasive.

import matplotlib.pyplot as plt

# Sample data: before and after feature launch
metrics = ['Active Users', 'Conversion Rate', 'Avg Session Time']
before = [1200, 0.15, 5.2]
after = [1450, 0.19, 6.1]

plt.figure(figsize=(8, 5))
plt.plot(metrics, before, marker='o', label='Before Launch')
plt.plot(metrics, after, marker='o', label='After Launch')

plt.title('Feature Impact on Key Metrics')
plt.xlabel('Metric')
plt.ylabel('Value')
plt.legend()
plt.tight_layout()
plt.show()


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import types
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from unittest.mock import patch

class TestTask(unittest.TestCase):
    def setUp(self):
        # Reset matplotlib state before each test
        plt.close('all')

    def test_both_series_plotted(self):
        # Patch plt.show to prevent actual rendering
        with patch('matplotlib.pyplot.show') as mock_show:
            import user_code
            importlib.reload(user_code)
            # Get all lines (Line2D objects)
            lines = plt.gca().get_lines()
            # There should be two lines: before and after
            _dynamic_test(
                self,
                len(lines) == 2,
                'Both before_launch and after_launch are plotted on the chart',
                f'Expected 2 lines plotted (before and after), got {len(lines)}',
            )
            # Check that x-data matches metrics labels
            expected_metrics = ['Daily Active Users', 'Signup Rate', 'Churn Rate']
            for line in lines:
                # xdata will be indexes, but labels are set as xticks
                xdata = line.get_xdata()
                _dynamic_test(
                    self,
                    len(xdata) == 3,
                    'Each plotted line uses all metric labels',
                    f'Plotted line does not use all metric labels (got {xdata})',
                )

    def test_chart_title_present(self):
        with patch('matplotlib.pyplot.show'):
            import user_code
            importlib.reload(user_code)
            title = plt.gca().get_title()
            _dynamic_test(
                self,
                isinstance(title, str) and 'feature' in title.lower() and 'impact' in title.lower(),
                'Chart title summarizes feature impact',
                f'Expected chart title to mention feature impact, got: {title}',
            )

    def test_axes_labels_present(self):
        with patch('matplotlib.pyplot.show'):
            import user_code
            importlib.reload(user_code)
            xlabel = plt.gca().get_xlabel()
            ylabel = plt.gca().get_ylabel()
            _dynamic_test(
                self,
                isinstance(xlabel, str) and 'metric' in xlabel.lower(),
                'X-axis is labeled appropriately',
                f'Expected x-axis label to include "Metric", got: {xlabel}',
            )
            _dynamic_test(
                self,
                isinstance(ylabel, str) and 'value' in ylabel.lower(),
                'Y-axis is labeled appropriately',
                f'Expected y-axis label to include "Value", got: {ylabel}',
            )

    def test_legend_present_and_labels(self):
        with patch('matplotlib.pyplot.show'):
            import user_code
            importlib.reload(user_code)
            legend = plt.gca().get_legend()
            _dynamic_test(
                self,
                legend is not None,
                'Chart includes a legend',
                'Expected a legend on the chart but none was found',
            )
            if legend is not None:
                labels = [t.get_text().lower() for t in legend.get_texts()]
                has_before = any('before' in label for label in labels)
                has_after = any('after' in label for label in labels)
                _dynamic_test(
                    self,
                    has_before and has_after,
                    'Legend distinguishes before and after launch',
                    f'Legend labels should mention both before and after, got: {labels}',
                )

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

A hands-on course designed for Product Managers to leverage Python for data-driven decision making, product analytics, and business insights. Learn how to use Python to analyze product metrics, visualize trends, and automate reporting, all without prior data science experience.

Learn how to use Python to explore, summarize, and interpret key product metrics. This section focuses on understanding user data, product usage, and basic analytics relevant to product management.

Explore how Python can be used to design, analyze, and interpret product experiments, including A/B testing and hypothesis validation.

Master Python techniques to automate repetitive product management tasks, generate reports, and streamline product operations.

Challenge: Visualize Feature Impact

Ratkaisu

Challenge: Visualize Feature Impact

Ratkaisu