This is the third lesson on matplotlib, covering strategies and techniques for building a visual argument. 

Making a Visual Argument

Charts and data visualizations help us to make sense of the world around us. They are most helpful when we can connect what we see on the page or screen to our everyday understanding of the world. 

We can make that connection easier by picking a chart that, whenever possible, leans on the audience’s real-world interaction with the data. For example, consider whether your data is better suited to a horizontal or vertical presentation. Simply changing the orientation of a chart can have a big impact on its readability – check out this example with two boxplots:

A boxplot of finishing times for a half-marathon makes most sense as a horizontal box plot, since linear time is often visualized horizontally from left to right (and distance is a “horizontal” measure). 

A box plot of women’s heights, on the other hand, makes sense visualized as a vertical box plot, since we measure standing height as a vertical measure.

No matter the type of chart, this simple choice can help to start the viewer off on the right foot. 

In the Jupyter notebook, we’re going to visualize the average tree heights of the five most common plant families in our dataset. We’ll visualize both the `crown_base` height (the trunk) and the `depth_crown` (the leafy part). What do you think will be the clearest way to communicate that visually?



Choose the right chart for the data

We just talked about the advantages of displaying multiple plots next to each other. One common challenge with subplots–as we saw in the last exercise– is getting the graphs _and_ their axes, labels, titles, and legends to display nicely. Luckily, the function `plt.figure()` can help us out.  

We can adjust any **single graph** in a subplot using its respective code – adding `xlabel` or `title` as usual, for example. We can make changes to the **whole grid** by defining the space around the subplots as a **“figure”** using matplotlib’s general function `plt.figure()`, like so:

```py
fig = plt.figure()
```

`plt.figure` can take parameters, including:
* `figsize`: adjusts the dimensions of the figure
* `tight_layout`: adjusts the spacing of plots for an automated “best fit” with a Boolean
* `facecolor`: sets the background color

```py
fig = plt.figure(figsize = (10, 4), tight_layout = True, facecolor=’lightgray’)
```

`fig`, the instance we’ve defined of `plt.figure`, also has its own methods, including:
* `suptitle()`: adds a centered title at the top of all subplots, with font size and spacing parameters
* `supxlabel()`: adds an xlabel to all plots
* `supylabel()`: adds a ylabel to all plots
* `subplots_adjust(hspace, wspace)`: manually adjusts spacing around plots

```py
fig.suptitle(‘Six line graphs’, fontsize=24, x=0.45, y=0.95)
fig.supxlabel(‘Time’)
fig.subplots_adjust(hspace = 0.5, wspace = 0.25)
```
These functions are helpful for uncluttering the figure when a single title or label applies to multiple subplots, or when graphs need more padding to prevent crowded labeling. 

Let’s return to the subplots we made in the last exercise and see if we can make them visually cleaner.

Clean up subplots

Annotations are one of the most helpful tools for building a strong visual argument. While it may seem like “the data should speak for itself” or that a visualization should be obvious with no textual help, this is far from the truth. 

Viewers almost always need and appreciate annotations to add depth and value to their understanding of a data visualization. 

Even though we _add_ annotations to a graph, good annotations can actually be one of the best ways to _reduce_ clutter and keep graphs clean – because of what they allow us to drop elsewhere. Depending on the graph, annotations can replace legends, axes labels, or paragraphs of description outside the graph.

And adding annotations is relatively simple: we can use `plt.annotate()`, and pass in parameters for `text` and `(xy)` position. 

```py
plt.annotate(‘Look at this point!’, (15, 35))
```

`plt.annotate()` also takes many more parameters for more detailed annotations, including:
* `fontsize` and `color`
* `ha` and `va` to set horizontal and vertical alignment
* `backgroundcolor`

In this exercise, we’ll use annotations to replace our x-axis labels and improve our use of space and make the figure appear less crowded. 

Add annotations (pt. I)

Finally, a crucial component to a strong visual argument is to help the audience understand **why the visualization matters**. Why is the takeaway from the graph relevant, interesting, or noteworthy? Often, even a single sentence of context can make a world of difference to the strength of the argument. 

While this is a critical skill for presenting data visualizations, it generally requires no coding. Instead, we’ll use our skills of analysis and communication to explain – simply and clearly – what the visualization means. 

As a reminder, here’s the context for our graph:
* Primary forests are forests that have had no human intervention.
* Secondary forests are regrowth forests that have been previously clear-cut or otherwise majorly disrupted by human activity such as logging. 
* Selectively Logged Forests are forests that are managed with limited extraction.

The crucial takeaway for this graph: How do different human interventions, or _no_ human interventions, impact the number and diversity of tree species in different types of Tapajos Forests?

We don’t have to answer _all parts_ of this large and complex question, but providing a starting place for the viewer to start drawing their own conclusions from the graph is super helpful. 


Present the graph with context

We know how to set colors in matplotlib using the `color` parameter for each graph, but how do we use color to advance an argument? 

The right color choices will:
* make the visualization easier to understand
* draw attention to the graph’s key takeaway(s)
* add emphasis, not distraction

