ipynb file.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "546f8513",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import glob\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b78377c7",
   "metadata": {},
   "source": [
    "# Combining both 2022 & 2023 .csv files together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3ad67ad2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of DataFrames in folder1: 74\n",
      "Number of DataFrames in folder2: 46\n",
      "Folders combined successfully!\n"
     ]
    }
   ],
   "source": [
    "def read_csv_files(folder):\n",
    "    csv_files = glob.glob(os.path.join(folder, '*.csv'))\n",
    "    dataframes = []\n",
    "\n",
    "    for file in csv_files:\n",
    "        try:\n",
    "            df = pd.read_csv(file, encoding='latin-1', low_memory=False)\n",
    "            dataframes.append(df)\n",
    "        except pd.errors.EmptyDataError:\n",
    "            print(f\"Warning: Empty file detected - {file}\")\n",
    "        except pd.errors.ParserError:\n",
    "            print(f\"Error reading file - {file}\")\n",
    "\n",
    "    return dataframes\n",
    "\n",
    "folder1 = \"/Users/apple/Desktop/csv_data_2023\"\n",
    "folder2 = \"/Users/apple/Desktop/csv_data_2022\"\n",
    "\n",
    "dataframes_folder1 = read_csv_files(folder1)\n",
    "dataframes_folder2 = read_csv_files(folder2)\n",
    "\n",
    "print(f\"Number of DataFrames in folder1: {len(dataframes_folder1)}\")\n",
    "print(f\"Number of DataFrames in folder2: {len(dataframes_folder2)}\")\n",
    "\n",
    "     # Combine dataframes from both folders.\n",
    "if dataframes_folder1 or dataframes_folder2:\n",
    "    df = pd.concat(dataframes_folder1+ dataframes_folder2, ignore_index=True)  \n",
    "    print(\"Folders combined successfully!\")\n",
    "else:\n",
    "    print(\"No objects to concatenate.\")\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eafc9bf",
   "metadata": {},
   "source": [
    "# Merging required columns and Droping rest of the columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "122d35fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/35/hh7sg70925x6lzyc48r11lkh0000gn/T/ipykernel_73802/3158389279.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  df['A_Time'] = df['Time'].fillna(df[' Time']).fillna(df['Time ( in AM)']).fillna(df['Time ']).fillna(df['TIME']).fillna(df['time'])\n"
     ]
    }
   ],
   "source": [
    "df['A_Time'] = df['Time'].fillna(df[' Time']).fillna(df['Time ( in AM)']).fillna(df['Time ']).fillna(df['TIME']).fillna(df['time'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2c2e1ef6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/35/hh7sg70925x6lzyc48r11lkh0000gn/T/ipykernel_73802/3499913171.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  df['A_Date'] = df['Date'].fillna(df['ï»¿Date']).fillna(df['ï»¿Date ']).fillna(df['DATE']).fillna(df['date']).fillna(df['Date of Car']).fillna(df['Date ']).fillna(df['ï»¿date'])\n"
     ]
    }
   ],
   "source": [
    "df['A_Date'] = df['Date'].fillna(df['ï»¿Date']).fillna(df['ï»¿Date ']).fillna(df['DATE']).fillna(df['date']).fillna(df['Date of Car']).fillna(df['Date ']).fillna(df['ï»¿date'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "43c8d66f",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop(['Date','ï»¿Date','ï»¿Date ','DATE','date','Date of Car','Date ','ï»¿date'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4ce7f996",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop(['Time',' Time','Time ( in AM)','Time ','time','TIME'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c1b73d1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/35/hh7sg70925x6lzyc48r11lkh0000gn/T/ipykernel_73802/3462095580.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  df['A_Direction'] = df['Direction'].fillna(df['DIRECTION']).fillna(df[' Direction']).fillna(df['Direction of Vehicle']).fillna(df['direction']).fillna(df['Direction of travel']).fillna(df['Direction of Vehicle']).fillna(df['Vehicle Category']).fillna(df['category'])\n"
     ]
    }
   ],
   "source": [
    "df['A_Direction'] = df['Direction'].fillna(df['DIRECTION']).fillna(df[' Direction']).fillna(df['Direction of Vehicle']).fillna(df['direction']).fillna(df['Direction of travel']).fillna(df['Direction of Vehicle']).fillna(df['Vehicle Category']).fillna(df['category'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0e07e948",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop(['Direction','DIRECTION',' Direction','Direction of Vehicle','direction','Direction of travel','Direction of Vehicle'],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2578aa73",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/35/hh7sg70925x6lzyc48r11lkh0000gn/T/ipykernel_73802/1171210128.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  df['A_Type'] = df['Type'].fillna(df['Type of vehicle']).fillna(df['VEHICLE TYPE']).fillna(df['Type ']).fillna(df['Type of Vehicle']).fillna(df[' Type']).fillna(df['Vehicle Type']).fillna(df['vehicle_type']).fillna(df['Category of vehicle']).fillna(df['TYPE']).fillna(df['type']).fillna(df['Vehicle Category']).fillna(df['category'])\n"
     ]
    }
   ],
   "source": [
    "df['A_Type'] = df['Type'].fillna(df['Type of vehicle']).fillna(df['VEHICLE TYPE']).fillna(df['Type ']).fillna(df['Type of Vehicle']).fillna(df[' Type']).fillna(df['Vehicle Type']).fillna(df['vehicle_type']).fillna(df['Category of vehicle']).fillna(df['TYPE']).fillna(df['type']).fillna(df['Vehicle Category']).fillna(df['category'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "115e16fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop(['Type of vehicle','VEHICLE TYPE','Type ','Type of Vehicle',' Type','Vehicle Type','vehicle_type','Category of vehicle','TYPE','type','Vehicle Category','category'],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "eaf2a876",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/35/hh7sg70925x6lzyc48r11lkh0000gn/T/ipykernel_73802/3053650026.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  df['A_Occupancy'] = df['Occupancy'].fillna(df['VEHICLE OCCUPANCY']).fillna(df[' Occupancy']).fillna(df['occupancy']).fillna(df['Occupancy of the Vehicle']).fillna(df['OCCUPANCY'])\n"
     ]
    }
   ],
   "source": [
    "df['A_Occupancy'] = df['Occupancy'].fillna(df['VEHICLE OCCUPANCY']).fillna(df[' Occupancy']).fillna(df['occupancy']).fillna(df['Occupancy of the Vehicle']).fillna(df['OCCUPANCY'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a5d77f0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop(['Occupancy','VEHICLE OCCUPANCY',' Occupancy','occupancy','Occupancy of the Vehicle','OCCUPANCY'],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1ebab350",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop(['Type'],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0dcd58de",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/35/hh7sg70925x6lzyc48r11lkh0000gn/T/ipykernel_73802/1044418144.py:1: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  df['A_Colour'] = df['Color'].fillna(df['Colour']).fillna(df['Vehicle Colour']).fillna(df['Colour of Vehicle'])\n"
     ]
    }
   ],
   "source": [
    "df['A_Colour'] = df['Color'].fillna(df['Colour']).fillna(df['Vehicle Colour']).fillna(df['Colour of Vehicle'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fa50d800",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop(['Color','Colour','Vehicle Colour','Colour of Vehicle'],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "22fd0897",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop(['Public/Private', 'is_carpool', 'is_rideshare', 'AdditionalData1', 'AdditionalData2', 'Driver Gender', 'Fuel Type', 'Is Electric', 'Service', 'Size', 'Vehicle Purpose', 'Vehicle Age(years)', 'Brand Name', 'Turn Signal', 'Carpool', 'Rideshare', 'Class of the VehicleÂ\\xa0', 'Electric', 'Family Car', 'Tint > 50%?', 'High Tinted Area', 'Weather', 'Area_Code', 'WEATHER', 'Brand', 'Green Vehicle', 'Date Code', 'Driver gender', 'Fuel type', 'Age Group', 'Eco-friendly', 'Vehicle Brand', 'Vehicle Year', 'EV', 'Car Brand', 'Driver_Gender', 'Mode_of_Travel', 'AgeIdentifier', 'Left', 'Right', 'CAR', 'BUS', 'BICYCLE', 'MOTORBIKE', 'TAXI', 'SCOOTER', 'VAN', 'MALE', 'FEMALE', 'MobilityService', 'Unnamed: 0', 'Unnamed: 1', 'Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4', 'Unnamed: 5', 'Unnamed: 6', 'Unnamed: 7', 'Unnamed: 8', 'Unnamed: 9', 'Unnamed: 10', 'Unnamed: 11', 'Unnamed: 12', 'Unnamed: 13', 'Unnamed: 14', 'Window_Tint', 'Rim_Type', 'Vehicle purpose', 'Age Identifier', 'Safety', 'Manufacturing Data', 'Manufactured after 2015', 'Origin', 'Tint > 50% ', 'Tint Area', 'Purpose', ' HasGreenNumberPlate', ' AdditionalData2', 'EcoFriendly', 'Date of vehicle', 'Age_ID', 'Is_env_fr', 'Public Vehicle', 'Zero Emissions', 'Low Emissions Compliant', 'Make', 'Green Badge', 'safety', 'manufacturing_data', 'manufactured_after_2015', 'Public / Private', 'Zero Emission', 'Class_of_the_vehicle\\xa0', 'Age_Id', 'Is_env_friendly', 'Year', 'Age group', 'Part of Mobility Service', 'Eco-Friendly', 'Approach/exit', 'Blinkers/Handgestures', 'Electric or not', 'Electric Vehicle', 'driverâ\\x80\\x98s gender', \"Driver's gender\", 'Car Size', 'Electric or Hybrid?', 'Wait Time', 'No of pedestrian', 'Gender', 'Exhaust Pipe', 'Black smoke', 'Engine Type', 'Turn', 'Use of Phone', 'Use of Seatbelt', 'Female Occupancy', 'Engine', 'Personal', 'Passenger Type', 'Frequency', ' Driver_Age', ' Electric_Vehicle', \"Driver's Gender\", 'CarType', 'DirectionofExit', 'capacity', 'not_petrol', 'Sound_level', 'Electric_vehicle', 'Electric / Non-Electric Vehicle', 'Gender of the driver', ' Vehicle Age', 'GENDER OF DRIVER', 'Data', 'Speed(km/h)', 'FUEL', 'Owner', 'Bus driver gender', 'Electric Vehicle ', 'eco-friendly', 'Transportation Type', '6', 'Public Transport', 'Car Company/Bus No', 'BusNo', 'Transport Type (Public/Private)', 'Pedestrian Count', 'ï»¿ DATA COLLECTION FORM;;;;;', ' Driver Gender', ' Bus Type', ' Vehicle Brand', ' Weather', ' Temperature (C)', 'Cumulative frequency', 'Undergraduate driver', 'Age identifier'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee10612a",
   "metadata": {},
   "source": [
    "# Renaming Columns Name and Reording"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b35ffdb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.rename(columns={'A_Time': 'Time',\n",
    "                        'A_Date': 'Date',\n",
    "                        'A_Direction': 'Direction',\n",
    "                        'A_Type': 'Type',\n",
    "                        'A_Colour': 'Colour',\n",
    "                        'A_Occupancy': 'Occupancy'})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "399295f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_order = ['Date','Time', 'Type','Direction','Occupancy','Colour' ]\n",
    "df = df[new_order]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f27ba35",
   "metadata": {},
   "source": [
    "# Handling Empty, Missing and Null values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4c061b12",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove empty rows\n",
    "df = df.dropna(axis=0, how='all')\n",
    "\n",
    "# Remove empty columns\n",
    "df = df.dropna(axis=1, how='all')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "17405596",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.dropna(subset=['Time'])\n",
    "df = df.dropna(subset=['Type'])\n",
    "df = df.dropna(subset=['Direction'])\n",
    "df = df.dropna(subset=['Occupancy'])\n",
    "df = df.dropna(subset=['Colour'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6190d95",
   "metadata": {},
   "source": [
    "# Handling Date Format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "74e3d512",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/35/hh7sg70925x6lzyc48r11lkh0000gn/T/ipykernel_73802/1148050915.py:2: UserWarning: The argument 'infer_datetime_format' is deprecated and will be removed in a future version. A strict version of it is now the default, see https://pandas.pydata.org/pdeps/0004-consistent-to-datetime-parsing.html. You can safely remove this argument.\n",
      "  df['Date'] = pd.to_datetime(df['Date'], infer_datetime_format=True, errors='coerce').dt.strftime('%d-%m-%Y')\n",
      "/var/folders/35/hh7sg70925x6lzyc48r11lkh0000gn/T/ipykernel_73802/1148050915.py:2: UserWarning: Parsing dates in %d-%m-%Y format when dayfirst=False (the default) was specified. Pass `dayfirst=True` or specify a format to silence this warning.\n",
      "  df['Date'] = pd.to_datetime(df['Date'], infer_datetime_format=True, errors='coerce').dt.strftime('%d-%m-%Y')\n"
     ]
    }
   ],
   "source": [
    "# Convert the 'A_Date' column to a standardized format\n",
    "df['Date'] = pd.to_datetime(df['Date'], infer_datetime_format=True, errors='coerce').dt.strftime('%d-%m-%Y')\n",
    "\n",
    "# Save the updated DataFrame back to a CSV file\n",
    "df.to_csv('Task_03.csv', index=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f3fff7c",
   "metadata": {},
   "source": [
    "\n",
    "# Creating a new column name 'Year'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "51b2bc1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Year'] = pd.to_datetime(df['Date'], format='%d-%m-%Y', errors='coerce').dt.year\n",
    "\n",
    "# Drop rows with missing or invalid date values\n",
    "df = df.dropna(subset=['Year'])\n",
    "\n",
    "# Convert 'Year' to integer\n",
    "df['Year'] = df['Year'].astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c7de3b63",
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Type'] = df['Type'].str.lower()\n",
    "df['Direction'] = df['Direction'].str.lower()\n",
    "df['Colour'] = df['Colour'].str.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7703538",
   "metadata": {},
   "source": [
    "## Handling Time Format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b846d523",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "# Define a function to convert various time formats to the desired format\n",
    "def convert_to_single_format(time_str):\n",
    "    try:\n",
    "        # Try to parse the time using various known formats\n",
    "        parsed_time = None\n",
    "        \n",
    "        # Format: '10:41:00 AM'\n",
    "        parsed_time = datetime.strptime(time_str, '%I:%M:%S %p')\n",
    "        \n",
    "    except ValueError:\n",
    "        try:\n",
    "            # Format: '10.50am'\n",
    "            parsed_time = datetime.strptime(time_str, '%I.%M%p')\n",
    "        except ValueError:\n",
    "            try:\n",
    "                # Add more formats as needed\n",
    "                # Format: '10:30 am'\n",
    "                parsed_time = datetime.strptime(time_str, '%I:%M %p')\n",
    "            except ValueError:\n",
    "                try:\n",
    "                  # Format: '10.50'\n",
    "                    parsed_time = datetime.strptime(time_str, '%I.%M')\n",
    "                except ValueError:\n",
    "                    try:\n",
    "                       # Format: '10:50am'\n",
    "                        parsed_time = datetime.strptime(time_str, '%I:%M%p')\n",
    "                    except ValueError:\n",
    "                        try:\n",
    "                           # Format: '10:50am'\n",
    "                           parsed_time = datetime.strptime(time_str, '%I:%M%p')\n",
    "                        except ValueError:\n",
    "                            try:\n",
    "                                parsed_time = datetime.strptime(time_str, '%I.%M%p')\n",
    "                            except ValueError:\n",
    "                                try:\n",
    "                                    #10:10:10\n",
    "                                    parsed_time = datetime.strptime(time_str, '%I:%M:%S')\n",
    "                                except ValueError:\n",
    "                                    return None\n",
    "                                \n",
    "                                \n",
    "    \n",
    "    # Return the time in the desired format\n",
    "    return parsed_time.strftime('%H:%M'+ 'am')\n",
    "\n",
    "# Apply the function to the Time column\n",
    "df['Time'] = df['Time'].apply(convert_to_single_format)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06af0d33",
   "metadata": {},
   "source": [
    "## Handling Type column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "a6e6282b",
   "metadata": {},
   "outputs": [],
   "source": [
    "name_mapping = {'c': 'car', ' car': 'car', 'electric car': 'car','electric bike': 'twowheeler','motorbike': 'twowheeler','escooter': 'twowheeler',' scooter': 'twowheeler','scooters': 'twowheeler','scooters': 'twowheeler','moto': 'twowheeler','bike': 'twowheeler',' motorbike': 'twowheeler','motor bike': 'twowheeler', 'b': 'bus', ' bus': 'bus', 'u2': 'bus', 'double decker bus': 'bus','single decker bus': 'bus','80%': 'bus','50%': 'bus','20%': 'bus','10%': 'bus','bu': 'bus','50%': 'bus','4': 'car','2': 'car','3': 'car','1': 'car','bi': 'bicycle','moterbike': 'twowheeler','m': 'twowheeler',' bicycle': 'bicycle'}\n",
    "df['Type'] = df['Type'].replace(name_mapping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e961cc21",
   "metadata": {},
   "outputs": [],
   "source": [
    "name_mapping = {' lorry': 'lorry', ' van': 'van', 'motor': 'twowheeler', 'motorbike': 'twowheeler','e-scooter': 'twowheeler',' scooter': 'twowheeler','scooter': 'twowheeler','scooters': 'twowheeler', 'v': 'van','s': 'twowheeler','t': 'taxi',' taxi': 'taxi', '90%': 'bus', 'bus': 'bus'}\n",
    "df['Type'] = df['Type'].replace(name_mapping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "5d84d144",
   "metadata": {},
   "outputs": [],
   "source": [
    "name_mapping = {'l': 'lorry', 'motobike': 'twowheeler', 'motorcycle': 'twowheeler','scooter': 'twowheeler','car': 'car'}\n",
    "df['Type'] = df['Type'].replace(name_mapping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e08c3d81",
   "metadata": {},
   "outputs": [],
   "source": [
    "name_mapping = {'a.v': 'car', \n",
    "                'bus ': 'bus', \n",
    "                'truck': 'lorry',\n",
    "                'scooter ': 'twowheeler',\n",
    "                'car ': 'car',\n",
    "                'bicycle' : 'twowheeler',\n",
    "                'bicycle ' : 'twowheeler',\n",
    "                'motorbike ':'twowheeler',\n",
    "                'tractor':'lorry',\n",
    "                'mini truck':'lorry',\n",
    "                'van ':'van',\n",
    "                'taxi ': 'taxi'\n",
    "                \n",
    "               }\n",
    "\n",
    "\n",
    "df['Type'] = df['Type'].replace(name_mapping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "87b35c6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df[df['Type'] != 'pedestrian']\n",
    "df = df[df['Type'] != 'authorised vehicle']\n",
    "df = df[df['Type'] != 'other']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f1dc957",
   "metadata": {},
   "source": [
    "# Handling Colour Type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f516a484",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique Types: ['grey' 'other' 'white' 'black' 'blue' 'red' 'bl' 's' 'b' 'n' 'y' 'gr' 'w'\n",
      " 'g' 'sl' 'p' 'r' 'br' 'orange' 'green' 'maroon' 'silver' 'purple' 'pink'\n",
      " 'brown' 'yellow' 't' 'indigo' nan 'cream' 'gray']\n"
     ]
    }
   ],
   "source": [
    "unique_types = df['Colour'].unique()\n",
    "\n",
    "# Print or inspect the unique types\n",
    "print(\"Unique Types:\", unique_types)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "6961430b",
   "metadata": {},
   "outputs": [],
   "source": [
    " name_mapping = {'gr': 'grey', \n",
    "                'w': 'white', \n",
    "                'bl': 'black',\n",
    "                's': 'silver',\n",
    "                'r': 'red',\n",
    "                'b' : 'blue',\n",
    "                'sl' : 'grey',\n",
    "                'g':'green',\n",
    "                'p':'red',\n",
    "                'y':'yellow',\n",
    "                'br':'brown',\n",
    "                'gray': 'grey',\n",
    "                'cream':'yellow',\n",
    "                 'n':'blue',\n",
    "                 'maroon':'brown',\n",
    "                 'purple':'blue',\n",
    "                 't':'yellow',\n",
    "                 'indigo':'blue'\n",
    "                }\n",
    "\n",
    "\n",
    "df['Colour'] = df['Colour'].replace(name_mapping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "74d583fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df[df['Colour'] != 'other']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b3cfc57",
   "metadata": {},
   "source": [
    "# Handling Direction columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "5a7af791",
   "metadata": {},
   "outputs": [],
   "source": [
    "name_mapping = {' in': 'in', \n",
    "                ' out': 'out', \n",
    "                ' in ': 'in',\n",
    "                '  in': 'in',\n",
    "                ' ': 'in',\n",
    "                '\"' : 'in'}\n",
    "\n",
    "df['Direction'] = df['Direction'].replace(name_mapping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "ddce70db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique Types: ['out' 'in']\n"
     ]
    }
   ],
   "source": [
    "unique_types = df['Direction'].unique()\n",
    "\n",
    "# Print or inspect the unique types\n",
    "print(\"Unique Types:\", unique_types)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80600da4",
   "metadata": {},
   "source": [
    "# Question what is the safest colour to drive?\n",
    "\n",
    "It is important to remember that the colour of your vehicle can play a role, how you drive and how aware you are of others on the road is even more influential at preventing a car accident.\n",
    "The safety of a car color is not solely determined by the color itself but by various factors such as visibility, lighting conditions, and driver behavior. However, some studies suggest that high-visibility colors, such as white, yellow, and orange, may be more visible on the road and, therefore, could potentially contribute to safety.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66fc7705",
   "metadata": {},
   "source": [
    "# Visualizing Data By Plotting Charts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0c25316",
   "metadata": {},
   "source": [
    "## 1. Comparison bar graph of vehicle colour distribution by year\n",
    "In the below comparison bar graph we can clearly see that in year 2022 & 2023 most people choose black colour for their vehicle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "48d4a7ec",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12, 6))\n",
    "sns.countplot(x='Colour', hue='Year',data=df, palette='viridis')\n",
    "\n",
    "plt.title('Comparison of Vehicle Color Distribution by Year')\n",
    "plt.xlabel('Vehicle Colour')\n",
    "plt.ylabel('Count')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a3e672c",
   "metadata": {},
   "source": [
    "# 2. Percentage of colour mostly used for vehicles by commute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "5de45388",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "colors_to_drop = ['pink', 'silver','brown','yellow']\n",
    "\n",
    "# Filter out the specified colors\n",
    "filtered_df = df[~df['Colour'].isin(colors_to_drop)]\n",
    "\n",
    "# Calculate the percentage distribution of vehicle colors after dropping specified colors\n",
    "color_percentage = filtered_df['Colour'].value_counts(normalize=True) * 100\n",
    "\n",
    "custom_palette = sns.color_palette('coolwarm', n_colors=len(color_percentage))\n",
    "\n",
    "# Plot a pie chart with the custom color palette\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.pie(color_percentage, labels=color_percentage.index, autopct='%1.1f%%', colors=custom_palette, startangle=25)\n",
    "plt.title('Percentage Distribution of Vehicle Colours (Pie Chart)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b18659d2",
   "metadata": {},
   "source": [
    "# 3. Distribution of Vehicle Colours using bar graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "7745b128",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# distribution of vehicle colour overall in both 2022 and 2023 files\n",
    "plt.figure(figsize=(10, 6))\n",
    "ax = sns.countplot(x='Colour', data=df, palette='viridis')\n",
    "\n",
    "for p in ax.patches:\n",
    "    ax.annotate(f'{p.get_height()}', (p.get_x() + p.get_width() / 2., p.get_height()),\n",
    "                ha='center', va='center', xytext=(0, 10), textcoords='offset points')\n",
    "\n",
    "plt.title('Distribution of Vehicle Colours')\n",
    "plt.xlabel('Vehicle Color')\n",
    "plt.ylabel('Count')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c39bf59c",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}