0_template/2_template_functions_plotly.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "46020739-24b8-4446-a117-924a438ca94b",
   "metadata": {},
   "source": [
    "# template functions plotly\n",
    "Template to functions:\n",
    "- transversal functions to transform data\n",
    "- transversal functions to plot data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f4e1220d-c620-49ea-b70d-8fbd9eb6c6cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import statsmodels\n",
    "import seaborn as sns\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from statsmodels.graphics import tsaplots\n",
    "\n",
    "# plotly\n",
    "import plotly\n",
    "import plotly.express as px\n",
    "import plotly.graph_objects as go\n",
    "import plotly.io as pio\n",
    "from plotly.subplots import make_subplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d367fef-4de0-4f55-aa8b-5a6d01f2f481",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ac8daa2c-a40b-424b-8468-8ed19e885651",
   "metadata": {},
   "source": [
    "## Transversal functions to plot data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f3b8798-ba55-40fd-b7a8-7961fd03c926",
   "metadata": {},
   "source": [
    "### 1. transform dataframe into plotly table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cef8a4ea-9492-4d1d-b254-5df0c43b2ede",
   "metadata": {},
   "outputs": [],
   "source": [
    "# auxliar function to plot a dataframe as a plotly table\n",
    "def plot_df_table_plotly(df_to_plotly):\n",
    "    \"\"\"\n",
    "    Given a dataframe, transform into a plotly table\n",
    "    Args\n",
    "        df_to_plotly (dataframe): dataframe that will be transformed into plotly table\n",
    "\n",
    "    Return\n",
    "        table_fig (figure plotly): fig of plotly with the plot generated\n",
    "    \"\"\"\n",
    "    table_fig = go.Figure(data=[go.Table(\n",
    "    header=dict(values=list(df_to_plotly.columns),\n",
    "                fill_color='paleturquoise',\n",
    "                align='left'),\n",
    "    cells=dict(values=[df_to_plotly[col] for col in df_to_plotly.columns],\n",
    "               fill_color='lavender',\n",
    "               align='left'))\n",
    "    ])\n",
    "    return table_fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80728bff-e4e2-444d-98f1-c94f84a4775f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d77e8c1-6a28-4234-82a0-fc4967df7fbf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f5424275-50cc-47a2-9845-be374fd93426",
   "metadata": {},
   "source": [
    "### 2. given a dataframe generate a individual plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e75e8fdd-2305-4eec-b105-7256aaa27bf5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_individual_hist_segment(df, var_segment, feature_hist):\n",
    "    \"\"\"\n",
    "    Plot individual hist\n",
    "    Args\n",
    "        df (dataframe): input dataframe\n",
    "        varg_segment (string): name of the column in the input dataframe that indicate the differents segments in the data\n",
    "        feature_hist (string): name of the feature in the input dataframe that will plot its histogram\n",
    "\n",
    "    Return\n",
    "        fig (figure plotly): fig of plotly with the plot generated\n",
    "    \"\"\"\n",
    "\n",
    "    # TODO: ADD CODE TO GENERATE FIGURE\n",
    "    fig = px.histogram(df, x = feature_hist, color = var_segment, barmode='overlay', opacity=0.4)\n",
    "\n",
    "    # update title\n",
    "    fig.update_layout(\n",
    "      title_text = f'Histogram: {feature_hist}',\n",
    "      title_x = 0.5, # centrar titulo\n",
    "      title_font = dict(size = 20)\n",
    "    )\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7acb6e1-4c06-4b07-bb03-fe9e555d2171",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7bffb4d7-8961-4601-9ba9-4f38d5b8f674",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2315aeb9-9e87-41ce-aec9-a53da037acfb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1d6c1124-59ae-4f3a-bd78-3055f278b1d0",
   "metadata": {},
   "source": [
    "### 3.1 given a dataframe generate multiple/subplots for each feature - use plotly graph object (go)\n",
    "- Using go in subplots, each plot generated have different color automatically"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2d8b3f14-c8f0-4201-b7da-215d10cc0e54",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_multiple_hist(df, number_columns = 2):\n",
    "    \"\"\"\n",
    "    Plot multiple hist for each feature in the dataframe\n",
    "    \n",
    "    Args\n",
    "        df (datafame)\n",
    "\n",
    "    Return\n",
    "        fig (figure plotly): fig of plotly with the plot generated\n",
    "    \"\"\"\n",
    "    # get list features\n",
    "    list_features = df.columns.tolist()\n",
    "\n",
    "\n",
    "    # get number of rows (number row = number of data / number of columns)\n",
    "    # (considering fixed the number of columns) \n",
    "    if (df.shape[1] % number_columns) != 0:\n",
    "        number_rows = (df.shape[1] // number_columns) + 1 \n",
    "    else:\n",
    "        number_rows = (df.shape[1] // number_columns)\n",
    "\n",
    "\n",
    "    ############################## \n",
    "    # Create los subplots\n",
    "    fig = make_subplots(rows = number_rows, cols = number_columns, shared_xaxes=False, subplot_titles=list_features)\n",
    "\n",
    "    # add each histogram\n",
    "    for index_feature, feature in enumerate(list_features):\n",
    "\n",
    "        # obtener índices en el subplot (en plotly los índices comienzan en 1, por lo que debe sumarse un 1 a los resultados obtenidos)\n",
    "        row = (index_feature // number_columns) + 1\n",
    "        column = (index_feature % number_columns) + 1\n",
    "        \n",
    "        # TODO: ADD CODE TO GENERATE GRAPH USING PLOTLY OBJECT (go)\n",
    "        fig.add_trace(go.Histogram(x = df[feature], name = feature), row = row, col = column)\n",
    "        \n",
    "\n",
    "    # update layout\n",
    "    fig.update_layout(height=len(list_features)*250, \n",
    "                      width=1600, \n",
    "                      title_text = \"Histograms\",\n",
    "                      title_x = 0.5, # centrar titulo\n",
    "                    title_font = dict(size = 28)\n",
    "                     )\n",
    "    #fig.update_layout( title_text = \"Histograms\")\n",
    "\n",
    "    \n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "274f1e52-33af-45bd-842b-8360af19602b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1ab8ad30-7769-4427-a3df-6e2b01903e60",
   "metadata": {},
   "source": [
    "### 3.2 given a dataframe generate multiple/subplots for each feature - use plotly express (px)\n",
    "- Using the same functions to individual plot, now to subplots.\n",
    "- In this case a individual figure is generated, then the data of the figure is extracted using \"fig.data\"\n",
    "- Depending of the number of figure, the \"fig.data\" could change its shape. For example in you do a line plot of one feature only exists one data and you can access with \"fig.data[0]\"\n",
    "- But when a multiple plots is generated (multiple in a way internall of plotly of count the plots) the list \"fig.data\" has more than one element. For example, ploting a line plot of 3 feature, the object figure has 3 differents data one for each plot. fig.data[0], fig.data[1], fig.data[2]\n",
    "- In addition, in this data getting you can modified the values and get change for example the color of the plot.\n",
    "- \"fig.data\" contains all the information necesary to plot the plotly figure\n",
    "- When in a subplots generate a individual plot with plotly express, the caracterstics of the plot is the same and only change the values. Por example, in a subplot for each feature in all subplot the values change according the values of the feature, but the color of the plot is the same in each subplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "58e838c3-612e-4bbf-ac77-dbbc038899b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_multiple_boxplot_months(df, number_columns = 1):\n",
    "    \"\"\"\n",
    "    Plot boxplots of each month and each year. See the montly distribution of ALL features\n",
    "\n",
    "    Args\n",
    "        df (datafame): dataframe input\n",
    "        number_columns (integer): number of columns, by default ONE column\n",
    "\n",
    "    Return\n",
    "        fig (figure plotly): fig of plotly with the plot generated\n",
    "    \"\"\"\n",
    "    \n",
    "    # get list of features\n",
    "    list_features = df.columns.tolist()\n",
    "\n",
    "    # get number of rows (number row = number of data / number of columns)\n",
    "    # (considering fixed the number of columns) \n",
    "    if (df.shape[1] % number_columns) != 0:\n",
    "        number_rows = (df.shape[1] // number_columns) + 1 \n",
    "    else:\n",
    "        number_rows = (df.shape[1] // number_columns)\n",
    "\n",
    "\n",
    "    ############################## \n",
    "    # create subplots\n",
    "    fig = make_subplots(rows = number_rows, \n",
    "                        cols = number_columns, \n",
    "                        subplot_titles = df.columns,\n",
    "                        shared_xaxes=False\n",
    "                        #vertical_spacing = 0.2 / len(number_rows) # with this parameter is possible reduce the vertical space, but the figure size need to be modified because the subplots become biggers\n",
    "                       )\n",
    "\n",
    "    # add subplot of boxplots for each month and year\n",
    "    for index_feature, feature in enumerate(list_features):\n",
    "\n",
    "        # obtener índices en el subplot (en plotly los índices comienzan en 1, por lo que debe sumarse un 1 a los resultados obtenidos)\n",
    "        row = (index_feature // number_columns) + 1\n",
    "        column = (index_feature % number_columns) + 1\n",
    "        \n",
    "        # TODO: DO PLOT WITH PLOTLY EXPRESS AND THEN GET THE INFROMATION OF EACH TRACE IN fig.data AND ADD IT INTO THE SUBPLOTS\n",
    "        box_fig = px.box(df, x=df.index.month, y=feature, color=df.index.year)\n",
    "        for trace in box_fig.data:\n",
    "            fig.add_trace(trace, row = row, col = column)\n",
    "\n",
    "\n",
    "  # adjust plot\n",
    "    fig.update_layout(title = 'Boxplots for Month and Year',\n",
    "                      xaxis_title='Month',\n",
    "                      yaxis_title='Value',\n",
    "                      legend_title='Year',\n",
    "                      title_x=0.5,  # center\n",
    "                      title_font=dict(size=20),\n",
    "                      height=1450 * number_rows,  # largo\n",
    "                      width=1850 * number_columns, # ancho\n",
    "                      showlegend=True,\n",
    "                      boxmode='group',  # Group boxplots by month\n",
    "                      boxgap=0.2)  # Adjust the gap between grouped boxplots\n",
    "    ############################## \n",
    "\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02cc7c11-19c0-4609-aed9-ed6fa37cb480",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bce32f7d-33a1-4acd-b5c8-9213e9e468d5",
   "metadata": {},
   "source": [
    "### 4. Change atributes of the plot with fig.data\n",
    "In this example the color of a trend line is modified"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "059ee5a0-8d36-492d-904b-c483ce6a21b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_individual_scatter_plot(df, feature_x, feature_y, marginal_hist = False):\n",
    "    \"\"\"\n",
    "    Create an individual scatter plot between two variables\n",
    "    \n",
    "    Args\n",
    "        df (dataframe): input dataframe with the feature to plot in the scatter plot\n",
    "        feature_x (string): name of the feature in x-axis\n",
    "        feature_y (string): name of the feature in y-axis\n",
    "        marginal_hist (bool): plot a histogram as marginal (feature_x and feature_y). By default in false\n",
    "    \n",
    "    Return\n",
    "        fig (figure plotly): fig of plotly with the plot generated\n",
    "    \"\"\"\n",
    "\n",
    "    # plot scatter plot\n",
    "    if marginal_hist == True:\n",
    "        fig = px.scatter(df, x = feature_x, y = feature_y, marginal_x = \"histogram\", marginal_y=\"histogram\", trendline=\"ols\")\n",
    "        tittle_plot = f'scatter plot: {feature_x} vs {feature_y}. Marginal distributions'\n",
    "    else:\n",
    "        fig = px.scatter(df, x = feature_x, y = feature_y, trendline=\"ols\")\n",
    "        tittle_plot = f'scatter plot: {feature_x} vs {feature_y}'\n",
    "\n",
    "    \n",
    "    # TODO CHANGE ATRIBUTES OF THE FEATURE IN fig.data\n",
    "    fig.data[-1]['marker']['color'] = '#d62728' # change color to brick red\n",
    "\n",
    "    # update title\n",
    "    fig.update_layout(\n",
    "      title_text = tittle_plot,\n",
    "      title_x = 0.5, # centrar titulo\n",
    "      title_font = dict(size = 20)\n",
    "    )\n",
    "\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "137ecc59-012b-4046-94a8-1f0dd6a71668",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6625e458-3f16-4be1-b36b-20940962f9ee",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10a94168-b592-4ea3-9c21-ef47cdb71d3b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b2655e81-f0c2-4b03-84b7-807e0f557e62",
   "metadata": {},
   "source": [
    "# Transversal functions to transform data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df187fde-e14d-41c0-b3f4-5b916ab6a6e6",
   "metadata": {},
   "source": [
    "### 1. Segmentation data: custom segmentation - percentile segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a60fe421-3ff8-467a-8fab-fa0627dcb463",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'  '"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##### SEGMENTATION DATA CUSTOM SEGMENTATION - PERCENTILE SEGMENTATION\n",
    "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\" SEGMENTATION DATA CUSTOM \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n",
    "def custom_segmentation(df, var_segment, intervals_segments, labels_segments):\n",
    "    \"\"\"\n",
    "    Given a dataframe, generate a new column with a categorical values that divide the data in differents segments. \n",
    "    Segment the data by a certain variable with a custom segmentation\n",
    "    \n",
    "    Args\n",
    "        df (dataframe): dataframe input\n",
    "        var_segment (string): variable feature/target used to segment the data\n",
    "        intervals_segments (list of numbers): list with the thresholds used to segment the data\n",
    "        labels_segments (list of strings): list with the names of the differents segments generated. Shape: len(intervals_segments) - 1\n",
    "\n",
    "    Return\n",
    "        df(dataframe): the input dataframe with a new column with the segment\n",
    "    \"\"\"\n",
    "\n",
    "    # apply pd.cut to generate intervals\n",
    "    df[f'{var_segment}_segments'] = pd.cut(df[var_segment], \n",
    "                                           bins = intervals_segments, \n",
    "                                           labels = labels_segments, \n",
    "                                           include_lowest = True\n",
    "                                          )\n",
    "\n",
    "    # order data by the custom segmentation - to generate plots it is neccesary to sort the data\n",
    "    # if the plot show a temporal relation like trends plots, it is necessary sort the data by index\n",
    "    df = df.sort_values(by = [var_segment])\n",
    "    \n",
    "    return df\n",
    "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"  \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n",
    "\n",
    "\n",
    "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\" SEGMENTATION DATA PERCENTILES \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n",
    "def generate_labels_percentile_segmentation(df, var_segment, list_percentile, list_labels_percentile_base):\n",
    "    \"\"\"\n",
    "    Given a dataframe and a feature to segment in percentiles, calculate the labels of the segmentation\n",
    "    \n",
    "    Choices of labels:\n",
    "        labels_percentile: ['q1', 'q2', 'q3', 'q4']\n",
    "        labels_values: ['(0.15-1.2)', '(1.2-1.8)', '(1.8-2.65)', '(2.65-5.0)']\n",
    "        labels_percentile_values: ['q1 - (0.15-1.2)', 'q2 - (1.2-1.8)', 'q3 - (1.8-2.65)', 'q4 - (2.65-5.0)']\n",
    "        \n",
    "    Args\n",
    "        df (dataframe): dataframe input\n",
    "        var_segment (string): variable feature/target used to segment the data\n",
    "        list_percentile (list): list of floats with the percentiles to divide the data\n",
    "        list_labels_percentile_base (list): list of strings with the base labels of percentiles to divide the data \n",
    "\n",
    "    Return\n",
    "        list_labels_percentile_base, list_labels_values_range, list_labels_percentile_values_range (lists). list of the 3 types of labels generated\n",
    "    \"\"\"\n",
    "\n",
    "    # get values of each percentile\n",
    "    list_percentile_values = [df[var_segment].quantile(x).round(2) for x in list_percentile]\n",
    "    \n",
    "    # generate a list of string with the start value and end value of each interval\n",
    "    list_percentile_start_end = [] \n",
    "    for index in range(len(list_percentile_values)-1): \n",
    "        start_value = list_percentile_values[index]\n",
    "        end_value = list_percentile_values[index+1]\n",
    "        string_start_end = f'{start_value}-{end_value}'\n",
    "        list_percentile_start_end.append(string_start_end)\n",
    "    \n",
    "    # output final v0 - base\n",
    "    #list_labels_percentile_base\n",
    "    \n",
    "    # output final v1 - only values start end\n",
    "    list_labels_values_range = []\n",
    "    for index in range(len(list_labels_percentile_base)):\n",
    "        string_output = f'({list_percentile_start_end[index]})'\n",
    "        list_labels_values_range.append(string_output)\n",
    "    \n",
    "    # output final v2 - percentile and values start end\n",
    "    list_labels_percentile_values_range = []\n",
    "    for index in range(len(list_labels_percentile_base)):\n",
    "        string_output = f'{list_labels_percentile_base[index]} - ({list_percentile_start_end[index]})'\n",
    "        list_labels_percentile_values_range.append(string_output)\n",
    "    \n",
    "    return list_labels_percentile_base, list_labels_values_range, list_labels_percentile_values_range\n",
    "\n",
    "\n",
    "\n",
    "def percentile_segmentation(df, var_segment, type_percentile):\n",
    "    \"\"\"\n",
    "    Given a dataframe, generate a new column with a categorical values that divide the data in differents segments. \n",
    "    Segment the data by a certain variable with a percentile segmentation. the segmentation could be by quartiles, quintiles, deciles\n",
    "    \n",
    "    Args\n",
    "        df (dataframe): dataframe input that will be modified\n",
    "        var_segment (string): variable feature/target used to segment the data\n",
    "        type_percentile(string): type of percentile segmentation\n",
    "    \n",
    "    Return\n",
    "        df(dataframe): the input dataframe with a new column with the segment\n",
    "\n",
    "    TODO: THE LABELS GERATED AND USED ARE ONLY ['q1 - (0.15-1.2)', 'q2 - (1.2-1.8)', 'q3 - (1.8-2.65)', 'q4 - (2.65-5.0)']\n",
    "    ADD A ARGS TO SELECT THE KIND OF LABELS\n",
    "    \"\"\"\n",
    "\n",
    "    # validate input - TODO: create a decent unit test\n",
    "    choices_segmentation = ['quartile', 'quintile', 'decile']\n",
    "    if type_percentile not in choices_segmentation:\n",
    "        print('error in choices of segmentation')\n",
    "        print(f'Possibles choices: {choices_segmentation}')\n",
    "        return 0\n",
    "\n",
    "    # quartile\n",
    "    if type_percentile == 'quartile':\n",
    "        quartile = [0, 0.25, 0.5, 0.75, 1]\n",
    "        labels_quartile_base = ['q1', 'q2', 'q3', 'q4']\n",
    "        _, _,  labels_quartile = generate_labels_percentile_segmentation(df, var_segment, quartile, labels_quartile_base)\n",
    "        df[f'quartile_{var_segment}'] = pd.qcut(df[var_segment], q = quartile, labels = labels_quartile)\n",
    "    \n",
    "    # quintile\n",
    "    if type_percentile == 'quintile':\n",
    "        quintile = [0, 0.2, 0.4, 0.6, 0.8, 1]\n",
    "        labels_quintile_base = ['q1', 'q2', 'q3', 'q4', 'q5']\n",
    "        _, _,  labels_quintile = generate_labels_percentile_segmentation(df, var_segment, quintile, labels_quintile_base)\n",
    "        df[f'quintile_{var_segment}'] = pd.qcut(df[var_segment], q = quintile, labels = labels_quintile)\n",
    "\n",
    "\n",
    "    # decile\n",
    "    if type_percentile == 'decile':\n",
    "        decile = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]\n",
    "        labels_decile_base = ['d1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8', 'd9', 'd10']\n",
    "        _, _,  labels_decile = generate_labels_percentile_segmentation(df, var_segment, decile, labels_decile_base)\n",
    "        df[f'decile_{var_segment}'] = pd.qcut(df[var_segment], q = decile, labels = labels_decile)\n",
    "\n",
    "    return df\n",
    "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"  \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "154641fc-88a0-4628-96f8-924c40fa4ef9",
   "metadata": {},
   "source": [
    "### 2. map pair of features. generate a list of tuple of each combination of features (feature_x, feature_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e592a9a1-c951-4310-b383-afdf68610b1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# auxiliar function to map features in a pair (feature_x, feature_y)\n",
    "def list_map_combinations_features(list_features, dim_combinations = 2):\n",
    "    \"\"\"\n",
    "    Given a list of features of a dataframe, map all the combinations between each features. combinations without replace and (a,b) is the same (b,a)\n",
    "    IN PREVIOUS CODES THERE ARE OTHER WAY TO MAP THE FEATURESS, ACUALLY THIS WAY IS BETTER\n",
    "\n",
    "    Args:\n",
    "        list_features (list): list of features that will generate the combinations\n",
    "        dim_combinations (string): dimensions of combinations. default 2 -> generate a pair of features (feature_x, feature_y)\n",
    "\n",
    "    Return\n",
    "        list_tuple_combinations (list): list where each element is a tuple with the combination\n",
    "    \"\"\"\n",
    "    # get all the possible combinations withtout repeteat\n",
    "    todas_combinaciones = combinations(list_features, dim_combinations)\n",
    "    \n",
    "    # generate output\n",
    "    list_tuple_combinations = []\n",
    "    for comb in todas_combinaciones:\n",
    "        list_tuple_combinations.append(comb)\n",
    "\n",
    "    return list_tuple_combinations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84f2396d-4e6d-46ac-af9d-3f3667520973",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89507ebc-9282-41a0-b17a-1ebbc88b9281",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c20313e4-259d-4b8f-b89f-16e378773b9e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "416f6120-5ecd-4350-a7c8-f08e6bba9c70",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}