This video provides a walkthrough of the challenge requirements for this chapter. You will learn how to create a cohort retention matrix using Python and visualize it to reveal user retention patterns over time. The video also guides you through interpreting the matrix and summarizing key business insights that can be derived from your analysis, helping you translate cohort data into actionable recommendations for business strategy.

Neste desafio, será necessário aplicar o conhecimento de análise de coorte gerando uma matriz de retenção e interpretando os resultados para extrair insights de negócios acionáveis. Comece criando uma matriz de retenção de coorte utilizando os dados de coorte preparados. Visualize a matriz para exibir claramente as taxas de retenção ao longo do tempo para cada coorte, utilizando bibliotecas Python apropriadas. Após gerar a visualização, analise os padrões e resuma os principais insights de negócios observados – como tendências de retenção de usuários, períodos de churn ou diferenças entre coortes. O resumo deve destacar pelo menos duas recomendações acionáveis que uma empresa poderia implementar com base nas tendências de retenção de coorte apresentadas na matriz.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import pandas as pd
import numpy as np
import importlib
import sys
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'user_id': [1,1,2,2,3,4,5,6,7,7,8,9],
            'cohort_month': ['2023-01','2023-02','2023-01','2023-02','2023-02','2023-02','2023-03','2023-03','2023-03','2023-03','2023-03','2023-03'],
            'activity_month': ['2023-01','2023-02','2023-02','2023-03','2023-02','2023-03','2023-03','2023-04','2023-03','2023-04','2023-04','2023-04']
        }
        self.df = pd.DataFrame(self.data)

    def test_generate_retention_matrix_structure_and_values(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'generate_retention_matrix', None)
        _dynamic_test(
            self,
            callable(func),
            'generate_retention_matrix is defined',
            'generate_retention_matrix is not defined',
        )
        retention = func(self.df)
        _dynamic_test(
            self,
            isinstance(retention, pd.DataFrame),
            'generate_retention_matrix returns a DataFrame',
            f'generate_retention_matrix did not return a DataFrame, got {type(retention)}',
        )
        # Check that all values are between 0 and 1
        all_values = retention.values.flatten()
        _dynamic_test(
            self,
            np.all((all_values >= 0) & (all_values <= 1)),
            'All retention rates are between 0 and 1',
            f'Some retention rates are outside [0,1]: {all_values}',
        )

    def test_plot_retention_matrix_heatmap(self):
        import user_code
        importlib.reload(user_code)
        func_matrix = getattr(user_code, 'generate_retention_matrix', None)
        func_plot = getattr(user_code, 'plot_retention_matrix', None)
        retention = func_matrix(self.df)
        _dynamic_test(
            self,
            callable(func_plot),
            'plot_retention_matrix is defined',
            'plot_retention_matrix is not defined',
        )
        # Suppress actual plot display for testing
        import matplotlib
        matplotlib.use('Agg')
        try:
            func_plot(retention)
            _dynamic_test(
                self,
                True,
                'plot_retention_matrix runs without error',
                'plot_retention_matrix raised an error',
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                '',
                f'plot_retention_matrix raised an exception: {e}',
            )

    

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

Domine técnicas de análise de coorte utilizando Python. Este curso aborda a estruturação de dados de coorte, segmentação avançada, análise de retenção e insights de negócios acionáveis, com desafios práticos em cada seção.

Aprenda a estruturar, pré-processar e preparar dados para análise avançada de coorte, incluindo atribuição de coorte e engenharia de atributos.

Aprofunde-se em estratégias avançadas de segmentação e cálculos de métricas de retenção para revelar insights mais profundos a partir dos dados de coorte.

Visualize dados de coorte e extraia insights de negócios acionáveis utilizando técnicas avançadas de plotagem e interpretação.

Desafio: Visualização de Coorte e Insights

Solução