part of Course 133 Navigating Matplotlib


x and y axis limits
ax.set_xlim(x_minimum, x_maximum)
ax.set_ylim(y_minimum, y_maximum)
x and y axes with logarithmic scaling
ax.set_xscale("log")
ax.set_yscale("log")
varying tick directions on x and y axes
ax.tick_params(axis="x", direction="in")
ax.tick_params(axis="y", direction="inout")
ticks added to the opposite side of the plot
ax.tick_params(
    bottom=False, top=True,
    left=True, right=True)
ax.tick_params(
    labelbottom=False, labeltop=True,
    labelleft=True, labelright=True)
varying tick styles on x and y axes
ax.tick_params(
    axis="x", direction="in",
    length=16, width=2, color="turquoise")
ax.tick_params(
    axis="y", direction="in",
    length=6, width=4, color="orange")
tick labels styled on the x and y axes
ax.tick_params(
    axis="x", labelsize=18,
    labelrotation=-60,
    labelcolor="turquoise")
ax.tick_params(
    axis="y", labelsize=12,
    labelrotation=20,
    labelcolor="orange")
minor ticks added to the plot
ax.xaxis.set_minor_locator(
    AutoMinorLocator())
ax.yaxis.set_minor_locator(
    AutoMinorLocator())
added minor tick labels on x and y axes
ax.yaxis.set_minor_formatter(
    FormatStrFormatter("%.3f"))
custom located and labeled ticks
x_locator = FixedLocator(tick_position_list)
x_formatter = FixedFormatter(tick_label_list)
ax.xaxis.set_major_locator(x_locator)
ax.xaxis.set_major_formatter(x_formatter)
added a grid to the plot
ax.grid(
    axis="x", color="green",
    alpha=.3, linestyle=":")
ax.grid(
    axis="y", color="black",
    alpha=.5, linewidth=.5)


Tip-Top Tick Tips and Tricks

Well formatted axis ticks elevate a plot from serviceable to professional, but unfortunately it’s one of the toughest things to do in Matplotlib. This recipe collection is designed to change that.

There are at least three different ways to perform most tick formatting operations. I’ve chosen to stick with the set that feels the most consistent, but don’t be surprised when you come across lots of alternatives on StackOverflow.

All the examples to follow will rely on this bit of setup. (See the Level Up post for a line-by-line breakdown.)

import matplotlib
matplotlib.use("agg")
import matplotlib.pyplot as plt
import numpy as np

# Create the curve data.
x = np.linspace(1, 13, 500)
y = 1 + np.sinc(x - 7)
fig = plt.figure()
ax = fig.gca()
ax.plot(x, y)


Impose axis limits

Setting axis limits is a good place to start. By default, Matplotlib uses the range of the data to choose reasonable limits. This is good enough most of the time, but occasionally you will want more control. You may want to avoid suppressing your zero or to ensure that multiple plots have the same scale or to drive a certain aspect ratio, or maybe you just like having the limits fall on even whole numbers. Whatever the reason, specifying limits gives you a greater degree of control over the framing of your plot.

ax.set_xlim(x_minimum, x_maximum)
ax.set_ylim(y_minimum, y_maximum)

This is thankfully one of the most self-explanatory examples in the bunch.

x and y axis limits

Use logarithmic scaling

Some data lends itself well to logarithmic scaling on one of its axes, or both. Matplotlib handles that transformation gracefully.

ax.set_xscale("log")
ax.set_yscale("log")

It even adds a second set of smaller ticks without labels, called minor ticks, to help the viewer resolve locations. Minor ticks will be showing up again in later examples.

x and y axes with logarithmic scaling

Put ticks inside and out

Fine control over ticks can make the story your plot tells crisper. By default they sit just outiside the plot frame, but you can place the ticks inside the frame or half in, half out.

ax.tick_params(axis="x", direction="in")
ax.tick_params(axis="y", direction="inout")

To adjust this aspect of tick behavior, we get to use tick_params(). With the direction argument we can specify in, out, or inout to get the precise placement we want.

Also, note how we can specify the axis we want to adjust. The default is both and when it's in force, anything we do will affect both x- and y-axes. When we want to adjust them separately, we can call them out individually, as we did here.

varying tick directions on x and y axes

Another power that we get with tick_params() is that everything we do with major ticks can also be done with minor ticks. The which argument lets us select between them. By default, it only operates on major ticks, but we could also call out which="minor" to perform the same operation on our minor ticks.

