Make bar charts, scatterplots, pie charts, and histograms using `matplotlib`. This is a followup to the Make A Line Chart lesson. 

Make the Other Charts

An animated GIF demonstrating the results of 4 graph functions and 4 general functions. The graph functions make a line chart, scatterplot, pie chart, and bar graph, respectively. The general functions make x and y-labels, a legend, annotations, and a title, respectively. 

Welcome to the next step in our `matplotlib` journey!

In this lesson, we will…
* Use graph functions to make a bar chart, scatterplot, pie chart and histogram
* Use general functions to add error bars, subplots, and AB lines to our charts

Here's a quick review of the five core plots we're learning:
* **line chart:** shows continuous change, often used to measure change over time _(covered in the Make A Line Chart lesson, not this lesson)_
* **bar chart:** uses bar height to compare a measure between categorical variables
* **scatterplot:** uses position to show the relationship, or correlation, between two numeric values 
* **pie chart:** shows us the breakdown of a whole into its parts
* **histogram:** shows how one kind of data is distributed

And a quick review of  **graph functions** and **general functions**:

**Graph functions** create charts, like a bar chart or pie chart. Inside the parentheses of the function, we put arguments that are specific to each kind of chart: for example, what color and weight to make each line of a line chart, which x and y values to use in a scatterplot or bar chart, or how big to make the bins in a histogram.

Almost all the other changes we can make in matplotlib are done _outside_ of the graph function. 

**General functions** allow us to change general aspects of a graph, like its title, legend, or axis scaling and labels. We call these general functions because they apply to all kinds of charts: for example, a scatterplot title is not different from a bar chart title. In both cases, a title would be added to a graph using `plt.title()` after the graph is made.


Review and Setup

Ah, the pie chart. It's a bit divisive in data visualization. Supporters say it's an intuitive way to visualize the breakdown of a whole into parts, and detractors say that it's clunky and likely to mislead people. 

Here at Codecademy, we just follow some best practices: pie charts work best for breakdowns of 2-8 parts, and they are only a good choice when the takeaway doesn't have to be too granular. People can't tell the difference between 18% and 20% when looking at a pie chart, but they can compare "about 30%" to "about 50%", for example. 

With those strengths and limitations in mind, how do we make a pie chart using matplotlib? We use the `plt.pie()` function! `plt.pie()` takes the following parameters:
* `x`: the numeric variable shown as pieces of the pie. The function adds up all the x values to compare part and whole and auto-generate the pieces of the pie.
* `labels`: the variable used to label each section of the pie chart
* `startangle`: the rotation of the pie chart, adjusted to improve readability
* `colors`: an array of colors the chart will cycle through. If blank, defaults to matplotlib's default 10-color "Tableau" palette.

`x` is the only required parameter here, but the others can all help make the pie chart more readable. A pie chart showing the five favorite donut flavors of conference attendees might be written with the following code:
```py
plt.pie(x = data.donut_vote_count, labels = data.donut_flavor, startangle = 30, colors = ['brown', 'pink', 'purple', 'white', 'red'])
```
The `startangle` may or may not need adjusting – generally, this depends on how the pie pieces (and subsequently their labels) are distributed. 


Make a pie chart

In data visualization, it's often helpful to compare multiple simple visualizations. As we saw in the last exercise, there were many Spotify categories to compare across genres, and viewing them as individual scatterplots _definitely_ made more sense than trying to fit them all into the same graph. 

Instead of scrolling between graphs, matplotlib also allows us to position plots in a grid using the **general function** for subplots: `plt.subplot()`. It takes the following parameters:
* num_rows: number of rows in the grid
* num_columns: number of columns in the grid
* index: the numbered position of the subplot, reading the grid from left-to-right, top-to-bottom

Organizationally, it's helpful to think of the `plt.subplot()` function as an introduction to the graph function and any general functions (like `title()`) that follow it, until the next subplot is introduced. 

Additionally, to add a single title at the top of all the subplots, we use the general function `plt.suptitle()` to add a super title.

To make a grid of 6 scatterplots, in two rows and three columns, with the plots colored in rainbow order, we could use the following code:
```py
plt.suptitle('Rainbow Scatterplots')
plt.subplot(2, 3, 1)
plt.scatter(x, y, color = red)
plt.subplot(2, 3, 2)
plt.scatter(x, y, color = orange)
plt.subplot(2, 3, 3)
plt.scatter(x, y, color = yellow)
plt.subplot(2, 3, 4)
plt.scatter(x, y, color = green)
plt.subplot(2, 3, 5)
plt.scatter(x, y, color = blue)
plt.subplot(2, 3, 6)
plt.scatter(x, y, color = purple)
```
Notice how all these subplots have the same first two numbers, (2, 3, __), since they're all part of the same 2-by-3 grid. Only the *index number* changes, indicating which subplot is being created. The grid would appear in this order:

