Figure Object

Now that we've seen the basics, let's break it all down with a more formal introduction of Matplotlib's Object Oriented API. This means we will instantiate figure objects and then call methods or attributes from that object.

The main idea in using the more formal Object Oriented method is to create figure objects and then just call methods or attributes off of that object. This approach is nicer when dealing with a canvas that has multiple plots on it.

To begin we create a figure instance. Then we can add axes to that figure. We manually have to set the axes position and size.

fig = plt.figure() # construct a figure object
axes = fig.add_axes([0.1,0.1,0.8,0.8]) #left, bottom, width, height  
axes.set_xlabel('X Label')
axes.set_ylabel('Y Label')
axes.set_title('Title')
axes.plot(x,y)

Multi-Plots on the Same Canvas

fig = plt.figure()
axes1 = fig.add_axes([0.1,0.1,0.8,0.8]) # main axes
axes2 = fig.add_axes([0.2,0.5,0.4,0.3]) # insert axes

# Larger Figure Axes 1
axes1.set_title('Larger Plot')
axes1.plot(x,y)

# Insert Figure Axes 2
axes2.set_title('Smaller Plot')
axes2.plot(y,x,'r--')

Subplots

The plt.subplots() object is an automatic axis manager built on top of plt.figure(). It is used similar to plt.figure() except it uses tuple unpacking to grab fig and axes. Using subplots the position and size of the axes are automatically set (though we can modify these if needed).

fig, axes = plt.subplots()

# Now use the axes object to add stuff to plot
axes.plot(x, y, 'r')
axes.set_xlabel('x')
axes.set_ylabel('y')
axes.set_title('title');

The number of columns and rows can be specified when creating the subplots() object.

# Empty canvas of 1 by 2 subplots
fig, axes = plt.subplots(nrows=2, ncols=3)

Notice the plots are fairly cramped, to relax the layout use the plt.tight_layout() or fig.tight_layout() command.

# Empty canvas of 1 by 2 subplots
fig, axes = plt.subplots(nrows=2, ncols=3)
fig.tight_layout() # or use plt.tight_layout()

The axes object returned by the subplots() method is an array, we can iterate through this array.

fig, axes = plt.subplots(nrows=1, ncols=2)

for ax in axes:
    ax.plot(x, y, 'g')
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.set_title('title')

fig.tight_layout()

Figure Size, Aspect Ration, and DPI

Matplotlib allows the aspect ratio, DPI and figure size to be specified when the Figure object is created. You can use the figsize and dpi keyword arguments.

• figsize is a tuple of the width and height of the figure in inches
• dpi is the dots-per-inch (pixel per inch).

For example:

fig = plt.figure(figsize=(8,4), dpi=100)

The same arguments can also be passed to layout managers, such as the subplots function:

fig, axes = plt.subplots(figsize=(12,3))

axes.plot(x, y, 'r')
axes.set_xlabel('x')
axes.set_ylabel('y')
axes.set_title('title');

Here is an example of two subplots.

fig, axes = plt.subplots(figsize=(12,3),nrows=1, ncols=2)

axes[0].plot(x, y, 'g')
axes[0].set_xlabel('x')
axes[0].set_ylabel('y')
axes[0].set_title('First')

axes[1].plot(y, x, 'b-*')
axes[1].set_xlabel('x')
axes[1].set_ylabel('y')
axes[1].set_title('Second')

Saving Figures

Matplotlib can generate high-quality output in a number formats, including PNG, JPG, EPS, SVG, PGF and PDF.

To save a figure to a file we can use the savefig method in the Figure class:

fig.savefig("filename.png")

Here we can also optionally specify the DPI and choose between different output formats:

fig.savefig("filename.png", dpi=200)

Legends, Labels, and Titles

Now that we have covered the basics of how to create a figure canvas and add axes instances to the canvas, let's look at how decorate a figure with titles, axis labels, and legends.

A title can be added to each axis instance in a figure. To set the title, use the set_title method in the axes instance. See examples above.

Similarly, with the methods set_xlabel and set_ylabel, we can set the labels of the X and Y axes.

# ax is an axes object in the plt.subplots() object
ax.set_title('title')
ax.set_xlabel('x')
ax.set_ylabel('y')

You can use the label="label text" keyword argument when plots or other objects are added to the figure, and then using the legend method without arguments to add the legend to the figure:

fig = plt.figure()

ax = fig.add_axes([0,0,1,1])

ax.plot(x, x**2, label=r"$y=x^2$") # latex style text formatting
ax.plot(x, x**3, label=r"$y=x^3$") # latex style text formatting
ax.legend()

