Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


Learn the general grammar needed to make visualizations with the popular R visualization package, ggplot2.

Intro to Visualization with R

In the previous exercises, we added geoms to the plot and explored the idea of layers inheriting the original aesthetic mappings of the canvas. Sometimes, you'll want individual layers to have their own mappings. For example, what if we wanted the scatterplot layer to classify the points based on a data-driven property? We achieve this by providing an aesthetic mapping for that layer only. 


Let's explore the aesthetic mappings for the [`geom_point()` layer](https://ggplot2.tidyverse.org/reference/geom_point.html). What if we wanted to color-code the points on the scatterplot based on a property? It's possible to customize the color by passing in an `aes()` aesthetic mapping with the color based on a data-driven property. Observe this example:

```R
viz <- ggplot(data=airquality, aes(x=Ozone, y=Temp)) +
       geom_point(aes(color=Month)) + 
       geom_smooth()

```
The code above would *only* change the color of the point layer, it would not affect the color of the smooth layer since the `aes()` aesthetic mapping is passed at the point layer. 
 
![Aesthetics Inheritance Example](https://content.codecademy.com/courses/Learn-R/aes-example.png)


Note: You can read about the individual aesthetics available for each geom when you read its documentation. There are some aesthetics shared across geoms and others that are specific to a particular ones.

Geom Aesthetics

The first thing you'll need to do to create a ggplot object is invoke the `ggplot()` function. Conceptualize this step as initializing the "canvas" of the visualization. In this step, it's also standard to associate the data frame the rest of the visualization will use with the canvas. What do we mean by "the rest" of the visualization? We mean all the layers you'll add as you build out your plot.

As we mentioned, at its heart, a ggplot visualization is a combination of layers that each display information or add style to the final graph. You "add" these layers to a starting canvas, or ggplot object, with a `+` sign. We'll add geometries and aesthetics in the next exercises. For now, let's stop to understand that any arguments inside the `ggplot()` function call are inherited by the rest of the layers on the plot. 

Here we invoke `ggplot()` to create a ggplot object and assign the dataframe `df`, saving it inside a variable named `viz`:
```R
viz <- ggplot(data=df)

viz
```
Note: The code above assigns the value of the canvas to `viz` and then states the variable name `viz` after so that the visualization is rendered in the notebook.

Any layers we add to `viz` would have access to the dataframe. We mentioned the idea of aesthetics before. It's important to understand that any aesthetics that you assign as the `ggplot()` arguments will also be inherited by other layers. We'll explore what this means in depth too, but for now, it's sufficient to conceptualize that arguments defined inside `ggplot()` are inherited by other layers.


Diagram visualizing the inheritance between the canvas, the aesthetics defined with the ggplot function, and the subsequent layers.

The ggplot() function

Before we teach you how to add aesthetics specific to a geom layer, let's create our first geom! As mentioned before, geometries or geoms are the shapes that represent our data.

In ggplot, there are many types of geoms for representing different relationships in data. You can read all about each one in the layers section of the [ggplot2 documentation](https://ggplot2.tidyverse.org/reference/). Once you learn the basic grammar of graphics, all you'll have to do is read the documentation of a particular geom and you'll be prepared to make a plot with it following the general pattern.  For simplicity's sake, let's start with the scatterplot geom, or `geom_point()`, which simply represents each datum as a point on the grid. Scatterplots are great for graphing paired numerical data or to detect a correlation between two variables. 

The following code adds a scatterplot layer to the visualization:
```R
viz <- ggplot(data=df, aes(x=col1,y=col2)) +
       geom_point()

```
In the code above:
+ Notice the layer is being added by using a `+` sign which comes after the ggplot object is created, and it comes on the same line.
+ The `geom_point()` function call is what adds the points layer to the plot. This call can take arguments but we are keeping it simple for now.

The code above would render the following plot:
![Scatterplot one layer](https://content.codecademy.com/courses/Learn-R/one-layer.png)

Another popular layer that allows you to eye patterns in the data by completing a line of best fit is the `geom_smooth()` layer. This layer, by nature, comes with a gray error band. You could add a smooth layer to the plot by typing the following:

```R
viz <- ggplot(data=df, aes(x=col1,y=col2)) +
       geom_point() + 
       geom_smooth()
```
+ Notice that you can add layers one on top of the other. We added the smooth line after adding the `geom_point()` layer. We could have just included the point layer, or just the line-of-best-fit layer. But the combination of the two enhances our visual understanding of the data, so they make a great pairing. 
+ It is nice to put each layer on its own line although it is not necessary, since it improves readability in the long run if you're collaborating with other people.

The code above would render the following plot: 
![Plot two layers with smooth line](https://content.codecademy.com/courses/Learn-R/two-layers.png)

Adding Geoms

We've gone over each of the basic units in the grammar of graphics: data, geometries, and aesthetics. Let's extend this new knowledge to create a new type of plot: [the bar chart](https://ggplot2.tidyverse.org/reference/geom_bar.html). Bar charts are great for showing the distribution of categorical data. Typically, one of the axes on a bar chart will have numerical values and the other will have the names of the different categories you wish to understand.

Let's build a bar chart by using some of the R built-in datasets. These are data frames that you can readily access in your code to explore and create visualizations. They are  handy because these built-in datasets usually include nicely distributed categorical data.

The `geom_bar()` layer adds a bar chart to the canvas. Typically when creating a bar chart, you assign an `aes()` aesthetic mapping with a single categorical value on the `x` axes and the `aes()` function will compute the count for each category and display the count values on the `y` axis. 

Since we're extending the grammar of graphics, let's also learn about how to save our visuals as local image files.

The following code maps the count of each category in the Language column in a dataset of 100 popular books to a bar length and then saves the visualization as a .png file named `"bar-example.png"`:

```R
bar <- ggplot(books, aes(x=Language)) + geom_bar()
bar
ggsave("bar-example.png")
```
Note: The [`ggsave()` function](https://www.rdocumentation.org/packages/ggplot2/versions/3.1.1/topics/ggsave) allows you to save  visualizations as a local file with the name of your choice. It's a useful function when developing visualizations locally.

The code above outputs the following plot:
![Bar chart displaying different languages spoken in popular books](https://content.codecademy.com/courses/Learn-R/bar-example.png)


Extending The Grammar

We've reviewed how to assign data-driven aesthetic mappings at the canvas level and at the geom level. However, sometimes you'll want to change an aesthetic based on visual preference and not data. You might think of this as "manually" changing an aesthetic.

If you have a pre-determined value in mind, you provide a named aesthetic parameter and the value for that property *without* wrapping it in an `aes()`. For example, if you wanted to make all the points on the scatter plot layer dark red because that's in line with the branding of the visualization you are preparing, you could simply pass in a `color` parameter with a manual value `darkred` or any color value like so:

```R
viz <- ggplot(data=airquality, aes(x=Ozone, y=Temp)) +
       geom_point(color="darkred")  
```
+ Note that we did not wrap the `color` argument inside `aes()` because we are manually setting that aesthetic. Here are more aesthetics for the `geom_point()` layer: `x`, `y`, `alpha`, `color`, `fill`, `group`, `shape`, `size`, `stroke`. The `alpha` aesthetic describes opacity of the points, and the `shape` of the dots could be different than a dot. Read more about the values each of these aesthetics take in the [`geom_point()` layer documentation](https://ggplot2.tidyverse.org/reference/geom_point.html).  

The code above would render the following plot:
![Dark scatterplot layer](https://content.codecademy.com/courses/Learn-R/dark-red-scatter.png)
We advise that your aesthetic choices have intention behind them. Too much styling can overcomplicate the appearance of a plot, making it difficult to read. 

Manual Aesthetics

In the context of ggplot, aesthetics are the instructions that determine the visual properties of the plot and its geometries.

Aesthetics can include things like the scales for the x and y axes, the color of the data on the plot based on a property or simply on a color preference, or the size or shape of different geometries. 

There are two ways to set aesthetics, by manually specifying individual attributes or by providing _aesthetic mappings_. We'll explore aesthetic mappings first and come back to manual aesthetics later in the lesson. Aesthetic mappings "map" variables from the data frame to visual properties in the plot. You can provide aesthetic mappings in two ways using the `aes()` mapping function:

+ At the canvas level: All subsequent layers on the canvas will inherit the aesthetic mappings you define when you create a ggplot object with `ggplot()`.
+ At the geom level: Only that layer will use the aesthetic mappings you provide. 


Let's discuss _inherited aesthetics_ first, or aesthetics you define at the canvas level. Here's an example of code that assigns `aes()` mappings for the `x` and `y` scales at the canvas level:

```R
viz <- ggplot(data=airquality, aes(x=Ozone, y=Temp)) +
       geom_point() + 
       geom_smooth()
```

![Aesthetics Inheritance Example](https://content.codecademy.com/courses/Learn-R/aes-inherit-example.png)


In the example above:
+ The aesthetic mapping is wrapped in the `aes()` aesthetic mapping function as an additional argument to `ggplot()`.
+ Both of the subsequent geom layers, `geom_point()` and `geom_smooth()` use the scales defined inside the aesthetic mapping assigned at the canvas level.

You should set aesthetics for subsequent layers at the canvas level if all layers will share those aesthetics.
 


What are aesthetics?

Before we go any further, let's stop to understand when the data gets bound to the visualization:

+ Data is bound to a ggplot2 visualization by passing a data frame as the first argument in the `ggplot()` function call. You can include the named argument like `ggplot(data=df_variable)` or simply pass in the data frame like `ggplot(data frame)`.
+ Because the data is bound at this step, this means that the rest of our layers, which are function calls we add with a `+` plus sign, all have access to the data frame and can use the column names as variables. 

For example, assume we have a data frame `sales` with the columns `cost` and `profit`. In this example, we assign the data frame `sales` to the `ggplot()` object that is initailized: 

```R
viz <- ggplot(data=sales) + 
       geom_point(aes(x=cost, y=profit))
viz # renders plot
``` 

In the example above:

+ The ggplot object or canvas was initialized with the data frame `sales` assigned to it
+ The subsequent `geom_point` layer used the `cost` and `profit` columns to define the scales of the axes for that particular geom. Notice that it simply referred to those columns with their column names.
+ We state the variable name of the visualization ggplot object so we can see the plot.

Note: There are other ways to bind data to layers if you want each layer to have a different dataset, but the most readable and popular way to bind the dataframe happens at the `ggplot()` step and your layers use data from that dataframe.

Associating the Data

So far, we've reviewed how to add geometries to represent our data. We've also learned how to modify aesthetic values in our plot- whether those aesthetics are data-driven or assigned manually. Another big part of creating a plot is in making sure it has reader-friendly labels. The ggplot2 package automatically assigns the name of the variable corresponding to the different components on the plot as the initial label. Code variable names are unfortunately not always legible to outside readers with no context. 

If you wish to customize your labels, you can add a `labs()` function call to your ggplot object. Inside the function call to `labs()` you can provide new labels for the `x` and `y` axes as well as a `title`, `subtitle`, or `caption`. You can check out the list of available label arguments in the [`labs()` documentation](https://ggplot2.tidyverse.org/reference/labs.html) here. 

The following `labs()` function call and these specified arguments would render the following plot:

```R
viz <- ggplot(df, aes(x=rent, y=size_sqft)) + 
       geom_point() +
       labs(title="Monthly Rent vs Apartment Size in Brooklyn, NY", subtitle="Data by StreetEasy (2017)", x="Monthly Rent ($)", y="Apartment Size (sq ft.)")
viz
```

![Labels are tweaked for readibility](https://content.codecademy.com/courses/Learn-R/labs-layer.png)


Labels

When you learn grammar in school you learn about the basic units to construct a sentence. The basic units in the "grammar of graphics" consist of:

+ The _data_ or the actual information you wish to visualize.
+ The _geometries_, shortened to "geoms", describe the shapes that represent our data. Whether it be dots on a scatter plot, bar charts on the graph, or a line to plot the data! The list goes on. Geoms are the shapes that "map" our data.
+ The _aesthetics_, or the visual attributes of the plot, including the scales on the axes, the color, the fill, and other attributes concerning appearance.

Another key component to understand is that in ggplot2, geoms are "added" as _layers_ to the original canvas which is just an empty plot with data associated to it. 

Once you learn these three basic grammatical units, you can create the equivalent of a basic sentence, or a basic plot. There are more units in the "grammar of graphics," but in this lesson we'll mostly be learning about these three. 

Layers and Geoms

Hello there! Today, we will be learning how to make visualizations with R's popular [ggplot2 package](https://ggplot2.tidyverse.org/). You can create simple visualizations with base R, but we are choosing to teach you ggplot2 because it is relatively easy to implement, well-documented, and supported by a community of data enthusiasts. 

The ggplot2 package is part of the tidyverse so it comes equipped with other data cleaning and processing tools. The package is designed with the grammar of graphics in mind. This grammar of graphics describes a general pattern to follow when you're creating visualization. In fact, that's where the "gg" in ggplot comes from: **g**rammar of **g**raphics. ggplot2 has fostered a large programming community so you'll find that as you forage into making your own plot outside of the Codecademy platform, there'll be lots of resources and examples to welcome you.

This lesson will teach you the basic grammar required to create a plot. After you learn the underlying structure or "philosophy" of ggplot2, you can extend the logic to create many types of plots. Once you get the basic structure down, our upcoming lessons will explore how to customize your plot and calculate statistics in your visualization. Let's get started. 


Animated gif showing layers being added to a canvas one by one.

Introduction

You've completed the introduction to ggplot lesson! You're ready to follow the general pattern for creating a visualization:

1. Determine what relationship you wish to explore in your data
2. Find the right geom(s) in the [ggplot2 documentation](https://ggplot2.tidyverse.org/reference/) to display that relationship and read about the arguments and aesthetics specific to that geom
3. Extend the grammar of graphics to follow the pattern learned in this lesson to add layers and create a visualization. Improve graph legibility by polishing labels and styles.

Some of the key concepts you learned in this lesson include:

+ The basic units of grammar include data, geoms, and aesthetics.
+ The dataframe associated to the plot by using the `ggplot()` function creates a ggplot object that is known as the canvas.
+ The geometries or geoms are the shapes that display the data. Geometries become layers as you add them to your ggplot object.
+ The aesthetics are visual instructions you provide the plot. Aesthetics can be inherited or specified at the geom level.
+ Aesthetic mappings are data-driven visual instructions for the plot.
+ You can add context to your plot by customizing its labels with the `labs()` function
