Rintro_part3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "2fa76457-e656-4397-9867-a09b09907379",
    "_uuid": "a9846c21e29b54b6f986ff40f3c48e7a311de237"
   },
   "source": [
    "![](https://www.r-project.org/Rlogo.png)\n",
    "\n",
    "____________________________________________________________________________________\n",
    "This tutorial is the third part of a series. You can start with the first part of the tutorial [here](https://www.kaggle.com/rtatman/getting-started-in-r-first-steps/).\n",
    "\n",
    "In this part of the tutorial, we'll:\n",
    "\n",
    "* make sure our data_frame has the right data types\n",
    "* summarize our data\n",
    "* find the summary statistics for a specific variable\n",
    "* summarize a variable by groups\n",
    "\n",
    "____________________________________________________________________________________\n",
    "\n",
    "\n",
    "### Learning goals:\n",
    "\n",
    "By the end of this tutorial, you will be able to do the following things. (Don't worry if you don't know what all these things are yet; we'll get there together!)\n",
    "\n",
    "* [Be familiar with basic concepts: functions, variables, data types and vectors](https://www.kaggle.com/rtatman/getting-started-in-r-first-steps/)\n",
    "* [Load data into R](https://www.kaggle.com/rtatman/getting-started-in-r-load-data-into-r)\n",
    "* [Summerize your data](https://www.kaggle.com/rtatman/getting-started-in-r-summarize-data)\n",
    "* [Graph data and save your graphs](https://www.kaggle.com/rtatman/getting-started-in-r-graphing-data/)\n",
    "\n",
    "______\n",
    "\n",
    "### Your turn!\n",
    "\n",
    "Throughout this tutorial, you'll have lots of opportunities to practice what you've just learned. Look for the phrase \"your turn!\" to find these exercises."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "5fc41a57-44a9-48da-9990-89dba03d6b74",
    "_uuid": "c81e2dc1b6b5687dcec2e4ba78e535137a92a108"
   },
   "source": [
    "> **This notebook is interactive! It will have errors until you fork it and add all the code it needs to run correctly. Don't worry: if you've been working through this tutorial you already know everything you need to get it working correctly and I'll give you instructions and reminders to help you out.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "867cad27-c506-416f-be34-ce1d747153c4",
    "_uuid": "8d7230f9a43418336b7f66a12245aaf94a440034"
   },
   "source": [
    "## Load our data into R\n",
    "\n",
    "Because this is a new notebook & it's not connected to our last notebook, we need to tell R that we're going to be using the tidyverse package, read in our data and remove the first row all over again. This is because this notebook is in a new session, and every time we start a new session R forgets everything we did in the last one. \n",
    "\n",
    "> Session: your current R working environment and anything that you've created within in, including libraries, datasets, variables and any functions that you've written.\n",
    "\n",
    "This is a great chance for you to review what we learned in the last part of the tutorial! Try to follow the steps below on your own first. If you forget, you can also look [back at the last section](https://www.kaggle.com/rtatman/getting-started-in-r-load-data-into-r) for help."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "1f8b9646-80d1-49a1-8b4c-5eccf7fbfe1b",
    "_uuid": "400c19d49c96f13b53eb6a90bda6fa5c21f40fa3",
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your turn!\n",
    "\n",
    "# call the \"tidyverse\" library using the library() function\n",
    "\n",
    "# read our data file into R and assign it to a variable called \"chocolateData\". \n",
    "# Remember that you can find out where the data is by expanding the \"Input Files\"\n",
    "# box above by clicking the + sign in the left corner.\n",
    "\n",
    "# remove the first row of the chocolateData data_frame using a negative index\n",
    "\n",
    "# check the first few rows of your data using the head() function to make sure it\n",
    "# looks alright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_cell_guid": "fb2c4d0e-dce9-48cc-9ddc-4d9d09fbb652",
    "_uuid": "99c6c48c7b7abc87ccbeced0a26be7bf73883f2a",
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in gsub(\"[[:space:]+]\", \"_\", names(chocolateData)): object 'chocolateData' not found\n",
     "output_type": "error",
     "traceback": [
      "Error in gsub(\"[[:space:]+]\", \"_\", names(chocolateData)): object 'chocolateData' not found\nTraceback:\n",
      "1. gsub(\"[[:space:]+]\", \"_\", names(chocolateData))"
     ]
    }
   ],
   "source": [
    "# Before we get going, let's get rid of the white spaces in the column names of this\n",
    "# dataset. This will make it possible for us to refer to columns by thier names, since\n",
    "# any white space in a name will mess R up.\n",
    "\n",
    "names(chocolateData) <- gsub(\"[[:space:]+]\", \"_\", names(chocolateData))\n",
    "str(chocolateData)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "7f520705-436c-4bfa-896d-faa06d2e0c2f",
    "_uuid": "013f50033dd520e270b61595c187aa7b23d3ade6"
   },
   "source": [
    "## Data Cleaning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "52f3936d-b721-4c2d-a926-066f7a509e02",
    "_uuid": "1273cfd468efff42c3c7ca88b026d36b36b632e8"
   },
   "source": [
    "Excellent! Now that we've read our data into R, however, we have lots of questions that we want to ask about it.\n",
    "\n",
    "The first thing that I usually do with a new dataset, however, is make sure that all of the data that I *think* should be a particular data type actually *is* that datatype. We can do this using the str() function we learned about in [the first part of this tutorial](https://www.kaggle.com/rtatman/getting-started-in-r-first-steps). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "_cell_guid": "5c394b81-ca26-4652-99b9-92645e4febc9",
    "_uuid": "d3eca0d5daf078eb9b7346f450372def9aee7e03",
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your turn!\n",
    "\n",
    "# Use the str() function to check the data type of the columns in chocolateData"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "0211d2ba-19ac-4c52-8e2d-cb96b48efb14",
    "_uuid": "2e029d6a7bfaaa1d69960b4845ea7e780364326a"
   },
   "source": [
    "This has a lot of output, but don't be scared! We'll work through it together. Your output should look something like this:\n",
    "\n",
    "![](https://image.ibb.co/eKYCK5/Screenshot_from_2017_08_29_16_09_09.png)\n",
    "\n",
    "The first row shows you the class of the object and its size. Like I mentioned in the last section, a data_frame is a special type of data.frame called a tibble, which is abbreviated here to tbl. You can see that this tibble is 1795 rows long and 9 columns wide.\n",
    "\n",
    "In R, the dollar sign ($) has a special meaning. It means that whatever comes directly after it is a column in a data_frame. You can use this to look at specific columns in a data_frame, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "_cell_guid": "a8a356c5-4a0f-4241-bea7-aa3440df8e0f",
    "_uuid": "e264a5fedcecef6609f3c5328d30bf5db7987685",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in head(chocolateData$Rating): object 'chocolateData' not found\n",
     "output_type": "error",
     "traceback": [
      "Error in head(chocolateData$Rating): object 'chocolateData' not found\nTraceback:\n",
      "1. head(chocolateData$Rating)"
     ]
    }
   ],
   "source": [
    "#print the first few values from the column named \"Rating\" in the dataframe \"chocolateData\" \n",
    "head(chocolateData$Rating)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "371b7590-5415-406b-b73b-7d2ad36a8d8f",
    "_uuid": "9eaec0d2790e4fca1a8014f16641dfe93f80e21a"
   },
   "source": [
    "So all the text that comes after each dollar sign ($) here is just telling you that that's a column and it has that specific name. If you count them, you can see that there are 9 columns, just like it says in the first row of the output.\n",
    "\n",
    "The next thing we can see from this is the type of data in each column. You can see from the fact that each column has \"chr\" printed after the colon (:) that all of these columns are of the data type \"character\". (We learned about data types in the very first part of the tutorial, [here](https://www.kaggle.com/rtatman/getting-started-in-r-first-steps/). If this doesn't sound familiar you might want to peek back for a quick refresher).\n",
    "\n",
    "The last thing we can see is the first couple of observations in each column. However, looking at these we can see that they're not all numbers. In fact, we probably want several of our columns, like REF, Review Date and Rating, to be numeric instead. We *could* convert each column using the as.numeric() function we learned in the first part of the tutorial.\n",
    "\n",
    "Fortunately, we don't have to. The tidyverse has a lot of nice utility functions that can make our lives much easier. One of them is type_convert, which will look at the first 1000 rows of each column, guess what the data type of that column should be and then convert that column into that data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "_cell_guid": "be92ef3a-fd8a-4fbf-9394-0a6182495140",
    "_uuid": "33e4b4fef60219a671da65b042b36686a19886b8",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in type_convert(chocolateData): could not find function \"type_convert\"\n",
     "output_type": "error",
     "traceback": [
      "Error in type_convert(chocolateData): could not find function \"type_convert\"\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# automatically convert the data types of our data_frame\n",
    "chocolateData <- type_convert(chocolateData)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "_cell_guid": "9e6ba6b0-8dcb-412d-a362-53863d6c407a",
    "_uuid": "2d99fffd8e53290a9393155b7d4db4ac376f542a",
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your turn!\n",
    "\n",
    "# Check out the structure of the converted data using the str() function. What do you notice?\n",
    "# Are all the columns the data type you expected?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "6ced3b22-ae74-4099-ab2b-eb562be752ea",
    "_uuid": "7fdbef9f263688d37756085f4242395e25a002f2"
   },
   "source": [
    "So it looks like there's still a bit of a problem: the column \"Cocoa Percent\" is a character, not a numeric value (which is what we'd usually want a percent to be). This is probably because the data in this column contains the percent symbol (%), which isn't a number. Let's remove all the percent symbols from this dataset & try again. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "_cell_guid": "f1994830-6dc2-4b8d-ab3a-4cdf9518a32f",
    "_uuid": "320a28421d1ba20ef0a40bff7a61a0caacfe95f9"
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in lapply(X = X, FUN = FUN, ...): object 'chocolateData' not found\n",
     "output_type": "error",
     "traceback": [
      "Error in lapply(X = X, FUN = FUN, ...): object 'chocolateData' not found\nTraceback:\n",
      "1. sapply(chocolateData$Cocoa_Percent, function(x) gsub(\"%\", \"\", \n .     x))",
      "2. lapply(X = X, FUN = FUN, ...)"
     ]
    }
   ],
   "source": [
    "# remove all the percent signs in the fifth column. You don't really need to worry about\n",
    "# all the different things that are happening in this line right now. \n",
    "chocolateData$Cocoa_Percent <- sapply(chocolateData$Cocoa_Percent, function(x) gsub(\"%\", \"\", x))\n",
    "\n",
    "# try the type_convert() function agian\n",
    "chocolateData <- type_convert(chocolateData)\n",
    "\n",
    "# check the structure to make sure it actually is a percent\n",
    "str(chocolateData)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "1941ef9c-6953-4bdd-a689-7171de395b6a",
    "_uuid": "3d853a2d31ea43345fc673ee36ddb5fc0a417020"
   },
   "source": [
    "Alright, that all looks good: now we're ready to begin our analysis! The steps we've done so far, getting to the point where we can do our analysis, is usually called \"data cleaning\", and it's a surprisingly large part of data analysis. \n",
    "\n",
    "> As the joke goes: “80 percent of data science is preparing data, and the other 20 percent is complaining about preparing data.”"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "8e63b64a-6789-4bf5-b162-1b107c17adc3",
    "_uuid": "80c589d96190c4ccada9b3cd1b90a1c86de278eb"
   },
   "source": [
    "## Summarizing data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "2fd1123b-d6bf-417f-9bb5-fd1f49a79c95",
    "_uuid": "3d8c944d2748823c2e102bb99cb01af84b640b13"
   },
   "source": [
    "Ok, our data is in R and clean. Now let's start summarizing it! There are a couple options for how to do this in R. \n",
    "\n",
    "> One thing you'll learn about R is that there are often multiple ways to do the same thing. This flexibility is really nice once you're comfortable in the language, but I also remember it being very frustrating when I was learning.\n",
    "\n",
    "Let's try two functions. The first, summary() is from base R, while the second, summarise_all(), is part of the Tidyverse. We'll run both and then compare the outputs.\n",
    "\n",
    "You can learn more about any function by looking at the documentation for that function. You can do that in a kernel by running a cell with a question mark in front of the function name, with no parentheses after it. (If you do this for more than one function in the same cell, you'll only see the documentation for the last one.) You can also use a search engine to find more information.\n",
    "\n",
    "> **Protip**: Never feel embarrassed about looking things up. Professional programmers look things up all the time; no one knows everything about every programming language!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "_cell_guid": "83e782a5-87e4-4ff4-af23-80da792ecfe0",
    "_uuid": "fce0016f967765ee564b54abc3004af334879040",
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# run this cell to learn more about the summary() function\n",
    "?summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "_cell_guid": "f58dcc1d-aad1-435c-af23-bb6d461feab4",
    "_uuid": "603d98408ae4ea990d7aa06a146e5c73c82d12fa",
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# run this cell to learn more about the summarise_all() function\n",
    "?summarise_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "_cell_guid": "c7278c90-91ba-4191-a5b3-76bbd6e04487",
    "_uuid": "27d3ae38a0b3630511d204f7db8bbbc5092d97e9",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in summary(chocolateData): object 'chocolateData' not found\n",
     "output_type": "error",
     "traceback": [
      "Error in summary(chocolateData): object 'chocolateData' not found\nTraceback:\n",
      "1. summary(chocolateData)"
     ]
    }
   ],
   "source": [
    "# summary function from base R (base R means no packages)\n",
    "summary(chocolateData)\n",
    "\n",
    "# summary function from the Tidyverse (specifically dplyr). To use this function, you need\n",
    "# to tell it what dataset to summarize and also what function to use. In this case I'm\n",
    "# asking for the average using the function mean()\n",
    "summarise_all(chocolateData, funs(mean))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "_cell_guid": "2fe871ba-8ee1-4d29-b615-ca437108fe39",
    "_uuid": "41cbee4f118b347fa92586bbde279cc745a13603",
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your turn!\n",
    "\n",
    "# Use the summarise_all() function to find the standard deviation of each numeric column.\n",
    "# The function to find the standard deviation is sd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "7efc54a2-e9d2-459e-aa28-b75800a4742d",
    "_uuid": "6a6603668ea4b0d48c74c9aea679acffb47b7fd2"
   },
   "source": [
    "## Summarizing a specific variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "491e3d58-7734-4180-b2bd-8c636c1339e5",
    "_uuid": "8f3c08ebfbfe1f1d71acaa330c0b743409c7ec85"
   },
   "source": [
    "The functions we used above give you an overview of the entire dataset, but often you're only interested in one or two variables. We can look at specific variables really easily using the summarise() function and pipes. Pipes are part of the Tidyverse package we loaded in the beginning: if you try to use them without load in the package, you'll get an error.\n",
    "\n",
    "> A pipe, which looks like this: %>% is a special operator. It takes all the output from the right side and passes it to whatever is on the left side.\n",
    "\n",
    "Let's take our chocolate dataset and then pipe it to the summarise() function. The summarise() function will return a data_frame, where each column contains a specific type of information we've asked for and has a name we've given in. In this example, we're going to get back two columns. One, called \"averageRating\" will have the average of the Rating column in it, while the second, called \"sdRating\" will have the standard deviation of the Rating column in it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "_cell_guid": "caf7ddb8-30c5-4726-a6bc-1751a7f8a13f",
    "_uuid": "c05960bf031757661d09ff6b9a699e9860e400d4",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in chocolateData %>% summarise(averageRating = mean(Rating), sdRating = sd(Rating)): could not find function \"%>%\"\n",
     "output_type": "error",
     "traceback": [
      "Error in chocolateData %>% summarise(averageRating = mean(Rating), sdRating = sd(Rating)): could not find function \"%>%\"\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# return a data_frame with the mean and sd of the Rating column, from the chocolate\n",
    "# dataset in it\n",
    "chocolateData %>%\n",
    "    summarise(averageRating = mean(Rating),\n",
    "             sdRating = sd(Rating))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "eaf42a2e-e68f-4352-81f5-5652903095c3",
    "_uuid": "ab166489b6f9726793e73b7fc880899ba76f4961"
   },
   "source": [
    "> ## Why are there line breaks after \"%>%\" and \"mean(Rating),\" in the code block above?\n",
    "> \n",
    "> So far all the functions we've seen have been all on one line. As we're learning more functions and stringing them together, however, some of our lines are going to get really, really long. Breaking up a line can help make your code easier to read. (Easy to read is good! The person who's most likely to need to read your code in the future is you after you've forgotten everything about about it. Make future you's life a little easier.)\n",
    ">\n",
    "> You can't break a line up just anywhere, though. Lines of code are like lines of text in a book: you can't just start wrap a line anywhere you want.\n",
    ">\n",
    ">> Th\n",
    ">>\n",
    ">>is is p\n",
    ">>\n",
    ">>retty hard t\n",
    ">>\n",
    ">> o read.\n",
    ">\n",
    ">In text, you need to do wrap lines between words, or between syllables of words with a hyphen (-) in between. This lets the reader know that the word continues in the next line. For R, some of the \"hyphens\" that let the computer know that your line continues on the next line are the comma (,), the pipe (%>%) and the plus sign (+), which we'll talk about later. If you split your line directly after one of these characters, R knows to keep looking for the rest of the code one the next line.\n",
    ">\n",
    "> You should also indent any wrapped lines after the first. This isn't necessary, but it makes your code easier to learn.  You can do this either by hitting TAB once, or space four times. (There are a lot of arguments on-line about which is better, but both work.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "_cell_guid": "a419e5e2-d32d-4f9b-a7e3-ab303388acab",
    "_uuid": "9f559410ce5888c45d627d14bd6c4e481825b0ee"
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in parse(text = x, srcfile = src): <text>:14:7: unexpected numeric constant\n13: mean(c(5,6,2\n14:       5\n          ^\n",
     "output_type": "error",
     "traceback": [
      "Error in parse(text = x, srcfile = src): <text>:14:7: unexpected numeric constant\n13: mean(c(5,6,2\n14:       5\n          ^\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# this is fine! :)\n",
    "mean(c(5,6,25,16))\n",
    "\n",
    "# this is fine! :)\n",
    "mean(c(5,6,\n",
    "       25,16))\n",
    "\n",
    "# this won't break your code, but it's hard to read :(\n",
    "mean(c(5,6,\n",
    "25,16))\n",
    "\n",
    "# this will break your code :'(\n",
    "mean(c(5,6,2\n",
    "      5,16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "_cell_guid": "2c5ba6af-4645-4d9d-9a59-ce4c67a82dd7",
    "_uuid": "cb3de78e8434e1bfa1168b2df68d0b7e69e19a37",
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your turn!\n",
    "\n",
    "# Can you use a pipe (%>%) and the summarise() function return a dataframe\n",
    "# with the average and sd of the Cocoa_Percent column? You can name the new columns\n",
    "# whatever you'd like, but keep in mind that clear names are the most helpful."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "a213b61f-2e03-47b8-9c1f-b69d7f6b714e",
    "_uuid": "f731784238476e5474ae129e860bf037e860123c"
   },
   "source": [
    "## Summarize a specific variable by group"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "e691bd6d-163f-4395-b77a-dd98bd3faed0",
    "_uuid": "0adbbbb91fadc1e389a32ac13b37b34ea4cfc556"
   },
   "source": [
    "At first pass, it may seem a bit silly to do things like calculate the mean and standard deviation this way. You can see why this is such a power technique, however, when we look at the the same variable across groups. \n",
    "\n",
    "We can use this with a hand function called group_by(). When you pipe a dataset into the group_by() function and tell it the name of a specific column, then it will look at all the values in that column and group together all the rows that have the same value in a given column. Then, when you pipe that data into the summarise() function, it will return the values you asked for for each group separately. Like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "_cell_guid": "e8df8de7-7a38-48d5-b032-e7d5c0860939",
    "_uuid": "9ccb1d25051915b774e9351b8ff9b76156053e4e",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in chocolateData %>% group_by(Review_Date) %>% summarise(averageRating = mean(Rating), : could not find function \"%>%\"\n",
     "output_type": "error",
     "traceback": [
      "Error in chocolateData %>% group_by(Review_Date) %>% summarise(averageRating = mean(Rating), : could not find function \"%>%\"\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# Return the average and sd of ratings by the year a rating was given\n",
    "chocolateData %>%\n",
    "    group_by(Review_Date) %>%\n",
    "    summarise(averageRating = mean(Rating),\n",
    "             sdRating = sd(Rating))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "_cell_guid": "97d3046a-a25a-416d-8250-781b32bfa0ae",
    "_uuid": "e70ab542d83262785ba0b7a70cbd4e2135ebea94",
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your turn!\n",
    "\n",
    "# Can you return a data_frame with the average and sd Cocoa_Percent by the year the reviews \n",
    "# were written?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "d9178109-2442-4427-b3ed-913694a8ff99",
    "_uuid": "27a0c1e956dba16f53dcecd8ac2235120aeccf26"
   },
   "source": [
    "This is a really efficient way to start understanding your data. For example, it looks like chocolate bar ratings might be trending slightly upwards by year. In the mid 2000's they were around 3.0, and now they're closer to 3.3.\n",
    "\n",
    "To really get a better understanding of this, however, I really want to want to graph this data so that I can see if there's been reliable change over time. So let's move on to the final part of this tutorial: graphing!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "88f612a3-3519-4d2e-a533-097191bda6fc",
    "_uuid": "ebf4ff75164b5479ae1444d329caee1fa2a75287"
   },
   "source": [
    "## Next step: [Graphing Data](https://www.kaggle.com/rtatman/getting-started-in-r-graphing-data/)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}