User_journey_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7a8c1b88",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6baa327c",
   "metadata": {},
   "source": [
    "## Function Definitions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d832f2a",
   "metadata": {},
   "source": [
    "#### Supporting Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1e70ea96",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_mask(data, match, target_column):\n",
    "    \"\"\"\n",
    "    Returns a boolean list (mask) indicating when match is contained in the target_column of data.\n",
    "    \n",
    "        Parameters:\n",
    "            data (pandas.DataFrame): The DataFrame for which we will create the mask\n",
    "            \n",
    "            match (str): The string to be matched in target_column. If \"All\", creates \n",
    "                a mask full of True values (i.e. matching the whole DataFrame)\n",
    "                \n",
    "            target_column (str): The column in which to search for the string match\n",
    "            \n",
    "        \n",
    "        Returns:\n",
    "            mask (bool list): A list of bool values mapping the locations where match is contained in target_column\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' type\n",
    "    if not isinstance(data, pd.DataFrame):\n",
    "        raise TypeError(\"'data' should be of type 'pandas.DataFrame': received {} instead\".format(type(data)))\n",
    "    \n",
    "    if not isinstance(match, str):\n",
    "        raise TypeError(\"'plan' should be of type 'str': received {} instead\".format(type(match)))\n",
    "    \n",
    "    if not isinstance(target_column, str):\n",
    "        raise TypeError(\"'target_column' should be of type 'str': received {} instead\".format(type(target_column)))\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' value\n",
    "    if target_column not in data.columns:\n",
    "        raise ValueError(\"No column named '{}' in the data\".format(target_column))\n",
    "    \n",
    "    \n",
    "    \n",
    "    ### MAIN FUNCTION BODY ###\n",
    "    \n",
    "    \n",
    "    \n",
    "    if match == \"All\":\n",
    "        size = len(data[target_column])\n",
    "        mask = [True]*size # list full of True with the same lenght as the data\n",
    "    \n",
    "    else:\n",
    "        mask = list(data[target_column] == match)\n",
    "    \n",
    "    \n",
    "    return mask\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f07a3059",
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_pages(data, target_column = \"user_journey\"):\n",
    "    \"\"\"\n",
    "    Given a pandas DataFrame, split the user journey strings into separate pages.\n",
    "    It does not update the DataFrame, rather returns a new numpy array.\n",
    "    \n",
    "    A user journey string is a string of the pages a user visited before purchassing, separated by a dash '-'.\n",
    "    This function removes the dash and obtains a numpy array of all the pages (as strings).\n",
    "    \n",
    "    \n",
    "        Parameters:\n",
    "            data (pandas.DataFrame): The DataFrame containg user journeys data\n",
    "            \n",
    "            target_column (str): The column containing the user journey strings\n",
    "                Default: 'user_journey', the expected name for the column\n",
    "        \n",
    "        \n",
    "        Returns:\n",
    "            user_journey (numpy.array): A numpy array containing arrays of the pages (str)\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' type\n",
    "    if not isinstance(data, pd.DataFrame):\n",
    "        raise TypeError(\"'data' should be of type 'pandas.DataFrame': received {} instead\".format(type(data)))\n",
    "    \n",
    "    if not isinstance(target_column, str):\n",
    "        raise TypeError(\"'target_column' should be of type 'str': received {} instead\".format(type(target_column)))\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' value\n",
    "    if target_column not in data.columns:\n",
    "        raise ValueError(\"No column named '{}' in the data\".format(target_column))\n",
    "    \n",
    "    \n",
    "    \n",
    "    ### MAIN FUNCTION BODY ###\n",
    "    \n",
    "    \n",
    "    # Transform the user journey column to a numpy array\n",
    "    # numpy.array needed in order to be able to use a mask (filter)\n",
    "    user_journeys = np.array(data[target_column])\n",
    "    \n",
    "    \n",
    "    # Split the journey strings into pages -> [[\"page1\", \"page2\", ...\"pageN\"], ...]\n",
    "    for i in range(len(user_journeys)):\n",
    "        user_journeys[i] = np.array(user_journeys[i].split(\"-\"))\n",
    "    \n",
    "    \n",
    "    return user_journeys\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bd4eb5dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_pages_set(data, target_column = \"user_journey\"):\n",
    "    \"\"\"\n",
    "    Obtain the set (unique values) of all pages contained in the data.\n",
    "    \n",
    "        Parameters:\n",
    "            data (pandas.DataFrame): The DataFrame containg user journeys data\n",
    "            \n",
    "            target_column (str): The column containing the user journey strings\n",
    "                Default: 'user_journey', the expected name for the column\n",
    "        \n",
    "        \n",
    "        Returns:\n",
    "            pages_set (set): A set of all unique pages contained in the user journey strings\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' type\n",
    "    if not isinstance(data, pd.DataFrame):\n",
    "        raise TypeError(\"'data' should be of type 'pandas.DataFrame': received {} instead\".format(type(data)))\n",
    "    \n",
    "    if not isinstance(target_column, str):\n",
    "        raise TypeError(\"'target_column' should be of type 'str': received {} instead\".format(type(target_column)))\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' value\n",
    "    if target_column not in data.columns:\n",
    "        raise ValueError(\"No column named '{}' in the data\".format(target_column))\n",
    "    \n",
    "    \n",
    "    \n",
    "    ### MAIN FUNCTION BODY ###\n",
    "    \n",
    "    \n",
    "    # Obtain a list of the pages in each journey string -> [[\"page1\", \"page2\", ...\"pageN\"], ...]\n",
    "    user_journeys = [journey.split(\"-\") for journey in list(data[target_column])]\n",
    "    \n",
    "    # Create an empty set and update it for each user journey\n",
    "    pages_set = set()\n",
    "    for journey in user_journeys:\n",
    "        pages_set.update(journey)\n",
    "    \n",
    "    \n",
    "    return pages_set\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55404076",
   "metadata": {},
   "source": [
    "#### Main Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c5dd2fde",
   "metadata": {},
   "outputs": [],
   "source": [
    "def page_count(data, target_column = 'user_journey', plan = \"All\", mask = None, sort = True):\n",
    "    \"\"\"\n",
    "    Calculates the number of times each page is found in the user journey strings.\n",
    "    \n",
    "        Parameters:\n",
    "            data (pandas.DataFrame): The DataFrame containing the user journeys data\n",
    "            \n",
    "            target_column (str): The column containing the user journey strings\n",
    "                Default: 'user_journey', the expected name of the column\n",
    "                \n",
    "            plan (str): The subscription plan to filter the user journeys by. If \"All\", consideres all user journeys \n",
    "                without filtering\n",
    "                Default: \"All\", includes all data\n",
    "                \n",
    "            mask (bool list): A user provided boolean list to use when selecting which data to analyze\n",
    "                Default: None, consider plan instead\n",
    "                \n",
    "            sort (bool): Whether to sort the resultant dictionary by values in decreasing order\n",
    "                Default: True, return a sorted dictionary\n",
    "            \n",
    "        \n",
    "        Returns:\n",
    "            dict {str: int}: A dictionary of every page and its count \n",
    "                {page: count}\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' type\n",
    "    if not isinstance(data, pd.DataFrame):\n",
    "        raise TypeError(\"'data' should be of type 'pandas.DataFrame': received {} instead\".format(type(data)))\n",
    "    \n",
    "    if not isinstance(plan, str):\n",
    "        raise TypeError(\"'plan' should be of type 'str': received {} instead\".format(type(plan)))\n",
    "    \n",
    "    if not isinstance(target_column, str):\n",
    "        raise TypeError(\"'target_column' should be of type 'str': received {} instead\".format(type(target_column)))\n",
    "    \n",
    "    if mask is not None:\n",
    "        if not isinstance(mask, list):\n",
    "            raise TypeError(\"'mask' should be of type 'list': received {} instead\".format(type(mask)))\n",
    "        for item in mask:\n",
    "            if not isinstance(item, bool):\n",
    "                raise TypeError(\"'mask' should be a list of 'bool': received list of {} instead\".format(type(item)))\n",
    "    \n",
    "    if not isinstance(sort, bool):\n",
    "        raise TypeError(\"'sort' should be of type 'bool': received {} instead\".format(type(sort)))\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' value\n",
    "    if target_column not in data.columns:\n",
    "        raise ValueError(\"No column named '{}' in the data\".format(target_column))\n",
    "    \n",
    "    if mask is not None and len(mask) != len(data):\n",
    "        raise ValueError(\"'mask' should have the same length as 'data'\")\n",
    "    \n",
    "    \n",
    "    # Warn for potential mistake in 'plan'\n",
    "    if plan not in (\"All\", \"Monthly\", \"Quarterly\", \"Annual\"):\n",
    "        warnings.warn(\"\\n\\nThe supplied string to plan is not recognized as a standard subscription plan. \"\n",
    "                      \"Please, check your spelling. \"\n",
    "                      \"If you intended to filter by plan = '{}', you can ignore this warning.\\n\"\n",
    "                      \"\\nStandard subscription plans are: 'All', 'Monthly', 'Quarterly', 'Annual'.\\n\".format(plan),\n",
    "                     stacklevel = 2)\n",
    "    \n",
    "    \n",
    "    \n",
    "    ### MAIN FUNCTION BODY ###\n",
    "    \n",
    "    \n",
    "    \n",
    "    # Set the proper mask if none was provided by the user\n",
    "    if mask is None:\n",
    "        mask = make_mask(data, plan, \"subscription_type\")\n",
    "    \n",
    "    # Obtain the relevant array of user journey pages\n",
    "    user_journeys = split_pages(data, target_column)\n",
    "    user_journeys = user_journeys[mask]\n",
    "    \n",
    "    \n",
    "    # Define the empty result dictionary\n",
    "    results = {}\n",
    "    results[\"Total pages\"] = 0\n",
    "    \n",
    "    # Populate the dictionary with page counts\n",
    "    for journey in user_journeys:\n",
    "        for page in journey:\n",
    "            results[page] = results.get(page, 0) + 1\n",
    "            results[\"Total pages\"] = results[\"Total pages\"] + 1\n",
    "    \n",
    "    \n",
    "    if not sort:\n",
    "        return results\n",
    "    \n",
    "    # Create a new dictionary, sorted by values (page counts) in decreasing order\n",
    "    sorted_keys = sorted(results, key = results.get, reverse = True)\n",
    "    sorted_results = {key: results[key] for key in sorted_keys}\n",
    "    \n",
    "    \n",
    "    \n",
    "    return sorted_results\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "73fb2419",
   "metadata": {},
   "outputs": [],
   "source": [
    "def page_presence(data, target_column = 'user_journey', plan = \"All\", mask = None, sort = True):\n",
    "    \"\"\"\n",
    "    Finds the number of journeys each page is present in (from the user jounrey strings).\n",
    "    \n",
    "        Parameters:\n",
    "            data (pandas.DataFrame): The DataFrame containing the user journeys data\n",
    "            \n",
    "            target_column (str): The column containing the user journey strings\n",
    "                Default: 'user_journey', the expected name of the column\n",
    "                \n",
    "            plan (str): The subscription plan to filter the user journeys by. If \"All\", consideres all user journeys \n",
    "                without filtering\n",
    "                Default: \"All\", includes all data\n",
    "                \n",
    "            mask (bool list): A user provided boolean list to use when selecting which data to analyze\n",
    "                Default: None, consider plan instead\n",
    "                \n",
    "            sort (bool): Whether to sort the resultant dictionary by values in decreasing order\n",
    "                Default: True, return a sorted dictionary\n",
    "        \n",
    "        \n",
    "        Returns:\n",
    "            dict {str: int}: A dictionary of every page and the number of journeys it is present in \n",
    "                {page: count_journeys}\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' type\n",
    "    if not isinstance(data, pd.DataFrame):\n",
    "        raise TypeError(\"'data' should be of type 'pandas.DataFrame': received {} instead\".format(type(data)))\n",
    "    \n",
    "    if not isinstance(plan, str):\n",
    "        raise TypeError(\"'plan' should be of type 'str': received {} instead\".format(type(plan)))\n",
    "    \n",
    "    if not isinstance(target_column, str):\n",
    "        raise TypeError(\"'target_column' should be of type 'str': received {} instead\".format(type(target_column)))\n",
    "    \n",
    "    if mask is not None:\n",
    "        if not isinstance(mask, list):\n",
    "            raise TypeError(\"'mask' should be of type 'list': received {} instead\".format(type(mask)))\n",
    "        for item in mask:\n",
    "            if not isinstance(item, bool):\n",
    "                raise TypeError(\"'mask' should be a list of 'bool': received list of {} instead\".format(type(item)))\n",
    "    \n",
    "    if not isinstance(sort, bool):\n",
    "        raise TypeError(\"'sort' should be of type 'bool': received {} instead\".format(type(sort)))\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' value\n",
    "    if target_column not in data.columns:\n",
    "        raise ValueError(\"No column named '{}' in the data\".format(target_column))\n",
    "    \n",
    "    if mask is not None and len(mask) != len(data):\n",
    "        raise ValueError(\"'mask' should have the same length as 'data'\")\n",
    "    \n",
    "    \n",
    "    # Warn for potential mistake in 'plan'\n",
    "    if plan not in (\"All\", \"Monthly\", \"Quarterly\", \"Annual\"):\n",
    "        warnings.warn(\"\\n\\nThe supplied string to plan is not recognized as a standard subscription plan. \"\n",
    "                      \"Please, check your spelling. \"\n",
    "                      \"If you intended to filter by plan = '{}', you can ignore this warning.\\n\"\n",
    "                      \"\\nStandard subscription plans are: 'All', 'Monthly', 'Quarterly', 'Annual'.\\n\".format(plan),\n",
    "                     stacklevel = 2)\n",
    "    \n",
    "    \n",
    "    \n",
    "    ### MAIN FUNCTION BODY ###\n",
    "    \n",
    "    \n",
    "    \n",
    "    # Set the proper mask if none was provided by the user\n",
    "    if mask is None:\n",
    "        mask = make_mask(data, plan, \"subscription_type\")\n",
    "    \n",
    "    # Obtain the relevant array of user journey pages\n",
    "    user_journeys = split_pages(data, target_column)\n",
    "    user_journeys = user_journeys[mask]\n",
    "    \n",
    "    \n",
    "    # Define the empty result dictionary\n",
    "    results = {}\n",
    "    results[\"Total journeys\"] = len(user_journeys)\n",
    "    \n",
    "    # Populate the dictionary with count journeys for each page\n",
    "    for journey in user_journeys:\n",
    "        \n",
    "        pages = set(journey) # Unique pages in a journey\n",
    "        \n",
    "        for page in pages:\n",
    "            results[page] = results.get(page, 0) + 1\n",
    "    \n",
    "    \n",
    "    if not sort:\n",
    "        return results\n",
    "    \n",
    "    # Create a new dictionary, sorted by values (page counts) in decreasing order\n",
    "    sorted_keys = sorted(results, key = results.get, reverse = True)\n",
    "    sorted_results = {key: results[key] for key in sorted_keys}\n",
    "    \n",
    "    \n",
    "    \n",
    "    return sorted_results\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "44981da9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def page_destinations(data, target_column = 'user_journey', plan = \"All\", mask = None, sort = True):\n",
    "    \"\"\"\n",
    "    For each page finds all follow up pages and their count (from the user journey strings).\n",
    "    \n",
    "        Parameters:\n",
    "            data (pandas.DataFrame): The DataFrame containing the user journeys data\n",
    "            \n",
    "            target_column (str): The column containing the user journey strings\n",
    "                Default: 'user_journey', the expected name of the column\n",
    "                \n",
    "            plan (str): The subscription plan to filter the user journeys by. If \"All\", consideres all user journeys \n",
    "                without filtering\n",
    "                Default: \"All\", includes all data\n",
    "                \n",
    "            mask (bool list): A user provided boolean list to use when selecting which data to analyze\n",
    "                Default: None, consider plan instead\n",
    "                \n",
    "            sort (bool): Whether to sort the resultant dictionary by values in decreasing order\n",
    "                Default: True, return a sorted dictionary\n",
    "        \n",
    "        \n",
    "        Returns:\n",
    "            dict {str: {str: int}}: A dictionary of every (starting) page.\n",
    "                The value is another dictionary containing all follow up pages and their count \n",
    "                {starting_page: {next_page: count}}\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' type\n",
    "    if not isinstance(data, pd.DataFrame):\n",
    "        raise TypeError(\"'data' should be of type 'pandas.DataFrame': received {} instead\".format(type(data)))\n",
    "    \n",
    "    if not isinstance(plan, str):\n",
    "        raise TypeError(\"'plan' should be of type 'str': received {} instead\".format(type(plan)))\n",
    "    \n",
    "    if not isinstance(target_column, str):\n",
    "        raise TypeError(\"'target_column' should be of type 'str': received {} instead\".format(type(target_column)))\n",
    "    \n",
    "    if mask is not None:\n",
    "        if not isinstance(mask, list):\n",
    "            raise TypeError(\"'mask' should be of type 'list': received {} instead\".format(type(mask)))\n",
    "        for item in mask:\n",
    "            if not isinstance(item, bool):\n",
    "                raise TypeError(\"'mask' should be a list of 'bool': received list of {} instead\".format(type(item)))\n",
    "    \n",
    "    if not isinstance(sort, bool):\n",
    "        raise TypeError(\"'sort' should be of type 'bool': received {} instead\".format(type(sort)))\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' value\n",
    "    if target_column not in data.columns:\n",
    "        raise ValueError(\"No column named '{}' in the data\".format(target_column))\n",
    "    \n",
    "    if mask is not None and len(mask) != len(data):\n",
    "        raise ValueError(\"'mask' should have the same length as 'data'\")\n",
    "    \n",
    "    \n",
    "    # Warn for potential mistake in 'plan'\n",
    "    if plan not in (\"All\", \"Monthly\", \"Quarterly\", \"Annual\"):\n",
    "        warnings.warn(\"\\n\\nThe supplied string to plan is not recognized as a standard subscription plan. \"\n",
    "                      \"Please, check your spelling. \"\n",
    "                      \"If you intended to filter by plan = '{}', you can ignore this warning.\\n\"\n",
    "                      \"\\nStandard subscription plans are: 'All', 'Monthly', 'Quarterly', 'Annual'.\\n\".format(plan),\n",
    "                     stacklevel = 2)\n",
    "    \n",
    "    \n",
    "    \n",
    "    ### MAIN FUNCTION BODY ###\n",
    "    \n",
    "    \n",
    "    \n",
    "    # Set the proper mask if none was provided by the user\n",
    "    if mask is None:\n",
    "        mask = make_mask(data, plan, \"subscription_type\")\n",
    "    \n",
    "    # Obtain the relevant array of user journey pages\n",
    "    user_journeys = split_pages(data, target_column)\n",
    "    user_journeys = user_journeys[mask]\n",
    "    \n",
    "    \n",
    "    # Construct a dictionary with keys being all the pages contained in user journeys\n",
    "    results = { key: dict() for key in get_pages_set(data, target_column)}\n",
    "    \n",
    "    # Populate the dictionary\n",
    "    for journey in user_journeys:\n",
    "        for i in range(len(journey) - 1):\n",
    "            page_source = journey[i]\n",
    "            page_next = journey[i+1]\n",
    "        \n",
    "            results[page_source][page_next] = results[page_source].get(page_next, 0) + 1\n",
    "    \n",
    "    if not sort:\n",
    "        return results\n",
    "    \n",
    "    \n",
    "    \n",
    "    sorted_results = {}\n",
    "    \n",
    "    # Sort the sub-dictionaries by values (page_destionation counts) in decreasing order\n",
    "    for page in results:\n",
    "        unsorted_dict = results[page]\n",
    "        sorted_keys = sorted(unsorted_dict, key = unsorted_dict.get, reverse = True)\n",
    "    \n",
    "        sorted_results[page] = { key: unsorted_dict[key] for key in sorted_keys}\n",
    "    \n",
    "    \n",
    "    \n",
    "    return sorted_results\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fd563aff",
   "metadata": {},
   "outputs": [],
   "source": [
    "def page_sequences(data, number_of_pages = 3, show_results = 10, target_column = 'user_journey', \n",
    "                      plan = \"All\", mask = None, sort = True):\n",
    "    \"\"\"\n",
    "    Finds the top consecutive page strings and their count (from the user jounrey strings).\n",
    "    \n",
    "        Parameters:\n",
    "            data (pandas.DataFrame): The DataFrame containing the user journeys data\n",
    "\n",
    "            number_of_pages (int): The amount of consecutive pages to include in each subset \n",
    "                Default: 3\n",
    "\n",
    "            show_results (int): The number of results to return\n",
    "                Default: 10\n",
    "\n",
    "            target_column (str): The column containing the user journey strings\n",
    "                Default: 'user_journey', the expected name of the column\n",
    "\n",
    "            plan (str): The subscription plan to filter the user journeys by. If \"All\", consideres all user journeys \n",
    "                without filtering\n",
    "                Default: \"All\", includes all data\n",
    "\n",
    "            mask (bool list): A user provided boolean list to use when selecting which data to analyze\n",
    "                Default: None, consider plan instead\n",
    "\n",
    "            sort (bool): Whether to sort the resultant dictionary by values in decreasing order\n",
    "                Default: True, return a sorted dictionary\n",
    "\n",
    "\n",
    "        Returns:\n",
    "            dict {tuple(str): int}: A dictionary where the key is a page combination tuple and the value is its count.\n",
    "                The result is sorted and contains only the top (show_results) tuples.\n",
    "                If sort = False, return all page combinations, unsorted.\n",
    "                {(page1, page2, ... pageN): count}\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' type\n",
    "    if not isinstance(data, pd.DataFrame):\n",
    "        raise TypeError(\"'data' should be of type 'pandas.DataFrame': received {} instead\".format(type(data)))\n",
    "    \n",
    "    if not isinstance(number_of_pages, int):\n",
    "        raise TypeError(\"'number_of_pages' should be of type 'int': received {} instead\".format(type(number_of_pages)))\n",
    "    \n",
    "    if not isinstance(show_results, int):\n",
    "        raise TypeError(\"'show_results' should be of type 'int': received {} instead\".format(type(show_results)))\n",
    "    \n",
    "    if not isinstance(plan, str):\n",
    "        raise TypeError(\"'plan' should be of type 'str': received {} instead\".format(type(plan)))\n",
    "    \n",
    "    if not isinstance(target_column, str):\n",
    "        raise TypeError(\"'target_column' should be of type 'str': received {} instead\".format(type(target_column)))\n",
    "    \n",
    "    if mask is not None:\n",
    "        if not isinstance(mask, list):\n",
    "            raise TypeError(\"'mask' should be a list of 'bool': received {} instead\".format(type(mask)))\n",
    "        for item in mask:\n",
    "            if not isinstance(item, bool):\n",
    "                raise TypeError(\"'mask' should be a list of 'bool': received list of {} instead\".format(type(item)))\n",
    "    \n",
    "    if not isinstance(sort, bool):\n",
    "        raise TypeError(\"'sort' should be of type 'bool': received {} instead\".format(type(sort)))\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' value\n",
    "    if number_of_pages < 0:\n",
    "        raise ValueError(\"'number_of_pages' must be a non-negative integer\")\n",
    "    \n",
    "    if show_results < 0:\n",
    "        raise ValueError(\"'show_results' must be a non-negative integer\")\n",
    "    \n",
    "    if target_column not in data.columns:\n",
    "        raise ValueError(\"No column named '{}' in the data\".format(target_column))\n",
    "    \n",
    "    if mask is not None and len(mask) != len(data):\n",
    "        raise ValueError(\"'mask' should have the same length as 'data'\")\n",
    "    \n",
    "    \n",
    "    # Warn for potential mistake in 'plan'\n",
    "    if plan not in (\"All\", \"Monthly\", \"Quarterly\", \"Annual\"):\n",
    "        warnings.warn(\"\\n\\nThe supplied string to plan is not recognized as a standard subscription plan. \"\n",
    "                      \"Please, check your spelling. \"\n",
    "                      \"If you intended to filter by plan = '{}', you can ignore this warning.\\n\"\n",
    "                      \"\\nStandard subscription plans are: 'All', 'Monthly', 'Quarterly', 'Annual'.\\n\".format(plan),\n",
    "                     stacklevel = 2)\n",
    "    \n",
    "    \n",
    "    \n",
    "    ### MAIN FUNCTION BODY ###\n",
    "    \n",
    "    \n",
    "    \n",
    "    # Set the proper mask if none was provided by the user\n",
    "    if mask is None:\n",
    "        mask = make_mask(data, plan, \"subscription_type\")\n",
    "    \n",
    "    # Obtain the relevant array of user journey pages\n",
    "    user_journeys = split_pages(data, target_column)\n",
    "    user_journeys = user_journeys[mask]\n",
    "    \n",
    "    \n",
    "    # Define the empty result dictionary\n",
    "    results = {}\n",
    "    \n",
    "    # Populate the result dictionary\n",
    "    for journey in user_journeys:\n",
    "        \n",
    "        flag = {} # Used to stop double counting of the same page combination in the same journey\n",
    "        \n",
    "        for i in range(len(journey) - number_of_pages + 1):\n",
    "            \n",
    "            page_combination = tuple(journey[i : i + number_of_pages])\n",
    "\n",
    "            if flag.get(page_combination, False): continue # If we have counted it already, skip it\n",
    "            \n",
    "            results[page_combination] = results.get(page_combination, 0) + 1\n",
    "            flag[page_combination] = True # Flag this combination as already counted in this journey\n",
    "    \n",
    "    \n",
    "    \n",
    "    if not sort:\n",
    "        return results\n",
    "    \n",
    "    # Create a new dictionary, sorted by values (page counts) in decreasing order\n",
    "    # Take only top 'show_results' pages\n",
    "    sorted_keys = sorted(results, key = results.get, reverse = True)[:show_results]\n",
    "    sorted_results = {key: results[key] for key in sorted_keys}\n",
    "    \n",
    "    \n",
    "    \n",
    "    return sorted_results\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "389d70d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def avg_journey_length(data, target_column = 'user_journey', plan = \"All\", mask = None):\n",
    "    \"\"\"\n",
    "    Finds the average length of a user journey in terms of the number of pages.\n",
    "    \n",
    "        Parameters:\n",
    "            data (pandas.DataFrame): The DataFrame containing the user journeys data\n",
    "\n",
    "            target_column (str): The column containing the user journey strings\n",
    "                Default: 'user_journey', the expected name of the column\n",
    "\n",
    "            plan (str): The subscription plan to filter the user journeys by. If \"All\", consideres all user journeys \n",
    "                without filtering\n",
    "                Default: \"All\", includes all data\n",
    "\n",
    "            mask (bool list): A user provided boolean list to use when selecting which data to analyze\n",
    "                Default: None, consider plan instead\n",
    "\n",
    "\n",
    "        Returns:\n",
    "            float: The average number of pages in the relevant user journey strings.\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' type\n",
    "    if not isinstance(data, pd.DataFrame):\n",
    "        raise TypeError(\"'data' should be of type 'pandas.DataFrame': received {} instead\".format(type(data)))\n",
    "    \n",
    "    if not isinstance(plan, str):\n",
    "        raise TypeError(\"'plan' should be of type 'str': received {} instead\".format(type(plan)))\n",
    "    \n",
    "    if not isinstance(target_column, str):\n",
    "        raise TypeError(\"'target_column' should be of type 'str': received {} instead\".format(type(target_column)))\n",
    "    \n",
    "    if mask is not None:\n",
    "        if not isinstance(mask, list):\n",
    "            raise TypeError(\"'mask' should be a list of 'bool': received {} instead\".format(type(mask)))\n",
    "        for item in mask:\n",
    "            if not isinstance(item, bool):\n",
    "                raise TypeError(\"'mask' should be a list of 'bool': received list of {} instead\".format(type(item)))\n",
    "    \n",
    "    \n",
    "    # Check for correct arguments' value\n",
    "    if target_column not in data.columns:\n",
    "        raise ValueError(\"No column named '{}' in the data\".format(target_column))\n",
    "    \n",
    "    if mask is not None and len(mask) != len(data):\n",
    "        raise ValueError(\"'mask' should have the same length as 'data'\")\n",
    "    \n",
    "    \n",
    "    # Warn for potential mistake in 'plan'\n",
    "    if plan not in (\"All\", \"Monthly\", \"Quarterly\", \"Annual\"):\n",
    "        warnings.warn(\"\\n\\nThe supplied string to plan is not recognized as a standard subscription plan. \"\n",
    "                      \"Please, check your spelling. \"\n",
    "                      \"If you intended to filter by plan = '{}', you can ignore this warning.\\n\"\n",
    "                      \"\\nStandard subscription plans are: 'All', 'Monthly', 'Quarterly', 'Annual'.\\n\".format(plan),\n",
    "                     stacklevel = 2)\n",
    "    \n",
    "    \n",
    "    \n",
    "    # Set the proper mask if none was provided by the user\n",
    "    if mask is None:\n",
    "        mask = make_mask(data, plan, \"subscription_type\")\n",
    "    \n",
    "    # Obtain the relevant array of user journey pages\n",
    "    user_journeys = split_pages(data, target_column)\n",
    "    user_journeys = user_journeys[mask]\n",
    "    \n",
    "    \n",
    "    # Find the total amount of pages in all user journeys\n",
    "    total = 0\n",
    "    for i in range(len(user_journeys)):\n",
    "        total = total + len(user_journeys[i])\n",
    "        \n",
    "    # The average journey length is the total amount of pages divided by the numebr of user journeys\n",
    "    avg_len = total/len(user_journeys)\n",
    "    \n",
    "    \n",
    "    return avg_len\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab639a73",
   "metadata": {},
   "source": [
    "## Main"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2d799f37",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the user journey data\n",
    "data = pd.read_csv('C:/Users/HP/Downloads/user_journey.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "806fc55c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>user_id</th>\n",
       "      <th>subscription_type</th>\n",
       "      <th>user_journey</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1516</td>\n",
       "      <td>Annual</td>\n",
       "      <td>Homepage-Log in-Other-Sign up-Log in-Homepage-...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3395</td>\n",
       "      <td>Annual</td>\n",
       "      <td>Other-Pricing-Sign up-Log in-Homepage-Pricing-...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10107</td>\n",
       "      <td>Annual</td>\n",
       "      <td>Homepage-Career tracks-Homepage-Career tracks-...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11145</td>\n",
       "      <td>Monthly</td>\n",
       "      <td>Homepage-Log in-Homepage-Log in-Homepage-Log i...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>12400</td>\n",
       "      <td>Monthly</td>\n",
       "      <td>Homepage-Career tracks-Sign up-Log in-Other-Ca...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   user_id subscription_type  \\\n",
       "0     1516            Annual   \n",
       "1     3395            Annual   \n",
       "2    10107            Annual   \n",
       "3    11145           Monthly   \n",
       "4    12400           Monthly   \n",
       "\n",
       "                                        user_journey  \n",
       "0  Homepage-Log in-Other-Sign up-Log in-Homepage-...  \n",
       "1  Other-Pricing-Sign up-Log in-Homepage-Pricing-...  \n",
       "2  Homepage-Career tracks-Homepage-Career tracks-...  \n",
       "3  Homepage-Log in-Homepage-Log in-Homepage-Log i...  \n",
       "4  Homepage-Career tracks-Sign up-Log in-Other-Ca...  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check how the data looks\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29968e17",
   "metadata": {},
   "source": [
    "### Most popular pages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "928c805b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Total pages': 14098,\n",
       " 'Homepage': 2679,\n",
       " 'Log in': 2234,\n",
       " 'Checkout': 1351,\n",
       " 'Sign up': 1247,\n",
       " 'Other': 1189,\n",
       " 'Courses': 1087,\n",
       " 'Career tracks': 1070,\n",
       " 'Pricing': 1053,\n",
       " 'Coupon': 720,\n",
       " 'Resources center': 546,\n",
       " 'Career track certificate': 468,\n",
       " 'Course certificate': 212,\n",
       " 'Upcoming courses': 110,\n",
       " 'Success stories': 49,\n",
       " 'Instructors': 43,\n",
       " 'About us': 20,\n",
       " 'Blog': 20}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "page_count(data, plan = \"All\", sort = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e147532",
   "metadata": {},
   "source": [
    "### How many times each page is part of a journey"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "29a10b74",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Total journeys': 1350,\n",
       " 'Homepage': 843,\n",
       " 'Checkout': 821,\n",
       " 'Log in': 756,\n",
       " 'Sign up': 738,\n",
       " 'Other': 623,\n",
       " 'Coupon': 606,\n",
       " 'Pricing': 476,\n",
       " 'Courses': 453,\n",
       " 'Career tracks': 380,\n",
       " 'Career track certificate': 228,\n",
       " 'Resources center': 184,\n",
       " 'Course certificate': 151,\n",
       " 'Upcoming courses': 83,\n",
       " 'Success stories': 38,\n",
       " 'Instructors': 25,\n",
       " 'About us': 17,\n",
       " 'Blog': 13}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "page_presence(data, plan = \"All\", sort = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59d4464a",
   "metadata": {},
   "source": [
    "### Most frequent follow-up after every page"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "26d3fbd1",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Log in': 953,\n",
       " 'Pricing': 449,\n",
       " 'Career tracks': 357,\n",
       " 'Sign up': 341,\n",
       " 'Courses': 246,\n",
       " 'Career track certificate': 117,\n",
       " 'Course certificate': 66,\n",
       " 'Resources center': 51,\n",
       " 'Other': 33,\n",
       " 'Instructors': 25,\n",
       " 'Coupon': 12,\n",
       " 'Upcoming courses': 10,\n",
       " 'About us': 5,\n",
       " 'Checkout': 5,\n",
       " 'Success stories': 4,\n",
       " 'Blog': 4}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "page_destinations(data, plan = \"All\", sort = True)['Homepage']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67ce968f",
   "metadata": {},
   "source": [
    "### Most popular N page strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "87a8270c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('Homepage', 'Log in', 'Checkout'): 239,\n",
       " ('Log in', 'Homepage', 'Log in'): 220,\n",
       " ('Homepage', 'Log in', 'Homepage'): 180,\n",
       " ('Sign up', 'Log in', 'Checkout'): 123,\n",
       " ('Sign up', 'Log in', 'Homepage'): 104,\n",
       " ('Homepage', 'Pricing', 'Checkout'): 100,\n",
       " ('Homepage', 'Sign up', 'Log in'): 97,\n",
       " ('Sign up', 'Homepage', 'Log in'): 94,\n",
       " ('Homepage', 'Sign up', 'Homepage'): 90,\n",
       " ('Log in', 'Other', 'Log in'): 83}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "page_sequences(data, number_of_pages = 3, show_results = 10, plan = \"All\", sort = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f0a2bba",
   "metadata": {},
   "source": [
    "### Average length of a journey (pages)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3816ef8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.442962962962962"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_journey_length(data, plan = \"All\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}