Learn how to make line charts, scatter plots, bar charts, and distributional graphs with seaborn.

Make Charts with Seaborn

Bar plots helped us view aggregated numeric data for different groups. What if we want to explore numeric data that are not aggregated? A scatter plot will help view data points for two numeric columns at the same time.

Seaborn's `sns.scatterplot()` function will create a scatter plot of two variables. As usual, we can set `data` to the DataFrame name and `x` and `y` to the columns we want along the x- and y-axis, respectively.

For example, using our restaurant dataset `df` from the previous exercise, we can plot `sales_totals` versus `daily_customers` using the following code.

```py
sns.scatterplot(data=df, x='daily_customers', y='sales_totals')
```

Scatterplots are a helpful chart type for statistical analysis. Patterns in the points can help us quickly identify if we may want to explore the relationship with further statistical analysis. These patterns allow us to visualize the strength and direction of a relationship between two variables. Visual patterns we look for in scatter plots include:

* **Spacing:** Points that are close together in a line or curve pattern show a stronger relationship. Points that are spaced out or more cloud-like show a weaker relationship.
* **Orientation:** A pattern of points starting in the lower left corner and following up to the upper right corner shows a positive relationship. A negative relationship might appear as a pattern of points starting in the upper left corner and following down to the lower right corner. 

A tightly-spaced line of points suggests a strong **correlation** between the variables that may be positive, negative, or neither. Curved patterns or patterns in spacing may mean a more complex relationship between the variables.


Make a scatter plot

Like scatter plots, line plots show the relationship between two variables. However, in a line plot we are exploring the continuous pattern of one variable over increments of another. Frequently, the incremental variable is a measurement of time.

We can use `sns.lineplot()` with the standard parameters `data`, `x`, and `y` to create a line plot with seaborn. Because we want to read the pattern continuously from left to right, we set `x` to the incremental variable and `y` to the variable of interest. For example, we could use the following code to plot `total_sales` over each `month` of a year from dataset `df`.

```py
sns.lineplot(data=df, x='month', y='sales_totals')
```

This code will work whether you have one value or multiple values of the continuous variable for each increment. 
* When there is only one value per increment, seaborn will plot the line at that value. 
* When there are multiple values per increment, seaborn will plot the line at the mean value for that increment.

When plotting means, seaborn will also plot a shaded area around the line that shows the 95% confidence interval at each increment. We can hide these shaded areas by setting the `ci` parameter to `None`. 

*Note:* For seaborn version >= 0.12.0, the `ci` parameter is deprecated in favor of the `errorbar` parameter. Set `errorbar=None` for later versions of seaborn.

Make a line chart

Now that we know the basics of seaborn syntax and have seen some of the plots we can make, let's start coding! For the rest of the lesson, we'll spend time creating each of the plots we previewed in the last exercise.

Let's start with a bar plot. After importing seaborn as `sns`, we make a bar plot using `sns.barplot()`. We set `data` to the name of our DataFrame. The bars are plotted vertically by default, so we set `x` to the column name of data with categories or groups so these are displayed along the x-axis. We set `y` (bar height on the y-axis) to the column name of data measured in numbers. This column's data will be aggregated for each group of the `x` variable.

The following code produces a vertical bar plot of mean `sales_totals` for each `server`.

```py
df = pd.read_csv('restaurant_data.csv')
sns.barplot(data=df, x='server', y='sales_totals')
```

The default aggregation method is to take the mean of each group, but we can change this by setting the `estimator` parameter to another method. Many functions from the NumPy library can be called like `np.median`, `np.max`, and `np.std`. This code will show us the same plot but with the median for each group instead of the mean.



```py
import numpy as np
sns.barplot(data=df, x='server', y='sales_totals', estimator=np.median)
```

We'll see more special parameters like `estimator` as we look at other plot types in the next exercises.

One last feature to note is that seaborn plots a line on each bar by default. These lines are error bars set at a 95% confidence interval. We can hide these bars by setting the `ci` parameter to `None`.

```py
sns.barplot(data=df, x='server', y='sales_totals', ci='None')
```

*Note:* For seaborn version >= 0.12.0, the `ci` parameter is deprecated in favor of the `errorbar` parameter. Set `errorbar=None` for later versions of seaborn.

Make a bar plot

Welcome to Make Charts with Seaborn! Seaborn is a Python data visualization library that is built on top of matplotlib. Matplotlib is Python's foundational plotting library and is highly customizable. While matplotlib is a commonly used library, seaborn makes it easier for data scientists to create graphs with less required coding. 

Seaborn has more built-in aesthetic themes and a more flexible and formulaic structure. You don't have to be familiar with matplotlib to use seaborn, but it's possible to use them in combination for more detailed customization when needed.