ax.tick_params(which="minor", "axis="x", direction="in")
ax.tick_params(which="minor", axis="y", direction="inout")

There is no inherent difference between major and minor ticks, but it's often convenient to have two sets. One might be larger, with labels and wider spacing, the other finer. By convention these are called major and minor, but the distinction ends there as far as Matplotlib is concerned.

The tick_params() function will come up a lot in the next few examples. If you want to take a closer look at the API to get a full sense of its abilities, you can find it here.



Put ticks on the top and right axes

By default, ticks and tick labels will be added to the left and bottom axes. To make changes to this, you can use tick_params() to turn ticks and tick labels on and off for each axis independently.

ax.tick_params(bottom=False, top=True, left=True, right=True)
ax.tick_params(labelbottom=False, labeltop=True, labelleft=True, labelright=True)

The boolean arguments bottom, top, right, and left determine whether the ticks are shown. As you might have guessed, tick labels are similarly controlled using labelbottom, labeltop, labelleft, and labelright. You can have one without the other, both, or neither on any axis in any combination.

ticks added to the opposite side of the plot

Stylize the ticks

Sometimes if your taste is particular, the default ticks just aren't quite right. Luckily you can adjust the length, width, and color of them as well.

ax.tick_params(axis="x", direction="in", length=16, width=2, color="turquoise")
ax.tick_params(axis="y", direction="in", length=6, width=4, color="orange")

The tick_params accepts these parameters with length and width measured in points and color any valid color, as in the lesson on setting line color.

varying tick styles on x and y axes

Tweak the label style

The lesson on text showed how to customize axis labels and plot text in a myriad of ways, but stopped short of showing how to handle tick labels. Now we finally get to that.

ax.tick_params(axis="x", labelsize=18, labelrotation=-60, labelcolor="turquoise")
ax.tick_params(axis="y", labelsize=12, labelrotation=20, labelcolor="orange")

We don't get quite the freedom with tick labels as we do with other text, but we get enough to make things interesting. Size, rotation, and color are all modifiable.

tick labels styled on the x and y axes

As you can see, this gives you a fair amount of power over your tick labels. If you need to go further than that, like changing the font or italicizing it, that's beyond the scope of this post. If you decide to turn to StackOverflow for this, a word of caution: it's a deep rabbit hole. My personal recommendation is to use text() and hand place them. It's a bit extreme, but after 2 hours of trial and error when you're neck deep in Matplotlib source code, you'll see why.

As a side note, notice how the x-label no longer fits on the graph after growing the x-axis tick labels. That's because, when the Axes are first created, Matplotlib makes a reasonable guess at how much space the ticks and axis labels are going to take and places the plot accordingly. This is a great illustration of how sometimes we will need to take the Axes layout into our own hands. That will be to topic of a forthcoming post.



Add minor ticks

We got minor ticks for free when we log scaled our axis, but if we want to add them on linear scales, we can do that too.

from matplotlib.ticker import AutoMinorLocator
ax.xaxis.set_minor_locator(AutoMinorLocator())
ax.yaxis.set_minor_locator(AutoMinorLocator())

To do this we have to introduce the notion of a Locator. It's a function that generates the locations according to some rules. There are several different types, but Auto locators are a great place to start. They automatically create a reasonable set of ticks. By default, major ticks are initialized with an Auto locator, but minor ticks aren't. To turn them on, we have to import the AutoMinorLocator and use it to set minor ticks for the x- and y-axes.

minor ticks added to the plot

Add labels to the minor ticks

Another powerful tick tool is a Formatter. It's a function that lets you transform the tick label to be an integer, a fixed-place decimal, or lots of other things.

from matplotlib.ticker import AutoMinorLocator, FormatStrFormatter
ax.xaxis.set_minor_locator(AutoMinorLocator())
ax.yaxis.set_minor_locator(AutoMinorLocator())
ax.yaxis.set_minor_formatter(FormatStrFormatter("%.3f"))

Here, we imported the FormatStrFormatter, and used it to create tick label strings using the coordinates of each tick.

added minor tick labels on x and y axes

The helpful package that contains all the Formatters and Locators is called ticker. If you are curious about all the Formatters and Locators you have at your disposal, I recommend the formatter gallery and the locator gallery.



Exercise total tick control

When you have to do some tick gymnastics that are at all non-standard, the FixedLocator and FixedFormatter are your friends. These let you hard code in every tick location and tick label.

from matplotlib.ticker import FixedLocator, FixedFormatter
x_formatter = FixedFormatter([
    "I like this spot", "and this", "and that", "but not this one."])
y_formatter = FixedFormatter(["-1e7", "111", "007", "xkcd"])
x_locator = FixedLocator([3, 7, 8.8, 12])
y_locator = FixedLocator([.85, 1.15, 1.28, 1.9])
ax.xaxis.set_major_formatter(x_formatter)
ax.yaxis.set_major_formatter(y_formatter)
ax.xaxis.set_major_locator(x_locator)
ax.yaxis.set_major_locator(y_locator)

Supplying a list of positions to FixedLocator and a list of labels of the same length to FixedFormatter lets you arbitrarily specify the position and label of each tick.

custom located and labeled ticks

You can immediately see the power that this bestows on you. Your axes can say whatever you want. Just remember that with great tick formatting power comes great responsibility. If you ever change your axes to intentionally misrepresent your data, you will be kicked out of data science club, no backsies.



Add a custom grid

The cousin of the tick is the grid, tick lines that cross the entire plot. Matplotlib makes it easy to create one and supplies us with a grid() command.

ax.grid(axis="x", color="green", alpha=.3, linewidth=2, linestyle=":")
ax.grid(axis="y", color="black", alpha=.5, linewidth=.5)

Although it defaults to making both x- and y-grid lines the same, grid() also handles them individually, as in our code here. It takes all the arguments that we could pass to plot() when formatting a line.

added a grid to the plot

After the complexity of ticks, grids offer a straightforward way to make our plots stylish and readable. To dig deeper into the options available, check out the grid API.


You now have mastery of ticks. I hope it sets you up well to make your plots look polished with a minimum of internet searching. There are a handful of other Matplotlib how-to's you can refer to: come take a look at the full set of tutorials.