Guided_project_4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/berkeucyildiz17/python-for-machine-learning/blob/main/Guided_project_4.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Chapter 4 \n",
        "##NumPy\n",
        "\n",
        "Rachel is very happy with the way you cleaned and structured the employee data last time, but she wants to take things one step further. The sales team wants to track the performance of the employees not only by the revenue they generated, but also taking the number of calls and the average deal size into account. For that, Rachel wants you to create a software for reporting. To be able to perform calculations on the data you decide that creating a data structure using Numpy will be best."
      ],
      "metadata": {
        "id": "QkcKMNzWAbg7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Get the data\n",
        "\n",
        "First, you need to get the data. You created lists with the relevant information in the last chapter.\n",
        "\n",
        "📌 Copy and paste the lists \"names\", \"call_numbers\", \"average_deal_size\", and \"revenues\" you created in chapter 3 and assign them to variables."
      ],
      "metadata": {
        "id": "LWlWyFTek4PO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Copy the lists \"names\", \"call_numbers\", \"average_deal_size\", and \"revenues\" from chapter 3\n",
        "names = ['Ben', 'Omer', 'Karen', 'Celine', 'Sue', 'Bora', 'Rose', 'Ellen', 'Bob', 'Taylor', 'Jude']\n",
        "call_numbers = [300, 10, 500, 70, 100, 100, 600, 800, 200, 450, 80]\n",
        "average_deal_sizes = [8, 6, 24, 32, 5, 25, 25, 40, 15, 10, 12]\n",
        "revenues = [2400, 60, 12000, 2275, 500, 770, 4000, 6000, 800, 1200, 500]"
      ],
      "metadata": {
        "id": "XtkCWxs4lGyX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Importing NumPy\n",
        "\n",
        "You plan to create a data structure using NumPy.\n",
        "\n",
        "📌 Import the NumPy library as."
      ],
      "metadata": {
        "id": "Ge6Rw3bkA1nq"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bkJKAysX41P0"
      },
      "outputs": [],
      "source": [
        "#Import the NumPy library\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Creating an initial (base) arrays\n",
        "\n",
        "Next, you need to prepare an array in which you will store the values. The initial array will be empty. Since it will hold numerical data, the data type should be integer.\n",
        "\n",
        "📌 Create an empty array using .array(). \n",
        "\n",
        "📌 Use the *dtype* parameter to specify the data type."
      ],
      "metadata": {
        "id": "V_RyXQRPDKDX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Create an empty array with the data type integer\n",
        "data = np.array([], dtype = int)"
      ],
      "metadata": {
        "id": "rhn8VLL5F1io"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Functions to add the data\n",
        "\n",
        "Now that your empty array is ready, you need to transfer the data from the lists to the array. You create 2 functions functions for this. \n",
        "\n",
        "1. append_names function: A function that takes the \"names\" list and adds the index of each name to the \"data\" array.\n",
        "\n",
        "  📌 Use a for loop and the .append() method for the indexes.\n",
        "\n",
        "2. append_performance_measures function: A function that takes one of the remaining lists to add the sales performance data like number of calls, average deal size and revenue to the \"data\" array.\n",
        "\n",
        "  📌 Use the .append() method."
      ],
      "metadata": {
        "id": "RTg7VcXco1pB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Define the append_names function\n",
        "def append_names(names_list):\n",
        "  global data\n",
        "  for i in names_list:\n",
        "    data = np.append(data, names.index(i))"
      ],
      "metadata": {
        "id": "aFt18Yn_Ai48"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Define the append_performance_measures function\n",
        "def append_performance_measures(feature_list):\n",
        "  global data\n",
        "  data = np.append(data, feature_list)"
      ],
      "metadata": {
        "id": "XZ0xJEnqUCt6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Call the functions to add the data to the array and print the array and its shape to see the result.\n",
        "\n",
        "📌 Use the .shape() method."
      ],
      "metadata": {
        "id": "JEQ_Il_JFPJR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Use the append_names and append_sales_performance_measures to add the data\n",
        "append_names(names)\n",
        "append_performance_measures(call_numbers)\n",
        "append_performance_measures(average_deal_sizes)\n",
        "append_performance_measures(revenues)\n",
        "\n",
        "#Print the array and its shape to see the result\n",
        "print(data)\n",
        "print(data.shape)"
      ],
      "metadata": {
        "id": "eknqraz75Qj9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b93a6d37-2624-4d6a-8162-2ec055c24c68"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[    0     1     2     3     4     5     6     7     8     9    10   300\n",
            "    10   500    70   100   100   600   800   200   450    80     8     6\n",
            "    24    32     5    25    25    40    15    10    12  2400    60 12000\n",
            "  2275   500   770  4000  6000   800  1200   500]\n",
            "(44,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Reshape the array\n",
        "\n",
        "But like this, your array is not very structured. You need a 2D-array to be able to work better with it. The original data was 4 lists each with 11 values. So, the \"data\" array should have 4 rows and 11 columns. Print the result afterwards.\n",
        "\n",
        "📌 Use the .reshape() method to rearrange the values in the array.\n"
      ],
      "metadata": {
        "id": "PrHY03X6C94s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Use the .reshape() method to change the array structure to 4 rows and 11 columns\n",
        "data = data.reshape(4, 11)\n",
        "\n",
        "#Print the resulting array and its shape\n",
        "print(data)\n",
        "print(data.shape)"
      ],
      "metadata": {
        "id": "__2N4NZB5k3Q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "05d99255-9dfe-499c-b96d-55e398b44d1a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[    0     1     2     3     4     5     6     7     8     9    10]\n",
            " [  300    10   500    70   100   100   600   800   200   450    80]\n",
            " [    8     6    24    32     5    25    25    40    15    10    12]\n",
            " [ 2400    60 12000  2275   500   770  4000  6000   800  1200   500]]\n",
            "(4, 11)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Accessing values\n",
        "\n",
        "Inside the array you can access the values in different ways. \n",
        "\n",
        "1. Print each row separately. \n",
        "\n",
        "  📌 Write down the array name and the index of the row you want to access.\n"
      ],
      "metadata": {
        "id": "-JgrV_l7MIwQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Print the name indexes\n",
        "print(data[0])"
      ],
      "metadata": {
        "id": "7IwKRbzORnjA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0409b4e1-3d40-43ce-80d1-68d87afe856c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 0  1  2  3  4  5  6  7  8  9 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Print the number of calls\n",
        "print(data[1])"
      ],
      "metadata": {
        "id": "4TZ-6AI3AJ3k",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b7a5fb71-fd34-42f2-d038-3e9e3cbfb2d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[300  10 500  70 100 100 600 800 200 450  80]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Print the average deal sizes\n",
        "print(data[2])"
      ],
      "metadata": {
        "id": "6AwKKNcVP-Z4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eb0d492e-dd05-4c5b-88df-86fe40b2b488"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 8  6 24 32  5 25 25 40 15 10 12]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Print the revenues \n",
        "print(data[3])"
      ],
      "metadata": {
        "id": "A0XcKZpKQRnI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2db8250a-b832-4f60-e010-4d12aa3d8b22"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 2400    60 12000  2275   500   770  4000  6000   800  1200   500]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. Print a specific value.\n",
        "\n",
        "  📌 Give the index of the row and the column of the value you want to access.\n",
        "  For example, to get the revenue generated by Ellen, specify the value in the 3rd row and 7th column."
      ],
      "metadata": {
        "id": "vwggtzzeAuGX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Print the revenue generated by Ellen\n",
        "print(data[3, 7])"
      ],
      "metadata": {
        "id": "qkHN7yCiSs7z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "17371482-c2f0-4afe-e010-f6d142be5764"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Analyzing the data\n",
        "\n",
        "Great, your array is ready!\n",
        "\n",
        "The sales team has a formula that they use to calculate the performance score of an employee.\n",
        "\n",
        "\n",
        "\\begin{align}\n",
        "        \\text{Performance} = \\frac{\\text{Average deal size x Revenue}}{\\text{Number of calls}}\n",
        "    \\end{align}\n",
        "\n",
        "\n",
        "📌 Create a function called “calculate_performance” to implement this formula. It should take the employee name as an input."
      ],
      "metadata": {
        "id": "HpcNsSjVVJ76"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Define the function calculate_performance\n",
        "def calculate_performance(employee_name):\n",
        "  idx = names.index(employee_name)\n",
        "  number_of_calls = data[1, idx]\n",
        "  avg_deal_size = data[2, idx]\n",
        "  revenue = data[3, idx]\n",
        "\n",
        "  score = (avg_deal_size * revenue) / number_of_calls\n",
        "\n",
        "  return score"
      ],
      "metadata": {
        "id": "UoB-hSG02lmJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Try it out\n",
        "\n",
        "Let's check Ellen's performance score and print the result."
      ],
      "metadata": {
        "id": "BJp7Qgxv5cVX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Use the calculate performance function to print Ellen's performance\n",
        "print(calculate_performance(\"Ellen\"))"
      ],
      "metadata": {
        "id": "kd2J09dg6n4i",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2a854c81-2b15-4f88-ef07-92e4264bcf2e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "300.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Calculate the performance of each employee\n",
        "Now you need to calculate the performance score of each employee and add these scores to a list.\n",
        "\n",
        "📌 Create an empty list \"performance_scores\" to hold the scores.\n",
        "\n",
        "📌 Use a for loop to convert the scores into integer type data and append it to the list \"sperformance_scores\"."
      ],
      "metadata": {
        "id": "4zUQIn2s7wwy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Calculate the performance of each employee\n",
        "performance_scores = []\n",
        "for name in names:\n",
        "  score = int(calculate_performance(name))\n",
        "  performance_scores.append(score)"
      ],
      "metadata": {
        "id": "xTroGqo745AO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Add the scores to the \"data\" array\n",
        "\n",
        "Next, you need to add the scores to your \"data\" array and print the result.\n",
        "\n",
        "📌 Use the .concatenate() method to add the \"performance_scores\" list to the \"data\" array. "
      ],
      "metadata": {
        "id": "JEjPMpP7FvOw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Add the \"performance_scores\" list to the \"data\" array\n",
        "data = np.concatenate((data, [performance_scores]), axis = 0)\n",
        "\n",
        "#Print the resulting array\n",
        "print(data)"
      ],
      "metadata": {
        "id": "zm4Zbzl9-1n-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "11ba04be-a32d-4da9-eeef-99ef9381ab85"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[    0     1     2     3     4     5     6     7     8     9    10]\n",
            " [  300    10   500    70   100   100   600   800   200   450    80]\n",
            " [    8     6    24    32     5    25    25    40    15    10    12]\n",
            " [ 2400    60 12000  2275   500   770  4000  6000   800  1200   500]\n",
            " [   64    36   576  1040    25   192   166   300    60    26    75]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Find out the best and worst performing employees\n",
        "\n",
        "Finally, you need to determine the best and worst performing employees.\n",
        "\n",
        "📌 Use the .argmax() and .argmin() methods to find the index of the best and worst performing employees."
      ],
      "metadata": {
        "id": "oWMMtqfDUZVs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Use .argmax() and .argmin() methods to determine the best and worst performing employees\n",
        "idx_best_employee = np.argmax(data[4])\n",
        "idx_worst_employee = np.argmin(data[4])\n",
        "\n",
        "#Print out the results\n",
        "print(f'Best Performing Employee: {names[idx_best_employee]}')\n",
        "print(f'Worst Performing Employee: {names[idx_worst_employee]}')"
      ],
      "metadata": {
        "id": "58fNLhRsQ18I",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8bdbb4c6-0d03-4cfd-c54b-187f443ad22c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best Performing Employee: Celine\n",
            "Worst Performing Employee: Sue\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Dxay8hqh3GKG"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}