We've going to use a set of demonstration libraries that we included with this notebook to extract and manipulate the automobile maker data. Like we did before, we will take advantage of the power provided by the Pandas statistical analysis library. Let's load our modules by using the following code:

In [10]: import sys
         sys.path.append("../lib")
         import demodata, demoplot

As you can see in the IPython Notebook, there's more data there than what we need for the subplotting tasks. Let's created a limited set by using the following code:

In [11]: limited_data = demodata.get_limited_data()
         limited_data.head()
Out[11]:

The following table is obtained as a result of the preceding command:

This has provided us with the full set of data minus the columns that we don't care about right now. However, we want to apply an additional constraint—we want to exclude auto manufacturers that have fewer than six rows in our dataset. We will do so with the help of the following command:

In [16]: data = demodata.get_limited_data(lower_bound=6)

We've got the data that we want, but we still have some preparations left to do. In particular, how are we going to compare data of different scales and relationships? Normalization seems like the obvious answer, but we want to make sure that the normalized values compare appropriately. High losses and a high riskiness factor are less favorable, while a higher number of miles per gallon is more favorable. All this is taken care of by the following code:

In [19]: normed_data = data.copy()
         normed_data.rename(
             columns={"horsepower": "power"}, inplace=True)
In [20]: demodata.norm_columns(
             ["city mpg", "highway mpg", "power"], normed_data)
In [21]: demodata.invert_norm_columns(
             ["price", "weight", "riskiness", "losses"],
             normed_data)

What we did in the preceding code was make a copy of the limited data that we've established as our starting point, and then we updated the copied set by calling two functions—the first function normalized the given columns whose values are more favorable when higher, and the other function inverted the normalized values to match the first normalization (as their pre-inverted values are more favorable when lower). We now have a normalized dataset in which all the values are more favorable when higher.

If you would like to have more exposure to Pandas in action, be sure to view the functions in the demodata module. There are several useful tricks that are employed there to manipulate data.

Before jumping into subplots, let's take a look at a few individual plots for our dataset that will be included as subplots. The first one that we will generate is for the automobile price ranges:

In [22]: figure = plt.figure(figsize=(15, 5))
         prices_gs = mpl.gridspec.GridSpec(1, 1)
         prices_axes = demoplot.make_autos_price_plot(
             figure, prices_gs, data)
         plt.show()

Note that we didn't use the usual approach that we had taken, in which we get the figure and axes objects from a call to plt.subplots. Instead, we opted to use the GridSpec class to generate our axes (in the make_autos_price_plot function). We've done this because later, we wish to use GridSpec to create our subplots.

Here is the output that is generated from the call to plt.show():

