Customer_Purchase_Analysis.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **Customer Purchase Analysis**\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "*   Customer Analysis:\n",
        "\n",
        "  1.   Repeat purchase rate\n",
        "  2.   Churn rate\n",
        "  3.   Retention rate\n",
        "  4.   Customer Lifetime Value (CLTV)\n",
        "  5.   Revenue impact of customer retentio\n",
        "\n",
        "\n",
        "\n",
        "*   Sales Performance Analysis:\n",
        "\n",
        "  1.   Monthly and yearly sales trends\n",
        "  2.   Products with the highest frequency\n",
        "  3.   Revenue analysis based on country\n",
        "  4.   Average revenue per transaction\n",
        "  5.   Popular days of the week for purchases\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "InQ-H6a_2LM8"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {
        "id": "p-EwZwhmh9o9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0918c38b-381e-4ae2-c31c-f50554eeee9d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-08-17 18:09:16--  https://archive.ics.uci.edu/static/public/352/online+retail.zip\n",
            "Resolving archive.ics.uci.edu (archive.ics.uci.edu)... 128.195.10.252\n",
            "Connecting to archive.ics.uci.edu (archive.ics.uci.edu)|128.195.10.252|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: unspecified\n",
            "Saving to: ‘online+retail.zip.1’\n",
            "\n",
            "online+retail.zip.1     [         <=>        ]  22.62M  4.56MB/s    in 5.2s    \n",
            "\n",
            "2024-08-17 18:09:22 (4.34 MB/s) - ‘online+retail.zip.1’ saved [23715478]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "!wget https://archive.ics.uci.edu/static/public/352/online+retail.zip"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n"
      ],
      "metadata": {
        "id": "rlMe9y0vs9cF"
      },
      "execution_count": 82,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!unzip online+retail.zip"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jwxo3TptXRBB",
        "outputId": "aeb423f9-c16c-4402-9252-064ba3ec256b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Archive:  online+retail.zip\n",
            "replace Online Retail.xlsx? [y]es, [n]o, [A]ll, [N]one, [r]ename: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!ls"
      ],
      "metadata": {
        "id": "mEQEDEuoXdyQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Install the necessary library\n",
        "\n",
        "import pandas as pd\n",
        "\n",
        "# Load the Excel file\n",
        "data = pd.read_excel('Online Retail.xlsx')\n",
        "\n",
        "# Save DataFrame to CSV\n",
        "data.to_csv('OnlineRetail.csv', index=False)\n",
        "\n",
        "# Verify by listing files\n",
        "!ls\n"
      ],
      "metadata": {
        "id": "mMn0oTSKXhJf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data = pd.read_csv('OnlineRetail.csv')\n",
        "data"
      ],
      "metadata": {
        "id": "eLQkid0jYBuV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data.shape"
      ],
      "metadata": {
        "id": "H8a25dLyY_Wi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The current dataset has around 541909 rows and 8 different columns"
      ],
      "metadata": {
        "id": "9DyYCSoTZNdZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Exploring around different columns\n",
        "data.columns"
      ],
      "metadata": {
        "id": "osZV3FHNZLa7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data.info()"
      ],
      "metadata": {
        "id": "u-O3LB_qZZPs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "From the information type we can observe some columns are not in correct dtype and format\n",
        "\n",
        "*   Invoice Number which is integer but is shown as \"Object\"\n",
        "*   InvoiceDate which is datetime is shown as \"Object\"\n"
      ],
      "metadata": {
        "id": "UIZIL2WiZxib"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Primary Goal ---> converting to correct format.\n",
        "#Targeted Columns ---> InvoiceDate and InvoiceNumber\n",
        "\n",
        "data['InvoiceDate'] = pd.to_datetime(data['InvoiceDate'])\n",
        "data['InvoiceNo'] = data['InvoiceNo'].astype(int)\n"
      ],
      "metadata": {
        "id": "SJApysc6ZhJU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can see that invoiceNo which seems to be int is not int and is also not getting convert to int.\n",
        "checking if it actually is a integer based column or not"
      ],
      "metadata": {
        "id": "NaR5YQ1ve4z0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "non_numeric_mask = ~data['InvoiceNo'].astype(str).str.isnumeric()\n",
        "non_numeric_values = data[non_numeric_mask]\n",
        "non_numeric_values"
      ],
      "metadata": {
        "id": "uMTsf9YrfIgw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see that there is string present in the avobe dataset for the column invoice number. SO, we cannot convert it"
      ],
      "metadata": {
        "id": "zn5QQJF8fKpk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data.info()"
      ],
      "metadata": {
        "id": "z7dFOhiJawbc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data.head()"
      ],
      "metadata": {
        "id": "FjW3KZmMiXWx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_copy = data.copy()\n",
        "data_copy"
      ],
      "metadata": {
        "id": "bC1L5vrrqLTj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_copy.head(3)"
      ],
      "metadata": {
        "id": "6Gl9wKIDqQdJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This report covers a detailed analysis about custoer purchase and a detailed analysis about how the factors are dependent on each other."
      ],
      "metadata": {
        "id": "2mTA-2vwp20p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Task: Calculate the total revenue generated by each country.\n",
        "data_copy['TotalRevenue'] = data_copy['Quantity'] * data_copy['UnitPrice']\n",
        "revenue_analysis = data_copy.groupby('Country')['TotalRevenue'].sum().sort_values(ascending = False).reset_index()\n",
        "revenue_analysis"
      ],
      "metadata": {
        "id": "merYZfO-ptyc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "top_countries = revenue_analysis.head(5)\n",
        "top_countries"
      ],
      "metadata": {
        "id": "YoTL7KqbsnLQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#creating another dummy dataset for storing the revenue of the countries that are not in top 5\n",
        "\n",
        "others = pd.DataFrame({'Country':'Others','TotalRevenue':[revenue_analysis['TotalRevenue'].iloc[5:].sum()]})\n",
        "others"
      ],
      "metadata": {
        "id": "KUoE8GBrtbB0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#To create a versatie pie chat to show the shares captured by top countries and others\n",
        "\n",
        "combined_revenue_analysis = pd.concat([top_countries, others], ignore_index=True)\n",
        "combined_revenue_analysis"
      ],
      "metadata": {
        "id": "FdVDxb4AuIST"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Versatile Pie Chat\n",
        "combined_revenue_analysis.set_index('Country', inplace=True)\n",
        "combined_revenue_analysis['TotalRevenue'].plot(kind='pie', autopct='%1.1f%%', figsize=(10, 8))\n"
      ],
      "metadata": {
        "id": "JzwuipKeukWk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_copy.head()"
      ],
      "metadata": {
        "id": "NR8s5R-GzFVy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Compute the total amount spent by each customer.\n",
        "consumer_spending_analysis = data_copy.groupby('CustomerID')['TotalRevenue'].sum().reset_index()\n",
        "consumer_spending_analysis"
      ],
      "metadata": {
        "id": "r36fzgXCvY1u"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Identify Top 10 customers based on TotalRevenue:\n",
        "top_customers = consumer_spending_analysis.sort_values(by = 'TotalRevenue', ascending = False).head(10)\n",
        "top_customers"
      ],
      "metadata": {
        "id": "5qy_Q4_2ztdv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Identify The transaction made by each customers:\n",
        "transaction_count = data_copy.groupby('CustomerID')['InvoiceNo'].nunique().reset_index(name='TransactionCount')\n",
        "transaction_count"
      ],
      "metadata": {
        "id": "eNzqFq9s0n2q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Merging the above data to top10\n",
        "top10_customers = top_customers.merge(transaction_count, on='CustomerID')\n",
        "top10_customers"
      ],
      "metadata": {
        "id": "YaWxSl4j1uKy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Calcuationg the average transaction per customer\n",
        "top10_customers['AverageSpendingPerTransaction'] = top10_customers['TotalRevenue'] / top10_customers['TransactionCount']\n",
        "top10_customers['AverageSpendingPerTransaction']"
      ],
      "metadata": {
        "id": "nGAkqwew14SY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_copy.head(4)"
      ],
      "metadata": {
        "id": "dcWxU4NM15wg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Analyze the sales performance over time.\n",
        "#Specifically, calculate the total revenue generated per month, and identify any trends or patterns.\n",
        "#Additionally, determine which month had the highest sales and which had the lowest.\n",
        "data_copy['month'] = data_copy['InvoiceDate'].dt.month\n",
        "sales_performance_analysis = data_copy.groupby('month')['TotalRevenue'].sum().reset_index()\n",
        "sales_performance_analysis"
      ],
      "metadata": {
        "id": "xHfZ9R9O69Ce"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Checking for the month that has observed the maximum revenue and the month with minium revenue\n",
        "max_sales_performance_analysis = sales_performance_analysis['TotalRevenue'].max()\n",
        "min_sales_performance_analysis = sales_performance_analysis['TotalRevenue'].min()\n",
        "\n",
        "#Extracting the month associated with the max values\n",
        "month_max_sales_performance_analysis = sales_performance_analysis.loc[sales_performance_analysis['TotalRevenue'].idxmax()]\n",
        "month_min_sales_performance_analysis = sales_performance_analysis.loc[sales_performance_analysis['TotalRevenue'].idxmin()]\n",
        "#observing the values\n",
        "print(f\"Highest Revenue: Month {month_max_sales_performance_analysis['month']} with ${month_max_sales_performance_analysis['TotalRevenue']:.2f}\")\n",
        "print(f\"Highest Revenue: Month {month_min_sales_performance_analysis['month']} with ${month_min_sales_performance_analysis['TotalRevenue']:.2f}\")\n"
      ],
      "metadata": {
        "id": "KRvRw9sf8Zel"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(10, 6))\n",
        "plt.plot(sales_performance_analysis['month'], sales_performance_analysis['TotalRevenue'], marker='o', linestyle='-', color='b', linewidth=2)\n",
        "\n",
        "# Highlighting the month with the highest revenue\n",
        "plt.plot(month_max_sales_performance_analysis['month'], month_max_sales_performance_analysis['TotalRevenue'], 'go', markersize=10, label='Max Revenue')\n",
        "\n",
        "# Highlighting the month with the lowest revenue\n",
        "plt.plot(month_min_sales_performance_analysis['month'], month_min_sales_performance_analysis['TotalRevenue'], 'ro', markersize=10, label='Min Revenue')\n",
        "\n",
        "# Adding title and labels\n",
        "plt.title('Monthly Revenue Trend')\n",
        "plt.xlabel('Month')\n",
        "plt.ylabel('Total Revenue')\n",
        "plt.xticks(sales_performance_analysis['month'])  # Ensure all months are shown on the x-axis\n",
        "\n",
        "# Adding a legend\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "EcV4MZMl_UJi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Analyze the sales performance over time.\n",
        "#Specifically, calculate the total revenue generated per YEAR, and identify any trends or patterns.\n",
        "#Additionally, determine which month had the highest sales and which had the lowest.\n",
        "data_copy['year'] = data_copy['InvoiceDate'].dt.year\n",
        "year_performance_analysis = data_copy.groupby('year')['TotalRevenue'].sum().reset_index()\n",
        "year_performance_analysis"
      ],
      "metadata": {
        "id": "qmzA5SBEBIAp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_copy['year'].value_counts()"
      ],
      "metadata": {
        "id": "RxVklmc0CMjW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "max_year_performance_analysis = year_performance_analysis.loc[year_performance_analysis['TotalRevenue'].idxmax()]\n",
        "min_year_performance_analysis = year_performance_analysis.loc[year_performance_analysis['TotalRevenue'].idxmin()]\n",
        "\n",
        "print(f\"Highest Revenue: Year {max_year_performance_analysis ['year']} with ${max_year_performance_analysis['TotalRevenue']:.2f}\")\n",
        "print(f\"Highest Revenue: Year {min_year_performance_analysis ['year']} with ${min_year_performance_analysis['TotalRevenue']:.2f}\")"
      ],
      "metadata": {
        "id": "E3_uT7J4DOFr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plotting the revenue trend by year\n",
        "plt.figure(figsize=(5, 5))\n",
        "\n",
        "# Plotting the total revenue per year\n",
        "plt.plot(year_performance_analysis['year'], year_performance_analysis['TotalRevenue'], marker='o', linestyle='-', color='b', label='Revenue')\n",
        "\n",
        "# Highlighting the year with maximum revenue\n",
        "plt.plot(max_year_performance_analysis['year'], max_year_performance_analysis['TotalRevenue'], 'go', markersize=10, label='Max Revenue')\n",
        "\n",
        "# Highlighting the year with minimum revenue\n",
        "plt.plot(min_year_performance_analysis['year'], min_year_performance_analysis['TotalRevenue'], 'ro', markersize=10, label='Min Revenue')\n",
        "\n",
        "# Adding title and labels\n",
        "plt.title('Yearly Revenue Trend')\n",
        "plt.xlabel('Year')\n",
        "plt.ylabel('Total Revenue')\n",
        "plt.xticks(year_performance_analysis['year'])  # Ensure all years are shown on the x-axis\n",
        "\n",
        "# Adding a legend\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "4UMbuptGCywi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_copy.head(4)\n"
      ],
      "metadata": {
        "id": "IsX_03l0ESjI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Identify the most frequently purchased products.\n",
        "\n",
        "#Task:\n",
        "#Find the top 10 products with the highest purchase frequency.\n",
        "#Display the product descriptions and the number of times each product was purchased.\n",
        "\n",
        "product_with_highest_frequency = data_copy.groupby('Description')['TotalRevenue'].size().reset_index(name='Frequency')\n",
        "product_with_highest_frequency.sort_values(by='Frequency', ascending=False).head(10)"
      ],
      "metadata": {
        "id": "8kBvkZvg1_iL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Analyze the sales performance by country.\n",
        "\n",
        "#Task:\n",
        "#Calculate the total revenue generated by each country.\n",
        "#Identify the top 5 countries with the highest revenue.\n",
        "#Plot a bar chart to visualize the revenue distribution among these top 5 countries.\n",
        "import seaborn as sns\n",
        "revenue_analysis_based_on_country = data_copy.groupby('Country')['TotalRevenue'].sum().reset_index()\n",
        "top_5_countries = revenue_analysis_based_on_country.sort_values(by = 'TotalRevenue', ascending = False).head(5)\n",
        "sns.barplot(x='TotalRevenue', y='Country', data=top_5_countries)\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "dxA0fham2tAR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Caculate the average revenue per transaction\n",
        "revenue_per_transcation = data_copy.groupby('InvoiceNo')['TotalRevenue'].mean().reset_index()\n",
        "revenue_per_transcation"
      ],
      "metadata": {
        "id": "InRzfgeRNizu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Determine the average revenue per transaction.\n",
        "\n",
        "#Task:\n",
        "#Calculate the average revenue generated per transaction (InvoiceNo).\n",
        "#Display the average revenue and the total number of transactions.\n",
        "\n",
        "revenue_per_transactions = data_copy.groupby('InvoiceNo')['TotalRevenue'].sum().reset_index()\n",
        "average_revenue_per_transaction = revenue_per_transactions['TotalRevenue'].mean()\n",
        "total_transactions = revenue_per_transactions['InvoiceNo'].nunique()\n",
        "total_transactions"
      ],
      "metadata": {
        "id": "PsMyc8O_O7u8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_copy.head(3)"
      ],
      "metadata": {
        "collapsed": true,
        "id": "Eq_Ozl2IPn4t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_copy['week'] = data_copy['InvoiceDate'].dt.day_name()\n",
        "data_copy['week']"
      ],
      "metadata": {
        "collapsed": true,
        "id": "ZepaX2AlQKA7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_copy.head(3)"
      ],
      "metadata": {
        "collapsed": true,
        "id": "y9dVxX6BQvrb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Identify the most popular day of the week for purchases.\n",
        "\n",
        "#Task:\n",
        "#Add a new column to the dataset indicating the day of the week for each transaction (e.g., Monday, Tuesday).\n",
        "#Determine which day of the week has the highest number of transactions.\n",
        "#Display the day and the number of transactions.\n",
        "\n",
        "data_copy['week'] = data_copy['InvoiceDate'].dt.day_name()\n",
        "highest_transaction_day = data_copy.groupby('week')['InvoiceNo'].size().reset_index(name = 'Count')\n",
        "topv = highest_transaction_day.loc[highest_transaction_day['Count'].idxmax()]  # Find the row with the highest count\n",
        "print(f\"The most popular day for purchases is {topv['week']} with {topv['Count']} transactions.\")\n"
      ],
      "metadata": {
        "id": "e8KthOORQyVo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_copy.head(1)"
      ],
      "metadata": {
        "id": "sajuSIIQhPQk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Identify the average revenue per transaction and compare it across different countries.\n",
        "\n",
        "#Task:\n",
        "\n",
        "#Calculate the average revenue per transaction for each country.\n",
        "#Display the countries with the highest and lowest average revenue per transaction.\n",
        "#Plot the average revenue per transaction for all countries.\n",
        "\n",
        "country_revenue = data_copy.groupby('Country')['TotalRevenue'].sum()\n",
        "country_transaction = data_copy.groupby('Country')['InvoiceNo'].nunique()\n",
        "average_transaction_per_country = (country_revenue / country_transaction).reset_index(name = 'Average_transaction_per_country')\n",
        "max_avg_revenue_country = average_transaction_per_country.loc[average_transaction_per_country['Average_transaction_per_country'].idxmax()]\n",
        "min_avg_revenue_country = average_transaction_per_country.loc[average_transaction_per_country['Average_transaction_per_country'].idxmin()]\n",
        "\n",
        "print(f\"Country with highest average revenue per transaction: {max_avg_revenue_country['Country']} (${max_avg_revenue_country['Average_transaction_per_country']:.2f})\")\n",
        "print(f\"Country with lowest average revenue per transaction: {min_avg_revenue_country['Country']} (${min_avg_revenue_country['Average_transaction_per_country']:.2f})\")\n",
        "plt.figure(figsize=(12,6))\n",
        "plt.bar(average_transaction_per_country['Country'], average_transaction_per_country['Average_transaction_per_country'], color='skyblue')\n",
        "plt.xticks(rotation=90)\n",
        "plt.xlabel('Country')\n",
        "plt.ylabel('Average Revenue per Transaction')\n",
        "plt.title('Average Revenue per Transaction by Country')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "Hx4xcrwARhQv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_copy.head(3)"
      ],
      "metadata": {
        "id": "z9Y8j3c1hrhn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Objective: Calculate the repeat purchase rate and customer churn rate.\n",
        "#Breaking down the part to two major part\n",
        "\n",
        "#Repeat Purchase Rate\n",
        "\n",
        "customer_repeat = data_copy.groupby('CustomerID')['InvoiceNo'].nunique()\n",
        "\n",
        "repeat_frequency = customer_repeat[customer_repeat>1].count()\n",
        "\n",
        "total_customer_frquency = customer_repeat.count()\n",
        "\n",
        "repeat_purchase_rate = (repeat_frequency/total_customer_frquency)*100\n",
        "\n",
        "#Customer Churn Rate\n",
        "\n",
        "churn_customers = customer_repeat[customer_repeat == 1].count()\n",
        "churn_rate = (churn_customers/total_customer_frquency)*100"
      ],
      "metadata": {
        "id": "9iCkS2eIzvSV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Identify trends in customer retention over time.\n",
        "\n",
        "# Identify the First Purchase Month for Each Customer\n",
        "first_purchase_month = data_copy.groupby('CustomerID')['month'].min().reset_index()\n",
        "first_purchase_month.columns = ['CustomerID', 'FirstPurchaseMonth']\n",
        "\n",
        "# Merge this with the original data\n",
        "data_copy = pd.merge(data_copy, first_purchase_month, on='CustomerID')\n",
        "data_copy"
      ],
      "metadata": {
        "id": "usA1xS1R5fIt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Tracking Subsequent Purchases\n",
        "data_copy['RepeatPurchase'] = (data_copy['month'] > data_copy['FirstPurchaseMonth']).astype(int)\n",
        "data_copy['RepeatPurchase']\n"
      ],
      "metadata": {
        "id": "P_ccPsp__uDJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#retention rate\n",
        "retention_rate = data_copy.groupby('FirstPurchaseMonth')['RepeatPurchase'].mean().reset_index()\n",
        "retention_rate.columns = ['CohortMonth', 'RetentionRate']\n",
        "\n",
        "retention_rate.columns\n",
        "retention_rate"
      ],
      "metadata": {
        "id": "S6VLKsUbAj0n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(10, 6))\n",
        "plt.plot(retention_rate['CohortMonth'], retention_rate['RetentionRate'], marker='o')\n",
        "plt.title('Customer Retention Rate Over Time')\n",
        "plt.xlabel('Cohort Month')\n",
        "plt.ylabel('Retention Rate')\n",
        "plt.xticks(rotation=45)\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "oWoo53o3BiRl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "monthly_customers = data_copy.groupby('month')['CustomerID'].nunique().reset_index(name='UniqueCustomers')\n",
        "data_copy['PrevYearMonth'] = data_copy['month'].shift(1)\n",
        "data_copy.head(5)"
      ],
      "metadata": {
        "id": "rQQ8gQ6rB2QP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Calculating Customer Lifetime Value (CLTV)\n",
        "\n",
        "#Calculating average revenue per transactions\n",
        "total_revenue_per_customer = data_copy['TotalRevenue'].sum()\n",
        "total_tranaction_per_customer = data_copy['InvoiceNo'].nunique()\n",
        "average_revenue_per_transactions = total_revenue_per_customer/total_tranaction_per_customer\n",
        "\n",
        "#Calculating Average Number of Transactions per customer\n",
        "customer_transactions = data_copy.groupby('CustomerID')['InvoiceNo'].nunique()\n",
        "avg_transactions_per_customer = customer_transactions.mean()\n",
        "\n",
        "#Calculate Customer Lifetime Value (CLTV)\n",
        "cltv = average_revenue_per_transactions * avg_transactions_per_customer\n",
        "\n",
        "print(f\"Customer Lifetime Value (CLTV): ${cltv:.2f}\")\n"
      ],
      "metadata": {
        "id": "80pZ4qbJLuwZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Revenue Impact Analysis\n",
        "\n",
        "# 1. Calculate Total Revenue\n",
        "total_revenue = data_copy['TotalRevenue'].sum()\n",
        "\n",
        "# 2. Calculate Retention Rate\n",
        "# Define retention calculation based on your method\n",
        "customer_ret = data_copy.groupby('CustomerID')['InvoiceNo'].nunique()\n",
        "retention_rate = (customer_ret > 1).mean() * 100\n",
        "\n",
        "# 3. Segment Customers Based on Retention Rate\n",
        "# Define segments - adjust as needed based on your data\n",
        "high_retention = customer_ret[customer_ret > customer_ret.median()]\n",
        "low_retention = customer_ret[customer_ret <= customer_ret.median()]\n",
        "\n",
        "# 4. Calculate Total Revenue for Each Segment\n",
        "revenue_high_retention = data_copy[data_copy['CustomerID'].isin(high_retention.index)]['TotalRevenue'].sum()\n",
        "revenue_low_retention = data_copy[data_copy['CustomerID'].isin(low_retention.index)]['TotalRevenue'].sum()\n",
        "\n",
        "# Display Results\n",
        "print(f\"Total Revenue: ${total_revenue:.2f}\")\n",
        "print(f\"Retention Rate: {retention_rate:.2f}%\")\n",
        "print(f\"Revenue for High Retention Customers: ${revenue_high_retention:.2f}\")\n",
        "print(f\"Revenue for Low Retention Customers: ${revenue_low_retention:.2f}\")"
      ],
      "metadata": {
        "id": "HHPcnWBWTfhc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Seasonality Analysis\n",
        "\n",
        "# Aggregate sales by month and year\n",
        "seasonal_sales = data_copy.groupby(['year', 'month'])['TotalRevenue'].sum().reset_index()\n",
        "\n",
        "# Plot seasonal trends\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "sns.lineplot(x='month', y='TotalRevenue', hue='year', data=seasonal_sales)\n",
        "plt.title('Seasonal Sales Trends')\n",
        "plt.xlabel('month')\n",
        "plt.ylabel('Total Revenue')\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "SoYJFM6IVCNH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Customer Purchase Frequency Analysis\n",
        "\n",
        "purchase_frequency = data_copy.groupby('CustomerID')['InvoiceNo'].size().reset_index(name='PurchaseFrequency')\n",
        "# Plot purchase frequency distribution\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "sns.histplot(purchase_frequency['PurchaseFrequency'], bins=20, kde=True)\n",
        "plt.title('Distribution of Purchase Frequency')\n",
        "plt.xlabel('Number of Purchases')\n",
        "plt.ylabel('Frequency')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "QPLA2WLIatP_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate AOV\n",
        "aov = data_copy.groupby('InvoiceNo')['TotalRevenue'].sum().reset_index()\n",
        "aov_mean = aov['TotalRevenue'].mean()\n",
        "\n",
        "# Aggregate AOV by month\n",
        "monthly_aov = data_copy.groupby(['year', 'month'])['TotalRevenue'].sum() / data_copy.groupby(['year', 'month'])['InvoiceNo'].nunique()\n",
        "monthly_aov = monthly_aov.reset_index(name='AOV')\n",
        "\n",
        "# Plot AOV trends\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "sns.lineplot(x='month', y='AOV', hue='year', data=monthly_aov)\n",
        "plt.title('Average Order Value (AOV) Trends')\n",
        "plt.xlabel('month')\n",
        "plt.ylabel('Average Order Value')\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "kEe_9bQNbluI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Sort by customer and date\n",
        "data_copy = data_copy.sort_values(by=['CustomerID', 'InvoiceDate'])\n",
        "\n",
        "# Calculate time between purchases\n",
        "data_copy['TimeBetweenPurchases'] = data_copy.groupby('CustomerID')['InvoiceDate'].diff().dt.days\n",
        "\n",
        "# Analyze the distribution of time between purchases\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "sns.histplot(data_copy['TimeBetweenPurchases'].dropna(), bins=30, kde=True)\n",
        "plt.title('Distribution of Time Between Purchases')\n",
        "plt.xlabel('Days')\n",
        "plt.ylabel('Frequency')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "_HaXEaZNb0zM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Detailed Review of Insights**\n",
        "\n",
        "\n",
        "# Sales Performance Analysis\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Monthly and Yearly Sales Trends:\n",
        "\n",
        "Monthly Trends: You analyzed the sales trends by month, identifying peak and low sales months. This insight helps understand seasonal variations and is crucial for strategic planning, inventory management, and marketing efforts.\n",
        "Yearly Trends: By examining yearly sales data, you identified overall growth or decline trends, which can inform long-term strategic decisions and investment priorities.\n",
        "\n",
        "Products with Highest Frequency:\n",
        "\n",
        "Top Products: Identifying products with high purchase frequencies helps in focusing marketing efforts and ensuring stock availability. This insight is key for optimizing product listings and promotional strategies.\n",
        "Low Frequency Products: Analyzing products with lower purchase frequencies allows you to assess their performance and decide if they need better marketing or should be discontinued.\n",
        "\n",
        "Revenue Analysis Based on Country:\n",
        "\n",
        "Top Revenue Generating Countries: This insight highlights the most lucrative markets, guiding where to focus sales and marketing efforts.\n",
        "Low Revenue Countries: Understanding low-performing markets helps identify potential issues and areas for improvement.\n",
        "\n",
        "Average Revenue per Transaction:\n",
        "\n",
        "High Value Transactions: Recognizing regions or segments with high average revenue per transaction allows for targeted premium strategies.\n",
        "Low Value Transactions: Identifying factors behind lower average revenue helps in implementing strategies to boost transaction values.\n",
        "\n",
        "Popular Days of the Week for Purchases:\n",
        "\n",
        "Peak Days: Knowing the days with the highest transaction volumes helps in optimizing staffing, promotions, and operational strategies.\n",
        "Low Traffic Days: Understanding days with lower activity helps in crafting strategies to increase engagement and sales on those days.\\\n",
        "\n",
        "\n",
        "# Customer Analysis\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "Repeat Purchase Rate:\n",
        "\n",
        "High Repeat Rate: Indicates strong customer loyalty and effectiveness of retention strategies. It’s essential to analyze and replicate successful practices to enhance overall customer retention.\n",
        "Low Repeat Rate: Signals potential issues in customer satisfaction or engagement. It’s important to investigate and implement strategies to improve repeat purchases.\n",
        "\n",
        "Churn Rate:\n",
        "\n",
        "High Churn Rate: Identifying high churn rates points to problems with customer retention. Strategies to address customer dissatisfaction and improve retention are crucial.\n",
        "Low Churn Rate: Reflects effective retention efforts. Maintaining and building upon successful practices can further enhance customer loyalty.\n",
        "\n",
        "Retention Rate:\n",
        "\n",
        "High Retention Rate: High retention rates indicate successful retention strategies. Emphasize and expand on successful tactics to maintain and increase retention.\n",
        "Low Retention Rate: Highlights the need for improved retention strategies. Explore reasons for low retention and develop targeted actions to address them.\n",
        "\n",
        "Customer Lifetime Value (CLTV):\n",
        "\n",
        "High CLTV: Represents valuable customers contributing significantly to revenue over their lifetime. Focus on nurturing these relationships to maximize their value.\n",
        "Low CLTV: Indicates the need to enhance strategies to increase the lifetime value of customers. Implementing upselling or cross-selling strategies may help improve CLTV.\n",
        "\n",
        "Revenue Impact of Customer Retention:\n",
        "\n",
        "Positive Impact: Higher retention rates positively influence revenue growth. Continue investing in retention strategies to leverage this impact further.\n",
        "Neutral/Negative Impact: Analyze the effectiveness of current retention strategies and adjust them to ensure they contribute positively to revenue growth."
      ],
      "metadata": {
        "id": "3dlEgk1Ti-Z3"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "INvx1zB3cNZd"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}