This lesson will cover the essential Matplotlib properties you need to get started with making two-dimensional graphs in Python! 

Line Graphs in Matplotlib

Eventually, we will want to show these plots to other people to convince them of important trends in our data. 
 When we do that, we’ll want to make our plots look as professional as possible.

The first step towards a professional-looking plot is adding labels to the x-axis and y-axis, and giving the plot a title. 

We can label the x- and y- axes by using `plt.xlabel()` and `plt.ylabel()`.
The plot title can be set by using `plt.title()`.

All of these commands require a string, which is a set of characters in either single (`'`) or double (`"`) quotes.
```py
"This is a string"
'This is also a string'

'This is NOT a string (the quotes do not match)"
```

For example, if someone has been keeping track of their happiness (on a scale out of 10) throughout the day and wants to display this information with labeled axes, we can use the following commands:
```py
hours = [9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
happiness = [9.8, 9.9, 9.2, 8.6, 8.3, 9.0, 8.7, 9.1, 7.0, 6.4, 6.9, 7.5]
plt.plot(hours, happiness)
plt.xlabel('Time of day')
plt.ylabel('Happiness Rating (out of 10)')
plt.title('My Self-Reported Happiness While Awake')
plt.show()
```

This will result in a labeled graph:

![axis_labels](https://content.codecademy.com/courses/matplotlib/axis_labels.png)

Now, you can try adding labels to plots of your own.


Labeling the Axes

When we have multiple lines on a single graph we can label them by using the command `plt.legend()`. 

The `legend` method takes a list with the labels to display.
So, for example, we can call:

```py
plt.plot([0, 1, 2, 3, 4], [0, 1, 4, 9, 16])
plt.plot([0, 1, 2, 3, 4], [0, 1, 8, 27, 64])
plt.legend(['parabola', 'cubic'])
plt.show()
```
which would display a legend on our graph, labeling each line:
![legend](https://content.codecademy.com/courses/matplotlib/legend.png)

 `plt.legend()` can also take a keyword argument `loc`, which will position the legend on the figure.  

These are the position values `loc` accepts:

| Number Code | String       |
|-------------|--------------|
| 0           | best         |
| 1           | upper right  |
| 2           | upper left   |
| 3           | lower left   |
| 4           | lower right  |
| 5           | right        |
| 6           | center left  |
| 7           | center right |
| 8           | lower center |
| 9           | upper center |
| 10          | center       |

**Note:** If you decide not to set a value for `loc`, it will default to choosing the "best" location.

For, example, we can call `plt.legend()` and set `loc` to `6`:

```py
plt.legend(['parabola', 'cubic'], loc=6)
plt.show()
```
which would move the legend to the left side of the graph:
![legend_loc](https://content.codecademy.com/courses/matplotlib/legend_loc.png)

Sometimes, it's easier to label each line as we create it.  If we want, we can use the keyword `label` inside of `plt.plot()`.  If we choose to do this, we don't pass any labels into `plt.legend()`.  For example:
```py
plt.plot([0, 1, 2, 3, 4], [0, 1, 4, 9, 16],
         label="parabola")
plt.plot([0, 1, 2, 3, 4], [0, 1, 8, 27, 64],
         label="cubic")
plt.legend() # Still need this command!
plt.show()
```

This would display a legend that looks just like what we had before:
![legend](https://content.codecademy.com/courses/matplotlib/legend.png)

Legends

We can also have multiple line plots displayed on the same set of axes. This can be very useful if we want to compare two datasets with the same scale and axis categories.

Matplotlib will automatically place the two lines on the same axes and give them different colors if you call `plt.plot()` twice.

Let's look at the graph we made in the last exercise to track lunch spending, where `days` is on the x-axis and spending (`money_spent`) is on the y-axis:

![money_spent](https://content.codecademy.com/courses/matplotlib/money_spent.png)

We could add a friend's lunch spending for comparison like this:

```py
# Days of the week:
days = [0, 1, 2, 3, 4, 5, 6]
# Your Money:
money_spent = [10, 12, 12, 10, 14, 22, 24]
# Your Friend's Money:
money_spent_2 = [11, 14, 15, 15, 22, 21, 12]
# Plot your money:
plt.plot(days, money_spent)
# Plot your friend's money:
plt.plot(days, money_spent_2)
# Display the result:
plt.show()
```

We then get two lines on the same plot:

![money_spent_2](https://content.codecademy.com/courses/matplotlib/money_spent_2.png)

By default, the first line is always blue, and the second line is always orange.  In the next exercise, we'll learn how to customize these lines ourselves.

Basic Line Plot II

Sometimes, we want to display two lines side-by-side, rather than in the same set of x- and y-axes.  When we have multiple axes in the same picture, we call each set of axes a *subplot*.  The picture or object that contains all of the subplots is called a *figure*.

We can have many different subplots in the same figure, and we can lay them out in many different ways.  We can think of our layouts as having rows and columns of subplots.  For instance, the following figure has six subplots split into 2 rows and 3 columns:
<img src="https://content.codecademy.com/courses/matplotlib/six_subplots.svg"></img>

We can create subplots using `.subplot()`.

The command `plt.subplot()` needs three arguments to be passed into it:
* The number of rows of subplots
* The number of columns of subplots
* The index of the subplot we want to create

For instance, the command `plt.subplot(2, 3, 4)` would create "Subplot 4" from the figure above.

Any `plt.plot()` that comes after ` plt.subplot()` will create a line plot in the specified subplot.  For instance:

```py
# Data sets
x = [1, 2, 3, 4]
y = [1, 2, 3, 4]

# First Subplot
plt.subplot(1, 2, 1)
plt.plot(x, y, color='green')
plt.title('First Subplot')

# Second Subplot
plt.subplot(1, 2, 2)
plt.plot(x, y, color='steelblue')
plt.title('Second Subplot')

# Display both subplots
plt.show()
```

This would result in a figure with the two plots arranged like this:

![subplots](https://content.codecademy.com/courses/learn-pandas/two_subplots.svg)


Subplots

We can specify a different color for a line by using the keyword `color` with either an <a href="https://www.w3schools.com/colors/colors_names.asp" target="_blank">HTML color name</a> or a <a href="https://www.w3schools.com/colors/colors_picker.asp" target="_blank">HEX code</a>:
```py
plt.plot(days, money_spent, color='green')
plt.plot(days, money_spent_2, color='#AAAAAA')
```

![money_colors](https://content.codecademy.com/courses/matplotlib/money_colors.png)

We can also make a line dotted or dashed using the keyword `linestyle`.
```py
# Dashed:
plt.plot(x_values, y_values, linestyle='--')
# Dotted:
plt.plot(x_values, y_values, linestyle=':')
# No line:
plt.plot(x_values, y_values, linestyle='')
```

We can also add a marker using the keyword `marker`:
```py
# A circle:
plt.plot(x_values, y_values, marker='o')
# A square:
plt.plot(x_values, y_values, marker='s')
# A star:
plt.plot(x_values, y_values, marker='*')
```


To see all of the possible options, check out the <a href="https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html#matplotlib.pyplot.plot" target="_blank">Matplotlib documentation</a>.
Here are a couple of those values applied to our plots about lunch spending:
```py
plt.plot(days, money_spent, color='green', linestyle='--')
plt.plot(days, money_spent_2, color='#AAAAAA',  marker='o')
```
![linestyles](https://content.codecademy.com/courses/matplotlib/linestyles.png)

Let’s get some practice with customizing lines on the same plot.

Linestyles

Now you’ve played around with several two-dimensional line plots in Matplotlib. You’ve seen how you can create simple, readable plots with few commands. You’ve also learned some commands to style and label your plots better.
These are the concepts you’ve seen in Matplotlib so far:

* Creating a line graph from data
* Changing the appearance of the line
* Zooming in on different parts of the axis
* Putting labels on titles and axes
* Creating a more complex figure layout
* Adding legends to graphs
* Changing tick labels and positions
* Saving what you've made

Moving on, we’ll learn how to make different kinds of plots (beyond line graphs!) in Matplotlib and how to choose between those plots when displaying data.

Let’s do a final round of practice with all of the cool plotting concepts you’ve learned so far!




Review

In all of our previous exercises, our commands have started with `plt.`.  In order to modify tick marks, we'll have to try something a little bit different.

Because our plots can have multiple subplots, we have to specify which one we want to modify.  In order to do that, we call `plt.subplot()` in a different way.
```py
ax = plt.subplot(1, 1, 1)
```
`ax` is an axes object, and it lets us modify the axes belonging to a specific subplot.  Even if we only have one subplot, when we want to modify the ticks, we will need to start by calling either `ax = plt.subplot(1, 1, 1)` or `ax = plt.subplot()` in order to get our axes object.

Suppose we wanted to set our x-ticks to be at 1, 2, and 4.  We would use the following code:
```py
ax = plt.subplot()
plt.plot([0, 1, 2, 3, 4], [0, 1, 4, 9, 16])
plt.plot([0, 1, 2, 3, 4], [0, 1, 8, 27, 64])
ax.set_xticks([1, 2, 4])
```
Our result would look like this:

![tick_marks](https://content.codecademy.com/courses/matplotlib/tick_marks.png)

We can also modify the y-ticks by using `ax.set_yticks()`.

When we change the x-ticks, their labels automatically change to match. But, if we want special labels (such as strings), we can use the command `ax.set_xticklabels()` or `ax.set_yticklabels()`. For example, we might want to have a y-axis with ticks at 0.1, 0.6, and 0.8, but label them 10%, 60%, and 80%, respectively. To do this, we use the following commands:

```py
ax = plt.subplot()
plt.plot([1, 3, 3.5], [0.1, 0.6, 0.8], 'o')
ax.set_yticks([0.1, 0.6, 0.8])
ax.set_yticklabels(['10%', '60%', '80%'])
```

This would result in this y-axis labeling:

![y_ticks](https://content.codecademy.com/courses/matplotlib/y_ticks.png)

Now, let’s practice with tick marks.


Modify Ticks

Sometimes, when we're putting multiple subplots together, some elements can overlap and make the figure unreadable:

![overlapping](https://content.codecademy.com/courses/matplotlib/overlapping_subplots.png)

We can customize the spacing between our subplots to make sure that the figure we create is visible and easy to understand. To do this, we use the `plt.subplots_adjust()` command. `.subplots_adjust()`  has some keyword arguments that can move your plots within the figure:
* `left` &mdash; the left-side margin, with a default of 0.125. You can increase this number to make room for a y-axis label
* `right` &mdash; the right-side margin, with a default of 0.9. You can increase this to make more room for the figure, or decrease it to make room for a legend
* `bottom` &mdash; the bottom margin, with a default of 0.1. You can increase this to make room for tick mark labels or an x-axis label
* `top` &mdash; the top margin, with a default of 0.9 
* `wspace` &mdash; the horizontal space between adjacent subplots, with a default of 0.2
* `hspace` &mdash; the vertical space between adjacent subplots, with a default of 0.2

For example, if we were adding space to the bottom of a graph by changing the bottom margin to 0.2 (instead of the default of 0.1), we would use the command:
```py
plt.subplots_adjust(bottom=0.2)
```

We can also use multiple keyword arguments, if we need to adjust multiple margins.  For instance, we could adjust both the `top` and the `hspace`:
```py
plt.subplots_adjust(top=0.95, hspace=0.25)
```

Let's use `wspace` to fix the figure above:

```py
# Left Plot
plt.subplot(1, 2, 1)
plt.plot([-2, -1, 0, 1, 2], [4, 1, 0, 1, 4])

# Right Plot
plt.subplot(1, 2, 2)
plt.plot([-2, -1, 0, 1, 2], [4, 1, 0, 1, 4])

# Subplot Adjust
plt.subplots_adjust(wspace=0.35)

plt.show()
```

This would give us figure with a better layout:

![fixed](https://content.codecademy.com/courses/matplotlib/fixed_subplots.png)


Subplots Part II

Sometimes, it can be helpful to zoom in or out of the plot, especially if there is some detail we want to address. To zoom, we can use `plt.axis()`. We use `plt.axis()` by feeding it a list as input. This list should contain:
1. The minimum x-value displayed
2. The maximum x-value displayed
3. The minimum y-value displayed
4. The maximum y-value displayed

For example, if we want to display a plot from `x=0` to `x=3` and from `y=2` to `y=5`, we would call `plt.axis([0, 3, 2, 5])`.

```py
x = [0, 1, 2, 3, 4]
y = [0, 1, 4, 9, 16]
plt.plot(x, y)
plt.axis([0, 3, 2, 5])
plt.show()
```

![axis_zoom](https://content.codecademy.com/courses/matplotlib/axis_zoom.png)

Axis and Labels

When we're making lots of plots, it's easy to end up with lines that have been plotted and not displayed. If we’re not careful, these "forgotten" lines will show up in your new plots. In order to be sure that you don't have any stray lines, you can use the command `plt.close('all')` to clear all existing plots before you plot a new one.

Previously, we learned how to put two sets of axes into the same figure.  Sometimes, we would rather have two separate figures.  We can use the command `plt.figure()` to create new figures and size them how we want. We can add the keyword `figsize=(width, height)` to set the size of the figure, in inches.  We use parentheses (`(` and `)`) to pass in the width and height, which are separated by a comma (`,`).

To create a figure with a width of 4 inches, and height of 10 inches, we would use:
```py
plt.figure(figsize=(4, 10))
```
It would look tall and skinny, like this:

![tall_fig](https://content.codecademy.com/courses/matplotlib/tall_fig.png)

Once we've created a figure, we might want to save it so that we can use it in a presentation or a website. We can use the command `plt.savefig()` to save out to many different file formats, such as `png`, `svg`, or `pdf`. After plotting, we can call `plt.savefig('name_of_graph.png')`:

```py
# Figure 2
plt.figure(figsize=(4, 10)) 
plt.plot(x, parabola)
plt.savefig('tall_and_narrow.png')
```
This will save `tall_and_narrow.png` to our file system.

Figures

Line graphs are helpful for visualizing how a variable changes over time.

Some possible data that would be displayed with a line graph:
* average prices of gasoline over the past decade
* weight of an individual over the past couple of months
* average temperature along a line of longitude over different latitudes

Using Matplotlib methods, the following code will create a simple line graph using `.plot()` and display it using `.show()` :
```py
x_values = [0, 1, 2, 3, 4]
y_values = [0, 1, 4, 9, 16]
plt.plot(x_values, y_values)
plt.show()
``` 


* `x_values` is a variable holding a list of x-values for each point on our line graph
* `y_values` is a variable holding a list of y-values for each point on our line graph
* `plt` is the name we have given to the Matplotlib  module we have imported at the top of the code
* `plt.plot(x_values, y_values)` will create the line graph
* `plt.show()` will actually display the graph

Our graph would look like this:

<img src=https://content.codecademy.com/courses/matplotlib/parabola.png style="top:100px">

Let’s get some practice with plotting lines.



Basic Line Plot

Demonstrative line chart with fake data. There are two lines on one graph. X-axis is "Amazing x-axis" and Y-axis is "Incredible y-axis."

Matplotlib is a Python library used to create charts and graphs.

In this first lesson, you will get an overview of the basic commands necessary to build and label a line graph. The concepts you will learn include:
* Creating a line graph from data
* Changing the appearance of the line
* Zooming in on different parts of the axis
* Putting labels on titles and axes
* Creating a more complex figure layout
* Adding legends to graphs
* Changing tick labels and positions
* Saving what you've made

By the end of the lesson, you’ll be well on your way to becoming a master at presenting and organizing your data in Python.

To the right, you can see an example of the kind of chart you'll be able to make by the end of this lesson!