PythonIntermediate/Project #2/Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Exploring Hacker News Posts\n",
    "\n",
    "<p>In this project we will work with a data set of submission to the popular technology site, Hacker News.</p>\n",
    "\n",
    "</p>Hacker News is a site started by the startup incubator Y Combinator, where user-submitted stories (known as \"posts\") are voted and commented upon, similar to reddit. Hacker News is extremely popular in technology and startup circles, and posts that make it to the top of Hacker News' listings can get hundreds of thousands of visitors as a result.</p>\n",
    "\n",
    "<u> NOTE: The data set used in this project can be found in this <strong>link</strong></u>: <a href = \"https://www.kaggle.com/hacker-news/hacker-news-posts\"> Click Here </a>\n",
    "\n",
    "We're specifically interested in posts whose titles begin with either Ask HN or Show HN. Users submit Ask HN posts to ask the Hacker News community a specific question. Below are a couple examples:\n",
    "\n",
    "Ask HN: How to improve my personal website?\n",
    "\n",
    "Ask HN: Am I the only one outraged by Twitter shutting down share counts?\n",
    "\n",
    "Ask HN: Aby recent changes to CSS that broke mobile?\n",
    "\n",
    "Likewise, users submit Show HN posts to show the Hacker News community a project, product, or just generally something interesting. Below are a couple of examples:\n",
    "\n",
    "Show HN: Wio Link  ESP8266 Based Web of Things Hardware Development Platform'\n",
    "\n",
    "Show HN: Something pointless I made\n",
    "\n",
    "Show HN: Shanhu.io, a programming playground powered by e8vm\n",
    "\n",
    "We'll compare these two types of posts to determine the following:\n",
    "\n",
    "<ul>Do Ask HN or Show HN receive more comments on average?</ul>\n",
    "<ul>Do posts created at a certain time receive more comments on average?</ul>\n",
    "\n",
    "## Introduction:\n",
    "Let's start by importing the libraries we need and reading the data set into a list of lists.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['id', 'title', 'url', 'num_points', 'num_comments', 'author', 'created_at']\n",
      "['12224879', 'Interactive Dynamic Video', 'http://www.interactivedynamicvideo.com/', '386', '52', 'ne0phyte', '8/4/2016 11:52']\n",
      "['10975351', 'How to Use Open Source and Shut the Fuck Up at the Same Time', 'http://hueniverse.com/2016/01/26/how-to-use-open-source-and-shut-the-fuck-up-at-the-same-time/', '39', '10', 'josep2', '1/26/2016 19:30']\n",
      "['11964716', \"Florida DJs May Face Felony for April Fools' Water Joke\", 'http://www.thewire.com/entertainment/2013/04/florida-djs-april-fools-water-joke/63798/', '2', '1', 'vezycash', '6/23/2016 22:20']\n",
      "['11919867', 'Technology ventures: From Idea to Enterprise', 'https://www.amazon.com/Technology-Ventures-Enterprise-Thomas-Byers/dp/0073523429', '3', '1', 'hswarna', '6/17/2016 0:01']\n"
     ]
    }
   ],
   "source": [
    "opened_file = open('hacker_news.csv')\n",
    "from csv import reader\n",
    "read_file = reader(opened_file)\n",
    "hn = list(read_file)\n",
    "\n",
    "\n",
    "#Printing the first 5  rows, gives us the following: \n",
    "print(hn[0])\n",
    "print(hn[1])\n",
    "print(hn[2])\n",
    "print(hn[3])\n",
    "print(hn[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Notice that the first list in the inner lists contains the column headers, and the lists after contain the data for one row. In order to analyze our data, we need to first remove the row containing the column headers. Let's remove that first row next.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['id', 'title', 'url', 'num_points', 'num_comments', 'author', 'created_at']\n",
      "['12224879', 'Interactive Dynamic Video', 'http://www.interactivedynamicvideo.com/', '386', '52', 'ne0phyte', '8/4/2016 11:52']\n",
      "['10975351', 'How to Use Open Source and Shut the Fuck Up at the Same Time', 'http://hueniverse.com/2016/01/26/how-to-use-open-source-and-shut-the-fuck-up-at-the-same-time/', '39', '10', 'josep2', '1/26/2016 19:30']\n",
      "['11964716', \"Florida DJs May Face Felony for April Fools' Water Joke\", 'http://www.thewire.com/entertainment/2013/04/florida-djs-april-fools-water-joke/63798/', '2', '1', 'vezycash', '6/23/2016 22:20']\n",
      "['11919867', 'Technology ventures: From Idea to Enterprise', 'https://www.amazon.com/Technology-Ventures-Enterprise-Thomas-Byers/dp/0073523429', '3', '1', 'hswarna', '6/17/2016 0:01']\n",
      "['10301696', 'Note by Note: The Making of Steinway L1037 (2007)', 'http://www.nytimes.com/2007/11/07/movies/07stein.html?_r=0', '8', '2', 'walterbell', '9/30/2015 4:12']\n"
     ]
    }
   ],
   "source": [
    "headers = hn[0]  #Assign headers to first row\n",
    "hn.remove(hn[0]) #Remove first row from hn\n",
    "print(headers)   #Display headers\n",
    "print(hn[0])     #As well as the first 5 rows of hn\n",
    "print(hn[1])\n",
    "print(hn[2])\n",
    "print(hn[3])\n",
    "print(hn[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Now that we've removed the headers from hn, we're ready to filter our data. Since we're only concerned with post titles beginning with Ask HN or Show HN, we'll create new lists of lists containing just the data for those titles.</p>\n",
    "\n",
    "<p>To find the posts that begin with either Ask HN or Show HN, we'll use the string method startswith. Given a string object, say, string1, we can check if starts with, say, dq by inspecting the output of the object string1.startswith('dq'). If string1 starts with dq, it will return True, otherwise it will return False.</p>\n",
    "\n",
    "<code>\n",
    "print('dataquest'.startswith('Data'))\n",
    "\n",
    "print('dataquest'.startswith('data'))\n",
    "\n",
    "False\n",
    "\n",
    "True\n",
    "\n",
    "</code>\n",
    "<p>\n",
    "In the example above, the first print call gives us False because dataquest does not start with Data. The second print call prints True because dataquest does start with data. Capitalization matters.\n",
    "\n",
    "If we wish to control for case, we can use the lower method which returns a lowercase version of the starting string. Here's an example:</p>\n",
    "\n",
    "<code>\n",
    "print('DataQuest'.lower())\n",
    "\n",
    "dataquest\n",
    "</code>\n",
    "\n",
    "Let's use these methods to separate posts beginning with Ask HN and Show HN (and case variations) into two different lists next."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1744\n",
      "1162\n",
      "17194\n"
     ]
    }
   ],
   "source": [
    "#Creating three empty lists:\n",
    "\n",
    "ask_posts   = []\n",
    "show_posts  = []\n",
    "other_posts = []\n",
    "\n",
    "#Loop through each row\n",
    "for row in hn:\n",
    "    title = row[1] #Get title from the data set (index 1)\n",
    "    \n",
    "    \n",
    "    #If the lowercase version of title starts with ask hn, \n",
    "    #append the row to ask_posts.\n",
    "    #Else if the lowercase version of title starts with \n",
    "    #show hn, append the row to show_posts.\n",
    "    #Otherwise, append to other_posts.\n",
    " \n",
    "    if title.lower().startswith('ask hn'):\n",
    "        ask_posts.append(row)\n",
    "    elif title.lower().startswith('show hn'):\n",
    "        show_posts.append(row)\n",
    "    else:\n",
    "        other_posts.append(row)\n",
    "        \n",
    "#Displaying the number of posts, we get the following:\n",
    "print(len(ask_posts))\n",
    "print(len(show_posts))\n",
    "print(len(other_posts))\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculating the Average Number of Comments for Ask HN and Show HN Posts:\n",
    "\n",
    "\n",
    "\n",
    "In the last screen, we separated the \"ask posts\" and the \"show posts\" into two list of lists named ask_posts and show_posts. \n",
    "\n",
    "Below are the first five rows in the ask_posts list of lists:\n",
    "<code>\n",
    "[\n",
    "\n",
    "    ['12296411', 'Ask HN: How to improve my personal website?', '', '2', '6', 'ahmedbaracat', '8/16/2016 9:55'], \n",
    "\n",
    "    ['10610020', 'Ask HN: Am I the only one outraged by Twitter shutting down share counts?', '', '28', '29', 'tkfx', '11/22/2015 13:43'], \n",
    "\n",
    "    ['11610310', 'Ask HN: Aby recent changes to CSS that broke mobile?', '', '1', '1', 'polskibus', '5/2/2016', 10:14'], \n",
    "\n",
    "    ['12210105', 'Ask HN: Looking for Employee #3 How do I do it?', '', '1', '3', 'sph130', '8/2/2016 14:20'], \n",
    "\n",
    "    ['10394168', 'Ask HN: Someone offered to buy my browser extension from me. What now?', '', '28', '17', 'roykolak', '10/15/2015 16:38']\n",
    "\n",
    "]\n",
    "</code>\n",
    "Below are the first five rows in the show_posts list of lists:\n",
    "<code>\n",
    "[\n",
    "\n",
    "    ['10627194', 'Show HN: Wio Link  ESP8266 Based Web of Things Hardware Development Platform', 'https://iot.seeed.cc', '26', '22', 'kfihihc', '11/25/2015 14:03'], \n",
    "\n",
    "    ['10646440', 'Show HN: Something pointless I made', 'http://dn.ht/picklecat/', '747', '102', 'dhotson', '11/29/2015 22:46'], \n",
    "\n",
    "    ['11590768', 'Show HN: Shanhu.io, a programming playground powered by e8vm', 'https://shanhu.io', '1', '1', 'h8liu', '4/28/2016 18:05'], \n",
    "\n",
    "    ['12178806', 'Show HN: Webscope  Easy way for web developers to communicate with Clients', 'http://webscopeapp.com', '3', '3', 'fastbrick', '7/28/2016 7:11'], \n",
    "\n",
    "    ['10872799', 'Show HN: GeoScreenshot  Easily test Geo-IP based web pages', 'https://www.geoscreenshot.com/', '1', '9', 'kpsychwave', '1/9/2016 20:45']\n",
    "\n",
    "]</code>\n",
    "\n",
    "\n",
    "\n",
    "Next, let's determine if ask posts or show posts receive more comments on average."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.038417431192661\n"
     ]
    }
   ],
   "source": [
    "total_ask_comments = 0\n",
    "\n",
    "for row in ask_posts:\n",
    "    total_ask_comments += int(row[4])\n",
    "\n",
    "avg_ask_comments = total_ask_comments / len(ask_posts)\n",
    "\n",
    "print(avg_ask_comments)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.31669535283993\n"
     ]
    }
   ],
   "source": [
    "total_show_comments = 0\n",
    "\n",
    "for row in show_posts:\n",
    "    total_show_comments += int(row[4])\n",
    "\n",
    "avg_show_comments = total_show_comments / len(show_posts)\n",
    "\n",
    "print(avg_show_comments)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conclusion: As we can see with our result, we find that there are in fact more ask comments on average (~14.03) than show comments (~10.31)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finding the Amount of Ask Posts and Comments by Hour Created\n",
    "\n",
    "<p>Next, we'll determine if ask posts created at a certain time are more likely to attract comments. We'll use the following steps to perform this analysis:\n",
    "<ul>\n",
    "    Calculate the amount of ask posts created in each hour of the day, along with the number of comments received.</ul>\n",
    "<ul>    Calculate the average number of comments ask posts receive by hour created.</ul>\n",
    "\n",
    "\n",
    "In this section, we'll tackle the first step — calculating the amount of ask posts and comments by hour created. We'll use <i>datetime</i> to work with the data in the \"created_at\" column.</p>\n",
    "\n",
    "We can use the <code>datetime.strptime()</code> constructor to parse dates stored as strings and return datetime objects:\n",
    "\n",
    "<code>\n",
    "date_1_str = \"December 24, 1984\"\n",
    "\n",
    "date_1_dt = dt.datetime.strptime(date_1_str, \"%B %d, %Y\")\n",
    "</code>\n",
    "\n",
    "Note in the example above that <code>%B</code> represents the full name of the month, <code>%d</code> represents a two digit day, and <code>%Y</code> represents the four digit year. To parse a string in a different format, we will need to make a slight adjustment to the codes above.\n",
    "\n",
    "Let's use this technique to calculate the amount of ask posts created per hour, along with the total amount of comments.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'00': 447,\n",
       " '01': 683,\n",
       " '02': 1381,\n",
       " '03': 421,\n",
       " '04': 337,\n",
       " '05': 464,\n",
       " '06': 397,\n",
       " '07': 267,\n",
       " '08': 492,\n",
       " '09': 251,\n",
       " '10': 793,\n",
       " '11': 641,\n",
       " '12': 687,\n",
       " '13': 1253,\n",
       " '14': 1416,\n",
       " '15': 4477,\n",
       " '16': 1814,\n",
       " '17': 1146,\n",
       " '18': 1439,\n",
       " '19': 1188,\n",
       " '20': 1722,\n",
       " '21': 1745,\n",
       " '22': 479,\n",
       " '23': 543}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import datetime as dt\n",
    "\n",
    "#A list of lists:\n",
    "\n",
    "result_list = []\n",
    "\n",
    "for post in ask_posts:\n",
    "    result_list.append(\n",
    "        [post[6], int(post[4])]\n",
    "    )\n",
    "\n",
    "#Create two dictionaries:\n",
    "comments_by_hour = {}\n",
    "counts_by_hour = {}\n",
    "date_format = \"%m/%d/%Y %H:%M\"\n",
    "\n",
    "#Iterate through result_list:\n",
    "#Asgn. date, comment to row[0], and row[1] \n",
    "#Parse the time with the datetime.strptime() function\n",
    "#Decide if hour is or isnt in key within dictionry \"counts_by_hour\"\n",
    "#Display result\n",
    "\n",
    "for each_row in result_list:\n",
    "    date = each_row[0]\n",
    "    comment = each_row[1]\n",
    "    time = dt.datetime.strptime(date, date_format).strftime(\"%H\")\n",
    "    if time in counts_by_hour:\n",
    "        comments_by_hour[time] += comment\n",
    "        counts_by_hour[time] += 1\n",
    "    else:\n",
    "        comments_by_hour[time] = comment\n",
    "        counts_by_hour[time] = 1\n",
    "\n",
    "comments_by_hour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculating the Average Number of Comments for Ask HN Posts by Hour:\n",
    "\n",
    "\n",
    "\n",
    "In the last screen, we created two dictionaries:\n",
    "\n",
    "   <code>counts_by_hour</code>: contains the number of ask posts created during each hour of the day.\n",
    "    <code>comments_by_hour</code>: contains the corresponding number of comments ask posts created at each hour received.\n",
    "\n",
    "Next, we'll use these two dictionaries to calculate the average number of comments for posts created during each hour of the day.\n",
    "\n",
    "To illustrate the technique, let's work with the following dictionary:\n",
    "<code>\n",
    "sample_dict = {\n",
    "\n",
    "                'apple': 2, \n",
    "\n",
    "                'banana': 4, \n",
    "\n",
    "                'orange': 6\n",
    "\n",
    "               }\n",
    "\n",
    "</code>\n",
    "Suppose we wanted to multiply each of the values by ten and return the results as a list of lists. We can use the following code:\n",
    "<coce>\n",
    "fruits = []\n",
    "\n",
    "\n",
    "\n",
    "for fruit in sample_dict:\n",
    "\n",
    "    fruits.append([fruit, 10*sample_dict[fruit]])\n",
    "\n",
    "Below are the results:\n",
    "\n",
    "[['apple', 20], ['banana', 40], ['orange', 60]]\n",
    "\n",
    "</code>\n",
    "In the example above, we:\n",
    "\n",
    "<ul>\n",
    "    Initialized an empty list (of lists) and assigned it to fruits.</ul>\n",
    "   <ul> Iterated over the keys of sample_dict and appended to fruits a list whose:</ul>\n",
    "      <ul>  First element is the key from sample_dict.</ul>\n",
    "       <ul> Second element is the value corresponding to that key multiplied by ten.</ul>\n",
    "       \n",
    "Let's use this format to create a list of lists containing the hours during which posts were created and the average number of comments those posts received.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['10', 13.440677966101696],\n",
       " ['14', 13.233644859813085],\n",
       " ['02', 23.810344827586206],\n",
       " ['21', 16.009174311926607],\n",
       " ['08', 10.25],\n",
       " ['18', 13.20183486238532],\n",
       " ['03', 7.796296296296297],\n",
       " ['09', 5.5777777777777775],\n",
       " ['23', 7.985294117647059],\n",
       " ['05', 10.08695652173913],\n",
       " ['04', 7.170212765957447],\n",
       " ['13', 14.741176470588234],\n",
       " ['15', 38.5948275862069],\n",
       " ['16', 16.796296296296298],\n",
       " ['11', 11.051724137931034],\n",
       " ['07', 7.852941176470588],\n",
       " ['19', 10.8],\n",
       " ['17', 11.46],\n",
       " ['22', 6.746478873239437],\n",
       " ['00', 8.127272727272727],\n",
       " ['01', 11.383333333333333],\n",
       " ['12', 9.41095890410959],\n",
       " ['06', 9.022727272727273],\n",
       " ['20', 21.525]]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_by_hour = []\n",
    "\n",
    "for hr in comments_by_hour:\n",
    "    avg_by_hour.append([hr, comments_by_hour[hr] / counts_by_hour[hr]])\n",
    "\n",
    "avg_by_hour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting and Printing Values from a List of Lists\n",
    "\n",
    "<p>In the last screen, we calculated the average number of comments for posts created during each hour of the day, and stored the results in a list of lists named avg_by_hour:</p>\n",
    "\n",
    "<code>\n",
    "\n",
    "[\n",
    "\n",
    " ['09', 5.5777777777777775],\n",
    " ['13', 14.741176470588234],\n",
    " ['10', 13.440677966101696],\n",
    " ['14', 13.233644859813085],\n",
    " ['16', 16.796296296296298],\n",
    " ['23', 7.985294117647059],\n",
    " ['12', 9.41095890410959],\n",
    " ['17', 11.46],\n",
    " ['15', 38.5948275862069],\n",
    " ['21', 16.009174311926607],\n",
    " ['20', 21.525],\n",
    " ['02', 23.810344827586206],\n",
    " ['18', 13.20183486238532],\n",
    " ['03', 7.796296296296297]... ]</code>\n",
    " \n",
    " <p>\n",
    "Although we now have the results we need, this format makes it hard to identify the hours with the highest values. Let's finish by sorting the list of lists and printing the five highest values in a format that's easier to read.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[13.440677966101696, '10'], [13.233644859813085, '14'], [23.810344827586206, '02'], [16.009174311926607, '21'], [10.25, '08'], [13.20183486238532, '18'], [7.796296296296297, '03'], [5.5777777777777775, '09'], [7.985294117647059, '23'], [10.08695652173913, '05'], [7.170212765957447, '04'], [14.741176470588234, '13'], [38.5948275862069, '15'], [16.796296296296298, '16'], [11.051724137931034, '11'], [7.852941176470588, '07'], [10.8, '19'], [11.46, '17'], [6.746478873239437, '22'], [8.127272727272727, '00'], [11.383333333333333, '01'], [9.41095890410959, '12'], [9.022727272727273, '06'], [21.525, '20']]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[38.5948275862069, '15'],\n",
       " [23.810344827586206, '02'],\n",
       " [21.525, '20'],\n",
       " [16.796296296296298, '16'],\n",
       " [16.009174311926607, '21'],\n",
       " [14.741176470588234, '13'],\n",
       " [13.440677966101696, '10'],\n",
       " [13.233644859813085, '14'],\n",
       " [13.20183486238532, '18'],\n",
       " [11.46, '17'],\n",
       " [11.383333333333333, '01'],\n",
       " [11.051724137931034, '11'],\n",
       " [10.8, '19'],\n",
       " [10.25, '08'],\n",
       " [10.08695652173913, '05'],\n",
       " [9.41095890410959, '12'],\n",
       " [9.022727272727273, '06'],\n",
       " [8.127272727272727, '00'],\n",
       " [7.985294117647059, '23'],\n",
       " [7.852941176470588, '07'],\n",
       " [7.796296296296297, '03'],\n",
       " [7.170212765957447, '04'],\n",
       " [6.746478873239437, '22'],\n",
       " [5.5777777777777775, '09']]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "swap_avg_by_hour = []\n",
    "\n",
    "for row in avg_by_hour:\n",
    "    swap_avg_by_hour.append([row[1], row[0]])\n",
    "\n",
    "print(swap_avg_by_hour)\n",
    "\n",
    "sorted_swap = sorted(swap_avg_by_hour, reverse = True)\n",
    "sorted_swap\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TOP 5 Hours for Ask Posts Comments:\n",
      "15:00: 38.59 average comments per post\n",
      "02:00: 23.81 average comments per post\n",
      "20:00: 21.52 average comments per post\n",
      "16:00: 16.80 average comments per post\n",
      "21:00: 16.01 average comments per post\n"
     ]
    }
   ],
   "source": [
    "print(\"TOP 5 Hours for Ask Posts Comments:\")\n",
    "\n",
    "for avg, hour in sorted_swap[:5]:\n",
    "    print(\"{}: {:.2f} average comments per post\".format(\n",
    "            dt.datetime.strptime(hour, \"%H\").strftime(\"%H:%M\"),avg))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion:\n",
    "\n",
    "\n",
    "\n",
    "The hour that receives the most comments per post on average is 15:00, with an average of 38.59 comments per post. There's about a 60% increase in the number of comments between the hours with the highest and second highest average number of comments.\n",
    "\n",
    "According to the data set documentation, the timezone used is Eastern Time in the US. So, we could also write 15:00 as 3:00 pm est.\n",
    "\n",
    "\n",
    "In this project, I analyzed ask posts and show posts to determine which type of post and time receive the most comments on average. Based on our analysis, to maximize the amount of comments a post receives, I'd recommend the post be categorized as ask post and created between 15:00 and 16:00 (3:00 pm est - 4:00 pm est).\n",
    "\n",
    "However, it should be noted that the data set we analyzed excluded posts without any comments. Given that, it's more accurate to say that of the posts that received comments, ask posts received more comments on average and ask posts created between 15:00 and 16:00 (3:00 pm est - 4:00 pm est) received the most comments on average.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}