F1 Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Data from Excel\n",
    "raw_event_points_df = pd.read_csv(r'F1Points.csv', index_col=0).transpose()\n",
    "raw_driver_points_df = pd.read_csv('CurrentPoints.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Strip Away Completed Events\n",
    "remaining_events_points = raw_event_points_df.loc[raw_event_points_df['Completed'].isnull()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "driver_points_df = raw_driver_points_df.copy()\n",
    "# Add Driver's Rank\n",
    "driver_points_df['Rank'] = driver_points_df['Points'].rank(ascending=False)\n",
    "# Sort Data Frame by Rank\n",
    "driver_points_df = driver_points_df.sort_values(by='Rank', ascending=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arrays of possible places for data frame indices\n",
    "place_array = [1,2,3,4,5,6,7,8,9,10]\n",
    "place_series = pd.Series(place_array)\n",
    "driver_place_array = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]\n",
    "driver_place_series = pd.Series(driver_place_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Return Filtered Dataframe \n",
    "def filter_first_false(df, column):\n",
    "    df = df.copy()\n",
    "    original_columns = df.columns\n",
    "    df['filtercol'] = df[column].cumsum()\n",
    "    df = df[df['filtercol']==0]\n",
    "    df = df[original_columns]\n",
    "    return df\n",
    "\n",
    "# Function to determine driver's position if they score all available points\n",
    "def drivers_max_points_rank(value):\n",
    "    new_df = driver_points_df[['Points', 'Rank']].copy()\n",
    "    new_df['test'] = new_df['Points'] < value\n",
    "    new_df = new_df[new_df['test']==True]\n",
    "    max = new_df['Rank'].min()\n",
    "    return max\n",
    "\n",
    "# Function to determine constructor's position if they score all available points\n",
    "def constructor_max_points_rank(value):\n",
    "    new_df = constructor_points_df[['Points', 'Rank']].copy()\n",
    "    new_df['test'] = new_df['Points'] < value\n",
    "    new_df = new_df[new_df['test']==True]\n",
    "    max = new_df['Rank'].min()\n",
    "    return max\n",
    "\n",
    "# Function to determine lowest place possible for driver\n",
    "def driver_min_points_rank(value):\n",
    "    # Change first df to adjust where this is\n",
    "    new_df = driver_points_df.copy()\n",
    "    new_df = new_df[(new_df['Rank'] >= value)]\n",
    "    first_points = new_df.head(1)['Points'].sum()\n",
    "    new_df['Points Difference'] = first_points - new_df['Points']\n",
    "    new_df['Cumulative Points Difference'] = new_df['Points Difference'].cumsum()\n",
    "    new_df = new_df.reset_index(drop=True)\n",
    "    new_df['Cumulative Available Points'] = place_points_cum\n",
    "    new_df['Cumulative Available Points'].fillna(method='ffill', inplace=True)\n",
    "    new_df['Cumulative Points Test'] = new_df['Cumulative Points Difference'] >= new_df['Cumulative Available Points']\n",
    "    new_df = filter_first_false(new_df, 'Cumulative Points Test')\n",
    "    redo = True\n",
    "    while redo == True:\n",
    "        frame_length = len(new_df['Cumulative Points Test'])\n",
    "        new_column = place_points[:frame_length]\n",
    "        new_column.sort_index(ascending=False, inplace=True)\n",
    "        new_column = new_column.reset_index(drop=True)\n",
    "        new_df['Individual Available Points'] = new_column\n",
    "        new_df['Individual Available Points Difference'] = new_df['Individual Available Points'] -  new_df['Points Difference']\n",
    "        new_df.sort_index(ascending=False, inplace=True)\n",
    "        new_df['IAPD Cum'] = new_df['Individual Available Points Difference'].cumsum()\n",
    "        new_df['IAPD Test'] = new_df['IAPD Cum'] < 0\n",
    "        new_df.sort_index(ascending=True, inplace=True)\n",
    "        if new_df['IAPD Test'].sum() > 0:\n",
    "            redo = True\n",
    "            new_df = new_df.head(frame_length-1)\n",
    "        else:\n",
    "            redo = False\n",
    "    return new_df['Rank'].max()\n",
    "\n",
    "# Function to determine lowest place possible for constructor\n",
    "def constructor_min_points_rank(value):\n",
    "    # Does figure out cumulative available points needs to be able to be cut down by frame length?\n",
    "    # Avoid copy errors\n",
    "    new_df = constructor_points_df.copy()\n",
    "    # Eliminate Ranks Above Current Race\n",
    "    new_df = new_df[(new_df['Rank'] >= value)]\n",
    "    # Calculate top row points for comparison\n",
    "    first_points = new_df.head(1)['Points'].sum()\n",
    "    # Calculate Figure out distance from each row to top row\n",
    "    new_df['Points Difference'] = first_points - new_df['Points']\n",
    "    # Calculate cumulative points difference\n",
    "    new_df['Cumulative Points Difference'] = new_df['Points Difference'].cumsum()\n",
    "    # Drop the index\n",
    "    new_df = new_df.reset_index(drop=True)\n",
    "    # Figure out cumulative available points\n",
    "    new_df['Cumulative Available Points'] = c_place_points_cum\n",
    "    # Fill down cumulative available points for places under 10\n",
    "    new_df['Cumulative Available Points'].fillna(method='ffill', inplace=True)\n",
    "    # Test to see if cumulative available points can fill the available points difference\n",
    "    new_df['Cumulative Points Test'] = new_df['Cumulative Points Difference'] >= new_df['Cumulative Available Points']\n",
    "    new_df = filter_first_false(new_df, 'Cumulative Points Test')\n",
    "    # Start loop to see if individual maximum points cars have enough available points to win the race\n",
    "    redo = True\n",
    "    while redo == True:\n",
    "        frame_length = len(new_df['Cumulative Points Test'])\n",
    "        new_column = c_place_points[:frame_length]\n",
    "        new_column.sort_index(ascending=False, inplace=True)\n",
    "        new_column = new_column.reset_index(drop=True)\n",
    "        new_df['Individual Available Points'] = new_column\n",
    "        new_df['Individual Available Points Difference'] = new_df['Individual Available Points'] -  new_df['Points Difference']\n",
    "        new_df.sort_index(ascending=False, inplace=True)\n",
    "        new_df['IAPD Cum'] = new_df['Individual Available Points Difference'].cumsum()\n",
    "        new_df['IAPD Test'] = new_df['IAPD Cum'] < 0\n",
    "        new_df.sort_index(ascending=True, inplace=True)\n",
    "        if new_df['IAPD Test'].sum() > 0:\n",
    "            redo = True\n",
    "            new_df = new_df.head(frame_length-1)\n",
    "        else:\n",
    "            redo = False\n",
    "    # Finishes loop\n",
    "    return new_df['Rank'].max()\n",
    "\n",
    "# Function to determine if lowest position analysis needs a closer look.\n",
    "def driver_min_points_rank_negtest_function(value):\n",
    "    # Change first df to adjust where this is\n",
    "    new_df = driver_points_df.copy()\n",
    "    new_df = new_df[(new_df['Rank'] >= value)]\n",
    "    first_points = new_df.head(1)['Points'].sum()\n",
    "    new_df['Points Difference'] = first_points - new_df['Points']\n",
    "    new_df['Cumulative Points Difference'] = new_df['Points Difference'].cumsum()\n",
    "    new_df = new_df.reset_index(drop=True)\n",
    "    new_df['Cumulative Available Points'] = place_points_cum\n",
    "    new_df['Cumulative Available Points'].fillna(method='ffill', inplace=True)\n",
    "    new_df['Cumulative Points Test'] = new_df['Cumulative Points Difference'] >= new_df['Cumulative Available Points']\n",
    "    new_df = filter_first_false(new_df, 'Cumulative Points Test')\n",
    "    redo = True\n",
    "    while redo == True:\n",
    "        frame_length = len(new_df['Cumulative Points Test'])\n",
    "        new_column = place_points[:frame_length]\n",
    "        new_column.sort_index(ascending=False, inplace=True)\n",
    "        new_column = new_column.reset_index(drop=True)\n",
    "        new_df['Individual Available Points'] = new_column\n",
    "        new_df['Individual Available Points Difference'] = new_df['Individual Available Points'] -  new_df['Points Difference']\n",
    "        new_df.sort_index(ascending=False, inplace=True)\n",
    "        new_df['IAPD Cum'] = new_df['Individual Available Points Difference'].cumsum()\n",
    "        new_df['IAPD Test'] = new_df['IAPD Cum'] < 0\n",
    "        new_df.sort_index(ascending=True, inplace=True)\n",
    "        if new_df['IAPD Test'].sum() > 0:\n",
    "            redo = True\n",
    "            new_df = new_df.head(frame_length-1)\n",
    "        else:\n",
    "            redo = False\n",
    "    new_df['IAPD Neg Test'] = new_df['Individual Available Points Difference'] < 0\n",
    "    neg_test_total = new_df['IAPD Neg Test'].sum()\n",
    "    return neg_test_total > 0\n",
    "\n",
    "# Function to determine if lowest position analysis needs a closer look.\n",
    "def constructor_min_points_rank_negtest_function(value):\n",
    "    # Change first df to adjust where this is\n",
    "    new_df = constructor_points_df.copy()\n",
    "    new_df = new_df[(new_df['Rank'] >= value)]\n",
    "    first_points = new_df.head(1)['Points'].sum()\n",
    "    new_df['Points Difference'] = first_points - new_df['Points']\n",
    "    new_df['Cumulative Points Difference'] = new_df['Points Difference'].cumsum()\n",
    "    new_df = new_df.reset_index(drop=True)\n",
    "    new_df['Cumulative Available Points'] = c_place_points_cum\n",
    "    new_df['Cumulative Available Points'].fillna(method='ffill', inplace=True)\n",
    "    new_df['Cumulative Points Test'] = new_df['Cumulative Points Difference'] >= new_df['Cumulative Available Points']\n",
    "    new_df = filter_first_false(new_df, 'Cumulative Points Test')\n",
    "    redo = True\n",
    "    while redo == True:\n",
    "        frame_length = len(new_df['Cumulative Points Test'])\n",
    "        new_column = place_points[:frame_length]\n",
    "        new_column.sort_index(ascending=False, inplace=True)\n",
    "        new_column = new_column.reset_index(drop=True)\n",
    "        new_df['Individual Available Points'] = new_column\n",
    "        new_df['Individual Available Points Difference'] = new_df['Individual Available Points'] -  new_df['Points Difference']\n",
    "        new_df.sort_index(ascending=False, inplace=True)\n",
    "        new_df['IAPD Cum'] = new_df['Individual Available Points Difference'].cumsum()\n",
    "        new_df['IAPD Test'] = new_df['IAPD Cum'] < 0\n",
    "        new_df.sort_index(ascending=True, inplace=True)\n",
    "        if new_df['IAPD Test'].sum() > 0:\n",
    "            redo = True\n",
    "            new_df = new_df.head(frame_length-1)\n",
    "        else:\n",
    "            redo = False\n",
    "    new_df['IAPD Neg Test'] = new_df['Individual Available Points Difference'] < 0\n",
    "    neg_test_total = new_df['IAPD Neg Test'].sum()\n",
    "    return neg_test_total > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create list of maximum points for each points place\n",
    "one = pd.to_numeric(remaining_events_points['1'])\n",
    "two = pd.to_numeric(remaining_events_points['2'])\n",
    "three = pd.to_numeric(remaining_events_points['3'])\n",
    "four = pd.to_numeric(remaining_events_points['4'])\n",
    "five = pd.to_numeric(remaining_events_points['5'])\n",
    "six = pd.to_numeric(remaining_events_points['6'])\n",
    "seven = pd.to_numeric(remaining_events_points['7'])\n",
    "eight = pd.to_numeric(remaining_events_points['8'])\n",
    "nine = pd.to_numeric(remaining_events_points['9'])\n",
    "ten = pd.to_numeric(remaining_events_points['10'])\n",
    "# Create Array of maximum constructors points for each points place\n",
    "c_one = one.append(two)\n",
    "c_two = three.append(four)\n",
    "c_three = five.append(six)\n",
    "c_four = seven.append(eight)\n",
    "c_five = nine.append(ten)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Sum of Maximum Points for each points place\n",
    "onesum = one.sum()\n",
    "twosum = two.sum()\n",
    "threesum = three.sum()\n",
    "foursum = four.sum()\n",
    "fivesum = five.sum()\n",
    "sixsum = six.sum()\n",
    "sevensum = seven.sum()\n",
    "eightsum = eight.sum()\n",
    "ninesum = nine.sum()\n",
    "tensum = ten.sum()\n",
    "\n",
    "# Create pandas series for each drivers points place\n",
    "place_points = pd.Series([onesum, twosum, threesum, foursum, fivesum, sixsum, sevensum, eightsum, ninesum, tensum], index=place_array)\n",
    "\n",
    "# Create Sum of Maximum Points for each constructors points place\n",
    "c_onesum = onesum + twosum\n",
    "c_twosum = threesum + foursum\n",
    "c_threesum = fivesum + sixsum\n",
    "c_foursum = sevensum + eightsum\n",
    "c_fivesum = ninesum + tensum\n",
    "\n",
    "# Create pandas series for each consturctors points place\n",
    "c_place_points = pd.Series([c_onesum, c_twosum, c_threesum, c_foursum, c_fivesum], index=[1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create cumalitive points series\n",
    "place_points_cum = place_points.cumsum()\n",
    "c_place_points_cum = c_place_points.cumsum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Figure maximum available points for drivers\n",
    "driver_points_df['Maximum Points'] = driver_points_df['Points'] + onesum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "driver_points_df['Best Possible Rank'] = driver_points_df['Maximum Points'].apply(drivers_max_points_rank)\n",
    "driver_points_df['Worst Possible Rank'] = driver_points_df['Rank'].apply(driver_min_points_rank)\n",
    "driver_points_df['Worst Possible Rank Neg Test'] = driver_points_df['Rank'].apply(driver_min_points_rank_negtest_function)\n",
    "driver_points_df = driver_points_df.set_index('Rank')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "constructor_points_df = raw_driver_points_df.copy()\n",
    "constructor_points_df = constructor_points_df[['Constructor', 'Points']]\n",
    "constructor_points_df = constructor_points_df.groupby('Constructor', as_index=False).sum()\n",
    "constructor_points_df['Rank'] = constructor_points_df['Points'].rank(ascending=False)\n",
    "constructor_points_df = constructor_points_df.sort_values(by='Rank', ascending=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "constructor_points_df['Maximum Points'] = constructor_points_df['Points'] + c_onesum\n",
    "constructor_points_df['Best Possible Rank'] = constructor_points_df['Maximum Points'].apply(constructor_max_points_rank)\n",
    "constructor_points_df['Worst Possible Rank'] = constructor_points_df['Rank'].apply(constructor_min_points_rank)\n",
    "constructor_points_df['Worst Possible Rank Neg Test'] = constructor_points_df['Rank'].apply(constructor_min_points_rank_negtest_function)\n",
    "constructor_points_df = constructor_points_df.set_index('Rank')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "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>Driver</th>\n",
       "      <th>Constructor</th>\n",
       "      <th>Points</th>\n",
       "      <th>Maximum Points</th>\n",
       "      <th>Best Possible Rank</th>\n",
       "      <th>Worst Possible Rank</th>\n",
       "      <th>Worst Possible Rank Neg Test</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Rank</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1.0</th>\n",
       "      <td>Verstappen</td>\n",
       "      <td>Red Bull</td>\n",
       "      <td>351.5</td>\n",
       "      <td>403.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2.0</th>\n",
       "      <td>Hamilton</td>\n",
       "      <td>Mercedes</td>\n",
       "      <td>343.5</td>\n",
       "      <td>395.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3.0</th>\n",
       "      <td>Bottas</td>\n",
       "      <td>Mercedes</td>\n",
       "      <td>203.0</td>\n",
       "      <td>255.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4.0</th>\n",
       "      <td>Perez</td>\n",
       "      <td>Red Bull</td>\n",
       "      <td>193.0</td>\n",
       "      <td>245.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5.0</th>\n",
       "      <td>Norris</td>\n",
       "      <td>McLaren</td>\n",
       "      <td>161.0</td>\n",
       "      <td>213.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6.0</th>\n",
       "      <td>Leclerc</td>\n",
       "      <td>Ferrari</td>\n",
       "      <td>150.0</td>\n",
       "      <td>202.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7.0</th>\n",
       "      <td>Sainz</td>\n",
       "      <td>Ferrari</td>\n",
       "      <td>143.5</td>\n",
       "      <td>195.5</td>\n",
       "      <td>4.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8.0</th>\n",
       "      <td>Ricciardo</td>\n",
       "      <td>McLaren</td>\n",
       "      <td>105.0</td>\n",
       "      <td>157.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9.0</th>\n",
       "      <td>Gasly</td>\n",
       "      <td>Alphatauri</td>\n",
       "      <td>92.0</td>\n",
       "      <td>144.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10.0</th>\n",
       "      <td>Alonso</td>\n",
       "      <td>Alpine</td>\n",
       "      <td>74.0</td>\n",
       "      <td>126.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11.0</th>\n",
       "      <td>Ocon</td>\n",
       "      <td>Alpine</td>\n",
       "      <td>58.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12.0</th>\n",
       "      <td>Vettel</td>\n",
       "      <td>Aston Martin</td>\n",
       "      <td>43.0</td>\n",
       "      <td>95.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13.0</th>\n",
       "      <td>Stroll</td>\n",
       "      <td>Aston Martin</td>\n",
       "      <td>32.0</td>\n",
       "      <td>84.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>19.5</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14.0</th>\n",
       "      <td>Tsunoda</td>\n",
       "      <td>Alphatauri</td>\n",
       "      <td>20.0</td>\n",
       "      <td>72.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>19.5</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15.0</th>\n",
       "      <td>Russell</td>\n",
       "      <td>Williams</td>\n",
       "      <td>16.0</td>\n",
       "      <td>68.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>19.5</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16.0</th>\n",
       "      <td>Raikkoken</td>\n",
       "      <td>Alfa Romeo</td>\n",
       "      <td>10.0</td>\n",
       "      <td>62.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>19.5</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17.0</th>\n",
       "      <td>Latifi</td>\n",
       "      <td>Williams</td>\n",
       "      <td>7.0</td>\n",
       "      <td>59.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>19.5</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18.0</th>\n",
       "      <td>Giovinazzi</td>\n",
       "      <td>Alfa Romeo</td>\n",
       "      <td>1.0</td>\n",
       "      <td>53.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>19.5</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19.5</th>\n",
       "      <td>Schumacher</td>\n",
       "      <td>Haas</td>\n",
       "      <td>0.0</td>\n",
       "      <td>52.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>19.5</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19.5</th>\n",
       "      <td>Mazepin</td>\n",
       "      <td>Haas</td>\n",
       "      <td>0.0</td>\n",
       "      <td>52.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>19.5</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          Driver   Constructor  Points  Maximum Points  Best Possible Rank  \\\n",
       "Rank                                                                         \n",
       "1.0   Verstappen      Red Bull   351.5           403.5                 1.0   \n",
       "2.0     Hamilton      Mercedes   343.5           395.5                 1.0   \n",
       "3.0       Bottas      Mercedes   203.0           255.0                 3.0   \n",
       "4.0        Perez      Red Bull   193.0           245.0                 3.0   \n",
       "5.0       Norris       McLaren   161.0           213.0                 3.0   \n",
       "6.0      Leclerc       Ferrari   150.0           202.0                 4.0   \n",
       "7.0        Sainz       Ferrari   143.5           195.5                 4.0   \n",
       "8.0    Ricciardo       McLaren   105.0           157.0                 6.0   \n",
       "9.0        Gasly    Alphatauri    92.0           144.0                 7.0   \n",
       "10.0      Alonso        Alpine    74.0           126.0                 8.0   \n",
       "11.0        Ocon        Alpine    58.0           110.0                 8.0   \n",
       "12.0      Vettel  Aston Martin    43.0            95.0                 9.0   \n",
       "13.0      Stroll  Aston Martin    32.0            84.0                10.0   \n",
       "14.0     Tsunoda    Alphatauri    20.0            72.0                11.0   \n",
       "15.0     Russell      Williams    16.0            68.0                11.0   \n",
       "16.0   Raikkoken    Alfa Romeo    10.0            62.0                11.0   \n",
       "17.0      Latifi      Williams     7.0            59.0                11.0   \n",
       "18.0  Giovinazzi    Alfa Romeo     1.0            53.0                12.0   \n",
       "19.5  Schumacher          Haas     0.0            52.0                12.0   \n",
       "19.5     Mazepin          Haas     0.0            52.0                12.0   \n",
       "\n",
       "      Worst Possible Rank  Worst Possible Rank Neg Test  \n",
       "Rank                                                     \n",
       "1.0                   2.0                         False  \n",
       "2.0                   2.0                         False  \n",
       "3.0                   5.0                         False  \n",
       "4.0                   6.0                         False  \n",
       "5.0                   7.0                         False  \n",
       "6.0                   8.0                         False  \n",
       "7.0                   8.0                         False  \n",
       "8.0                  11.0                         False  \n",
       "9.0                  12.0                         False  \n",
       "10.0                 13.0                         False  \n",
       "11.0                 15.0                          True  \n",
       "12.0                 18.0                          True  \n",
       "13.0                 19.5                          True  \n",
       "14.0                 19.5                         False  \n",
       "15.0                 19.5                         False  \n",
       "16.0                 19.5                         False  \n",
       "17.0                 19.5                         False  \n",
       "18.0                 19.5                         False  \n",
       "19.5                 19.5                         False  \n",
       "19.5                 19.5                         False  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(driver_points_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1     52\n",
       "2     36\n",
       "3     30\n",
       "4     24\n",
       "5     20\n",
       "6     16\n",
       "7     12\n",
       "8      8\n",
       "9      4\n",
       "10     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "place_points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "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>Constructor</th>\n",
       "      <th>Points</th>\n",
       "      <th>Maximum Points</th>\n",
       "      <th>Best Possible Rank</th>\n",
       "      <th>Worst Possible Rank</th>\n",
       "      <th>Worst Possible Rank Neg Test</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Rank</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1.0</th>\n",
       "      <td>Mercedes</td>\n",
       "      <td>546.5</td>\n",
       "      <td>634.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2.0</th>\n",
       "      <td>Red Bull</td>\n",
       "      <td>544.5</td>\n",
       "      <td>632.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3.0</th>\n",
       "      <td>Ferrari</td>\n",
       "      <td>293.5</td>\n",
       "      <td>381.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4.0</th>\n",
       "      <td>McLaren</td>\n",
       "      <td>266.0</td>\n",
       "      <td>354.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5.0</th>\n",
       "      <td>Alpine</td>\n",
       "      <td>132.0</td>\n",
       "      <td>220.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6.0</th>\n",
       "      <td>Alphatauri</td>\n",
       "      <td>112.0</td>\n",
       "      <td>200.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7.0</th>\n",
       "      <td>Aston Martin</td>\n",
       "      <td>75.0</td>\n",
       "      <td>163.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8.0</th>\n",
       "      <td>Williams</td>\n",
       "      <td>23.0</td>\n",
       "      <td>111.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9.0</th>\n",
       "      <td>Alfa Romeo</td>\n",
       "      <td>11.0</td>\n",
       "      <td>99.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10.0</th>\n",
       "      <td>Haas</td>\n",
       "      <td>0.0</td>\n",
       "      <td>88.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       Constructor  Points  Maximum Points  Best Possible Rank  \\\n",
       "Rank                                                             \n",
       "1.0       Mercedes   546.5           634.5                 1.0   \n",
       "2.0       Red Bull   544.5           632.5                 1.0   \n",
       "3.0        Ferrari   293.5           381.5                 3.0   \n",
       "4.0        McLaren   266.0           354.0                 3.0   \n",
       "5.0         Alpine   132.0           220.0                 5.0   \n",
       "6.0     Alphatauri   112.0           200.0                 5.0   \n",
       "7.0   Aston Martin    75.0           163.0                 5.0   \n",
       "8.0       Williams    23.0           111.0                 7.0   \n",
       "9.0     Alfa Romeo    11.0            99.0                 7.0   \n",
       "10.0          Haas     0.0            88.0                 7.0   \n",
       "\n",
       "      Worst Possible Rank  Worst Possible Rank Neg Test  \n",
       "Rank                                                     \n",
       "1.0                   2.0                         False  \n",
       "2.0                   2.0                         False  \n",
       "3.0                   4.0                         False  \n",
       "4.0                   4.0                         False  \n",
       "5.0                   7.0                         False  \n",
       "6.0                   7.0                         False  \n",
       "7.0                   9.0                         False  \n",
       "8.0                  10.0                         False  \n",
       "9.0                  10.0                         False  \n",
       "10.0                 10.0                         False  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(constructor_points_df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    88\n",
       "2    54\n",
       "3    36\n",
       "4    20\n",
       "5     6\n",
       "dtype: int64"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_place_points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1      52\n",
       "2      88\n",
       "3     118\n",
       "4     142\n",
       "5     162\n",
       "6     178\n",
       "7     190\n",
       "8     198\n",
       "9     202\n",
       "10    204\n",
       "dtype: int64"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "place_points_cum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "def driver_min_points_rank_negtest_function(value):\n",
    "    # Change first df to adjust where this is\n",
    "    new_df = driver_points_df.copy()\n",
    "    new_df = new_df.reset_index(drop=False)\n",
    "    new_df = new_df[(new_df['Rank'] >= value)]\n",
    "    first_points = new_df.head(1)['Points'].sum()\n",
    "    new_df['Points Difference'] = first_points - new_df['Points']\n",
    "    new_df['Cumulative Points Difference'] = new_df['Points Difference'].cumsum()\n",
    "    new_df = new_df.reset_index(drop=True)\n",
    "    new_df['Cumulative Available Points'] = place_points_cum\n",
    "    new_df['Cumulative Available Points'].fillna(method='ffill', inplace=True)\n",
    "    new_df['Cumulative Points Test'] = new_df['Cumulative Points Difference'] >= new_df['Cumulative Available Points']\n",
    "    new_df = filter_first_false(new_df, 'Cumulative Points Test')\n",
    "    redo = True\n",
    "    while redo == True:\n",
    "        frame_length = len(new_df['Cumulative Points Test'])\n",
    "        new_column = place_points[:frame_length]\n",
    "        new_column.sort_index(ascending=False, inplace=True)\n",
    "        new_column = new_column.reset_index(drop=True)\n",
    "        new_df['Individual Available Points'] = new_column\n",
    "        new_df['Individual Available Points Difference'] = new_df['Individual Available Points'] -  new_df['Points Difference']\n",
    "        new_df.sort_index(ascending=False, inplace=True)\n",
    "        new_df['IAPD Cum'] = new_df['Individual Available Points Difference'].cumsum()\n",
    "        new_df['IAPD Test'] = new_df['IAPD Cum'] < 0\n",
    "        new_df.sort_index(ascending=True, inplace=True)\n",
    "        if new_df['IAPD Test'].sum() > 0:\n",
    "            redo = True\n",
    "            new_df = new_df.head(frame_length-1)\n",
    "        else:\n",
    "            redo = False\n",
    "    new_df['IAPD Neg Test'] = new_df['Individual Available Points Difference'] < 0\n",
    "    neg_test_total = new_df['IAPD Neg Test'].sum()\n",
    "    new_df = new_df.set_index('Rank')\n",
    "    return new_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "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>Driver</th>\n",
       "      <th>Constructor</th>\n",
       "      <th>Points</th>\n",
       "      <th>Maximum Points</th>\n",
       "      <th>Best Possible Rank</th>\n",
       "      <th>Worst Possible Rank</th>\n",
       "      <th>Worst Possible Rank Neg Test</th>\n",
       "      <th>Points Difference</th>\n",
       "      <th>Cumulative Points Difference</th>\n",
       "      <th>Cumulative Available Points</th>\n",
       "      <th>Cumulative Points Test</th>\n",
       "      <th>Individual Available Points</th>\n",
       "      <th>Individual Available Points Difference</th>\n",
       "      <th>IAPD Cum</th>\n",
       "      <th>IAPD Test</th>\n",
       "      <th>IAPD Neg Test</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Rank</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>11.0</th>\n",
       "      <td>Ocon</td>\n",
       "      <td>Alpine</td>\n",
       "      <td>58.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>False</td>\n",
       "      <td>20</td>\n",
       "      <td>20.0</td>\n",
       "      <td>41.0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12.0</th>\n",
       "      <td>Vettel</td>\n",
       "      <td>Aston Martin</td>\n",
       "      <td>43.0</td>\n",
       "      <td>95.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>True</td>\n",
       "      <td>15.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>52.0</td>\n",
       "      <td>False</td>\n",
       "      <td>24</td>\n",
       "      <td>9.0</td>\n",
       "      <td>21.0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13.0</th>\n",
       "      <td>Stroll</td>\n",
       "      <td>Aston Martin</td>\n",
       "      <td>32.0</td>\n",
       "      <td>84.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>19.5</td>\n",
       "      <td>True</td>\n",
       "      <td>26.0</td>\n",
       "      <td>41.0</td>\n",
       "      <td>88.0</td>\n",
       "      <td>False</td>\n",
       "      <td>30</td>\n",
       "      <td>4.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14.0</th>\n",
       "      <td>Tsunoda</td>\n",
       "      <td>Alphatauri</td>\n",
       "      <td>20.0</td>\n",
       "      <td>72.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>19.5</td>\n",
       "      <td>False</td>\n",
       "      <td>38.0</td>\n",
       "      <td>79.0</td>\n",
       "      <td>118.0</td>\n",
       "      <td>False</td>\n",
       "      <td>36</td>\n",
       "      <td>-2.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15.0</th>\n",
       "      <td>Russell</td>\n",
       "      <td>Williams</td>\n",
       "      <td>16.0</td>\n",
       "      <td>68.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>19.5</td>\n",
       "      <td>False</td>\n",
       "      <td>42.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>142.0</td>\n",
       "      <td>False</td>\n",
       "      <td>52</td>\n",
       "      <td>10.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       Driver   Constructor  Points  Maximum Points  Best Possible Rank  \\\n",
       "Rank                                                                      \n",
       "11.0     Ocon        Alpine    58.0           110.0                 8.0   \n",
       "12.0   Vettel  Aston Martin    43.0            95.0                 9.0   \n",
       "13.0   Stroll  Aston Martin    32.0            84.0                10.0   \n",
       "14.0  Tsunoda    Alphatauri    20.0            72.0                11.0   \n",
       "15.0  Russell      Williams    16.0            68.0                11.0   \n",
       "\n",
       "      Worst Possible Rank  Worst Possible Rank Neg Test  Points Difference  \\\n",
       "Rank                                                                         \n",
       "11.0                 15.0                          True                0.0   \n",
       "12.0                 18.0                          True               15.0   \n",
       "13.0                 19.5                          True               26.0   \n",
       "14.0                 19.5                         False               38.0   \n",
       "15.0                 19.5                         False               42.0   \n",
       "\n",
       "      Cumulative Points Difference  Cumulative Available Points  \\\n",
       "Rank                                                              \n",
       "11.0                           0.0                          NaN   \n",
       "12.0                          15.0                         52.0   \n",
       "13.0                          41.0                         88.0   \n",
       "14.0                          79.0                        118.0   \n",
       "15.0                         121.0                        142.0   \n",
       "\n",
       "      Cumulative Points Test  Individual Available Points  \\\n",
       "Rank                                                        \n",
       "11.0                   False                           20   \n",
       "12.0                   False                           24   \n",
       "13.0                   False                           30   \n",
       "14.0                   False                           36   \n",
       "15.0                   False                           52   \n",
       "\n",
       "      Individual Available Points Difference  IAPD Cum  IAPD Test  \\\n",
       "Rank                                                                \n",
       "11.0                                    20.0      41.0      False   \n",
       "12.0                                     9.0      21.0      False   \n",
       "13.0                                     4.0      12.0      False   \n",
       "14.0                                    -2.0       8.0      False   \n",
       "15.0                                    10.0      10.0      False   \n",
       "\n",
       "      IAPD Neg Test  \n",
       "Rank                 \n",
       "11.0          False  \n",
       "12.0          False  \n",
       "13.0          False  \n",
       "14.0           True  \n",
       "15.0          False  "
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "driver_min_points_rank_negtest_function(11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}