bike2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import all necessary packages and functions.\n",
    "import csv # read and write csv files\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from datetime import datetime # operations to parse dates\n",
    "from pprint import pprint # use to print data structures like dictionaries in\n",
    "                          # a nicer way than the base print function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "City: NYC\n",
      "OrderedDict([('tripduration', '839'),\n",
      "             ('starttime', '1/1/2016 00:09:55'),\n",
      "             ('stoptime', '1/1/2016 00:23:54'),\n",
      "             ('start station id', '532'),\n",
      "             ('start station name', 'S 5 Pl & S 4 St'),\n",
      "             ('start station latitude', '40.710451'),\n",
      "             ('start station longitude', '-73.960876'),\n",
      "             ('end station id', '401'),\n",
      "             ('end station name', 'Allen St & Rivington St'),\n",
      "             ('end station latitude', '40.72019576'),\n",
      "             ('end station longitude', '-73.98997825'),\n",
      "             ('bikeid', '17109'),\n",
      "             ('usertype', 'Customer'),\n",
      "             ('birth year', ''),\n",
      "             ('gender', '0')])\n",
      "\n",
      "City: Chicago\n",
      "OrderedDict([('trip_id', '9080545'),\n",
      "             ('starttime', '3/31/2016 23:30'),\n",
      "             ('stoptime', '3/31/2016 23:46'),\n",
      "             ('bikeid', '2295'),\n",
      "             ('tripduration', '926'),\n",
      "             ('from_station_id', '156'),\n",
      "             ('from_station_name', 'Clark St & Wellington Ave'),\n",
      "             ('to_station_id', '166'),\n",
      "             ('to_station_name', 'Ashland Ave & Wrightwood Ave'),\n",
      "             ('usertype', 'Subscriber'),\n",
      "             ('gender', 'Male'),\n",
      "             ('birthyear', '1990')])\n",
      "\n",
      "City: Washington\n",
      "OrderedDict([('Duration (ms)', '427387'),\n",
      "             ('Start date', '3/31/2016 22:57'),\n",
      "             ('End date', '3/31/2016 23:04'),\n",
      "             ('Start station number', '31602'),\n",
      "             ('Start station', 'Park Rd & Holmead Pl NW'),\n",
      "             ('End station number', '31207'),\n",
      "             ('End station', 'Georgia Ave and Fairmont St NW'),\n",
      "             ('Bike number', 'W20842'),\n",
      "             ('Member Type', 'Registered')])\n"
     ]
    }
   ],
   "source": [
    "def print_first_point(data_file):\n",
    "    city = data_file.split('-')[0]\n",
    "    print('\\nCity: {}'.format(city))\n",
    "    \n",
    "    with open(data_file, 'r') as f_in:\n",
    "\n",
    "        trip_reader = csv.DictReader(f_in)\n",
    "        first_trip = next(trip_reader)\n",
    "        pprint(first_trip)\n",
    "    return (city, first_trip)\n",
    "\n",
    "data_files = ['NYC-CitiBike-2016.csv',\n",
    "              'Chicago-Divvy-2016.csv',\n",
    "              'Washington-CapitalBikeshare-2016.csv',]\n",
    "example_trips = {}\n",
    "for data_file in data_files:\n",
    "    city, first_trip = print_first_point(data_file)\n",
    "    example_trips[city] = first_trip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "def duration_in_mins(datum, city):\n",
    "    if city == 'NYC':\n",
    "        duration = float(datum['tripduration'])\n",
    "    elif city == 'Chicago':\n",
    "        duration = float(datum['tripduration'])\n",
    "    else:\n",
    "        duration = float(datum['Duration (ms)'])/1000\n",
    "    \n",
    "    return duration/60\n",
    "        \n",
    "tests = {'NYC': 13.9833,\n",
    "         'Chicago': 15.4333,\n",
    "         'Washington': 7.1231}\n",
    "for city in tests:\n",
    "    assert abs(duration_in_mins(example_trips[city], city) - tests[city]) < .001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def time_of_trip(datum, city):\n",
    "    if city == 'NYC':\n",
    "        month =  datum['starttime'].split('/')[0]\n",
    "        hour = datum['starttime'].split()[1].split(':')[0]\n",
    "        day_of_week = datetime.strptime('1/1/2016 00:09:55','%m/%d/%Y %H:%M:%S').strftime('%A')\n",
    "           \n",
    "    elif city == 'Chicago':\n",
    "        month =  datum['starttime'].split('/')[0]\n",
    "        hour = datum['starttime'].split()[1].split(':')[0]\n",
    "        day_of_week = datetime.strptime('3/31/2016 23:30','%m/%d/%Y %H:%M').strftime('%A')\n",
    "         \n",
    "    else:\n",
    "        month =  datum['Start date'].split('/')[0]\n",
    "        hour = datum['Start date'].split()[1].split(':')[0]\n",
    "        day_of_week = datetime.strptime('3/31/2016 22:57','%m/%d/%Y %H:%M').strftime('%A')\n",
    "        \n",
    "    return(int(month), int(hour), day_of_week)\n",
    "\n",
    "tests = {'NYC': (1, 0, 'Friday'),\n",
    "         'Chicago': (3, 23, 'Thursday'),\n",
    "         'Washington': (3, 22, 'Thursday')}\n",
    "\n",
    "for city in tests:\n",
    "    assert time_of_trip(example_trips[city], city) == tests[city]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def type_of_user(datum, city):\n",
    "    if city =='NYC':\n",
    "        user_type = datum['usertype']\n",
    "    \n",
    "    elif city =='Chicago':\n",
    "        user_type = datum['usertype']\n",
    "       \n",
    "    else :\n",
    "        if datum['Member Type'] == 'Registered':\n",
    "            user_type = 'Subscriber'\n",
    "        else :\n",
    "            user_type = 'Customer'\n",
    "    return(user_type)\n",
    "            \n",
    "\n",
    "tests = {'NYC': 'Customer',\n",
    "         'Chicago': 'Subscriber',\n",
    "         'Washington': 'Subscriber'}\n",
    "\n",
    "for city in tests:\n",
    "    assert type_of_user(example_trips[city], city) == tests[city]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "def condense_data(in_file, out_file, city):\n",
    "    with open(out_file, 'w') as f_out, open(in_file, 'r') as f_in:\n",
    "        out_colnames = ['duration', 'month', 'hour', 'day_of_week', 'user_type']        \n",
    "        trip_writer = csv.DictWriter(f_out, fieldnames = out_colnames)\n",
    "        trip_writer.writeheader()\n",
    "        \n",
    "        trip_reader = list(csv.DictReader(f_in))\n",
    "\n",
    "        for row in trip_reader:\n",
    "            new_point = {}\n",
    "            month, hour, day_of_week = time_of_trip(row, city)\n",
    "            new_point['duration'] = duration_in_mins(row, city)\n",
    "            new_point['month'] = month\n",
    "            new_point['hour'] = hour\n",
    "            new_point['day_of_week'] = day_of_week\n",
    "            new_point['user_type'] = type_of_user(row, city)\n",
    "\n",
    "            f_out.write(\"{},\".format(new_point['duration']))\n",
    "            f_out.write(\"{},\".format(new_point['month']))\n",
    "            f_out.write(\"{},\".format(new_point['hour']))\n",
    "            f_out.write(\"{},\".format(new_point['day_of_week']))\n",
    "            f_out.write(\"{}\\n\".format(new_point['user_type']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "City: Washington\n",
      "OrderedDict([('duration', '7.123116666666666'),\n",
      "             ('month', '3'),\n",
      "             ('hour', '22'),\n",
      "             ('day_of_week', 'Thursday'),\n",
      "             ('user_type', 'Subscriber')])\n",
      "\n",
      "City: Chicago\n",
      "OrderedDict([('duration', '15.433333333333334'),\n",
      "             ('month', '3'),\n",
      "             ('hour', '23'),\n",
      "             ('day_of_week', 'Thursday'),\n",
      "             ('user_type', 'Subscriber')])\n",
      "\n",
      "City: NYC\n",
      "OrderedDict([('duration', '13.983333333333333'),\n",
      "             ('month', '1'),\n",
      "             ('hour', '0'),\n",
      "             ('day_of_week', 'Friday'),\n",
      "             ('user_type', 'Customer')])\n"
     ]
    }
   ],
   "source": [
    "# Run this cell to check your work\n",
    "city_info = {'Washington': {'in_file': 'Washington-CapitalBikeshare-2016.csv',\n",
    "                            'out_file': 'Washington-2016-Summary.csv'},\n",
    "             'Chicago': {'in_file': 'Chicago-Divvy-2016.csv',\n",
    "                         'out_file': 'Chicago-2016-Summary.csv'},\n",
    "             'NYC': {'in_file': 'NYC-CitiBike-2016.csv',\n",
    "                     'out_file': 'NYC-2016-Summary.csv'}}\n",
    "\n",
    "for city, filenames in city_info.items():\n",
    "    condense_data(filenames['in_file'], filenames['out_file'], city)\n",
    "    print_first_point(filenames['out_file'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def number_of_trips(filename):\n",
    "    with open(filename, 'r') as f_in:\n",
    "        reader = csv.DictReader(f_in)\n",
    "\n",
    "        no_subscribers = 0\n",
    "        no_customers = 0\n",
    "   \n",
    "        for row in reader:\n",
    "            if row['user_type'] == 'Subscriber':\n",
    "                no_subscribers += 1\n",
    "            else:\n",
    "                no_customers += 1\n",
    "    \n",
    "        total = no_subscribers + no_customers\n",
    "        return(no_subscribers, no_customers, total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(245896, 30902, 276798)\n",
      "(54982, 17149, 72131)\n",
      "(51753, 14573, 66326)\n"
     ]
    }
   ],
   "source": [
    "data_file = 'NYC-2016-Summary.csv'\n",
    "print(number_of_trips(data_file))\n",
    "\n",
    "data_file = 'Chicago-2016-Summary.csv'\n",
    "print(number_of_trips(data_file))\n",
    "\n",
    "data_file = 'Washington-2016-Summary.csv'\n",
    "print(number_of_trips(data_file))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "def avg_trip_length(filename) :\n",
    "    avg_time = 0\n",
    "    total_time = 0\n",
    "    trip_count = 0\n",
    "    long_trip = 0\n",
    "    percent_long_trip = 0\n",
    "    \n",
    "    with open(filename,'r') as f_in :\n",
    "        avgdur_reader = csv.DictReader(f_in)\n",
    "        \n",
    "        for row in avgdur_reader :\n",
    "            time = float(row.get('duration'))\n",
    "            total_time += time\n",
    "            if time > 30 :\n",
    "                long_trip += 1\n",
    "            trip_count += 1   \n",
    "        avg_time = float(total_time/trip_count)\n",
    "        percent_long_trip = float((long_trip/trip_count)*100)\n",
    "        return(avg_time ,percent_long_trip) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NYC: Avg Len:15.81259299802294 min, %age of long trip:7.3024371563378345\n",
      "Chicago: Avg Len:16.563629368787335 min, %age of long trip:8.332062497400562\n",
      "Washington: Avg Len:18.93287355913721 min, %age of long trip:10.83888671109369\n"
     ]
    }
   ],
   "source": [
    "data_file_N = 'NYC-2016-Summary.csv'\n",
    "data_file_C = 'Chicago-2016-Summary.csv'\n",
    "data_file_W = 'Washington-2016-Summary.csv'\n",
    "\n",
    "avg_time ,percent_long_trip = avg_trip_length(data_file_N)\n",
    "print(\"NYC: Avg Len:{} min, %age of long trip:{}\".format(avg_time ,percent_long_trip))\n",
    "\n",
    "avg_time, percent_long_trip = avg_trip_length(data_file_C)\n",
    "print(\"Chicago: Avg Len:{} min, %age of long trip:{}\".format(avg_time ,percent_long_trip))\n",
    "\n",
    "avg_time, percent_long_trip = avg_trip_length(data_file_W)\n",
    "print(\"Washington: Avg Len:{} min, %age of long trip:{}\".format(avg_time ,percent_long_trip))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "def avg_trip_length(filename) :\n",
    "    avg_time = 0\n",
    "    total_time = 0\n",
    "    trip_count = 0\n",
    "    long_trip = 0\n",
    "    percent_long_trip = 0\n",
    "    \n",
    "    with open(filename,'r') as f_in :\n",
    "        avgdur_reader = csv.DictReader(f_in)\n",
    "\n",
    "        for row in avgdur_reader :\n",
    "            time = float(row.get('duration'))\n",
    "            total_time += time\n",
    "\n",
    "            if time > 30 :\n",
    "                long_trip += 1\n",
    "            trip_count += 1   \n",
    "\n",
    "        avg_time = float(total_time/trip_count)\n",
    "        percent_long_trip = float((long_trip/trip_count)*100)\n",
    "        return(avg_time ,percent_long_trip) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NYC: Avg Len:15.81259299802294 min, %age of long trip:7.3024371563378345\n",
      "Chicago: Avg Len:16.563629368787335 min, %age of long trip:8.332062497400562\n",
      "Washington: Avg Len:18.93287355913721 min, %age of long trip:10.83888671109369\n"
     ]
    }
   ],
   "source": [
    "data_file_N = 'NYC-2016-Summary.csv'\n",
    "data_file_C = 'Chicago-2016-Summary.csv'\n",
    "data_file_W = 'Washington-2016-Summary.csv'\n",
    "\n",
    "avg_time ,percent_long_trip = avg_trip_length(data_file_N)\n",
    "print(\"NYC: Avg Len:{} min, %age of long trip:{}\".format(avg_time ,percent_long_trip))\n",
    "\n",
    "avg_time, percent_long_trip = avg_trip_length(data_file_C)\n",
    "print(\"Chicago: Avg Len:{} min, %age of long trip:{}\".format(avg_time ,percent_long_trip))\n",
    "\n",
    "avg_time, percent_long_trip = avg_trip_length(data_file_W)\n",
    "print(\"Washington: Avg Len:{} min, %age of long trip:{}\".format(avg_time ,percent_long_trip))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "def user_trip_duration(filename):\n",
    "    duration_of_customer = 0\n",
    "    duration_of_subscriber = 0\n",
    "    trip_cust = 0\n",
    "    trip_subs = 0\n",
    "    \n",
    "    with open(filename,'r') as f_in :\n",
    "        userdur_reader = csv.DictReader(f_in)\n",
    "        for row in userdur_reader:\n",
    "            if row.get('user_type') == 'Customer':\n",
    "                duration_of_customer += float(row['duration'])\n",
    "                trip_cust += 1\n",
    "            else:\n",
    "                duration_of_subscriber += float(row['duration'])\n",
    "                trip_subs += 1\n",
    "\n",
    "        avg_customer_trip = (duration_of_customer/trip_cust)\n",
    "        avg_subscriber_trip = (duration_of_subscriber/trip_subs)\n",
    "        return(avg_customer_trip ,avg_subscriber_trip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NYC: Avg cust trip:32.982004306775025 , Avg subs trip:13.711087074350004\n",
      "Chicago: Avg cust trip:30.979781133982506 , Avg subs trip:12.067201690250076\n",
      "Washington: Avg cust trip:41.67803139252976 min, Avg subs trip:12.528120499294745\n"
     ]
    }
   ],
   "source": [
    "data_file_N = 'NYC-2016-Summary.csv'\n",
    "data_file_C = 'Chicago-2016-Summary.csv'\n",
    "data_file_W = 'Washington-2016-Summary.csv'\n",
    "\n",
    "avg_customer_trip ,avg_subscriber_trip = user_trip_duration(data_file_N)\n",
    "print(\"NYC: Avg cust trip:{} , Avg subs trip:{}\".format(avg_customer_trip ,avg_subscriber_trip))\n",
    "\n",
    "avg_customer_trip, avg_subscriber_trip = user_trip_duration(data_file_C)\n",
    "print(\"Chicago: Avg cust trip:{} , Avg subs trip:{}\".format(avg_customer_trip ,avg_subscriber_trip))\n",
    "\n",
    "avg_customer_trip, avg_subscriber_trip = user_trip_duration(data_file_W)\n",
    "print(\"Washington: Avg cust trip:{} min, Avg subs trip:{}\".format(avg_customer_trip ,avg_subscriber_trip))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fc5283f12b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline \n",
    "\n",
    "data = [ 7.65,  8.92,  7.42,  5.50, 16.17,  4.20,  8.98,  9.62, 11.48, 14.33,\n",
    "        19.02, 21.53,  3.90,  7.97,  2.62,  2.67,  3.08, 14.40, 12.90,  7.83,\n",
    "        25.12,  8.30,  4.93, 12.43, 10.60,  6.17, 10.88,  4.78, 15.15,  3.53,\n",
    "         9.43, 13.32, 11.72,  9.85,  5.22, 15.10,  3.95,  3.17,  8.78,  1.88,\n",
    "         4.55, 12.68, 12.38,  9.78,  7.63,  6.45, 17.38, 11.90, 11.52,  8.63,]\n",
    "plt.hist(data)\n",
    "plt.title('Distribution of Trip Durations')\n",
    "plt.xlabel('Duration (m)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fc4e30011d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Use this and additional cells to collect all of the trip times as a list ##\n",
    "## and then use pyplot functions to generate a histogram of trip times.     ##\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "def histogram(filename):\n",
    "    with open(filename,'r') as f_in :\n",
    "        r = csv.DictReader(f_in)\n",
    "        trip = []\n",
    "        for i in r :\n",
    "            trip += row['duration']\n",
    "        return trip\n",
    "\n",
    "filename = 'NYC-2016-Summary.csv'\n",
    "plt.hist(filename,bins = 5,rwidth = 0.5)\n",
    "plt.xlabel(\"Duration in mins\")\n",
    "plt.title(\"Distribution of trip duration\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fc528f77a20>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fc52e94ac88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def histogram_subscriber(filename,user_type='Subscriber'):\n",
    "    with open(filename,'r') as f_in:\n",
    "        reader=csv.DictReader(f_in)\n",
    "        duration_list=[]\n",
    "        for row in reader:\n",
    "            if row['user_type']==user_type:\n",
    "                duration_list.append(float(row['duration']))\n",
    "    return duration_list\n",
    "\n",
    "filename = 'Washington-2016-Summary.csv'\n",
    "plt.hist(histogram_subscriber(filename), range=[0,75],rwidth=0.7,color = 'yellow')\n",
    "plt.title('Distribution of Trip Durations For Subscribers')\n",
    "plt.xlabel('Duration in mins')\n",
    "plt.show()\n",
    "\n",
    "filename = 'Washington-2016-Summary.csv'\n",
    "plt.hist(histogram_subscriber(filename,user_type='Customer'), range=[0,75],rwidth=0.7,color ='pink')\n",
    "plt.title('Distribution of Trip Durations For Customers')\n",
    "plt.xlabel('Duration in mins')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from subprocess import call\n",
    "call(['python', '-m', 'nbconvert', 'Bike_Share_Analysis.ipynb'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6",
   "language": "python",
   "name": "python36"
  },
  "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}