Using ggplot in Python: Visualizing Data With plotnine

Data: The Source of Information

Your first step when you’re creating a data visualization is specifying which data to plot. In plotnine, you do this by creating a ggplot object and passing the dataset that you want to use to the constructor.

The following code creates a ggplot object using plotnine’s fuel economy example dataset, mpg:

from plotnine.data import mpg
from plotnine import ggplot

ggplot(mpg)

This code creates an object belonging to the class ggplot using the mpg dataset. Note that since you haven’t specified the aesthetics or geometric object yet, the above code will generate a blank plot. Next, you’ll build the plot piece by piece.

As you’ve seen before, you can inspect the dataset from Jupyter Notebook with the following code:

from plotnine.data import mpg

mpg

These two lines of code import and show the dataset, displaying the following output:

  manufacturer  model  displ  year  cyl  trans      drv  cty  hwy  fl  class
0 audi          a4      1.8   1999  4    auto(l5)   f    18   29   p  compact
1 audi          a4      1.8   1999  4    manual(m5) f    21   29   p  compact
2 audi          a4      2.0   2008  4    manual(m6) f    20   31   p  compact
...

The output is a table containing fuel consumption data for 234 cars from 1999 to 2008. The displacement (displ) field is the size of the engine in liters. cty and hwy are the fuel economy in miles per gallon for city and highway driving.

In the following sections, you’ll learn the steps to turn this raw data into graphics using plotnine.

Aesthetics: Define Variables for Each Axis

After specifying the data that you want to visualize, the next step is to define the variable that you want to use for each axis in your plot. Each row in a DataFrame can contain many fields, so you have to tell plotnine which variables you want to use in the graphic.

Aesthetics maps data variables to graphical attributes, like 2D position and color. For example, the following code creates a graphic that shows vehicle classes on the x-axis and highway fuel consumption on the y-axis:

from plotnine.data import mpg
from plotnine import ggplot, aes

ggplot(mpg) + aes(x="class", y="hwy")

Using the ggplot object from the previous section as the base for the visualization, the code maps the vehicle class attribute to the horizontal graphical axis and the hwy fuel economy to the vertical axis.

But the generated plot is still blank because it’s missing the geometric object for representing each data element.

Geometric Objects: Choose Different Plot Types

After defining your data and the attributes that you want to use in the graphic, you need to specify a geometric object to tell plotnine how data points should be drawn.

plotnine provides a lot of geometric objects that you can use out of the box, like lines, points, bars, polygons, and a lot more. A list of all available geometric objects is available in plotnine’s geoms API Reference.

The following code illustrates how to use the point geometric object to plot data:

from plotnine.data import mpg
from plotnine import ggplot, aes, geom_point

ggplot(mpg) + aes(x="class", y="hwy") + geom_point()

In the code above, geom_point() selects the point geometric object. Running the code produces the following output:

As you can see, the generated data visualization has a point for each vehicle in the dataset. The axes show the vehicle class and the highway fuel economy.

There are many other geometric objects that you can use to visualize the same dataset. For example, the following code uses the bar geometric object to show the count of vehicles for each class:

from plotnine.data import mpg
from plotnine import ggplot, aes, geom_bar

ggplot(mpg) + aes(x="class") + geom_bar()

Here, geom_bar() sets the geometric object to bar. Since the code doesn’t specify any attribute for the y-axis, geom_bar() implicitly groups data points by the attribute used for the x-axis and then uses the count of points in each group for the y-axis.

Running the code, you’ll see the following output:

The height of each bar in the plot represents the number of vehicles belonging to the corresponding vehicle class. You’ll learn more about data aggregation and grouping the latter sections.

In this section, you learned about the three compulsory components that must be specified when creating data visualizations:

1. Data
2. Aesthetics
3. Geometric objects

You also learned how to combine them using the + operator.

In the following sections, you’ll learn about some optional components that you can use to create more complex and beautiful graphics.

Statistical Transformations: Aggregate and Transform Your Data

Statistical transformations apply some computation to the data before plotting it, for example to display some statistical indicator instead of the raw data. plotnine includes several statistical transformations that you can use.

Let’s say that you want to create a histogram to display the distributions of the levels of Lake Huron from 1875 to 1975. This dataset is included with plotnine. You can use the following code to inspect the dataset from Jupyter Notebook and learn about its format:

# Import our example dataset with the levels of Lake Huron 1875–1975
from plotnine.data import huron

huron

The code imports and shows the dataset, producing the following output:

    year  level   decade
0   1875  580.38  1870
1   1876  581.86  1870
...
96  1971  579.89  1970
97  1972  579.96  1970

As you can see, the dataset contains three columns:

1. year
2. level
3. decade

Now you can build the histogram in two steps:

1. Group the level measurements into bins.
2. Display the number of measurements in each bin using a bar plot.

The following code shows how these steps can be done in plotnine:

from plotnine.data import huron
from plotnine import ggplot, aes, stat_bin, geom_bar

ggplot(huron) + aes(x="level") + stat_bin(bins=10) + geom_bar()

In the above code, stat_bin() divides the level range into ten equally sized bins. Then the number of measurements that falls into each bin is drawn using a bar plot.

Running the code produces the following graphic:

This plot shows the number of measurements for each range of lake levels. As you can see, most of the time the level was between 578 and 580.

For most common tasks, like building histograms, plotnine includes very convenient functions that make the code more concise. For example, with geom_histogram(), you can build the above histogram like this:

from plotnine.data import huron
from plotnine import ggplot, aes, geom_histogram

ggplot(huron) + aes(x="level") + geom_histogram(bins=10)

Using geom_histogram() is the same as using stats_bin() and then geom_bar(). Running this code generates the same graphic you saw above.

Now let’s look at another example of a statistical transformation. A box plot is a very popular statistical tool used to show the minimum, maximum, sample median, first and third quartiles, and outliers from a dataset.

Suppose you want to build a visualization based on the same dataset to show a box plot for each decade’s level measurements. You can build this plot in two steps:

1. Group the measurements by decade.
2. Create a box plot for each group.

You can do the first step using factor() in the aesthetics specification. factor() groups together all data points that share the same value for the specified attribute.

Then, once you’ve grouped the data by decade, you can draw a box plot for each group using geom_boxplot().

The following code creates a plot using the steps described above:

from plotnine.data import huron
from plotnine import ggplot, aes, geom_boxplot

(
  ggplot(huron)
  + aes(x="factor(decade)", y="level")
  + geom_boxplot()
)

The code groups the data rows by decade using factor() and then uses geom_boxplot() to create the box plots.

As you saw in the previous example, some geometrical objects have implicit statistical transformations. This is really convenient as it makes your code more concise. Using geom_boxplot() implies stat_boxplot(), which takes care of calculating the quartiles and outliers.

Running the above code, you’ll obtain the following graphic:

The graphic shows the distributions of the water levels using a box plot for each decade.

There are other statistical transformations that you can use to build data visualizations using ggplot in Python. You can learn about them in plotnine’s stats API documentation.

Scales: Change Data Scale According to Its Meaning

Scales are another kind of transformation that you can apply during the mapping from data to aesthetics. They can help make your visualizations easier to understand.

At the beginning of this tutorial, you saw a plot that showed the population for each year since 1970. The following code shows how you can use scales to show the elapsed years since 1970 instead of raw dates:

from plotnine.data import economics
from plotnine import ggplot, aes, scale_x_timedelta, labs, geom_line

(
    ggplot(economics)
    + aes(x="date", y="pop")
    + scale_x_timedelta(name="Years since 1970")
    + labs(title="Population Evolution", y="Population")
    + geom_line()
)

Using scale_x_timedelta() transforms each point’s x-value by computing its difference from the oldest date in the dataset. Note that the code also uses labs() to set a more descriptive label to the y-axis and the title.

Running the code shows this plot:

Without changing the data, you’ve made the visualization easier to understand and friendlier to the reader. As you can see, the plot now has better descriptions, and the x-axis shows the elapsed years since 1970 instead of dates.

plotnine provides a large number of scale transformations for you to choose from, including logarithmic and other non-linear scales. You can learn about them in plotnine’s scales API reference.

Coordinates Systems: Map Data Values to 2D Space

A coordinates system defines how data points are mapped to 2D graphical locations in the plot. You can think of it as a map from mathematical variables to graphical positions. Choosing the right coordinates system can improve the readability of your data visualizations.

Let’s revisit the previous example of the bar plot to count vehicles belonging to different classes. You created the plot using the following code:

from plotnine.data import mpg
from plotnine import ggplot, aes, geom_bar

ggplot(mpg) + aes(x="class") + geom_bar()

The code uses geom_bar() to draw a bar for each vehicle class. Since no particular coordinates system is set, the default one is used.

Running the code generates the following plot:

The height of each bar in the plot represents the number of vehicles in a class.

While there’s nothing wrong with the above graphic, the same information could be better visualized by flipping the axes to display horizontal bars instead of vertical ones.

plotnine provides several functions that allow you to modify the coordinates system. You can flip the axes using coord_flip():

from plotnine.data import mpg
from plotnine import ggplot, aes, geom_bar, coord_flip

ggplot(mpg) + aes(x="class") + geom_bar() + coord_flip()

The code flips the x- and y-axes using coord_flip(). Running the code, you’ll see the following graphic:

This graphic shows the same information you saw in the previous plot, but by flipping the axes you may find it easier to understand and compare different bars.

There’s no hard rule about which coordinate system is better. You should pick the one that best suits your problem and data. Give them a try and do some experiments to learn what works for each case. You can find more information about other coordinates systems in plotnine’s coordinates API reference.

Facets: Plot Subsets of Data Into Panels in the Same Plot

In this section, you’re going to learn about facets, one of the coolest features of plotnine. Facets allow you to group data by some attributes and then plot each group individually, but in the same image. This is particularly useful when you want to show more than two variables in the same graphic.

For example, let’s say you want to take the fuel economy dataset (mpg) and build a plot showing the miles per gallon for each engine size (displacement) for each vehicle class for each year. In this case your plot needs to display information from four variables:

1. hwy: Miles per gallon
2. displ: Engine size
3. class: Vehicle class
4. year: Model year

This presents a challenge, because you have more variables than graphical dimensions. You could use a 3D perspective if you had to display three variables, but a four-dimensional graphic is hard to even imagine.

There’s a two-step trick that you can use when faced with this problem:

1. Start by partitioning the data into groups where all data points in a group share the same values for some attributes.

2. Plot each group individually, showing only the attributes not used in the grouping.

Going back to the example, you can group vehicles by class and year and then plot each group to show displacement and miles per gallon. The following visualization was generated using this technique:

As you can see in the above graphic, there’s a panel for each group. Each panel shows the miles per gallon for different engine displacements belonging to that vehicle class and year.

This data visualization was generated with the following code:

from plotnine.data import mpg
from plotnine import ggplot, aes, facet_grid, labs, geom_point

(
    ggplot(mpg)
    + facet_grid(facets="year~class")
    + aes(x="displ", y="hwy")
    + labs(
        x="Engine Size",
        y="Miles per Gallon",
        title="Miles per Gallon for Each Year and Vehicle Class",
    )
    + geom_point()
)

The code partitions data by year and vehicle class using facet_grid(), passing it the attributes to use for the partitioning with facets="year~class". For each data partition, the plot is built using the components that you saw in previous sections, like aesthetics, geometric objects, and labs().

facet_grid() displays the partitions in a grid, using one attribute for rows and the other for columns. plotnine provides other faceting methods that you can use to partition your data using more than two attributes. You can learn more about them in plotnine’s facets API Reference.

Themes: Improve the Look of Your Visualization

Another great way to improve the presentation of your data visualizations is to choose a non-default theme to make your plots stand out, making them more beautiful and vibrant.

plotnine includes several themes that you can pick from. The following code generates the same graphic that you saw in the previous section, but using the dark theme:

from plotnine.data import mpg
from plotnine import ggplot, aes, facet_grid, labs, geom_point, theme_dark

(
    ggplot(mpg)
    + facet_grid(facets="year~class")
    + aes(x="displ", y="hwy")
    + labs(
        x="Engine Size",
        y="Miles per Gallon",
        title="Miles per Gallon for Each Year and Vehicle Class",
    )
    + geom_point()
    + theme_dark()
)

In the code above, specifying theme_dark() tells plotnine to draw the plot using a dark theme. Here’s the graphic generated by this code:

As you can see in the image, setting the theme affects the colors, fonts, and shapes styles.

theme_xkcd() is another theme that’s worth mentioning because it gives you a really cool comic-like look. It makes your data visualizations look like xkcd comics:

Choosing the right theme can help you attract and retain the attention of your audience. You can see a list of available themes in plotnine’s themes API reference.

In the preceding sections, you’ve learned about the most important aspects of grammars of graphics and how to use plotnine to build data visualizations. Using ggplot in Python allows you to build visualizations incrementally, first focusing on your data and then adding and tuning components to improve its graphical representation.

In the next section, you’ll learn how to use colors and how to export your visualizations.