Websites, publications and news sources all have their own styles. Take a look at the financial data published by, say, the BBC or The New York Times. Or polling data on Nate Silver’s FiveThirtyEight website. They each have a clear and consistent look.

We are going to look at how we can achieve something similar with our Pandas charts and plots. First, by using the built-in styles that are available to us and then by looking at how we can create our own customizations.

The default style renders a line graph like the image, below. It’s a clean-looking image but there are several more built-in styles if you prefer something different.

The availablestyles are stored in a list in the Matplotlib library. First, we need to import the library and, we’ll import numpy at the same time as we will use this shortly.

import matplotlib.pyplot as plt
import numpy as np

The styles are in plt.style.available - the code below prints a neat list of the styles.

styles = plt.style.available
for style in styles:
    print(style)

Here is the list.

    Solarize_Light2
    _classic_test_patch
    _mpl-gallery
    _mpl-gallery-nogrid
    bmh
    classic
    dark_background
    fast
    fivethirtyeight
    ggplot
    grayscale
    petroff10
    seaborn-v0_8
    seaborn-v0_8-bright
    seaborn-v0_8-colorblind
    seaborn-v0_8-dark
    seaborn-v0_8-dark-palette
    seaborn-v0_8-darkgrid
    seaborn-v0_8-deep
    seaborn-v0_8-muted
    seaborn-v0_8-notebook
    seaborn-v0_8-paper
    seaborn-v0_8-pastel
    seaborn-v0_8-poster
    seaborn-v0_8-talk
    seaborn-v0_8-ticks
    seaborn-v0_8-white
    seaborn-v0_8-whitegrid
    tableau-colorblind10

The list from my installation which is version 3.10.0 of Matplotlib. If you have a different version you may have a different list.

Many of the styles have been created for the plotting package Seaborn but you can use any style with any plotting library that is based on Matplotlib.

Other styles are emulations of other plotting systems or websites. The ggplot style is based on the ggplot2 library that is commonly used in the R language.

Below is a function that can be used to explore the different styles. It generates some pseudo-random data and then plots a line graph in Matplotlib. We can pass a style as a parameter to it.

In the code, two Numpy sequences are created for the two axes x and y. x is created using np.linspace(0, 10, 100), which generates 100 evenly spaced values between 0 and 10.

y is created by taking the sine of x values and adding some random noise to it using np.random.normal(0, 0.1, 100), which generates 100 random values from a normal distribution with a mean of 0 and a standard deviation of 0.1.

The code below displays a plot with the seaborn-v0_8 style.

def plot_with_style(style):
    # Create random data
    x = np.linspace(0, 10, 100)
    y = np.sin(x) + np.random.normal(0, 0.1, 100)

    # Set the style
    plt.style.use(style)

    # Plot the data
    plt.plot(x, y)
    plt.xlabel('X-axis')
    plt.ylabel('Y-axis')
    plt.title(f'Random Data Line Graph - {style} style')
    plt.show()

# Example usage
plot_with_style('seaborn-v0_8')

png

This is what the ggplot style looks like.

plot_with_style('ggplot')

png

How about a spooky dark background?

plot_with_style('dark_background')

png

So that’s how we change to one of the built-in styles and one of these might be suitable for your purposes. Or maybe you want to be a little more adventurous.

Changing individual attributes

The attributes for Matplotlib graphs are stored in a dictionary called rcParams. You can change individual attributes by setting values in that dictionary. So, if you wanted to change the font size from its default value of 10 to something smaller, you could do this:

plt.rcParams['font.size'] = 8

Any subsequent plot that you make will now have a font size of 8. You can easily find all of the rcParams simply by printing them.

print(plt.rcParams)

There are an awful lot of parameters so I won’t list them here. The purpose of some parameters is a little obscure and you would need to study the Matplotlib documentation to understand theier use. Others are fairly clear and below is some code that uses a few of these.

The resulting plot is a little garish. The aim is not to be aesthetically pleasing but to make it plain how the parameters map onto the various parts of the plot.

import matplotlib as mpl
from cycler import cycler

# Reset everything to the default style
mpl.style.use('default')

# Set custom rcParams for the plot
mpl.rcParams['lines.linewidth'] = 4         # Set line width to 4
mpl.rcParams['lines.linestyle'] = '--'      # Set line style to dashed
 # Set color cycle for lines, the first is red and that is what will be used
