Changing the "tick frequency" on x or y axis in matplotlib?
I am trying to fix how python plots my data.
x = [0,5,9,10,15]
y = [0,1,2,3,4]
Then I would do:
and the x axis' ticks are plotted in intervals of 5. Is there a way to make it show intervals of 1?
You could explicitly set where you want to tick marks with
plt.xticks(np.arange(min(x), max(x)+1, 1.0))
import numpy as np import matplotlib.pyplot as plt x = [0,5,9,10,15] y = [0,1,2,3,4] plt.plot(x,y) plt.xticks(np.arange(min(x), max(x)+1, 1.0)) plt.show()
np.arange was used rather than Python's
range function just in case
max(x) are floats instead of ints.)
ax.plot) function will automatically set default
y limits. If you wish to keep those limits, and just change the stepsize of the tick marks, then you could use
ax.get_xlim() to discover what limits Matplotlib has already set.
start, end = ax.get_xlim() ax.xaxis.set_ticks(np.arange(start, end, stepsize))
The default tick formatter should do a decent job rounding the tick values to a sensible number of significant digits. However, if you wish to have more control over the format, you can define your own formatter. For example,
Here's a runnable example:
import numpy as np import matplotlib.pyplot as plt import matplotlib.ticker as ticker x = [0,5,9,10,15] y = [0,1,2,3,4] fig, ax = plt.subplots() ax.plot(x,y) start, end = ax.get_xlim() ax.xaxis.set_ticks(np.arange(start, end, 0.712123)) ax.xaxis.set_major_formatter(ticker.FormatStrFormatter('%0.1f')) plt.show()
Read more... Read less...
Another approach is to set the axis locator:
import matplotlib.ticker as plticker loc = plticker.MultipleLocator(base=1.0) # this locator puts ticks at regular intervals ax.xaxis.set_major_locator(loc)
There are several different types of locator depending upon your needs.
Here is a full example:
import matplotlib.pyplot as plt import matplotlib.ticker as plticker x = [0,5,9,10,15] y = [0,1,2,3,4] fig, ax = plt.subplots() ax.plot(x,y) loc = plticker.MultipleLocator(base=1.0) # this locator puts ticks at regular intervals ax.xaxis.set_major_locator(loc) plt.show()
I like this solution (from the Matplotlib Plotting Cookbook):
import matplotlib.pyplot as plt import matplotlib.ticker as ticker x = [0,5,9,10,15] y = [0,1,2,3,4] tick_spacing = 1 fig, ax = plt.subplots(1,1) ax.plot(x,y) ax.xaxis.set_major_locator(ticker.MultipleLocator(tick_spacing)) plt.show()
This solution give you explicit control of the tick spacing via the number given to
ticker.MultipleLocater(), allows automatic limit determination, and is easy to read later.
In case anyone is interested in a general one-liner, simply get the current ticks and use it to set the new ticks by sampling every other tick.
This is a bit hacky, but by far the cleanest/easiest to understand example that I've found to do this. It's from an answer on SO here:
for label in ax.get_xticklabels()[::2]: label.set_visible(False)
Then you can loop over the labels setting them to visible or not depending on the density you want.
edit: note that sometimes matplotlib sets labels ==
'', so it might look like a label is not present, when in fact it is and just isn't displaying anything. To make sure you're looping through actual visible labels, you could try:
visible_labels = [lab for lab in ax.get_xticklabels() if lab.get_visible() is True and lab.get_text() != ''] plt.setp(visible_labels[::2], visible=False)
This is an old topic, but I stumble over this every now and then and made this function. It's very convenient:
import matplotlib.pyplot as pp import numpy as np def resadjust(ax, xres=None, yres=None): """ Send in an axis and I fix the resolution as desired. """ if xres: start, stop = ax.get_xlim() ticks = np.arange(start, stop + xres, xres) ax.set_xticks(ticks) if yres: start, stop = ax.get_ylim() ticks = np.arange(start, stop + yres, yres) ax.set_yticks(ticks)
One caveat of controlling the ticks like this is that one does no longer enjoy the interactive automagic updating of max scale after an added line. Then do
gca().set_ylim(top=new_top) # for example
and run the resadjust function again.