The legend function takes an optional keyword argument loc that can be used to specify where in the figure the legend is to be drawn. The allowed values of loc are numerical codes for the various places the legend can be drawn. See the documentation page for details. Some of the most common loc values are:

# Lots of options....

ax.legend(loc=0) # let matplotlib decide the optimal location
ax.legend(loc=1) # 'upper right' corner
ax.legend(loc=2) # 'upper left' corner
ax.legend(loc=3) # 'lower left' corner
ax.legend(loc=4) # 'lower right' corner

# .. many more options are available including a 2-tuple for
# the lower left corner of the legend

# Most common to choose
ax.legend(loc=4) # let matplotlib decide the optimal location
fig

Setting Colours, Linewidths, Linetypes

Matplotlib gives you a lot of options for customizing colours, linewidths, and linetypes.

There is the basic MATLAB like syntax (which I would suggest you avoid using for clairty sake).

With matplotlib, we can define the colors of lines and other graphical elements in a number of ways. First of all, we can use the MATLAB-like syntax where 'b' means blue, 'g' means green, etc. The MATLAB API for selecting line styles are also supported: where, for example, 'b.-' means a blue line with dots:

# recall
x = np.linspace(0,5,11)
# MATLAB style line color and style
fig, ax = plt.subplots()
ax.plot(x, x**2, 'b.-') # blue line with dots
ax.plot(x, x**3, 'g--') # green dashed line

We can also define colors by their names or RGB hex codes and optionally provide an alpha value using the color and alpha keyword arguments. Alpha indicates opacity.

# using color= parameter
fig, ax = plt.subplots()

ax.plot(x, x+1, color="blue", alpha=0.5) # half-transparant
ax.plot(x, x+2, color="#8B008B")        # RGB hex code
ax.plot(x, x+3, color="#FF8C00")        # RGB hex code

To change the line width, we can use the linewidth or lw keyword argument. The line style can be selected using the linestyle or ls keyword arguments.

fig, ax = plt.subplots(figsize=(12,6))

ax.plot(x, x+1, color="red", linewidth=0.25)
ax.plot(x, x+2, color="red", linewidth=0.50)
ax.plot(x, x+3, color="red", linewidth=1.00)
ax.plot(x, x+4, color="red", linewidth=2.00)

# possible linestyle options '-', '-.', ':', 'steps'
ax.plot(x, x+5, color="green", lw=3, linestyle='-')
ax.plot(x, x+6, color="green", lw=3, ls='-.')
ax.plot(x, x+7, color="green", lw=3, ls=':')

# custom dash
line, = ax.plot(x, x+8, color="black", lw=1.50)
line.set_dashes([5, 10, 15, 10]) # format: line length, space length, ...

# possible marker symbols: marker = '+','o','*','s',',','.',1,2,3,4
ax.plot(x, x+ 9, color="blue", lw=3, ls='-', marker='+')
ax.plot(x, x+10, color="blue", lw=3, ls='--', marker='o')
ax.plot(x, x+11, color="blue", lw=3, ls='-', marker='s')
ax.plot(x, x+12, color="blue", lw=3, ls='--', marker='1')

# marker size and color
ax.plot(x, x+13, color="purple", lw=1, ls='-', marker='o', markersize=2)
ax.plot(x, x+14, color="purple", lw=1, ls='-', marker='o', markersize=4)
ax.plot(x, x+15, color="purple", lw=1, ls='-', marker='o', markersize=8,
  markerfacecolor="red")
ax.plot(x, x+16, color="purple", lw=1, ls='-', marker='s', markersize=8,
 markerfacecolor="yellow", markeredgewidth=3,
 markeredgecolor="green")

Plot Range

We can configure the ranges of the axes using the set_ylim and set_xlim methods in the axis object, or axis('tight') for automatically getting "tightly fitted" axes ranges.

fig, axes = plt.subplots(1, 3, figsize=(12, 4))

axes[0].plot(x, x**2, x, x**3)
axes[0].set_title("default axes ranges")

axes[1].plot(x, x**2, x, x**3)
axes[1].axis('tight')
axes[1].set_title("tight axes")

axes[2].plot(x, x**2, x, x**3)
axes[2].set_ylim([0, 60])
axes[2].set_xlim([2, 5])
axes[2].set_title("custom axes range");

Special Plot Types

There are many specialized plots we can create, such as barplots, histograms, scatter plots, and much more. Most of these type of plots we will actually create using seaborn, a statistical plotting library for Python. But here are a few examples of these type of plots with Matplotlib.

plt.scatter(x,y)

from random import sample
data = sample(range(1, 1000), 100)
plt.hist(data)

data = [np.random.normal(0, std, 100) for std in range(1, 4)]

# rectangular box plot
plt.boxplot(data,vert=True,patch_artist=True);