mpl.rcParams['axes.prop_cycle'] = cycler(color=['r', 'g', 'b', 'y']) 
mpl.rcParams['figure.facecolor'] = 'yellow' # Set figure background color to yellow
mpl.rcParams['axes.facecolor'] = 'lightblue'# Set axes background color to light blue
mpl.rcParams['font.size'] = 14              # Set font size to 14
mpl.rcParams['text.color'] = 'red'          # Set text color to red

# Generate random data
x = np.linspace(0, 10, 100)
y = np.sin(x) + np.random.normal(0, 0.1, 100)

# Plot the data with custom style
plt.plot(x, y)
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Random Data Line Graph - custom style')
plt.show()

png

You can see what changing each of the parameters has done in the resulting chart - the meaning of these parameters is fairly clear but the comments tell you exactly what they are doing. The colour cycle is slightly more complicated - you don’t just set a single colour but a sequence of them that will be cycled through. In this case, of course, there is only one plot so only one colour is used. (I am not, by the way suggesting that you adopt this particular colour scheme!)

Create your own stylesheet

You don’t have to specify the parameters you want in every program you write. You can create your own stylesheet and use that instead of one of the built-in ones. All you have to do is create a text file with the rcParams set the way you want them and then use that as your stylesheet in a similar way to the built-in ones, for example:

mpl.style.use('path-to-my-style-sheet')

And you don’t have to specify all of the rcParams only the ones that you want to change.

Here is an example of a simple style sheet that I have saved in the file example.mlpstyle. It sets the colours to various shades of blue.

lines.linewidth: 2          # Set line width to 2
figure.facecolor: eff3ff    # Set figure background color
axes.facecolor: bdd7e7      # Set axes background color
font.size: 14               # Set font size to 14
text.color: 08519c          # Set text color
axes.labelcolor: 08519c     # set the axes labels

The code below uses this style but it first sets the default style. This has the effect that the new style sheet changes the values specified in that sheet but leaves all the others as they are.

# Reset everything to the default style
mpl.style.use('default')

# Now apply the new stylesheet
mpl.style.use('example.mplstyle')

# Generate random data
x = np.linspace(0, 10, 100)
y = np.sin(x) + np.random.normal(0, 0.1, 100)

# Plot the data with custom style
plt.plot(x, y)
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Random Data Line Graph - custom style')
plt.show()

png

As you can see, Matplotlib rcParams lets you create your own unique, and reusable, style for your Pandas plots.

The examples here are, of course, deliberately simple, but you can explore how the parameters are used in the built-in styles by looking at their source code.

Stylelib

You can find the code for all the different styles in the Matplotlib Github repository in the Stylelib folder. Try looking at the Classic style — this demonstrates setting pretty much all the possible parameters. Or, for a much simpler stylesheet, look at greyscale where, as you might imagine, the colours are set to black, white and varying shades of grey.

Third-party styles

You can also find third-party libraries on GitHub (and elsewhere, no doubt), for example in the matplotx package. Below is an example of the ‘Dracula’ style for that package.

You will need to install the matplotx package and use the following code in front of your plots.

import matplotx
plt.style.use(matplotx.styles.dracula)

Here is the code that uses it.

import matplotx
plt.style.use(matplotx.styles.dracula)

# Generate random data
x = np.linspace(0, 10, 100)
y = np.sin(x) + np.random.normal(0, 0.1, 100)

# Plot the data with custom style
#with plt.style.context(matplotx.styles.dracula):
plt.plot(x, y)
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Random Data Line Graph - custom style')
plt.show()

png

There are several other repos that include style libraries that you can explore and that are available on PyPi.

Conclusion

As we have seen, Matplotlib provides a lot of scope for customising your plots. You can use one of the variety of built-in styles, you can modify the styles by changing the rcParams, make your own stylesheet to replace or modify existing ones, or you can find and install style packages from PyPi.

Matplotlib is a very flexible and powerful plotting library and the ability to change styles means you can create your own brand or house style. Also because many other plotting libraries are based on Matplotlib, these techniques can be used with those libraries, too.

As always, thanks for reading and I hope you found this useful. If you’d like to know when I publish other articles, please follow me on Medium or LinkedIn.

Create Your Own House Style for Matplotlib Plots and Charts

Customise your Matplotlib plots with off-the-shelf style sheets - or design your own

Changing individual attributes

Create your own stylesheet

Stylelib

Third-party styles

Conclusion

Streamlit from Scratch

Recommended books

Alberto Cairo

Cole Nussbaumer Knaflic