While matplotlib has limited built-in ability to assign colors based on the data, there’s a relatively simple workaround for applying color in a data-driven way. By adding a `color_label` column to the dataframe, we can programmatically and flexibly add color to a matplotlib graph. Adding a column to a dataframe is outside the scope of this course, however, it can be done…
* manually by directly editing a spreadsheet in Excel, Google Sheets, etc.
* programmatically using `pandas`

(If you’re curious to see how we set up the dataframe for this exercise using `pandas`, check out the commented code in our `data_manipulation` Jupyter notebook.)

As we’ll see in the Jupyter notebook, some tree types (the top 5 in each kind of forest) will have a corresponding “emphasis” color assigned to them. All the others will be colored `lightgray`. 

Why? Using a different color for every tree genus would be just as hard to understand as leaving them all gray. Instead, we’ll use color strategically. 

Once this is done, we can simply set `plt.bar()`’s `color` parameter equal to the `color_label` column of our dataframe. On to the notebook to try it out!

Use color for emphasis

Not only can subplots help us fit graphs nicely onto a page, the arrangement of graphs in a subplot can _also_ be used as a tool to make a clearer visual argument. 

* **Side-by-side** charts allow us to quickly compare y-axis (vertical) changes. This is often the best presentation for direct comparisons of similar charts, especially when the x-axis is consistent.

* **Stacked** charts allow for easy comparison of changes on the x-axis (horizontal).

* A **tiled grid** creates a setup known as “small multiples”. This is ideal for showing a pattern between multiple visualizations, or emphasizing one visualization in the context of others. 

With any setup, we should **keep the scale and axis-bounds the same whenever possible** so that the graphs can be compared directly. If that’s not possible, we need to make sure the viewer knows what’s being changed between each graph. Graphs can become **confusing or even misleading** if the scale, axes, or units are changed without explicit notice. Titles, annotations, or axis-labels are good places to put this information. 

To make these subplot arrangements, we use the `plt.subplot()` function, which takes parameters for `row`, `column`, and `index` (i.e. position in the grid). For example, the code below makes a grid with 4 rows and 2 columns (so, 8 squares), and will “select” the sixth square in the grid:

```py
plt.subplot(4, 2, 6)
## code for plot #6 goes here
```
![Diagram of a subplot code.](https://static-assets.codecademy.com/Courses/data-viz-with-python/mpl-subplot-diagram.svg)

Let’s put some of these to work on our dataset now. Again, we’ll load the tree inventory dataset, and subsets of relevant information. This time, the trees are subsetted by forest type: `PF` (primary forest), `SF` (secondary forest), and `SLF` (selectively logged forest). We’ll use multiple vertical bar charts to compare the counts of the most common trees in each forest type. Our goal for the next few visualizations is to **better understand biodiversity in the three different types of forest**.


Use subplots to compare multiple charts

As we just saw, adding annotations is relatively simple: we can use `plt.annotate()`, and pass in parameters for `text` and `(xy)` position. To recap: 

```py
plt.annotate(‘Look at this point!’, (15, 35))
```

`plt.annotate()` also takes many more parameters for more detailed annotations, including:
* `fontsize` and `color`
* `ha` and `va` to set horizontal and vertical alignment
* `backgroundcolor`

We can also use `plt.annotate()` to add arrows to a graph, with the following parameters:
* `arrowprops` to style an arrow from the annotation to a point
* `xytext` to reposition the text, if an arrow is used – the arrowhead will automatically be positioned at `(xy)`

Heads up: `arrowprops` is a dictionary of parameters – so we’ll actually end up with a list of `arrowprops` parameters nested inside our list of `plt.annotate` parameters. 

```py
plt.annotate('Look at this point!', xy=(15, 35), xytext=(17, 40), fontsize=14, color='blue', arrowprops=dict(arrowstyle= '-|-|>', color='blue'))

```

In this exercise, we’ll further improve our species count graph by using annotations to highlight a few tree genuses of interest. 

Add annotations (pt. II)

All design choices impact how a viewer will understand a data visualization. Even the simplest visualizations have an argument, a thesis, or a central point — and the design choices we make (or ignore) can have a positive or negative effect on getting that point across. 

For the goal of creating more readable and understandable visualizations, there are some simple, effective tools at our disposal in matplotlib. Here are 6 strategies we’ll learn for making a strong, clear visual argument:

* choose the right chart
* use subplots to compare multiple graphs
* remove distracting lines (i.e., chartjunk)
* use color for emphasis
* add annotations to the graph
* present the graph with context

In this lesson, we’ll work with a dataset that catalogs trees around the Tapajós River, a tributary of the Amazon River that runs through the Amazon Rainforest. Some preliminary data manipulation has been done for you to aggregate and organize the data for our purposes. (This is a crucial step in most data visualization processes, and a great reason to become familiar with the `pandas` library! You can check out the other notebook in this folder if you want to see how we organized the data using `pandas`.) Use the Jupyter notebook to the right to explore the data, and then we’ll dive into making some visualizations in the next exercise! 