Keep in mind that the preceding plot is a bit contrived (there's no inherent meaning in connecting manufacturer maximum, mean, and minimum values). Its sole purpose is to simply provide some eye candy for the subplot that we will be creating. As you can see from the instantiation of GridSpec, this plot has one set of axes that takes up the entire plot. Most of our individual plots will have the same geometry. The one exception to this is the radar plot that we will be creating.

Radar plots are useful when you wish to compare normalized data to multiple variables and populations. Radar plots are capable of providing visual cues that reveal insights instantly. For example, consider the following figure:

The preceding figure shows the data that was consolidated from several 1985 Volvo models across the dimensions of price, inverse losses to insurers, inverse riskiness, weight, horsepower, and the highway and city miles per gallon. Since the data has been normalized for the highest values as the most positive, the best scenario would be for a manufacturer to have colored polygons at the limits of the axes. The conclusions that we can draw from this is this—relative to the other manufacturers in the dataset, the 1985 Volvos are heavy, expensive, and have a pretty good horsepower. However, where they really shine is in the safety for insurance companies—low losses and a very low risk (again, the values that are larger are better). Even Volvo's minimum values are high in these categories. That's one manufacturer. Let's look at the whole group:

In [27]: figure = plt.figure(figsize=(15, 5))
         radar_gs = mpl.gridspec.GridSpec(
             3, 7, height_ratios=[1, 10, 10], wspace=0.5
0,
             hspace=0.60, top=0.95, bottom=0.25)
         radar_axes = demoplot.make_autos_radar_plot(
             figure, radar_gs, normed_data)
         plt.show()

The following table is obtained as a result of the preceding code:

There are interesting conclusions to the graph from this view of the data, but we will focus on the code that generated it. In particular, note the geometry of the grid—three by seven. What does this mean and how are we going to use it? We have two rows of six manufacturers. However, we added an extra row for an empty (and hidden) axis. This is used at the top for the overall title. We then added an extra column for the legend, which spans two rows. This brings us from a grid of two by six to a grid of three by seven. The remaining 12 axes in the grid are populated with a highly customized polar plot, giving us the radar plots for each of the manufacturers.

This example was included not only because it's visually compelling, but also because it will show how flexible the grid specification system for matplotlib is when we put them together. We have the ability to place plots within plots.

We've seen a small aspect of the GridSpec usage. This has been a tiny warm-up exercise compared to what's coming! Let's refresh with the ASCII sketch of the subplots that we wanted to create. Flip back to that page and look at the layout. We have three axes that will be stretching all the way across the title, price ranges, and the MPG data at the bottom. The three riskiness or losses plots will then be placed on the left-hand side in the middle of the page, and the radar plots will take the other half of that part of the plot on the right-hand side.

We can plot what this will look like before adding any of the data, just by creating the grid and subplot specification objects. The following may look a bit hairy, but keep in mind that when splicing the subplot specs, you're using the same technique that was used when splicing the NumPy array data:

In [28]: figure = plt.figure(figsize=(10, 8))
         gs_master = mpl.gridspec.GridSpec(
             4, 2, height_ratios=[1, 2, 8, 2])
         # Layer 1 - Title
         gs_1 = mpl.gridspec.GridSpecFromSubplotSpec(
             1, 1, subplot_spec=gs_master[0, :])
         title_axes = figure.add_subplot(gs_1[0])
         # Layer 2 - Price
         gs_2 = mpl.gridspec.GridSpecFromSubplotSpec(
             1, 1, subplot_spec=gs_master[1, :])
         price_axes = figure.add_subplot(gs_2[0])
         # Layer 3 - Risks & Radar
         gs_31 = mpl.gridspec.GridSpecFromSubplotSpec(
             2, 2, height_ratios=[2, 1],
             subplot_spec=gs_master[2, :1])
         risk_and_loss_axes = figure.add_subplot(gs_31[0, :])
         risk_axes = figure.add_subplot(gs_31[1, :1])
         loss_axes = figure.add_subplot(gs_31[1:, 1])
         gs_32 = mpl.gridspec.GridSpecFromSubplotSpec(
             1, 1, subplot_spec=gs_master[2, 1])
         radar_axes = figure.add_subplot(gs_32[0])
         # Layer 4 - MPG
         gs_4 = mpl.gridspec.GridSpecFromSubplotSpec(
             1, 1, subplot_spec=gs_master[3, :])
         mpg_axes = figure.add_subplot(gs_4[0])
         # Tidy up
         gs_master.tight_layout(figure)
         plt.show()

In the preceding code, when we instantiated GridSpec, we provided a geometry of four rows and two columns. We then passed the data for the height ratios so that each row will have an appropriate size that is relative to the others. In the section at the middle, for the risk and radar plots, we gave a geometry of two rows and two columns, and again passed the height ratios that provide the proportions we desire. This code results in the following plot:

That's exactly what we were aiming for. Now, we're ready to start adding individual plots. The code that generated the preceding skeleton plot differs from the final result in the following three key ways:

Here is the code that inserts all the individual plots into their own subplots:

In [29]: figure = plt.figure(figsize=(15, 15))
         gs_master = mpl.gridspec.GridSpec(
             4, 2, height_ratios=[1, 24, 128, 32], hspace=0,
             wspace=0)

         # Layer 1 - Title
         gs_1 = mpl.gridspec.GridSpecFromSubplotSpec(
             1, 1, subplot_spec=gs_master[0, :])
         title_axes = figure.add_subplot(gs_1[0])
         title_axes.set_title(
             "Demo Plots for 1985 Auto Maker Data",
             fontsize=30, color="#cdced1")
         demoplot.hide_axes(title_axes)

         # Layer 2 - Price
         gs_2 = mpl.gridspec.GridSpecFromSubplotSpec(
             1, 1, subplot_spec=gs_master[1, :])
         price_axes = figure.add_subplot(gs_2[0])
         demoplot.make_autos_price_plot(
             figure, pddata=data, axes=price_axes)

         # Layer 3, Part I - Risks
         gs_31 = mpl.gridspec.GridSpecFromSubplotSpec(
             2, 2, height_ratios=[2, 1], hspace=0.4,
             subplot_spec=gs_master[2, :1])
         risk_and_loss_axes = figure.add_subplot(gs_31[0, :])
         demoplot.make_autos_loss_and_risk_plot(
            figure, pddata=normed_data,
            axes=risk_and_loss_axes, x_label=False,
            rotate_ticks=True)
         risk_axes = figure.add_subplot(gs_31[1, :1])
         demoplot.make_autos_riskiness_plot(
             figure, pddata=normed_data, axes=risk_axes,
             legend=False, labels=False)
         loss_axes = figure.add_subplot(gs_31[1:, 1])
         demoplot.make_autos_losses_plot(
             figure, pddata=normed_data, axes=loss_axes,
             legend=False, labels=False)

         # Layer 3, Part II - Radar
         gs_32 = mpl.gridspec.GridSpecFromSubplotSpec(
            5, 3, height_ratios=[1, 20, 20, 20, 20],
            hspace=0.6, wspace=0,
            subplot_spec=gs_master[2, 1])
         (rows, cols) = geometry = gs_32.get_geometry()
         title_axes = figure.add_subplot(gs_32[0, :])
         inner_axes = []
         projection = radar.RadarAxes(spoke_count=len(
             normed_data.groupby("make").mean().columns))
         [inner_axes.append(figure.add_subplot(
             m, projection=projection))
             for m in [n for n in gs_32][cols:]]
         demoplot.make_autos_radar_plot(
             figure, pddata=normed_data,
             title_axes=title_axes, inner_axes=inner_axes,
             legend_axes=False, geometry=geometry)

         # Layer 4 - MPG
         gs_4 = mpl.gridspec.GridSpecFromSubplotSpec(
             1, 1, subplot_spec=gs_master[3, :])
         mpg_axes = figure.add_subplot(gs_4[0])
         demoplot.make_autos_mpg_plot(
             figure, pddata=data, axes=mpg_axes)

         # Tidy up
         gs_master.tight_layout(figure)
         plt.show()

Though there is a lot of code here, keep in mind that it's essentially the same as the skeleton of subplots that we created. For most of the plots, all we had to do was make a call to the function that creates the desired plot, passing the axes that we created by splicing a part of the spec and adding a subplot for that splice to the figure. The one that wasn't so straightforward was the radar plot collection. This is due to the fact that we not only needed to define the projection for each radar plot, but also needed to create the 12 axes needed for each manufacturer. Despite this complication, the use of GridSpec and GridSpecFromSubplotSpec clearly demonstrates the ease with which complicated visual data can be assembled to provide all the power and convenience of a typical dashboard view.

The following plot is the result of the preceding code:

The creation of complex subplots in matplotlib can be perceived as a daunting task. However, the following basic practices can help you make it a painless process of creating visual goodness: