# Introduction to PyPlot

Hey - Nick here! This page is a free excerpt from my \$199 course Python for Finance, which is 50% off for the next 50 students.

In this lesson, we will discuss the fundamentals of the pyplot framework in matplotlib.

## The Imports For This Lesson

For this lesson, we will need to run our standard matplotilb import as well as the magic function that allows us to display plots within the Jupyter Notebook:

``````import matplotlib.pyplot as plt

%matplotlib inline``````

I will also run the command to set my display to 'Retina Mode':

``````from IPython.display import set_matplotlib_formats

set_matplotlib_formats('retina')``````

Lastly, we will import the NumPy numerical computing library:

``import numpy as np``

## Pyplot's Stateful Interface

Pyplot operates using what is called a `stateful interface`. This is essentially a fancy term that means that you can change the state of a plot after it is created.

In practice, this means that we generally create a plot in one step, and then modify the plot over time using a series of additional steps until it has the appearance and characteristics that we desire.

To see an example of this, let's create three random datasets using NumPy's `randn` function:

``````data1 = np.random.randn(10)

data2 = np.random.randn(10)

data3 = np.random.randn(10)``````

Note that since `randn` is a random number generator, each of these data sets will be different despite being generated using the same command.

Now let's plot each of these datasets using the `plt.plot()` method that we used earlier in this course. To do this, simply run multiple `plt.plot()` methods one after the other, like this:

``````plt.plot(data1)

plt.plot(data2)

plt.plot(data3)``````

Here's the output of that code (note that your plot may look slightly different since your randomly-generated datasets will be different than mine): This is an excellent example of pyplot's stateful interface - instead of trying to plot all three data sets on one line, you can plot them one-by-one onto the same canvas.

The same principle applies with other plot characteristics like titles and axis labels. You can use the `title`, `xlabel`, and `ylabel` methods to places titles on your chart:

``````plt.plot(data1)

plt.plot(data2)

plt.plot(data3)

plt.title("Some randomly generated datasets")

plt.xlabel("These are the x labels")

plt.ylabel("These are the y labels")``````

Here is the new output of this code: ## Pyplot's Interactive Mode

Pyplot has an attribute called `interactive mode` that changes whether a plot is displayed after modifying it.

When `interactive mode` is turned on, the plot is displayed whenever it is modified. You can turn interactive mode on using `plt.ion()`.

When `interactive mode` is turned off, the plot is not displayed whenever it is modified. In this case, you would display the plot using the `plt.show()` method. You can turn interactive mode off using `plt.ioff`.

If you are not sure whether or not you are currently operating in `interactive mode`, you can test this using `plt.isinteractive()`. It will return `True` if `interactive mode` is enabled and `False` if `interactive mode` is disabled.

If you test this in your Jupyter Notebook, you will notice that your plots will still display even if `interactive mode` is disabled. This is because of the `%matplotlib inline` command we executed at the beginning of this lesson.

You can disabled this forced plot display by executing the following code:

``````shell = get_ipython()

from ipykernel.pylab.backend_inline import flush_figures

shell.events.unregister('post_execute', flush_figures)``````

## Moving On

In this lesson, we learned about the basics of matplotlib's pyplot interface. After working through some practice problems in the next section, we will explore pyplot's `plot` method in more detail.