![A grid of 6 identical scatterplots in 2 rows and 3 columns. From top left to bottom right, the plots are colored red, orange, yellow, green, blue and purple.](https://static-assets.codecademy.com/Courses/data-viz-with-python/rainbow-subplots-title.png)

These scatterplots all use the same data, so there's not much to compare. In this exercise, we'll use real data about the characteristics of Spotify genres: our goal will be to see if any of the variables have a correlation with the `popularity` variable. 

View in subplots

Let's check out another chart: the bar chart.

Bar charts use the length of bars to compare categorical data. For example, a bar chart could show the heights of different trial groups of pea plants, the GDPs of five countries, or the number of flu vaccines administered at a pharmacy each day in October.

The bar chart graph function is `plt.bar()`. It takes the following parameters:
- `x`: categorical data for each bar
- `height`: numeric data to determine the height of each bar
- `width`: a number we can pass in to set the width of each bar
- `align`: set to `'center'` or `'edge'` to align each bar on the x-axis

For example, for a bar chart comparing the yearly profits of 5 local businesses, our code might read:

```py
plt.bar(x = data.business_name, height = data.profit, width = 0.8, align = 'center')
```
We'll use general functions to add all the information that will make the graph readable. The code below demonstrates how we would add title and axis labels to the same graph. 

```py
plt.bar(x = data.business_name, height = data.profit, width = 0.8, align = 'center')
plt.title("Profits at 5 Businesses, 2021")
plt.xlabel("Business Name")
plt.ylabel("Profit ($)")
```
We'll practice making a bar chart in the Jupyter notebook. 


Make a bar chart

Let's explore another useful chart: the scatterplot. Scatterplots are great for directly comparing two continuous numeric variables, helping us to visualize the relationship or **correlation** between them. 

* If the points are scattered from bottom-left to top-right in the graph, we'd be able to say "As X increases, Y also increases." This indicates a **positive correlation**. 
* If the points are scattered from top-left to bottom-right in the graph, we'd be able to say "As X increases, Y decreases." This indicates a **negative correlation**.
* If the points are scattered in a horizontal line, we can say "As X increases, Y remains constant." This indicates **no correlation**. A cloud of scattered points with no clear directional grouping also indicates no correlation.

Closely grouped points in a line or curve are evidence of a stronger and more consistent relationship between the variables, while a looser cloud of points indicates a weaker relationship. 

With that in mind, how do we make a scatterplot in matplotlib? With the scatterplot graph function, of course! Use `plt.scatter()` with the following parameters:
* `x` and `y`: the continuous numeric variables to be compared
* `color`: marker color, as a color code, color name, or hex code
* `alpha`: marker opacity, as a number between 0 (transparent) and 1 (opaque)

Only `x` and `y` are required parameters, but adjusting the formatting of the markers helps make patterns in the graph more apparent. For scatterplots with many overlapping points, for example, adjusting the `alpha` to make semi-transparent points can turn the scatterplot from a unicolored blob into an effective heatmap. We can also adjust marker shape and size using the `marker` and `s` parameters, respectively. The default is a size 2 circle. 

Let's check out an example: suppose we have a dataset of tree measurements. We might expect increased age to also increase the trunk circumference (a positive correlation!) since trees get bigger as they get older. To visualize the relationship between age and tree trunk circumference, the following plot could be used:

```py
plt.scatter(data.tree_age, data.trunk_circumference, color='yellowgreen', alpha=0.5)
plt.title('Effect of Tree Age on Trunk Circumference in Red Oaks')
plt.ylabel('Trunk Circumference (cm)')
plt.xlabel('Tree Age (years)')
plt.show()
```
We'd expect to see a positive correlation, since we know that as oak trees get older, their trunks get thicker. Let's check out some music-related correlations in the Jupyter notebook.


Make a scatterplot

It's common to have some amount of uncertainty or imprecision in measurements, particularly in empirical measurements collected by observation. 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 visually represent this uncertainty by adding error bars to a graph. We'll use matplotlib's **general function** `plt.errorbar()`, which takes parameters for…
* `x` and `y`: restate the X and Y values of the underlying graph
* `yerr` and/or `xerr`: set error values in the X or Y direction
* `color`: set the color of the error bar (optional)
* `fmt`: change the marker 

`xerr` or `yerr` can be added as a column from the same dataframe that contains `x` and `y` data, or from a separate array. Error values are calculated using statistics -- exactly how it's done is outside the scope of this course, so we'll focus on implementing given error values. Say our local business profit dataset has a column of called `error_value` that gives an over/under amount for each business' profit. We can use that information to add error bars to the Profits graph like so:

```py
## make the bar graph
plt.bar(x = data.business_name, height = data.profit, width = 0.8, align = 'center')
plt.title("Profits at 5 Businesses, 2021")
plt.xlabel("Business Name")
plt.ylabel("Profit ($)")

## add the error bars 
plt.errorbar(x = data.business_name, y = data.profit, yerr = data.error_value, fmt='o', color='purple')
```
This will produce a bar graph with purple error bars that have circle markers. If instead, we added error bars from a separate array, the code would look like this:

```py
## make the bar graph
plt.bar(x = data.business_name, height = data.profit, width = 0.8, align = 'center')
plt.title("Profits at 5 Businesses, 2021")
plt.xlabel("Business Name")
plt.ylabel("Profit ($)")

## define the error array (one error measure for each business)
error_bars = [15, 35, 70, 25, 30]

## add the error bars from the array
plt.errorbar(x = data.business_name, y = data.profit, yerr = error_bars, fmt='o', color='purple')
```

In the Jupyter notebook, let's add error bars to the bar chart we made in the last exercise. 


Add error bars

On to the next chart: what if we want to understand how data is distributed? Matplotlib has a graph function for that, of course! Let's use `plt.hist()` to make a histogram, a graph that shows the spread of one variable of continuous data. 

`plt.hist()` takes the following parameters:
* `x`: the value being distributed (like shoe size, or height) – note that it should not be an aggregated value
* `bins`: specifies how many bins to make (e.g. 10) OR where the edges of the bins are (as a list of values)
* `range`: the lower and upper range of the bins. If unspecified, set to the min and max values for `x`
* `color`: sets the color of the bars

To make a histogram of women's shoe sales by size, with bins every half-size, we might use the code:
```py
plt.hist(x = df.shoe_size, bins = 12, range = (5, 12), color = 'dodgerblue')
```
The imaginary shoe size data spans from size 5.5 to 11.5, so this range will help the graph appear balanced and not squeezed. 

As with most of our other graph functions, only the data portion (`x`) is strictly necessary, but adjusting other parameters makes a much more useful graph. 

For this Jupyter exercise, our data comes from the cold waters of Maine, where lobster fishing is a crucial industry. There are minimum- and maximum-size regulations in place that limit which lobsters may be caught and which are thrown back into the ocean. Any lobster too small or too big is thrown back. Let's see if this human intervention in the population shows up in the size distribution of lobsters caught and tagged during a field experiment. 

Make a histogram

We've covered a lot! We learned about new **graph functions**…
* `plt.bar()` makes a bar chart
* `plt.scatter()` makes a scatterplot
* `plt.pie()` makes a pie chart
* `plt.hist()` makes a histogram

And some new **general functions**…
* `plt.errorbar()` adds error bars, or confidence intervals, to any kind of chart
* `plt.subplot()` allows us to compare graphs in a side-by-side or tiled format
* `plt.axline()` creates AB lines to mark reference lines on a graph
* `plt.annotate()` allows us to place annotations and arrows anywhere on a graph


Wrap up

In data visualization, it's important not to assume that the data speaks for itself. Occasionally, the conclusion of a graph is blatantly obvious at first glance. The majority of the time, however, even if the data visualization reveals valuable information, providing some guidance on how to read it is very helpful.

Let's do just that, and improve the histogram from our last exercise by adding AB lines and annotations. Both are added to matplotlib graphs using general functions. 

An **AB line** is a straight line added to a graph (i.e. "from point A to point B"). It can be vertical, horizontal, or diagonal. Generally, an AB line helps to demarcate one area from another or provide context that helps the viewer make sense of the data in the graph. In matplotlib, the function `plt.axvline()` makes a vertical AB line, and `plt.axhline()` makes a horizontal AB line. We'll work with `plt.axvline()`, which takes the following parameters:
* `x`: where to position the line along the x-axis
* `ymin`: how close to the bottom of the graph the line starts. Setting `ymin=0` starts the line at the bottom of the graph, `ymin=.5` would start it halfway up, and `ymin=1` would start at the top of the graph. Usually set to 0
* `ymax`: how close to the bottom of the graph the line ends. Setting `ymax=0` ends the line at the bottom of the graph, `ymax=.5` would end it halfway up, and `ymax=1` would end at the top of the graph. Usually set to 1
* `linewidth`: line width of the AB line
* `dashes`: dash pattern given as (`line_length`, `space_length`)
* `color`: color of the AB line

`plt.axhline()` functions exactly the same, but with `y`, `xmin`, and `xmax`  parameters to determine position. 

For example, the following code could be used to make a horizontal AB line for "mastery" on a bar graph of test scores out of 100.

```py
plt.bar( x = school_subject, y = test_score)
plt.axhline(y = 85, xmin = 0, xmax = 1, linewidth = 2, color = red)
```

We can easily add **annotations** to a graph (or label an AB line) using `plt.annotate()`, which allows us to position and format text on a graph. To split an annotation over two or more lines, we can simply add line breaks to the annotation `text` using `\n`.

`plt.annotate()` takes the following arguments:
* `text`: annotation text
* `xy`: (x, y) coordinate position for annotation
* `color`: color of annotation text and arrow