In this lesson we will…
* review the general structure of seaborn code
* learn how to make bar charts, scatter plots, and line graphs using seaborn
* explore three ways to visualize a distribution

In the Jupyter notebook to the right, we’ll start by comparing two plots: one made using matplotlib and the other using seaborn. These plots appear similar to one another but use different code and DataFrame formats.


Introducing seaborn

Congratulations! You've completed the Make Charts with Seaborn lesson. In this lesson, you learned how to:

* benefit from seaborn's built-in aesthetics
* create bar plots to summarize data across categories
* examine variable relationships in scatter plots
* plot data over time in a line plot
* graph three different types of plots to illustrate distributions

Review

Just like we can use a scatter plot to examine the relationship between two numeric variables, we can use distribution plots to examine a numeric variable's distribution of values. 

#### Histograms
The most basic way to plot our data is to create a histogram. A histogram looks like a bar chart, but instead of having a bar for each category of a variable, it has a bar for sets of numeric values called **bins**. The height of the bar shows how many data points of the variable fall within that bin's range of values.

We can create a histogram of `total_sales` from our restaurant dataset `df` using the seaborn function `sns.histplot()`.

```py
sns.histplot(data=df, x='sales_totals')
```

This code will display a histogram with vertical bars. Using `y` instead of `x` will create a histogram with horizontal bars.

Seaborn sets the `bins` parameter to `auto` by default, but we can change the binning of values in a number of ways.
* **Number of bins:** an integer for the number of bins to fit the data to
* **Bin breaks:** a list of values for where bins should start and end
* **Reference rule:** the name of a method to compute the optimal bin width, including `auto` (the larger of the `sturges` and `fd` reference rules)

Note that poorly chosen bin sizes can distort histograms, making it difficult to understand the histogram's underlying data.

#### KDE plots
Another option for displaying a distribution is a kernel density estimation (KDE) plot. A KDE plot displays a continuous probability density curve for the distribution. This estimation looks a lot like a smoothed version of a histogram.

We can create a KDE plot of `total_sales` using `kdeplot()`. We can also set the optional parameter `fill` to `True` so that the plot will be shaded below the KDE curve.

```py
sns.kdeplot(data=df, x='sales_totals', fill=True)
```

Like histograms, using `y` instead of `x` will create a horizontal orientation.

#### Box plots
Finally, let's look at a plot that displays distributions for each category of a second variable. The box plot communicates specific information about each category's distribution through a pattern of lines and a box, as shown in the following diagram:

![Diagram of a box plot showing median, outliers, quartiles, minimum, and maximum.](https://static-assets.codecademy.com/Courses/data-viz-with-python/box-plot-diagram.svg)

*Note:* seaborn will create a horizontal box plot by default but will create a vertical box plot like the previous diagram if given the `y` parameter instead of `x`.

If we want to see a distribution of `total_sales` for each `day` of the week, we can use `sns.boxplot()` as shown in the following code.

```py
sns.boxplot(data=df, x='sales_totals', y='day')
```

Swapping the `x` and `y` parameters will change the orientation of the plot.


Make distribution plots

As we saw in the last exercise, the structure of seaborn plotting functions is a little different from that of matplotlib. Seaborn works well with pandas DataFrames in long format. Most plotting functions in seaborn follow the same general structure:

```py
import seaborn as sns

sns.plot(data=df, x='col1', y='col2')
```

The main parameters are `data`, `x`, and `y`.
* `data` is an optional parameter for the name of the pandas DataFrame.
* `x` is the column name for the x-axis of the plot.
* `y` is the column name for y-axis of the plot.

Depending on the type of plot, we may need only `x`, only `y`, or both. We may also set other parameters to add more detail to the plot. 

Also note that if we are working with arrays, we can enter the arrays in either the `data` parameter or the `x` and `y` parameters. The arrays can be named or entered directly into the function.

Let's review some of the available plot options we have with seaborn.

* **bar chart** | `sns.barplot()`: uses bar height to compare a measure between categorical variables
* **scatter plot** | `sns.scatterplot()`: uses position to show the relationship, or correlation, between two numeric values
* **line chart** | `sns.lineplot()`: shows continuous change, often used to measure change over time
* **histogram** | `sns.histplot()`: shows how one kind of data is distributed
* **KDE plot** | `sns.kdeplot()`: shows a distribution like a histogram but with smoothed lines
* **box plot** | `sns.boxplot()`: shows specific information about a distribution, such as median and outliers

Seaborn doesn't cover every plot type (for example, pie charts are not included), but it allows us to make many kinds of pre-formatted plots quickly. Because seaborn works well with pandas and long-format data, we can usually make styled plots with fewer lines of code and less preprocessing of the data as compared with matplotlib.
