Change plotting parameters to display complex information, improve your plot's messaging, and make your plot more interesting.

Modify Chart Parameters with Seaborn

Seaborn makes it easy to customize which set of colors it uses in its plot functions. There are premade sets of colors to choose from as well as the flexibility to design our own.

#### Palette options
Seaborn includes six **qualitative** color palettes: deep, muted, pastel, bright, dark, and colorblind. These palettes are six versions of the same set of colors that are in no specific order, making them a good choice for categorical data groups. 

![Image showing the six colors palettes available in seaborn as rows of six squares in each color.](https://content.codecademy.com/programs/dataviz-python/unit-5/seaborn-design-2/article2_image6.png)

However, if we have ordered data, we may be better off with a choice between two types of ordered palettes:
* **Sequential** palettes change from lighter to darker colors in one direction. These palettes may be a good choice for ordered categories or continuous numeric scales.
![Ten squares arranged in a horizontal line that progressively change from white to blue.](https://static-assets.codecademy.com/Courses/data-viz-with-python/seqBlues.svg)
* **Diverging** palettes generally include a sequence over two colors where increments change from dark to light in the center to dark again at the end. These palettes may be a good choice to show absolute values for data that include both negative and positive values, or data where two things are opposites, like political parties or favorable and unfavorable outcomes.
![Ten squares arranged in a horizontal line that progressively change from blue to white to orange.](https://static-assets.codecademy.com/Courses/data-viz-with-python/diverging.svg)

For any of the three palette types, we can choose from [seaborn](https://seaborn.pydata.org/tutorial/color_palettes.html), [matplotlib](https://matplotlib.org/stable/tutorials/colors/colormaps.html), or [Color Brewer](https://colorbrewer2.org/) included palettes. 

#### Custom palettes
We can also name and create a custom palette with `sns.color_palette()`. For example, to make a sequential color palette of blues from light to dark in 10 increments, we can use the following code:

```py
seqBlues = sns.color_palette("light:blue", n_colors=10)
```

We can make our `seqBlues` palette into a matplotlib continuous colormap by swapping `n_colors=10` for `as_cmap=True`. Other seaborn palette functions with more specific objectives can also be used for palette creation, such as `sns.light_palette()` or `sns.diverging_palette()`.

#### Applying palettes
We can change a plot's palette by setting the `palette` parameter to the palette's name. Premade palette names are given in quotes, while custom palettes are given without quotes.

```py
# apply a premade palette
sns.barplot(data=df, x='week', y='sales', palette='dark')

# apply a custom palette
sns.barplot(data=df, x='week', y='sales', palette=seqBlues)
```

Finally, we can apply settings to all plots by running a function at the start of our notebook:
* `sns.set_palette()` applies the same color palette to all plots.
* `sns.set_theme()` sets the same plotting parameters to all plots, including features like borders, grids, and background color.

Let's start trying out some color palettes in our plots! You may want to reference the [seaborn documentation on color palettes](https://seaborn.pydata.org/tutorial/color_palettes.html) as you are working.

Use color palettes

While the `hue` and `style` parameters can help add more information to the same plot, too much information in one plot can make it difficult to understand. When we want to be able to make comparisons without overcomplicating a single plot, we may want to use **faceting**, where we make one plot for each group and align them next to each other.

In seaborn, we can use the `sns.FacetGrid()` function to build a grid of plots and then map a plotting function onto it. Alternatively, we may use one of a few plotting functions that are built off of `sns.FacetGrid()`. These functions take a `kind` parameter to specify the type of plot and then add the familiar parameters like `data`, `x`, `y`, `hue`, or `style`.
* `sns.relplot()` plots relational data of multiple variables like `'line'` or `'scatter'` plots.
* `sns.displot()` plots distributional data like histograms (`'hist'`) or `'kde'` plots.
* `sns.catplot()` plots categorical data like `'bar'` or `'box'` plots.

To create the facets, we set one of two parameters to a grouping variable: `row` to display the plot vertically in rows or `col` to display the plots horizontally in columns.

The following code plots multiple line plots horizontally, one plot for each `year`.

```py
sns.relplot(kind='line', data=df, x='month', y='sales', col='year')
```

So when might we want to switch from `sns.lineplot()` to `sns.relplot()`?

The function `sns.lineplot()` and the other familiar plotting functions:
* are all **axes-level** functions
* integrate well with other matplotlib functions
* provide control of the plots individually and position them together with more flexibility, allowing for more complex or custom layouts

Functions like `sns.relplot()` that build off of `sns.FacetGrid()`:
* are **figure-level** functions
* make it easy to facet the same plot type across groups with a legend automatically positioned outside the plots
* don't provide as much individual control over the plots or their positions, but lots of the work is done for us already

When using multiple plots just to explore a dataset, there are other functions in seaborn that may be more useful.
* `sns.pairplot()` plots multiple variables in pairs so that we can quickly check many variables for notable relationships.
* `sns.jointplot()` plots two variables together along with their individual distributions in the margins so that we can quickly check out a relationship on multiple levels at once.

You can find more details about these functions in the [seaborn API documentation](https://seaborn.pydata.org/api.html).

Display multiple graphs

Congratulations! You finished the Modify Chart Parameters with Seaborn lesson! We explored a lot of exciting ways to make basic seaborn plots more informative and formatted. In this lesson, we:
* Added confidence intervals to bar plots and line plots
* Indicated group membership by color and style of lines and points
* Explored color palette types and functions
* Created grids with multiple plots
* Wrote titles, labels, and annotations on our plots


Review

Colors and styles help us create clear, informative plots. We can add even more clarity and specialized information with titles, labels, and annotations. These are often essential to helping our audience get as much as possible out of the plot, particularly if they are less familiar with the underlying data or research. Let's start with adding basic titles and renaming axis labels.

#### Single plot
For axes-level plots, like `sns.lineplot()` or `sns.boxplot()`, we can quickly add a title and axis labels as parameters of `.set()`. The following example plots a histogram with a title and customized axis labels. 
*Note:* Throughout this exercise, axes-level plots will be named `axplot` while figure-level plots will be named `figplot`.

```py
# create a histogram of ages
axplot = sns.histplot(data= df, x='age')
# add titles and update axis labels
axplot.set(title="Distribution of Ages", xlabel="Age (in years)", ylabel="Count")
```

We can also add text annotations at a specific point (x, y) using `.annotate()` at the axes level. The following code adds annotations in red, marking the first and second modes in the age histogram saved as `axplot`.

```py
# text for first mode
axplot.annotate(text="First Mode", xy=(24,40), color='red')
# text for second mode
axplot.annotate(text="Second Mode", xy=(32,50), color='red')
```

#### Multiple plots
For figure-level plots, like `sns.relplot()` or `sns.catplot()`, we set the axis labels for all the plots in the figure using `.set_axis_labels()`. The following code creates a row of histograms showing the distribution of `age` for each `location` in the dataset `df`.

```py
# create histogram of ages for each location
figplot = sns.displot(kind='hist', data= df, x='age', col='location')
# set axis labels for all plots
figplot.set_axis_labels(xlabel="Age (in years)", ylabel="Count")
```

We can use `.set_titles()` and a `{col_name}` template to programmatically give an axes-level title to each plot in the figure. The following code adds a unique title for each plot by substituting the location name for `{col_name}` in the string.

```py
# add a histogram title for each location
figplot.set_titles("Distribution of Ages in {col_name}")
```

*Note:* We would use `{row_name}` instead of `{col_name}` if we had used `row=location` instead of `col=location` in `sns.displot()` earlier.

To add a main title to a figure-level plot, we can use the following code.
```py
figplot.fig.suptitle("Age Distributions for Locations in the U.S.", y=1.05 )
```
Setting `y=1.05` places the title above the plot so it doesn't overwrite any axes-level titles.

Finally, we can add the same annotation to the first histogram in the figure by accessing the specific plot within the figure.
```py
figplot.axes.flat[0].annotate(text="There are two modes in the first histogram", xy=(29,50), color='red')
```

Let's try adding some titles, labels, and annotations to our plots!

Add labels and annotations

Seaborn is a great tool for quickly producing formatted plots without much coding work. However, by adding a few chart parameters to a plotting function, we can customize our plots and present more complex information.

For example, we can make it easier to compare plots by positioning them side-by-side. We can also show trends for multiple groups through differences in color and style in a single plot. We can even use seaborn parameters to make our plots publication-ready by adding titles, writing in annotations, and choosing color palettes that are appropriate to the plot's use.

In this lesson, we will:
* Add confidence intervals to bars and lines
* Adjust the color and style of lines and points
* Create multi-plot displays
* Annotate plots to make them even more informative!

In the Jupyter notebook to the right, we’ll start by running some code examples to see how modifying chart parameters can transform our plots.

Chart parameters overview

One major difference between matplotlib and seaborn is how elements by group are added to the same plot. In matplotlib, we have to identify and label each group that will be added to the plot. This is why wide-format data is sometimes easier to use for matplotlib plots.

In contrast, when our data is in long-format, we can add plot elements by group with seaborn by setting the `hue` parameter to the grouping variable. Most plot functions include the `hue` parameter, and many also include the `style` parameter to differentiate groups by line or point style as well. Seaborn includes a legend by default, so there is no extra coding required to create and label the legend.

The following code creates a scatter plot of `sales_totals` versus `daily_customers`. We can group the points in different colors for each day of the week by setting `hue` to `weekday`.

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

By setting the `style` parameter to the grouping variable, the points will also be a different shape for each group. The `style` parameter makes the plot more visually accessible and is also a great alternative to `hue` for publishing in grayscale. The `size` parameter may also be used as a grouping parameter to change the point size by group.

The `hue` parameter can be used in most plot functions. The following code produces a line plot of average `sales` per `month` where each `location` has a line that is a unique color and pattern. We made all the lines thicker by setting the `linewidth` parameter to `3`.

```py
sns.lineplot(data=df, x='month', y='sales', hue='location', style='location', linewidth=3)
```

Adding the `hue` parameter in functions like `sns.histplot()`, `sns.kdeplot()`, and `sns.boxplot()` allows us to view the distributions of multiple groups. While there is no `style` parameter for these functions, we can adjust the `multiple` parameter for histograms and KDE plots.

Group with hue and style

To display summaries of our data visually, we often plot statistics like the mean. These statistics may be more or less precise. Frequently, we quantify this uncertainty through confidence intervals, which account for the spread and number of data points included in the computation of our summary statistic.

We can illustrate confidence intervals using features like error bars and shaded regions. For example, the `bar.plot()` function in seaborn automatically plots an error line on each bar of the plot. The line (called an **error bar**) has a length that represents a 95% confidence interval for that statistic. 

Additional parameters for the style of the error bars include color (`errcolor`), width (`errwidth`), and cap length (`capsize`). For example, we could use the following code to make a bar plot of mean `sales_totals` for each `server` with thick red error bars with long caps.

```py
sns.barplot(data=df, x='server', y='sales_totals', errcolor='red', errwidth=5, capsize=0.5)
```

We can also show confidence intervals on line plots using shaded regions. Seaborn's `line.plot()` function automatically plots shading for confidence intervals when the values are averages. The style can be changed from a shaded error band to vertical error bars using the `err_style` parameter as shown in the following code.

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

Let's create a couple of plots and adjust how the confidence intervals are displayed.