DS Project - Analyzing Police Activity.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Case Study - Police Activity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\T0230575\\source\\repos\\DataCamp__\\Python\\_data\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "from matplotlib import pyplot as plt\n",
    "import os, sys\n",
    "\n",
    "path = 'C:/Users/T0230575/source/repos/DataCamp__/Python/_data/' \n",
    "os.chdir(path)\n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examining the dataset\n",
    "Throughout this course, you'll be analyzing a dataset of traffic stops in Rhode Island that was collected by the Stanford Open Policing Project.\n",
    "\n",
    "Before beginning your analysis, it's important that you familiarize yourself with the dataset. In this exercise, you'll read the dataset into pandas, examine the first few rows, and then count the number of missing values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  state   stop_date stop_time  county_name driver_gender driver_race  \\\n",
      "0    RI  2005-01-04     12:55          NaN             M       White   \n",
      "1    RI  2005-01-23     23:15          NaN             M       White   \n",
      "2    RI  2005-02-17     04:15          NaN             M       White   \n",
      "3    RI  2005-02-20     17:15          NaN             M       White   \n",
      "4    RI  2005-02-24     01:20          NaN             F       White   \n",
      "\n",
      "                    violation_raw  violation  search_conducted search_type  \\\n",
      "0  Equipment/Inspection Violation  Equipment             False         NaN   \n",
      "1                        Speeding   Speeding             False         NaN   \n",
      "2                        Speeding   Speeding             False         NaN   \n",
      "3                Call for Service      Other             False         NaN   \n",
      "4                        Speeding   Speeding             False         NaN   \n",
      "\n",
      "    stop_outcome is_arrested stop_duration  drugs_related_stop district  \n",
      "0       Citation       False      0-15 Min               False  Zone X4  \n",
      "1       Citation       False      0-15 Min               False  Zone K3  \n",
      "2       Citation       False      0-15 Min               False  Zone X4  \n",
      "3  Arrest Driver        True     16-30 Min               False  Zone X1  \n",
      "4       Citation       False      0-15 Min               False  Zone X3  \n",
      "state                     0\n",
      "stop_date                 0\n",
      "stop_time                 0\n",
      "county_name           91741\n",
      "driver_gender          5205\n",
      "driver_race            5202\n",
      "violation_raw          5202\n",
      "violation              5202\n",
      "search_conducted          0\n",
      "search_type           88434\n",
      "stop_outcome           5202\n",
      "is_arrested            5202\n",
      "stop_duration          5202\n",
      "drugs_related_stop        0\n",
      "district                  0\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Import the pandas library as pd\n",
    "import pandas as pd\n",
    "\n",
    "# Read 'police.csv' into a DataFrame named ri\n",
    "ri = pd.read_csv('police.csv')\n",
    "\n",
    "# Examine the head of the DataFrame\n",
    "print(ri.head())\n",
    "\n",
    "# Count the number of missing values in each column\n",
    "print(ri.isnull().sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like most of the columns have at least some missing values. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dropping columns\n",
    "Often, a DataFrame will contain columns that are not useful to your analysis. Such columns should be dropped from the DataFrame, to make it easier for you to focus on the remaining columns.\n",
    "\n",
    "In this exercise, you'll drop the county_name column because it only contains missing values, and you'll drop the state column because all of the traffic stops took place in one state (Rhode Island). Thus, these columns can be dropped because they contain no useful information. The number of missing values in each column has been printed to the console for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(91741, 15)\n",
      "(91741, 13)\n"
     ]
    }
   ],
   "source": [
    "# Examine the shape of the DataFrame\n",
    "print(ri.shape)\n",
    "\n",
    "# Drop the 'county_name' and 'state' columns\n",
    "ri.drop(['county_name', 'state'], axis='columns', inplace=True)\n",
    "\n",
    "# Examine the shape of the DataFrame (again)\n",
    "print(ri.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dropping rows\n",
    "When you know that a specific column will be critical to your analysis, and only a small fraction of rows are missing a value in that column, it often makes sense to remove those rows from the dataset.\n",
    "\n",
    "During this course, the driver_gender column will be critical to many of your analyses. Because only a small fraction of rows are missing driver_gender, we'll drop those rows from the dataset.\n",
    "\n",
    "- Count the number of missing values in each column.\n",
    "- Drop all rows that are missing driver_gender by passing the column name to the subset parameter of .dropna().\n",
    "- Count the number of missing values in each column again, to verify that none of the remaining rows are missing driver_gender.\n",
    "- Examine the DataFrame's .shape to see how many rows and columns remain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stop_date                 0\n",
      "stop_time                 0\n",
      "driver_gender          5205\n",
      "driver_race            5202\n",
      "violation_raw          5202\n",
      "violation              5202\n",
      "search_conducted          0\n",
      "search_type           88434\n",
      "stop_outcome           5202\n",
      "is_arrested            5202\n",
      "stop_duration          5202\n",
      "drugs_related_stop        0\n",
      "district                  0\n",
      "dtype: int64\n",
      "stop_date                 0\n",
      "stop_time                 0\n",
      "driver_gender             0\n",
      "driver_race               0\n",
      "violation_raw             0\n",
      "violation                 0\n",
      "search_conducted          0\n",
      "search_type           83229\n",
      "stop_outcome              0\n",
      "is_arrested               0\n",
      "stop_duration             0\n",
      "drugs_related_stop        0\n",
      "district                  0\n",
      "dtype: int64\n",
      "(86536, 13)\n"
     ]
    }
   ],
   "source": [
    "# Count the number of missing values in each column\n",
    "print(ri.isnull().sum())\n",
    "\n",
    "# Drop all rows that are missing 'driver_gender'\n",
    "ri.dropna(subset=['driver_gender'], inplace=True)\n",
    "\n",
    "# Count the number of missing values in each column (again)\n",
    "print(ri.isnull().sum())\n",
    "\n",
    "# Examine the shape of the DataFrame\n",
    "print(ri.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We dropped around 5,000 rows, which is a small fraction of the dataset, and now only one column remains with any missing values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fixing a data type\n",
    "We saw in the previous exercise that the is_arrested column currently has the object data type. In this exercise, we'll change the data type to bool, which is the most suitable type for a column containing True and False values.\n",
    "\n",
    "Fixing the data type will enable us to use mathematical operations on the is_arrested column that would not be possible otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    False\n",
      "1    False\n",
      "2    False\n",
      "3     True\n",
      "4    False\n",
      "Name: is_arrested, dtype: object\n",
      "bool\n"
     ]
    }
   ],
   "source": [
    "# Examine the head of the 'is_arrested' column\n",
    "print(ri.is_arrested.head())\n",
    "\n",
    "# Change the data type of 'is_arrested' to 'bool'\n",
    "ri['is_arrested'] = ri.is_arrested.astype('bool')\n",
    "\n",
    "# Check the data type of 'is_arrested' \n",
    "print(ri.is_arrested.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combining object columns\n",
    "Currently, the date and time of each traffic stop are stored in separate object columns: stop_date and stop_time.\n",
    "\n",
    "In this exercise, you'll combine these two columns into a single column, and then convert it to datetime format. This will enable convenient date-based attributes that we'll use later in the course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stop_date                     object\n",
      "stop_time                     object\n",
      "driver_gender                 object\n",
      "driver_race                   object\n",
      "violation_raw                 object\n",
      "violation                     object\n",
      "search_conducted                bool\n",
      "search_type                   object\n",
      "stop_outcome                  object\n",
      "is_arrested                     bool\n",
      "stop_duration                 object\n",
      "drugs_related_stop              bool\n",
      "district                      object\n",
      "stop_datetime         datetime64[ns]\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# Concatenate 'stop_date' and 'stop_time' (separated by a space)\n",
    "combined = ri.stop_date.str.cat(ri.stop_time, sep = \" \")\n",
    "\n",
    "# Convert 'combined' to datetime format\n",
    "ri['stop_datetime'] = pd.to_datetime(combined)\n",
    "\n",
    "# Examine the data types of the DataFrame\n",
    "print(ri.dtypes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting the index\n",
    "The last step that you'll take in this chapter is to set the stop_datetime column as the DataFrame's index. By replacing the default index with a DatetimeIndex, you'll make it easier to analyze the dataset by date and time, which will come in handy later in the course!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DatetimeIndex(['2005-01-04 12:55:00', '2005-01-23 23:15:00',\n",
      "               '2005-02-17 04:15:00', '2005-02-20 17:15:00',\n",
      "               '2005-02-24 01:20:00', '2005-03-14 10:00:00',\n",
      "               '2005-03-29 21:55:00', '2005-04-04 21:25:00',\n",
      "               '2005-07-14 11:20:00', '2005-07-14 19:55:00',\n",
      "               ...\n",
      "               '2015-12-31 13:23:00', '2015-12-31 18:59:00',\n",
      "               '2015-12-31 19:13:00', '2015-12-31 20:20:00',\n",
      "               '2015-12-31 20:50:00', '2015-12-31 21:21:00',\n",
      "               '2015-12-31 21:59:00', '2015-12-31 22:04:00',\n",
      "               '2015-12-31 22:09:00', '2015-12-31 22:47:00'],\n",
      "              dtype='datetime64[ns]', name='stop_datetime', length=86536, freq=None)\n",
      "Index(['stop_date', 'stop_time', 'driver_gender', 'driver_race',\n",
      "       'violation_raw', 'violation', 'search_conducted', 'search_type',\n",
      "       'stop_outcome', 'is_arrested', 'stop_duration', 'drugs_related_stop',\n",
      "       'district'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# Set 'stop_datetime' as the index\n",
    "ri.set_index('stop_datetime', inplace=True)\n",
    "\n",
    "# Examine the index\n",
    "print(ri.index)\n",
    "\n",
    "# Examine the columns\n",
    "print(ri.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Do the genders commit different violations?\n",
    "\n",
    "Relationship between Gender and Policing.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examining traffic violations\n",
    "Before comparing the violations being committed by each gender, you should examine the violations committed by all drivers to get a baseline understanding of the data.\n",
    "\n",
    "In this exercise, you'll count the unique values in the violation column, and then separately express those counts as proportions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Speeding               48423\n",
      "Moving violation       16224\n",
      "Equipment              10921\n",
      "Other                   4409\n",
      "Registration/plates     3703\n",
      "Seat belt               2856\n",
      "Name: violation, dtype: int64\n",
      "Speeding               0.559571\n",
      "Moving violation       0.187483\n",
      "Equipment              0.126202\n",
      "Other                  0.050950\n",
      "Registration/plates    0.042791\n",
      "Seat belt              0.033004\n",
      "Name: violation, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Count the unique values in 'violation'\n",
    "print(ri.violation.value_counts())\n",
    "\n",
    "# Express the counts as proportions\n",
    "print(ri.violation.value_counts(normalize=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing violations by gender\n",
    "The question we're trying to answer is whether male and female drivers tend to commit different types of traffic violations.\n",
    "\n",
    "In this exercise, you'll first create a DataFrame for each gender, and then analyze the violations in each DataFrame separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Female data:\n",
      " Speeding               0.658114\n",
      "Moving violation       0.138218\n",
      "Equipment              0.105199\n",
      "Registration/plates    0.044418\n",
      "Other                  0.029738\n",
      "Seat belt              0.024312\n",
      "Name: violation, dtype: float64\n",
      "Male data:\n",
      " Speeding               0.522243\n",
      "Moving violation       0.206144\n",
      "Equipment              0.134158\n",
      "Other                  0.058985\n",
      "Registration/plates    0.042175\n",
      "Seat belt              0.036296\n",
      "Name: violation, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Create a DataFrame of female drivers\n",
    "female = ri[ri['driver_gender'] == 'F']\n",
    "\n",
    "# Create a DataFrame of male drivers\n",
    "male = ri[ri['driver_gender'] == 'M']\n",
    "\n",
    "# Compute the violations by female drivers (as proportions)\n",
    "print(\"Female data:\\n\",female.violation.value_counts(normalize=True))\n",
    "\n",
    "# Compute the violations by male drivers (as proportions)\n",
    "print(\"Male data:\\n\", male.violation.value_counts(normalize=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "About two-thirds of female traffic stops are for speeding, whereas stops of males are more balanced among the six categories. This doesn't mean that females speed more often than males, however, since we didn't take into account the number of stops or drivers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing speeding outcomes by gender\n",
    "When a driver is pulled over for speeding, many people believe that gender has an impact on whether the driver will receive a ticket or a warning. Can you find evidence of this in the dataset?\n",
    "\n",
    "First, you'll create two DataFrames of drivers who were stopped for speeding: one containing females and the other containing males.\n",
    "\n",
    "Then, for each gender, you'll use the stop_outcome column to calculate what percentage of stops resulted in a \"Citation\" (meaning a ticket) versus a \"Warning\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Citation            0.952192\n",
      "Warning             0.040074\n",
      "Arrest Driver       0.005752\n",
      "N/D                 0.000959\n",
      "Arrest Passenger    0.000639\n",
      "No Action           0.000383\n",
      "Name: stop_outcome, dtype: float64\n",
      "Citation            0.952192\n",
      "Warning             0.040074\n",
      "Arrest Driver       0.005752\n",
      "N/D                 0.000959\n",
      "Arrest Passenger    0.000639\n",
      "No Action           0.000383\n",
      "Name: stop_outcome, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Create a DataFrame of female drivers stopped for speeding\n",
    "female_and_speeding = ri[(ri.driver_gender == 'F') & (ri.violation == 'Speeding')]\n",
    "\n",
    "# Create a DataFrame of male drivers stopped for speeding\n",
    "male_and_speeding = ri[(ri.driver_gender == 'M') & (ri.violation == 'Speeding')]\n",
    "\n",
    "# Compute the stop outcomes for female drivers (as proportions)\n",
    "print(female_and_speeding.stop_outcome.value_counts(normalize=True))\n",
    "\n",
    "# Compute the stop outcomes for male drivers (as proportions)\n",
    "print(female_and_speeding.stop_outcome.value_counts(normalize=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The numbers are similar for males and females: about 95% of stops for speeding result in a ticket. Thus, the data fails to show that gender has an impact on who gets a ticket for speeding."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculating the search rate\n",
    "During a traffic stop, the police officer sometimes conducts a search of the vehicle. In this exercise, you'll calculate the percentage of all stops in the ri DataFrame that result in a vehicle search, also known as the search rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bool\n",
      "False    0.961785\n",
      "True     0.038215\n",
      "Name: search_conducted, dtype: float64\n",
      "0.0382153092354627\n"
     ]
    }
   ],
   "source": [
    "# Check the data type of 'search_conducted'\n",
    "print(ri.search_conducted.dtype)\n",
    "\n",
    "# Calculate the search rate by counting the values\n",
    "print(ri.search_conducted.value_counts(normalize=True))\n",
    "\n",
    "# Calculate the search rate by taking the mean\n",
    "print(ri.search_conducted.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like the search rate is about 3.8%. Next, you'll examine whether the search rate varies by driver gender."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing search rates by gender\n",
    "In this exercise, you'll compare the rates at which female and male drivers are searched during a traffic stop. Remember that the vehicle search rate across all stops is about 3.8%.\n",
    "\n",
    "First, you'll filter the DataFrame by gender and calculate the search rate for each group separately. Then, you'll perform the same calculation for both genders at once using a .groupby()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.019180617481282074\n"
     ]
    }
   ],
   "source": [
    "# Calculate the search rate for female drivers\n",
    "print(ri[ri['driver_gender']=='F'].search_conducted.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.04542557598546892\n"
     ]
    }
   ],
   "source": [
    "# Calculate the search rate for male drivers\n",
    "print(ri[ri['driver_gender']=='M'].search_conducted.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "driver_gender\n",
      "F    0.019181\n",
      "M    0.045426\n",
      "Name: search_conducted, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Calculate the search rate for both groups simultaneously\n",
    "print(ri.groupby('driver_gender').search_conducted.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Male drivers are searched more than twice as often as female drivers. Why might this be?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding a second factor to the analysis\n",
    "Even though the search rate for males is much higher than for females, it's possible that the difference is mostly due to a second factor.\n",
    "\n",
    "For example, you might hypothesize that the search rate varies by violation type, and the difference in search rate between males and females is because they tend to commit different violations.\n",
    "\n",
    "You can test this hypothesis by examining the search rate for each combination of gender and violation. If the hypothesis was true, you would find that males and females are searched at about the same rate for each violation. Find out below if that's the case!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "driver_gender  violation          \n",
      "F              Equipment              0.039984\n",
      "               Moving violation       0.039257\n",
      "               Other                  0.041018\n",
      "               Registration/plates    0.054924\n",
      "               Seat belt              0.017301\n",
      "               Speeding               0.008309\n",
      "M              Equipment              0.071496\n",
      "               Moving violation       0.061524\n",
      "               Other                  0.046191\n",
      "               Registration/plates    0.108802\n",
      "               Seat belt              0.035119\n",
      "               Speeding               0.027885\n",
      "Name: search_conducted, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Calculate the search rate for each combination of gender and violation\n",
    "print(ri.groupby(['driver_gender', 'violation']).search_conducted.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "violation            driver_gender\n",
      "Equipment            F                0.039984\n",
      "                     M                0.071496\n",
      "Moving violation     F                0.039257\n",
      "                     M                0.061524\n",
      "Other                F                0.041018\n",
      "                     M                0.046191\n",
      "Registration/plates  F                0.054924\n",
      "                     M                0.108802\n",
      "Seat belt            F                0.017301\n",
      "                     M                0.035119\n",
      "Speeding             F                0.008309\n",
      "                     M                0.027885\n",
      "Name: search_conducted, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Reverse the ordering to group by violation before gender\n",
    "print(ri.groupby(['violation','driver_gender']).search_conducted.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For all types of violations, the search rate is higher for males than for females, disproving our hypothesis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incident to Arrest                                          1290\n",
      "Probable Cause                                               924\n",
      "Inventory                                                    219\n",
      "Reasonable Suspicion                                         214\n",
      "Protective Frisk                                             164\n",
      "Incident to Arrest,Inventory                                 123\n",
      "Incident to Arrest,Probable Cause                            100\n",
      "Probable Cause,Reasonable Suspicion                           54\n",
      "Incident to Arrest,Inventory,Probable Cause                   35\n",
      "Probable Cause,Protective Frisk                               35\n",
      "Incident to Arrest,Protective Frisk                           33\n",
      "Inventory,Probable Cause                                      25\n",
      "Protective Frisk,Reasonable Suspicion                         19\n",
      "Incident to Arrest,Inventory,Protective Frisk                 18\n",
      "Incident to Arrest,Probable Cause,Protective Frisk            13\n",
      "Inventory,Protective Frisk                                    12\n",
      "Incident to Arrest,Reasonable Suspicion                        8\n",
      "Incident to Arrest,Probable Cause,Reasonable Suspicion         5\n",
      "Probable Cause,Protective Frisk,Reasonable Suspicion           5\n",
      "Incident to Arrest,Inventory,Reasonable Suspicion              4\n",
      "Incident to Arrest,Protective Frisk,Reasonable Suspicion       2\n",
      "Inventory,Reasonable Suspicion                                 2\n",
      "Inventory,Probable Cause,Reasonable Suspicion                  1\n",
      "Inventory,Protective Frisk,Reasonable Suspicion                1\n",
      "Inventory,Probable Cause,Protective Frisk                      1\n",
      "Name: search_type, dtype: int64\n",
      "bool\n",
      "303\n"
     ]
    }
   ],
   "source": [
    "# Count the 'search_type' values\n",
    "print(ri.search_type.value_counts())\n",
    "\n",
    "# Check if 'search_type' contains the string 'Protective Frisk'\n",
    "ri['frisk'] = ri.search_type.str.contains('Protective Frisk', na=False)\n",
    "\n",
    "# Check the data type of 'frisk'\n",
    "print(ri.frisk.dtype)\n",
    "\n",
    "# Take the sum of 'frisk'\n",
    "print(ri.frisk.sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like there were 303 drivers who were frisked. Next, you'll examine whether gender affects who is frisked."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing frisk rates by gender\n",
    "In this exercise, you'll compare the rates at which female and male drivers are frisked during a search. Are males frisked more often than females, perhaps because police officers consider them to be higher risk?\n",
    "\n",
    "Before doing any calculations, it's important to filter the DataFrame to only include the relevant subset of data, namely stops in which a search was conducted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.09162382824312065\n",
      "driver_gender\n",
      "F    0.074561\n",
      "M    0.094353\n",
      "Name: frisk, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Create a DataFrame of stops in which a search was conducted\n",
    "searched = ri[ri.search_conducted == True]\n",
    "\n",
    "# Calculate the overall frisk rate by taking the mean of 'frisk'\n",
    "print(searched.frisk.mean())\n",
    "\n",
    "# Calculate the frisk rate for each gender\n",
    "print(searched.groupby('driver_gender').frisk.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The frisk rate is higher for males than for females, though we can't conclude that this difference is caused by the driver's gender."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculating the hourly arrest rate\n",
    "When a police officer stops a driver, a small percentage of those stops ends in an arrest. This is known as the arrest rate. In this exercise, you'll find out whether the arrest rate varies by time of day.\n",
    "\n",
    "First, you'll calculate the arrest rate across all stops in the ri DataFrame. Then, you'll calculate the hourly arrest rate by using the hour attribute of the index. The hour ranges from 0 to 23, in which:\n",
    "\n",
    "0 = midnight\n",
    "12 = noon\n",
    "23 = 11 PM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                      stop_date stop_time driver_gender driver_race  \\\n",
      "stop_datetime                                                         \n",
      "2005-01-04 12:55:00  2005-01-04     12:55             M       White   \n",
      "2005-01-23 23:15:00  2005-01-23     23:15             M       White   \n",
      "2005-02-17 04:15:00  2005-02-17     04:15             M       White   \n",
      "2005-02-20 17:15:00  2005-02-20     17:15             M       White   \n",
      "2005-02-24 01:20:00  2005-02-24     01:20             F       White   \n",
      "\n",
      "                                      violation_raw  violation  \\\n",
      "stop_datetime                                                    \n",
      "2005-01-04 12:55:00  Equipment/Inspection Violation  Equipment   \n",
      "2005-01-23 23:15:00                        Speeding   Speeding   \n",
      "2005-02-17 04:15:00                        Speeding   Speeding   \n",
      "2005-02-20 17:15:00                Call for Service      Other   \n",
      "2005-02-24 01:20:00                        Speeding   Speeding   \n",
      "\n",
      "                     search_conducted search_type   stop_outcome  is_arrested  \\\n",
      "stop_datetime                                                                   \n",
      "2005-01-04 12:55:00             False         NaN       Citation        False   \n",
      "2005-01-23 23:15:00             False         NaN       Citation        False   \n",
      "2005-02-17 04:15:00             False         NaN       Citation        False   \n",
      "2005-02-20 17:15:00             False         NaN  Arrest Driver         True   \n",
      "2005-02-24 01:20:00             False         NaN       Citation        False   \n",
      "\n",
      "                    stop_duration  drugs_related_stop district  frisk  \n",
      "stop_datetime                                                          \n",
      "2005-01-04 12:55:00      0-15 Min               False  Zone X4  False  \n",
      "2005-01-23 23:15:00      0-15 Min               False  Zone K3  False  \n",
      "2005-02-17 04:15:00      0-15 Min               False  Zone X4  False  \n",
      "2005-02-20 17:15:00     16-30 Min               False  Zone X1  False  \n",
      "2005-02-24 01:20:00      0-15 Min               False  Zone X3  False  \n",
      "0.0355690117407784\n",
      "stop_datetime\n",
      "0     0.051431\n",
      "1     0.064932\n",
      "2     0.060798\n",
      "3     0.060549\n",
      "4     0.048000\n",
      "5     0.042781\n",
      "6     0.013813\n",
      "7     0.013032\n",
      "8     0.021854\n",
      "9     0.025206\n",
      "10    0.028213\n",
      "11    0.028897\n",
      "12    0.037399\n",
      "13    0.030776\n",
      "14    0.030605\n",
      "15    0.030679\n",
      "16    0.035281\n",
      "17    0.040619\n",
      "18    0.038204\n",
      "19    0.032245\n",
      "20    0.038107\n",
      "21    0.064541\n",
      "22    0.048666\n",
      "23    0.047592\n",
      "Name: is_arrested, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(ri.head())\n",
    "# Calculate the overall arrest rate\n",
    "print(ri.is_arrested.mean())\n",
    "\n",
    "# Calculate the hourly arrest rate\n",
    "print(ri.groupby(ri.index.hour).is_arrested.mean())\n",
    "\n",
    "# Save the hourly arrest rate\n",
    "hourly_arrest_rate = ri.groupby(ri.index.hour).is_arrested.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import matplotlib.pyplot as plt\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Create a line plot of 'hourly_arrest_rate'\n",
    "hourly_arrest_rate.plot()\n",
    "\n",
    "# Add the xlabel, ylabel, and title\n",
    "plt.xlabel('Hour')\n",
    "plt.ylabel('Arrest Rate')\n",
    "plt.title('Arrest Rate by Time of Day')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting drug-related stops\n",
    "In a small portion of traffic stops, drugs are found in the vehicle during a search. In this exercise, you'll assess whether these drug-related stops are becoming more common over time.\n",
    "\n",
    "The Boolean column drugs_related_stop indicates whether drugs were found during a given stop. You'll calculate the annual drug rate by resampling this column, and then you'll use a line plot to visualize how the rate has changed over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stop_datetime\n",
      "2005-12-31    0.006501\n",
      "2006-12-31    0.007258\n",
      "2007-12-31    0.007970\n",
      "2008-12-31    0.007505\n",
      "2009-12-31    0.009889\n",
      "2010-12-31    0.010081\n",
      "2011-12-31    0.009731\n",
      "2012-12-31    0.009921\n",
      "2013-12-31    0.013094\n",
      "2014-12-31    0.013826\n",
      "2015-12-31    0.012266\n",
      "Freq: A-DEC, Name: drugs_related_stop, dtype: float64\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculate the annual rate of drug-related stops\n",
    "print(ri.drugs_related_stop.resample('A').mean())\n",
    "\n",
    "# Save the annual rate of drug-related stops\n",
    "annual_drug_rate = ri.drugs_related_stop.resample('A').mean()\n",
    "\n",
    "# Create a line plot of 'annual_drug_rate'\n",
    "annual_drug_rate.plot()\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The rate of drug-related stops nearly doubled over the course of 10 years. Why might that be the case?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing drug and search rates\n",
    "As you saw in the last exercise, the rate of drug-related stops increased significantly between 2005 and 2015. You might hypothesize that the rate of vehicle searches was also increasing, which would have led to an increase in drug-related stops even if more drivers were not carrying drugs.\n",
    "\n",
    "You can test this hypothesis by calculating the annual search rate, and then plotting it against the annual drug rate. If the hypothesis is true, then you'll see both rates increasing over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculate and save the annual search rate\n",
    "annual_search_rate = ri.search_conducted.resample('A').mean()\n",
    "\n",
    "# Concatenate 'annual_drug_rate' and 'annual_search_rate'\n",
    "annual = pd.concat([annual_drug_rate, annual_search_rate], axis=1)\n",
    "\n",
    "# Create subplots from 'annual'\n",
    "annual.plot(subplots=True)\n",
    "\n",
    "# Display the subplots\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The rate of drug-related stops increased even though the search rate decreased, disproving our hypothesis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tallying violations by district\n",
    "The state of Rhode Island is broken into six police districts, also known as zones. How do the zones compare in terms of what violations are caught by police?\n",
    "\n",
    "In this exercise, you'll create a frequency table to determine how many violations of each type took place in each of the six zones. Then, you'll filter the table to focus on the \"K\" zones, which you'll examine further in the next exercise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "violation  Equipment  Moving violation  Other  Registration/plates  Seat belt  \\\n",
      "district                                                                        \n",
      "Zone K1          672              1254    290                  120          0   \n",
      "Zone K2         2061              2962    942                  768        481   \n",
      "Zone K3         2302              2898    705                  695        638   \n",
      "Zone X1          296               671    143                   38         74   \n",
      "Zone X3         2049              3086    769                  671        820   \n",
      "Zone X4         3541              5353   1560                 1411        843   \n",
      "\n",
      "violation  Speeding  \n",
      "district             \n",
      "Zone K1        5960  \n",
      "Zone K2       10448  \n",
      "Zone K3       12322  \n",
      "Zone X1        1119  \n",
      "Zone X3        8779  \n",
      "Zone X4        9795  \n",
      "violation  Equipment  Moving violation  Other  Registration/plates  Seat belt  \\\n",
      "district                                                                        \n",
      "Zone K1          672              1254    290                  120          0   \n",
      "Zone K2         2061              2962    942                  768        481   \n",
      "Zone K3         2302              2898    705                  695        638   \n",
      "\n",
      "violation  Speeding  \n",
      "district             \n",
      "Zone K1        5960  \n",
      "Zone K2       10448  \n",
      "Zone K3       12322  \n"
     ]
    }
   ],
   "source": [
    "# Create a frequency table of districts and violations\n",
    "print(pd.crosstab(ri.district, ri.violation))\n",
    "\n",
    "# Save the frequency table as 'all_zones'\n",
    "all_zones = pd.crosstab(ri.district, ri.violation)\n",
    "\n",
    "# Select rows 'Zone K1' through 'Zone K3'\n",
    "print(all_zones.loc['Zone K1':'Zone K3'])\n",
    "\n",
    "# Save the smaller table as 'k_zones'\n",
    "k_zones = all_zones.loc['Zone K1':'Zone K3']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting violations by district\n",
    "Now that you've created a frequency table focused on the \"K\" zones, you'll visualize the data to help you compare what violations are being caught in each zone.\n",
    "\n",
    "First you'll create a bar plot, which is an appropriate plot type since you're comparing categorical data. Then you'll create a stacked bar plot in order to get a slightly different look at the data. Which plot do you find to be more insightful?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a bar plot of 'k_zones'\n",
    "k_zones.plot(kind=\"bar\")\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEpCAYAAAB4CO7gAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl8VPX1//HXYRMQBBT0h6AGLDuJYVdEDEUFKVVcg1VBbKFUkGotioqKWP3SilWxCmK1oGWJhYKIqFgLiooCgTRsyqJRIxQRC7KlbOf3x9xMJ0w2SGAy4f18POaRued+7p0z3CEn9/O587nm7oiIiESqEOsERESk7FFxEBGRKCoOIiISRcVBRESiqDiIiEgUFQcREYmi4iAiIlFUHEREJIqKg4iIRKkU6wSOVt26dT0hISHWaYiIxJX09PTv3L1eUe3itjgkJCSwbNmyWKchIhJXzOzL4rQrslvJzM4yswVmttbMVpvZr4P4qWb2jpmtD37WCeJmZuPMbIOZZZpZ24h99Q/arzez/hHxdma2MthmnJnZkb9lEREpLcUZczgA3OXuLYDzgSFm1hIYAbzr7k2Ad4NlgMuBJsFjEDAeQsUEeAjoBHQEHsotKEGbQRHb9Sz5WxMRkaNVZHFw983uvjx4vhNYCzQArgQmB80mA32C51cCL3vIx0BtM6sP9ADecffv3f0/wDtAz2DdKe6+2ENTxL4csS8REYmBIxpzMLMEoA3wCXCGu2+GUAExs9ODZg2AryM2yw5ihcWz84kfsf3795OdnU1OTs7RbC7lQNWqVWnYsCGVK1eOdSoica3YxcHMagAzgTvc/YdChgXyW+FHEc8vh0GEup84++yzo9ZnZ2dTs2ZNEhIS0LDFicfd2bZtG9nZ2TRq1CjW6YjEtWJ9z8HMKhMqDFPc/e9BeEvQJUTw89sgng2cFbF5Q2BTEfGG+cSjuPtEd2/v7u3r1Yu+EisnJ4fTTjtNheEEZWacdtppOnMUKQXFuVrJgBeBte7+x4hVc4DcK476A69FxPsFVy2dD+wIup/eBi4zszrBQPRlwNvBup1mdn7wWv0i9nXEVBhObDr+IqWjON1KFwI3AyvNLCOI3QeMAV41s58DXwHXBevmAb2ADcAeYACAu39vZo8AS4N2o939++D5r4BJQDXgzeAhIiIxUmRxcPcPyH9cAKB7Pu0dGFLAvl4CXsonvgxoXVQuJ4JNmzYxbNgwZsyYUWCbhQsXMnbsWObOnVtgm4yMDDZt2kSvXr0AmDNnDmvWrGHEiBEFbiNSFj2R2jvWKRxTd6UV/P84ljS3Uhlz5plnFloYiisjI4N58+aFl6+44goVBhEpNhWHGLrnnnt47rnnwsujRo3iiSeeoHXr0ElUTk4OAwYMIDExkTZt2rBgwYKofSxZsoTOnTvTpk0bOnfuzGeffca+fft48MEHSUtLIzk5mbS0NCZNmsTQoUMB+PLLL+nevTtJSUl0796dr776CoBbbrmFYcOG0blzZxo3blwqRUpE4pOKQwz17duXtLS08PKrr75Khw4dwsvPPvssACtXrmTatGn0798/6kqc5s2b8/7777NixQpGjx7NfffdR5UqVRg9ejSpqalkZGSQmpqaZ5uhQ4fSr18/MjMzufHGGxk2bFh43ebNm/nggw+YO3euzjRETmBxO/FeedCmTRu+/fZbNm3axNatW6lTp06e72988MEH3H777UCoCJxzzjmsW7cuzz527NhB//79Wb9+PWbG/v37i3zdxYsX8/e/h65Ivvnmm7n77rvD6/r06UOFChVo2bIlW7ZsKY23KSJxSMUhxq699lpmzJjBv//9b/r27ZtnXWhsv3APPPAA3bp1Y9asWWRlZZGSknLEOURe/nnSSScd0euLSPmkbqUY69u3L9OnT2fGjBlce+21edZ17dqVKVOmALBu3Tq++uormjVrlqfNjh07aNAgNNvIpEmTwvGaNWuyc+fOfF+zc+fOTJ8+HYApU6bQpUuX0no7IlJOqDjEWKtWrdi5cycNGjSgfv36edbddtttHDx4kMTERFJTU5k0aVKev+wB7r77bu69914uvPBCDh48GI5369aNNWvWhAekI40bN46//OUvJCUl8corr/D0008fuzcoInHJ4rXroH379n74zX7Wrl1LixYtYpSRlBX6HJQv+p5D6TKzdHdvX1Q7nTmIiEgUFQcREYmi4iAiIlFUHEREJIqKg4iIRFFxEBGRKOX6G9IJI94o1f1ljflJkW0qVqxIYmJieLlv375HPUdR586d+eijj45q25J66qmnGDRoENWrV4/J64tIbJXr4hAL1apVIyMjo+iGxRCrwgCh4nDTTTepOIicoNStdJy89dZbNG/enC5dujBs2DB69w59sWfUqFGMHTs23K5169ZkZWUBUKNGDSB0c5+uXbty1VVX0bJlSwYPHsyhQ4fCbe655x7atWvHJZdcwpIlS0hJSaFx48bMmTMHgIMHDzJ8+HA6dOhAUlISzz//fHi/KSkpXHvttTRv3pwbb7wRd2fcuHFs2rSJbt260a1bt+P1TyQiZYiKQynbu3cvycnJ4UdaWho5OTkMHDiQ119/nUWLFvHvf//7iPe7ZMkSnnjiCVauXMnGjRvDs6ru3r2blJQU0tPTqVmzJiNHjuSdd95h1qxZPPjggwC8+OKL1KpVi6VLl7J06VJeeOEFvvjiCwBWrFjBU089xZo1a/j888/58MMPGTZsGGeeeSYLFizI9x4SIlL+FVkczOwlM/vWzFZFxNLMLCN4ZOXeW9rMEsxsb8S6CRHbtDOzlWa2wczGWTAVqJmdambvmNn64GedY/FGj5fcbqXcR2pqKp9++imNGjWiSZMmmBk33XTTEe+3Y8eONG7cmIoVK3LDDTfwwQcfAFClShV69uwJQGJiIhdffDGVK1cmMTExfAYyf/58Xn75ZZKTk+nUqRPbtm1j/fr14f02bNiQChUqkJycHN5GRE5sxRlzmAT8CXg5N+Du4bvHmNkTwI6I9hvdPTmf/YwHBgEfA/OAnsCbwAjgXXcfY2YjguV7juxtlH2R02JHqlSpUriLCIi6mU9B2+cuV65cOfy8QoUK4Yn5KlSowIEDB4DQ1NvPPPMMPXr0yLOPhQsX5pnIr2LFiuFtyhPNzSNy5Io8c3D394Hv81sX/PV/PTCtsH2YWX3gFHdf7KGZ/l4G+gSrrwQmB88nR8TLjebNm/PFF1+wceNGAKZN+98/V0JCAsuXLwdg+fLl4e6ewy1ZsoQvvviCQ4cOkZaWdkTTbPfo0YPx48eHbwS0bt06du/eXeg2hU35LSLlX0mvVroI2OLu6yNijcxsBfADMNLdFwENgOyINtlBDOAMd98M4O6bzez0gl7MzAYROvvIc8e0ghTn0tPSljvmkKtnz56MGTOGiRMn8pOf/IS6devSpUsXVq0K9dJdc8014S6fDh060LRp03z3e8EFFzBixAhWrlwZHpwurl/84hdkZWXRtm1b3J169eoxe/bsQrcZNGgQl19+OfXr19e4g8gJqKTF4QbynjVsBs52921m1g6YbWatgPz6VI54rnB3nwhMhNCU3UeR7zEXeU+FSD179uTTTz8FQt05ucWhWrVqzJ8/P99tdu3aFX5evXr1qPsyHN5m1KhR+a6rUKECjz32GI899lie9SkpKXnuHPenP/0p/Pz2228P36JURE48R10czKwScDXQLjfm7v8F/hs8TzezjUBTQmcKDSM2bwhsCp5vMbP6wVlDfeDbo81JRERKR0kuZb0E+NTdw91FZlbPzCoGzxsDTYDPg26jnWZ2fjBO0Q94LdhsDtA/eN4/Il5upaSkMHdu8QcRj7S9iEhJFedS1mnAYqCZmWWb2c+DVX2JHojuCmSa2b+AGcBgd88dzP4V8GdgA7CR0JVKAGOAS81sPXBpsCwiIjFUZLeSu99QQPyWfGIzgZkFtF8GtM4nvg3oXlQeIiJy/Ogb0iIiEkXFQUREopTvWVlH1Srl/e0osknu9BivvPIKAAcOHKB+/fp06tTpqAaVJ0yYQPXq1enXr98Rb1tcvXr1YurUqdSuXbvANjVq1Mhz2ezhtm/fztSpU7ntttsA2LRpE8OGDWPGjBmlnq+IHHs6cyhlJ598MqtWrWLv3r0AvPPOOzRo0KCIrQo2ePDgY1oYAObNm1doYSiO7du389xzz4WXzzzzTBUGkTim4nAMXH755bzxRuhGQ9OmTeOGG/43pv/999/Tp08fkpKSOP/888nMzOTQoUMkJCSwffv2cLsf/ehHbNmyJc+U3ikpKdxzzz107NiRpk2bsmjRIgD27NnD9ddfT1JSEqmpqXTq1Illy5blyenNN9/k+uuvDy8vXLiQn/70p0BoCo/vvvsOgD/+8Y+0bt2a1q1b89RTT0W9t127dtG9e3fatm1LYmIir70WuvJ4xIgRbNy4keTkZIYPH05WVhatW4euP8jJyWHAgAEkJibSpk2b8DeuJ02axNVXX03Pnj1p0qQJd999dwn+1UWkNKk4HAN9+/Zl+vTp5OTkkJmZSadOncLrHnroIdq0aUNmZiaPPfYY/fr1o0KFClx55ZXMmjULgE8++YSEhATOOOOMqH0fOHCAJUuW8NRTT/Hwww8D8Nxzz1GnTh0yMzN54IEHSE9Pj9ru0ksv5eOPPw7PqZSWlkZqamqeNunp6fzlL3/hk08+4eOPP+aFF15gxYoVedpUrVqVWbNmsXz5chYsWMBdd92FuzNmzBjOPfdcMjIyePzxx/Ns8+yzzwKwcuVKpk2bRv/+/cMTDGZkZJCWlsbKlStJS0vj66+/PqJ/axE5NlQcjoGkpCSysrKYNm0avXr1yrPugw8+4Oabbwbgxz/+Mdu2bWPHjh2kpqaGp8eYPn161C/uXFdffTUA7dq1C0+v/cEHH9C3b18gdLOgpKSkqO0qVapEz549ef311zlw4ABvvPEGV155ZVRuV111FSeffDI1atTg6quvDp+d5HJ37rvvPpKSkrjkkkv45ptv2LJlS6H/HpHvuXnz5pxzzjmsW7cOgO7du1OrVi2qVq1Ky5Yt+fLLLwvdl4gcH+V7QDqGrrjiCn7729+ycOFCtm3bFo6HJqXNy8y44IIL2LBhA1u3bmX27NmMHDky3/3mTrEdOb12fvvMT2pqKs8++yynnnoqHTp0oGbNmnnWF2c/U6ZMYevWraSnp1O5cmUSEhIKnGa8OPs9EaYMF4lHOnM4Rm699VYefPBBEhMT88S7du3KlClTgFC/f926dTnllFMwM6666ip+85vf0KJFC0477bRiv1aXLl149dVXAVizZg0rV67Mt11KSgrLly/nhRdeyPfMpGvXrsyePZs9e/awe/duZs2axUUXXZSnzY4dOzj99NOpXLkyCxYsCP+lX9gU35Hved26dXz11Vc0a9as2O9PRI6/8n3mUIxLT4+Vhg0b8utf/zoqPmrUKAYMGEBSUhLVq1dn8uTJ4XWpqal06NCBSZMmHdFr3XbbbfTv35+kpCTatGlDUlIStWpFX8ZbsWJFevfuzaRJk/K8bq62bdtyyy230LFjRyA01XebNm3ytLnxxhv56U9/Svv27UlOTqZ58+YAnHbaaVx44YW0bt2ayy+/nCFDhuTJb/DgwSQmJlKpUiUmTZqU54xBRMoeK26XRFnTvn17P/yKnLVr19KiRYsYZRQ7Bw8eZP/+/VStWpWNGzfSvXt31q1bR5UqVWKdWkwc/jnQneDim45f6TKzdHdvX1S78n3mcILYs2cP3bp1Y//+/bg748ePP2ELg4iUDhWHcqBmzZpR32sQESkJDUiLiEgUFQcREYmi4iAiIlFUHEREJEqRA9Jm9hLQG/jW3VsHsVHAQGBr0Ow+d58XrLsX+DlwEBjm7m8H8Z7A00BF4M/uPiaINwKmA6cCy4Gb3X1faby5xMmJRTc6Aiv75//lskjZ2dkMGTKENWvWcOjQIXr37s3jjz/OmjVr2LRpU3g6jVGjRlGjRg1++9vflmqOIiKloThnDpOAnvnEn3T35OCRWxhaErq3dKtgm+fMrKKZVQSeBS4HWgI3BG0Bfh/sqwnwH0KFJS65O1dffTV9+vRh/fr1rFu3jl27dnH//feTkZHBvHnzSu21Dh48WGr7EhE5XJHFwd3fB74v5v6uBKa7+3/d/QtgA9AxeGxw98+Ds4LpwJVmZsCPgdyJ/ycDfY7wPZQZ//znP6latSoDBgwAQt9IfvLJJ/nzn//M3XffTVpaGsnJyeEJ9tasWUNKSgqNGzdm3Lhx4f389a9/pWPHjiQnJ/PLX/4yXAhq1KjBgw8+SKdOnVi8ePHxf4MicsIoyZjDUDPLNLOXzKxOEGsARM65nB3ECoqfBmx39wOHxePS6tWradeuXZ7YKaecQkJCAiNHjiQ1NZWMjIzwvEaffvopb7/9NkuWLOHhhx9m//79rF27lrS0ND788EMyMjKoWLFieF6i3bt307p1az755BO6dOly3N+fiJw4jvZLcOOBRwAPfj4B3ApYPm2d/IuQF9I+X2Y2CBgEcPbZZx9ZxseBuxM6GSpe/Cc/+QknnXQSJ510Eqeffjpbtmzh3XffJT09nQ4dOgCwd+9eTj/9dCB0JnLNNdcc2zchIsJRFgd3D0/gb2YvALmTg2QDZ0U0bQhsCp7nF/8OqG1mlYKzh8j2+b3uRGAihOZWOprcj6VWrVoxc+bMPLEffviBr7/+mooVK0a1z2+6anenf//+/N///V9U+6pVq+a7HxGR0nZU3UpmVj9i8SpgVfB8DtDXzE4KrkJqAiwBlgJNzKyRmVUhNGg9x0Oz/i0Arg227w+8djQ5lQXdu3dnz549vPzyy0Bo0Piuu+7illtu4YwzzihwSuvD9zFjxgy+/fZbIHRbUd0AR0SOt+JcyjoNSAHqmlk28BCQYmbJhLqAsoBfArj7ajN7FVgDHACGuPvBYD9DgbcJXcr6kruvDl7iHmC6mf0OWAG8WFpvrjiXnpYmM2PWrFncdtttPPLIIxw6dIhevXrx2GOPsXv3bsaMGUNycjL33ntvgfto2bIlv/vd77jssss4dOgQlStX5tlnn+Wcc845ju9ERE50RRYHd78hn3CBv8Dd/VHg0Xzi84Coaznd/XNCVzOVC2eddRavv/56VPykk05i6dKlBW63atWq8PPU1NR8b8aza9eu0klSRKQI+oa0iIhEUXEQEZEoKg4iIhJFxUFERKKoOIiISBQVBxERiVKu7yG9tnmLUt1fi0/XFtmmYsWKJCYmcuDAARo1asQrr7xC7dq1j+r1HnzwQbp27coll1yS7/rZs2fTtGlTWrZsme/6gixcuJAqVarQuXNnACZMmED16tXp16/fUeUJ0K5dOxYvXkyVKlXyXX/LLbfQu3dvrr322nzXA0yaNInLLruMM88886jzEJHSoTOHUlatWjUyMjJYtWoVp556Ks8+++xR72v06NEFFgYIFYc1a9bku+7AgQP5xiFUHD766KPw8uDBg0tUGLKysmjQoEGBhaG4Jk2axKZNBc6eIiLHkYrDMXTBBRfwzTffhJcff/xxOnToQFJSEg899FA4/sgjj9C8eXMuvfRSbrjhBsaOHQuE/tqeMSM0m/mIESNo2bIlSUlJ/Pa3v+Wjjz5izpw5DB8+nOTkZDZu3EhKSgr33XcfF198MU8//TSvv/46nTp1ok2bNlxyySVs2bKFrKwsJkyYwJNPPklycjKLFi1i1KhR4dfMyMjg/PPPJykpiauuuor//Oc/AKSkpHDPPffQsWNHmjZtyqJFi8L5v/nmm/TsGbrlR40aNbjrrrto27Yt3bt3Z+vWrRxu9OjRdOjQgdatWzNo0CDcnRkzZrBs2TJuvPFGkpOT2bt3L+np6Vx88cW0a9eOHj16sHnzZgDGjRsX/rfo27dvaR4yEQmoOBwjBw8e5N133+WKK64AYP78+axfv54lS5aQkZFBeno677//PsuWLWPmzJmsWLGCv//97yxbtixqX99//z2zZs1i9erVZGZmMnLkSDp37swVV1zB448/TkZGBueeey4A27dv57333uOuu+6iS5cufPzxx6xYsYK+ffvyhz/8gYSEBAYPHsydd95JRkYGF110UZ7X6tevH7///e/JzMwkMTGRhx9+OLzuwIEDLFmyhKeeeipP/K233goXh927d9O2bVuWL1/OxRdfnKddrqFDh7J06VJWrVrF3r17mTt3Ltdeey3t27dnypQpZGRkUKlSJW6//XZmzJhBeno6t956K/fffz8AY8aMYcWKFWRmZjJhwoQSHikRyU+5HnOIhb1795KcnExWVhbt2rXj0ksvBULFYf78+bRp0wYITYWxfv16du7cyZVXXkm1atUA+OlPfxq1z1NOOYWqVavyi1/8gp/85Cf07t27wNePnHYjOzub1NRUNm/ezL59+2jUqFGhue/YsYPt27dz8cUXA9C/f3+uu+668Pqrr74aCI0vZGVlAbBv3z6ys7Np3LgxABUqVAjncNNNN4W3ibRgwQL+8Ic/sGfPHr7//ntatWoV9b4/++wzVq1aFf73O3jwIPXrh+Z7TEpK4sYbb6RPnz706RO394YSKdN05lDKcsccvvzyS/bt2xcec3B37r33XjIyMsjIyGDDhg38/Oc/JzQxbeEqVarEkiVLuOaaa5g9e3b4r/T8nHzyyeHnt99+O0OHDmXlypU8//zz5OTklOi95U4xnju9OMCiRYsKvfHQ4fexyMnJ4bbbbmPGjBmsXLmSgQMH5puXu9OqVavwv9fKlSuZP38+AG+88QZDhgwhPT2ddu3aFTq+IiJHR8XhGKlVqxbjxo1j7Nix7N+/nx49evDSSy+FJ8/75ptv+Pbbb+nSpQuvv/46OTk57Nq1izfeeCNqX7t27WLHjh306tWLp556ioyMDABq1qxZ6DTgO3bsoEGD0I31Jk+eHI4XtF2tWrWoU6dOeDzhlVdeCZ9FFOStt97i8ssvDy8fOnQoPE4yderUqMKRWwjq1q3Lrl27wm0Pz6tZs2Zs3bo1fDvU/fv3s3r1ag4dOsTXX39Nt27d+MMf/sD27ds1IaHIMVCuu5WKc+npsdSmTRvOO+88pk+fzs0338zatWu54IILgNDA7V//+lc6dOjAFVdcwXnnncc555xD+/btqVWrVp795HY95eTk4O48+eSTAPTt25eBAwcybty4PL9kc40aNYrrrruOBg0acP755/PFF18Aoa6ra6+9ltdee41nnnkmzzaTJ09m8ODB7Nmzh8aNG/OXv/yl0Pe4cOFCRo8eHV4++eSTw7dLrVWrVvh+2blq167NwIEDSUxMJCEhIXzHOwgNwA8ePJhq1aqxePFiZsyYwbBhw9ixYwcHDhzgjjvuoGnTptx0003s2LEDd+fOO+886kuFRaRgVpxujbKoffv2fvjg7dq1a2nRonS/23A87Nq1ixo1arBnzx66du3KxIkTadu2bazTKlJ2djYDBw7kzTffDMdq1KgR87/kD/8cPJFa8BhNeXBX2tyiG8UxHb/SZWbp7t6+qHbl+swhXgwaNIg1a9aQk5ND//7946IwADRs2DBPYRCR8kPFoQyYOnVqrFMoNbE+axCR0qEBaRERiVJkcTCzl8zsWzNbFRF73Mw+NbNMM5tlZrWDeIKZ7TWzjOAxIWKbdma20sw2mNk4C65xNLNTzewdM1sf/KxzLN6oiIgUX3HOHCYBh19Y/w7Q2t2TgHXAvRHrNrp7cvAYHBEfDwwCmgSP3H2OAN519ybAu8GyiIjEUJHFwd3fB74/LDbf3XO/efQx0LCwfZhZfeAUd1/socujXgZyv9p6JZB7Ef7kiLiIiMRIaQxI3wpEXszeyMxWAD8AI919EdAAyI5okx3EAM5w980A7r7ZzE4v6IXMbBChsw/OPvvsIhN7dvA/j+BtFG3IhB8X2ebRRx9l6tSpVKxYkQoVKvD888/TqVOnI36twqbjLs7015GysrLo3bs3q1atIiMjg02bNtGrV68jzklEThwlGpA2s/uBA8CUILQZONvd2wC/Aaaa2SmA5bP5EX/Bwt0nunt7d29fr169o037mFm8eDFz585l+fLlZGZm8o9//IOzzjrrqPZV2HTcJZGRkcG8efNKfb8iUr4cdXEws/5Ab+DGoKsId/+vu28LnqcDG4GmhM4UIrueGgK5E/dvCbqdcrufvj3anGJt8+bN1K1bNzwHUd26dcM3rilo+ukXXniBDh06cN5553HNNdewZ8+efKfjPtw//vEPLrroIpo2bcrcuaEv0Rw8eJDhw4eHpwV//vnn82yzb98+HnzwQdLS0khOTo769rKISK6jKg5m1hO4B7jC3fdExOuZWcXgeWNCA8+fB91GO83s/OAqpX7Aa8Fmc4D+wfP+EfG4c9lll/H111/TtGlTbrvtNt577z0gNC9QQdNPX3311SxdupR//etftGjRghdffLHA6bgjZWVl8d577/HGG28wePBgcnJyePHFF6lVqxZLly5l6dKlvPDCC+EpMwCqVKnC6NGjSU1NJSMjI88MriIikYocczCzaUAKUNfMsoGHCF2ddBLwTnBF6sfBlUldgdFmdgA4CAx299zB7F8RuvKpGvBm8AAYA7xqZj8HvgL+N0d0nKlRowbp6eksWrSIBQsWkJqaypgxY2jfvn2B00+vWrWKkSNHhieQ69GjR7Fe6/rrr6dChQo0adKExo0b8+mnnzJ//nwyMzPD8yzt2LGD9evX07Rp02PzhkWk3CqyOLj7DfmEXyyg7UxgZgHrlgGt84lvA7oXlUe8qFixIikpKaSkpJCYmMjkyZNp164drVq1Cs8wGumWW25h9uzZnHfeeUyaNImFCxcW63UOnwrbzHB3nnnmmagCk3vvBRGR4tI3pEvRZ599xvr168PLGRkZnHPOOQVOPw2hGVfr16/P/v37mTJlSnjboqbj/tvf/sahQ4fYuHEjn3/+Oc2aNaNHjx6MHz+e/fv3A7Bu3Tp2796dZ7ui9isiAuV8bqXiXHpamnbt2sXtt9/O9u3bqVSpEj/60Y+YOHEiVapUyXf66VatWvHII4/QqVMnzjnnHBITE8O/uA+fjvvwcYdmzZpx8cUXs2XLFiZMmBCFLrdjAAAUgElEQVS+U1xWVhZt27bF3alXrx6zZ8/Os123bt0YM2YMycnJ3HvvvRp3EJF8acpuKXc0ZXf5ouNXuoo7Zbe6lUREJIqKg4iIRFFxEBGRKCoOIiISRcVBRESiqDiIiEiUcv09h9K+BK44l5yV1pTdxZGSksLYsWNp3749vXr1YurUqdSuXfuYvJaInFjKdXE43iKn7D7ppJP47rvv2Ldv33F5bU3DLSKlSd1KpaigKbsTEhK455576NixIx07dmTDhg0AbN26lWuuuYYOHTrQoUMHPvzwQwB2797NrbfeSocOHWjTpg2vvRaaqHbv3r307duXpKQkUlNT2bt3b/i1ExIS+O6778jKyqJFixYMHDiQVq1acdlll4XbLV26lKSkJC644AKGDx9O69ZRU12JiAAqDqWqoCm7AU455RSWLFnC0KFDueOOOwD49a9/zZ133snSpUuZOXMmv/jFL4BQ19SPf/xjli5dyoIFCxg+fDi7d+9m/PjxVK9enczMTO6//37S09PzzWP9+vUMGTKE1atXU7t2bWbODM2FOGDAACZMmMDixYupWLHiMf7XEJF4pm6lUlTQlN0AN9xwQ/jnnXfeCYRu2BN5t7cffviBnTt3Mn/+fObMmcPYsWMByMnJ4auvvuL9999n2LBhACQlJZGUlJRvHo0aNSI5ORmAdu3akZWVxfbt29m5cyedO3cG4Gc/+1n4JkEiIodTcShl+U3ZDXmn2M59fujQIRYvXky1atXy7MPdmTlzJs2aNYva/+FTdecnt1srN5+9e/cSr3NoiUhsqFupFBU0ZTcQviVnWloaF1xwARDqhvrTn/6Upz1Ajx49eOaZZ8K/0FesWAFA165dw9N6r1q1iszMzGLnVqdOHWrWrMnHH38MwPTp04/qPYrIiaFcnzkc79kOC5qye+7cufz3v/+lU6dOHDp0iGnTpgEwbtw4hgwZQlJSEgcOHKBr165MmDCBBx54gDvuuIOkpCTcnYSEBObOncuvfvUrBgwYQFJSEsnJyXTs2PGI8nvxxRcZOHAgJ598MikpKdSqVetY/DOISDlQrCm7zewloDfwrbu3DmKnAmlAApAFXO/u/wnuEf000AvYA9zi7suDbfoDI4Pd/s7dJwfxdvzvFqLzgF97EYnF05TdCQkJLFu2jLp168Y0j127dlGjRg0AxowZw+bNm3n66adjmtOxoCm7yxcdv9JV2lN2TwJ6HhYbAbzr7k2Ad4NlgMuBJsFjEDA+SOhUQvef7gR0BB4yszrBNuODtrnbHf5aUgreeOMNkpOTad26NYsWLWLkyJFFbyQiJ6RidSu5+/tmlnBY+EogJXg+GVgI3BPEXw7+8v/YzGqbWf2g7Tvu/j2Amb0D9DSzhcAp7r44iL8M9AHePNo3VdaUlXs4p6am6s5vIlIsJRmQPsPdNwMEP08P4g2AryPaZQexwuLZ+cSPiq7KObHp+IuUjmNxtVJ+11r6UcSjd2w2yMyWmdmyrVu3Rq2vWrUq27Zt0y+IE5S7s23bNqpWrRrrVETiXkmuVtpiZvXdfXPQbfRtEM8Gzopo1xDYFMRTDosvDOIN82kfxd0nAhMhNCB9+PqGDRuSnZ1NfoVDTgxVq1alYcOGRTcUkUKVpDjMAfoDY4Kfr0XEh5rZdEKDzzuCAvI28FjEIPRlwL3u/r2Z7TSz84FPgH7AM0eTUOXKlWnUqNHRvyMREQGKWRzMbBqhv/rrmlk2oauOxgCvmtnPga+A64Lm8whdxrqB0KWsAwCCIvAIsDRoNzp3cBr4Ff+7lPVNytFgtIhIPCru1Uo3FLCqez5tHRhSwH5eAl7KJ74M0BShIiJlhKbPEBGRKCoOIiISRcVBRESiqDiIiEgUFQcREYmi4iAiIlFUHEREJIqKg4iIRFFxEBGRKCoOIiISRcVBRESiqDiIiEgUFQcREYlSkvs5nFCeSO0d6xSOqbvS5sY6BREpQ3TmICIiUVQcREQkioqDiIhEUXEQEZEoR10czKyZmWVEPH4wszvMbJSZfRMR7xWxzb1mtsHMPjOzHhHxnkFsg5mNKOmbEhGRkjnqq5Xc/TMgGcDMKgLfALOAAcCT7j42sr2ZtQT6Aq2AM4F/mFnTYPWzwKVANrDUzOa4+5qjzU1EREqmtC5l7Q5sdPcvzaygNlcC0939v8AXZrYB6Bis2+DunwOY2fSgrYqDiEiMlNaYQ19gWsTyUDPLNLOXzKxOEGsAfB3RJjuIFRSPYmaDzGyZmS3bunVrKaUuIiKHK3FxMLMqwBXA34LQeOBcQl1Om4Encpvms7kXEo8Ouk909/bu3r5evXolyltERApWGt1KlwPL3X0LQO5PADN7Acj96m02cFbEdg2BTcHzguIiIhIDpVEcbiCiS8nM6rv75mDxKmBV8HwOMNXM/khoQLoJsITQmUMTM2tEaFC7L/CzUshLBICqdX4T6xSkBHT8YqNExcHMqhO6yuiXEeE/mFkyoa6hrNx17r7azF4lNNB8ABji7geD/QwF3gYqAi+5++qS5CUiIiVTouLg7nuA0w6L3VxI+0eBR/OJzwPmlSQXEREpPfqGtIiIRFFxEBGRKLqfg5R7P144JNYpHGNrY52AlEM6cxARkSg6cxCRMk1nfrGhMwcREYmi4iAiIlFUHEREJIqKg4iIRFFxEBGRKLpaScq96+8t3x/zlbFOQMql8v2/RkTinop7bKhbSUREoqg4iIhIFBUHERGJouIgIiJRVBxERCRKiYuDmWWZ2UozyzCzZUHsVDN7x8zWBz/rBHEzs3FmtsHMMs2sbcR++gft15tZ/5LmJSIiR6+0rhHr5u7fRSyPAN519zFmNiJYvge4HGgSPDoB44FOZnYq8BDQntC9p9PNbI67/6eU8hOROLXyi69incIJ6Vh1K10JTA6eTwb6RMRf9pCPgdpmVh/oAbzj7t8HBeEdoOcxyk1ERIpQGmcODsw3Mweed/eJwBnuvhnA3Teb2elB2wbA1xHbZgexguJ5mNkgYBDA2WefXQqpy4lAf3mKHLnSKA4XuvumoAC8Y2afFtLW8ol5IfG8gVDhmQjQvn37qPUiIlI6Styt5O6bgp/fArOAjsCWoLuI4Oe3QfNs4KyIzRsCmwqJi4hIDJSoOJjZyWZWM/c5cBmwCpgD5F5x1B94LXg+B+gXXLV0PrAj6H56G7jMzOoEVzZdFsRERCQGStqtdAYwy8xy9zXV3d8ys6XAq2b2c+Ar4Lqg/TygF7AB2AMMAHD3783sEWBp0G60u39fwtxEROQolag4uPvnwHn5xLcB3fOJO5Dv3cLd/SXgpZLkIyIipUPfkBYRkSgqDiIiEkXFQUREoqg4iIhIFBUHERGJouIgIiJRVBxERCSKioOIiERRcRARkSgqDiIiEkXFQUREoqg4iIhIFBUHERGJouIgIiJRVBxERCSKioOIiERRcRARkSgqDiIiEuWoi4OZnWVmC8xsrZmtNrNfB/FRZvaNmWUEj14R29xrZhvM7DMz6xER7xnENpjZiJK9JRERKamS3EP6AHCXuy83s5pAupm9E6x70t3HRjY2s5ZAX6AVcCbwDzNrGqx+FrgUyAaWmtkcd19TgtxERKQEjro4uPtmYHPwfKeZrQUaFLLJlcB0d/8v8IWZbQA6Bus2uPvnAGY2PWir4iAiEiOlMuZgZglAG+CTIDTUzDLN7CUzqxPEGgBfR2yWHcQKiuf3OoPMbJmZLdu6dWtppC4iIvkocXEwsxrATOAOd/8BGA+cCyQTOrN4IrdpPpt7IfHooPtEd2/v7u3r1atX0tRFRKQAJRlzwMwqEyoMU9z97wDuviVi/QvA3GAxGzgrYvOGwKbgeUHxMqPXvzbGOgWRE1JCztRYp3BMZcU6gQIcdXEwMwNeBNa6+x8j4vWD8QiAq4BVwfM5wFQz+yOhAekmwBJCZw5NzKwR8A2hQeufHW1ex8r195aojpZ5K2OdgIiUKSX5jXchcDOw0swygth9wA1mlkyoaygL+CWAu682s1cJDTQfAIa4+0EAMxsKvA1UBF5y99UlyEtEREqoJFcrfUD+4wXzCtnmUeDRfOLzCttOpCTULSFy5Mp3X0kpWvnFV7FOQUTkuNH0GSIiEkXFQUREoqg4iIhIFBUHERGJouIgIiJRVBxERCSKioOIiERRcRARkSgqDiIiEkXFQUREoqg4iIhIFBUHERGJoon3ikkze4rIiURnDiIiEkXFQUREoqg4iIhIlDJTHMysp5l9ZmYbzGxErPMRETmRlYniYGYVgWeBy4GWhO5D3TK2WYmInLjKRHEAOgIb3P1zd98HTAeujHFOIiInrLJyKWsD4OuI5Wyg0+GNzGwQMChY3GVmnx2H3GKlLvDd8Xox+/3xeqUTgo5dfCvvx++c4jQqK8XB8ol5VMB9IjDx2KcTe2a2zN3bxzoPOXI6dvFNxy+krHQrZQNnRSw3BDbFKBcRkRNeWSkOS4EmZtbIzKoAfYE5Mc5JROSEVSa6ldz9gJkNBd4GKgIvufvqGKcVaydE91k5pWMX33T8AHOP6toXEZETXFnpVhIRkTJExUFERKKoOIiISJQyMSAtIhILZtYRcHdfGkzZ0xP41N3nxTi1mNOZQxlmZgNinYMUzsyam1l3M6txWLxnrHKS4jGzh4BxwHgz+z/gT0ANYISZ3R/T5MoAXa1UhpnZV+5+dqzzkPyZ2TBgCLAWSAZ+7e6vBeuWu3vbWOYnhTOzlYSO20nAv4GG7v6DmVUDPnH3pJgmGGPqVooxM8ssaBVwxvHMRY7YQKCdu+8yswRghpkluPvT5D8ljJQtB9z9ILDHzDa6+w8A7r7XzA7FOLeYU3GIvTOAHsB/Dosb8NHxT0eOQEV33wXg7llmlkKoQJyDikM82Gdm1d19D9AuN2hmtYATvjhozCH25gI13P3Lwx5ZwMLYpiZF+LeZJecuBIWiN6FZPRNjlpUUV9egMODukcWgMtAvNimVHRpzKMPMrEpwfwspg8ysIaGuiX/ns+5Cd/8wBmlJMZnZA+7+SD7xWsBr7p5y/LMqO3TmEGNm9kAB8VrA/OOcjhyZAQUUhlOAR2OQjxyZi8wsz3Eys/8HvA/8MzYplR0qDrFX2Ad0QWxSkmIq6NgtQr9c4sEVwHlm9kcAM2sCfAA85+6jY5pZGaBupRgzs6rADGCdu/8m+IC+CTzu7s/HNjspjI5d/DOzyoRuS7wfuAC4w91nxTarskHFoQzQBzR+6djFLzP7TfC0MnA3oTO+93PXu/sfY5FXWaHiEGP6gMYvHbv4FnxDukDu/vDxyqUs0vccYq9mxPNx+cSk7NKxi2Mn+i//oujMQUREouhqJRERiaLiICIiUVQcROSEZmZnmNmLZvZmsNzSzH4e67xiTcWhjNAHNH7p2MW9ScDbwJnB8jrgjphlU0aoOJQdk9AHNF5NQscuntV191cJZmJ19wPAwdimFHsqDmWHPqDxS8cuvu02s9MABzCz84EdsU0p9vQ9h7JDH9D4pWMX334DzAHONbMPgXrAtbFNKfb0PYcywszaAs8ArYFVBB9Qdy/oTnFSRujYxT8zqwQ0I3STps/cfX+MU4o5FYcyRB/Q+KVjF9/MrDOQQERviru/HLOEygAVhzJEH9D4pWMXv8zsFeBcIIP/jRW5uw+LXVaxpzGHMqKgDyigXzBlnI5d3GsPtHT9pZyHikPZoQ9o/NKxi2+rgP8HbI51ImWJikPZoQ9o/NKxi291gTVmtgT4b27Q3a+IXUqxp+JQdugDGr907OLbqFgnUBZpQLqMMLOL84u7+3vHOxc5Mjp28c/MzgA6BItL3P3bWOZTFqg4lCH6gMYvHbv4ZWbXA48DCwldinwRMNzdZ8Qyr1hTcSgj9AGNXzp28c3M/gVcmlvQzawe8A93Py+2mcWWikMZoQ9o/NKxi29mttLdEyOWKwD/ioydiDQgXXZUOKwrYhuaGDFe6NjFt7fM7G1gWrCcCrwZw3zKBBWHskMf0PilYxfH3H24mV0NdCHULTjR3WfFOK2YU7dSGXLYB/R9fUDjh45d/DGzHu7+dgHrrnP3vx3vnMoSFYcY0wc0funYxTczOwi8D9zk7t8ctm65u7eNTWZlg/pFY2+emS0wswb5rLv3uGcjR0LHLr5lAlOBj83susPWWQzyKVNUHGJPH9D4pWMX39zdXwC6A3eb2V/MrHruuhjmVSaoOMSePqDxS8euHHD3dcAFwBZghZl1inFKZYKKQxmhD2j80rGLW+GzO3c/4O4jgF8SuuqsScyyKiN0KWvs5fmAAiPM7C1CH9B6MctKikPHLr49fHjA3ReaWTtCReKEpquVYszM+rj77HzidYBfuvuYGKQlxaBjJ+WZioOIiETRmIOIiERRcRARkSgakBYphJmNAnYBpxCaFuMfBbTrA6xz9zUFrB8M7HH3lwtYnwB0dveppZC2SImpOIgUg7s/WESTPsBcIKo4mFkld59QxPYJwM8IfalOJOY0IC1yGDO7H+gHfA1sBdKB1sBcd59hZmOAK4ADwHzg74QKw47gcQ3wIvARcCEwB6gJ7HL3sWb2I2ACoctdDwLXAVOAFsAXwGR3f/L4vFuR/OnMQSRCcI17X6ANof8fywkVh9z1pwJXAc3d3c2strtvN7M5BMUjaAdQ290vDpZHRbzMFGCMu88ys6qExv5GAL91997H+j2KFIcGpEXyugiY5e573P0HQn/1R/oByAH+HEzTvaeQfaUdHjCzmkCD3Cm93T3H3Qvbh0hMqDiIRCuwrzX4JnRHYCahcYa3CtnP7nximpBP4oKKg0he7wNXmVm14K/8n0auNLMaQC13nwfcASQHq3YSGlcoVHA2kh1c3YSZnRRM1les7UWOFxUHkQjuvpxQd1AGobODRYc1qQnMNbNM4D3gziA+HRhuZivM7NwiXuZmYFiwj4+A/0do+u8DZvYvM7uz0K1FjgNdrSQiIlF05iAiIlFUHEREJIqKg4iIRFFxEBGRKCoOIiISRcVBRESiqDiIiEiU/w+xYkeeHA4kkgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a stacked bar plot of 'k_zones'\n",
    "k_zones.plot(kind=\"bar\", stacked=True)\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The vast majority of traffic stops in Zone K1 are for speeding, and Zones K2 and K3 are remarkably similar to one another in terms of violations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting stop durations to numbers\n",
    "In the traffic stops dataset, the stop_duration column tells you approximately how long the driver was detained by the officer. Unfortunately, the durations are stored as strings, such as '0-15 Min'. How can you make this data easier to analyze?\n",
    "\n",
    "In this exercise, you'll convert the stop durations to integers. Because the precise durations are not available, you'll have to estimate the numbers using reasonable values:\n",
    "\n",
    "Convert '0-15 Min' to 8\n",
    "Convert '16-30 Min' to 23\n",
    "Convert '30+ Min' to 45"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0-15 Min' '16-30 Min' '30+ Min']\n",
      "[ 8 23 45]\n"
     ]
    }
   ],
   "source": [
    "# Print the unique values in 'stop_duration'\n",
    "print(ri.stop_duration.unique())\n",
    "\n",
    "# Create a dictionary that maps strings to integers\n",
    "mapping = {'0-15 Min':8, '16-30 Min':23, '30+ Min':45}\n",
    "\n",
    "# Convert the 'stop_duration' strings to integers using the 'mapping'\n",
    "ri['stop_minutes'] = ri.stop_duration.map(mapping)\n",
    "\n",
    "# Print the unique values in 'stop_minutes'\n",
    "print(ri.stop_minutes.unique())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting stop length\n",
    "If you were stopped for a particular violation, how long might you expect to be detained?\n",
    "\n",
    "In this exercise, you'll visualize the average length of time drivers are stopped for each type of violation. Rather than using the violation column in this exercise, you'll use violation_raw since it contains more detailed descriptions of the violations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "violation_raw\n",
      "APB                                 17.967033\n",
      "Call for Service                    22.124371\n",
      "Equipment/Inspection Violation      11.445655\n",
      "Motorist Assist/Courtesy            17.741463\n",
      "Other Traffic Violation             13.844490\n",
      "Registration Violation              13.736970\n",
      "Seatbelt Violation                   9.662815\n",
      "Special Detail/Directed Patrol      15.123632\n",
      "Speeding                            10.581562\n",
      "Suspicious Person                   14.910714\n",
      "Violation of City/Town Ordinance    13.254144\n",
      "Warrant                             24.055556\n",
      "Name: stop_minutes, dtype: float64\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculate the mean 'stop_minutes' for each value in 'violation_raw'\n",
    "print(ri.groupby(ri.violation_raw).stop_minutes.mean())\n",
    "\n",
    "# Save the resulting Series as 'stop_length'\n",
    "stop_length = ri.groupby(ri.violation_raw).stop_minutes.mean()\n",
    "\n",
    "# Sort 'stop_length' by its values and create a horizontal bar plot\n",
    "stop_length.sort_values().plot(kind=\"barh\")\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting the temperature\n",
    "In this exercise, you'll examine the temperature columns from the weather dataset to assess whether the data seems trustworthy. First you'll print the summary statistics, and then you'll visualize the data using a box plot.\n",
    "\n",
    "When deciding whether the values seem reasonable, keep in mind that the temperature is measured in degrees Fahrenheit, not Celsius!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['STATION', 'DATE', 'TAVG', 'TMIN', 'TMAX', 'AWND', 'WSF2', 'WT01',\n",
      "       'WT02', 'WT03', 'WT04', 'WT05', 'WT06', 'WT07', 'WT08', 'WT09', 'WT10',\n",
      "       'WT11', 'WT13', 'WT14', 'WT15', 'WT16', 'WT17', 'WT18', 'WT19', 'WT21',\n",
      "       'WT22'],\n",
      "      dtype='object')\n",
      "              TMIN         TAVG         TMAX\n",
      "count  4017.000000  1217.000000  4017.000000\n",
      "mean     43.484441    52.493016    61.268608\n",
      "std      17.020298    17.830714    18.199517\n",
      "min      -5.000000     6.000000    15.000000\n",
      "25%      30.000000    39.000000    47.000000\n",
      "50%      44.000000    54.000000    62.000000\n",
      "75%      58.000000    68.000000    77.000000\n",
      "max      77.000000    86.000000   102.000000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Read 'weather.csv' into a DataFrame named 'weather'\n",
    "weather = pd.read_csv('weather.csv')\n",
    "print(weather.columns)\n",
    "# Describe the temperature columns\n",
    "print(weather[['TMIN','TAVG','TMAX']].describe())\n",
    "\n",
    "# Create a box plot of the temperature columns\n",
    "weather[['TMIN','TAVG','TMAX']].plot(kind='box')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The temperature data looks good so far: the TAVG values are in between TMIN and TMAX, and the measurements and ranges seem reasonable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting the temperature difference\n",
    "In this exercise, you'll continue to assess whether the dataset seems trustworthy by plotting the difference between the maximum and minimum temperatures.\n",
    "\n",
    "What do you notice about the resulting histogram? Does it match your expectations, or do you see anything unusual?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    4017.000000\n",
      "mean       17.784167\n",
      "std         6.350720\n",
      "min         2.000000\n",
      "25%        14.000000\n",
      "50%        18.000000\n",
      "75%        22.000000\n",
      "max        43.000000\n",
      "Name: TDIFF, dtype: float64\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a 'TDIFF' column that represents temperature difference\n",
    "weather['TDIFF'] = weather['TMAX'] - weather['TMIN']\n",
    "\n",
    "# Describe the 'TDIFF' column\n",
    "print(weather.TDIFF.describe())\n",
    "\n",
    "# Create a histogram with 20 bins to visualize 'TDIFF'\n",
    "weather.TDIFF.plot(kind=\"hist\", bins=10)\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The TDIFF column has no negative values and its distribution is approximately normal, both of which are signs that the data is trustworthy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Counting bad weather conditions\n",
    "The weather DataFrame contains 20 columns that start with 'WT', each of which represents a bad weather condition. For example:\n",
    "\n",
    "WT05 indicates \"Hail\"\n",
    "WT11 indicates \"High or damaging winds\"\n",
    "WT17 indicates \"Freezing rain\"\n",
    "For every row in the dataset, each WT column contains either a 1 (meaning the condition was present that day) or NaN (meaning the condition was not present).\n",
    "\n",
    "In this exercise, you'll quantify \"how bad\" the weather was each day by counting the number of 1 values in each row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Copy 'WT01' through 'WT22' to a new DataFrame\n",
    "WT = weather.loc[:, 'WT01':'WT22']\n",
    "\n",
    "# Calculate the sum of each row in 'WT'\n",
    "weather['bad_conditions'] = WT.sum(axis=1)\n",
    "\n",
    "# Replace missing values in 'bad_conditions' with '0'\n",
    "weather['bad_conditions'] = weather.bad_conditions.fillna(0).astype('int')\n",
    "\n",
    "# Create a histogram to visualize 'bad_conditions'\n",
    "weather['bad_conditions'].plot(kind=\"hist\")\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " It looks like many days didn't have any bad weather conditions, and only a small portion of days had more than four bad weather conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    1749\n",
      "1     613\n",
      "2     367\n",
      "3     380\n",
      "4     476\n",
      "5     282\n",
      "6     101\n",
      "7      41\n",
      "8       4\n",
      "9       4\n",
      "Name: bad_conditions, dtype: int64\n",
      "bad      1836\n",
      "good     1749\n",
      "worse     432\n",
      "Name: rating, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Count the unique values in 'bad_conditions' and sort the index\n",
    "print(weather.bad_conditions.value_counts().sort_index())\n",
    "\n",
    "# Create a dictionary that maps integers to strings\n",
    "mapping = {0:'good', 1:'bad', 2:'bad', 3:'bad',4:'bad',5:'worse',6:'worse',7:'worse',8:'worse',9:'worse'}\n",
    "\n",
    "# Convert the 'bad_conditions' integers to strings using the 'mapping'\n",
    "weather['rating'] = weather.bad_conditions.map(mapping)\n",
    "\n",
    "# Count the unique values in 'rating'\n",
    "print(weather['rating'].value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing the data type to category\n",
    "Since the rating column only has a few possible values, you'll change its data type to category in order to store the data more efficiently. You'll also specify a logical order for the categories, which will be useful for future exercises."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    bad\n",
      "1    bad\n",
      "2    bad\n",
      "3    bad\n",
      "4    bad\n",
      "Name: rating, dtype: category\n",
      "Categories (3, object): [good < bad < worse]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Program Files\\Anaconda3\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3296: FutureWarning: specifying 'categories' or 'ordered' in .astype() is deprecated; pass a CategoricalDtype instead\n",
      "  exec(code_obj, self.user_global_ns, self.user_ns)\n"
     ]
    }
   ],
   "source": [
    "# Create a list of weather ratings in logical order\n",
    "cats = ['good','bad','worse']\n",
    "\n",
    "# Change the data type of 'rating' to category\n",
    "weather['rating'] = weather.rating.astype('category', ordered=True, categories=cats)\n",
    "\n",
    "# Examine the head of 'rating'\n",
    "print(weather['rating'].head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing the DataFrames\n",
    "In this exercise, you'll prepare the traffic stop and weather rating DataFrames so that they're ready to be merged:\n",
    "\n",
    "With the ri DataFrame, you'll move the stop_datetime index to a column since the index will be lost during the merge.\n",
    "With the weather DataFrame, you'll select the DATE and rating columns and put them in a new DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        stop_datetime   stop_date stop_time driver_gender driver_race  \\\n",
      "0 2005-01-04 12:55:00  2005-01-04     12:55             M       White   \n",
      "1 2005-01-23 23:15:00  2005-01-23     23:15             M       White   \n",
      "2 2005-02-17 04:15:00  2005-02-17     04:15             M       White   \n",
      "3 2005-02-20 17:15:00  2005-02-20     17:15             M       White   \n",
      "4 2005-02-24 01:20:00  2005-02-24     01:20             F       White   \n",
      "\n",
      "                    violation_raw  violation  search_conducted search_type  \\\n",
      "0  Equipment/Inspection Violation  Equipment             False         NaN   \n",
      "1                        Speeding   Speeding             False         NaN   \n",
      "2                        Speeding   Speeding             False         NaN   \n",
      "3                Call for Service      Other             False         NaN   \n",
      "4                        Speeding   Speeding             False         NaN   \n",
      "\n",
      "    stop_outcome  is_arrested stop_duration  drugs_related_stop district  \\\n",
      "0       Citation        False      0-15 Min               False  Zone X4   \n",
      "1       Citation        False      0-15 Min               False  Zone K3   \n",
      "2       Citation        False      0-15 Min               False  Zone X4   \n",
      "3  Arrest Driver         True     16-30 Min               False  Zone X1   \n",
      "4       Citation        False      0-15 Min               False  Zone X3   \n",
      "\n",
      "   frisk  stop_minutes  \n",
      "0  False             8  \n",
      "1  False             8  \n",
      "2  False             8  \n",
      "3  False            23  \n",
      "4  False             8  \n",
      "         DATE rating\n",
      "0  2005-01-01    bad\n",
      "1  2005-01-02    bad\n",
      "2  2005-01-03    bad\n",
      "3  2005-01-04    bad\n",
      "4  2005-01-05    bad\n"
     ]
    }
   ],
   "source": [
    "# Reset the index of 'ri'\n",
    "ri.reset_index(inplace=True)\n",
    "\n",
    "# Examine the head of 'ri'\n",
    "print(ri.head())\n",
    "\n",
    "# Create a DataFrame from the 'DATE' and 'rating' columns\n",
    "weather_rating = weather[['DATE', 'rating']]\n",
    "\n",
    "# Examine the head of 'weather_rating'\n",
    "print(weather_rating.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(86536, 16)\n",
      "(86536, 18)\n"
     ]
    }
   ],
   "source": [
    "# Examine the shape of 'ri'\n",
    "print(ri.shape)\n",
    "\n",
    "# Merge 'ri' and 'weather_rating' using a left join\n",
    "ri_weather = pd.merge(left=ri, right=weather_rating, left_on='stop_date', right_on='DATE', how='left')\n",
    "\n",
    "# Examine the shape of 'ri_weather'\n",
    "print(ri_weather.shape)\n",
    "\n",
    "# Set 'stop_datetime' as the index of 'ri_weather'\n",
    "ri_weather.set_index('stop_datetime', inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing arrest rates by weather rating\n",
    "Do police officers arrest drivers more often when the weather is bad? Find out below!\n",
    "\n",
    "First, you'll calculate the overall arrest rate.\n",
    "Then, you'll calculate the arrest rate for each of the weather ratings you previously assigned.\n",
    "Finally, you'll add violation type as a second factor in the analysis, to see if that accounts for any differences in the arrest rate.\n",
    "Since you previously defined a logical order for the weather categories, good < bad < worse, they will be sorted that way in the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0355690117407784\n"
     ]
    }
   ],
   "source": [
    "# Calculate the overall arrest rate\n",
    "print(ri_weather.is_arrested.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rating\n",
      "good     0.033715\n",
      "bad      0.036261\n",
      "worse    0.041667\n",
      "Name: is_arrested, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Calculate the arrest rate for each 'rating'\n",
    "print(ri_weather.groupby('rating').is_arrested.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "violation            rating\n",
      "Equipment            good      0.059007\n",
      "                     bad       0.066311\n",
      "                     worse     0.097357\n",
      "Moving violation     good      0.056227\n",
      "                     bad       0.058050\n",
      "                     worse     0.065860\n",
      "Other                good      0.076966\n",
      "                     bad       0.087443\n",
      "                     worse     0.062893\n",
      "Registration/plates  good      0.081574\n",
      "                     bad       0.098160\n",
      "                     worse     0.115625\n",
      "Seat belt            good      0.028587\n",
      "                     bad       0.022493\n",
      "                     worse     0.000000\n",
      "Speeding             good      0.013405\n",
      "                     bad       0.013314\n",
      "                     worse     0.016886\n",
      "Name: is_arrested, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Calculate the arrest rate for each 'violation' and 'rating'\n",
    "print(ri_weather.groupby(['violation','rating']).is_arrested.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The arrest rate increases as the weather gets worse, and that trend persists across many of the violation types. This doesn't prove a causal link, but it's quite an interesting result!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "violation            rating\n",
      "Equipment            good      0.059007\n",
      "                     bad       0.066311\n",
      "                     worse     0.097357\n",
      "Moving violation     good      0.056227\n",
      "                     bad       0.058050\n",
      "                     worse     0.065860\n",
      "Other                good      0.076966\n",
      "                     bad       0.087443\n",
      "                     worse     0.062893\n",
      "Registration/plates  good      0.081574\n",
      "                     bad       0.098160\n",
      "                     worse     0.115625\n",
      "Seat belt            good      0.028587\n",
      "                     bad       0.022493\n",
      "                     worse     0.000000\n",
      "Speeding             good      0.013405\n",
      "                     bad       0.013314\n",
      "                     worse     0.016886\n",
      "Name: is_arrested, dtype: float64\n",
      "0.05804964058049641\n",
      "rating\n",
      "good     0.013405\n",
      "bad      0.013314\n",
      "worse    0.016886\n",
      "Name: is_arrested, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Save the output of the groupby operation from the last exercise\n",
    "# Multi - indexing loc\n",
    "arrest_rate = ri_weather.groupby(['violation', 'rating']).is_arrested.mean()\n",
    "\n",
    "# Print the 'arrest_rate' Series\n",
    "print(arrest_rate)\n",
    "\n",
    "# Print the arrest rate for moving violations in bad weather\n",
    "print(arrest_rate.loc['Moving violation','bad'])\n",
    "\n",
    "# Print the arrest rates for speeding violations in all three weather conditions\n",
    "print(arrest_rate.loc['Speeding'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshaping the arrest rate data\n",
    "In this exercise, you'll start by reshaping the arrest_rate Series into a DataFrame. This is a useful step when working with any multi-indexed Series, since it enables you to access the full range of DataFrame methods.\n",
    "\n",
    "Then, you'll create the exact same DataFrame using a pivot table. This is a great example of how pandas often gives you more than one way to reach the same result!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rating                   good       bad     worse\n",
      "violation                                        \n",
      "Equipment            0.059007  0.066311  0.097357\n",
      "Moving violation     0.056227  0.058050  0.065860\n",
      "Other                0.076966  0.087443  0.062893\n",
      "Registration/plates  0.081574  0.098160  0.115625\n",
      "Seat belt            0.028587  0.022493  0.000000\n",
      "Speeding             0.013405  0.013314  0.016886\n",
      "rating                   good       bad     worse\n",
      "violation                                        \n",
      "Equipment            0.059007  0.066311  0.097357\n",
      "Moving violation     0.056227  0.058050  0.065860\n",
      "Other                0.076966  0.087443  0.062893\n",
      "Registration/plates  0.081574  0.098160  0.115625\n",
      "Seat belt            0.028587  0.022493  0.000000\n",
      "Speeding             0.013405  0.013314  0.016886\n"
     ]
    }
   ],
   "source": [
    "# Unstack the 'arrest_rate' Series into a DataFrame\n",
    "print(arrest_rate.unstack())\n",
    "\n",
    "# Create the same DataFrame using a pivot table\n",
    "print(ri_weather.pivot_table(index='violation', columns='rating', values='is_arrested'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}