# Changing the "tick frequency" on x or y axis in matplotlib?

## Changing the "tick frequency" on x or y axis in matplotlib?

### Question

I am trying to fix how python plots my data.

Say

```
x = [0,5,9,10,15]
```

and

```
y = [0,1,2,3,4]
```

Then I would do:

```
matplotlib.pyplot.plot(x,y)
matplotlib.pyplot.show()
```

and the x axis' ticks are plotted in intervals of 5. Is there a way to make it show intervals of 1?

### Accepted Answer

You could explicitly set where you want to tick marks with `plt.xticks`

:

```
plt.xticks(np.arange(min(x), max(x)+1, 1.0))
```

For example,

```
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 `min(x)`

and `max(x)`

are floats instead of ints.)

The `plt.plot`

(or `ax.plot`

) function will automatically set default `x`

and `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,

```
ax.xaxis.set_major_formatter(ticker.FormatStrFormatter('%0.1f'))
```

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.

```
ax.set_xticks(ax.get_xticks()[::2])
```

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:

Cleanest way to hide every nth tick label in matplotlib colorbar?

```
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.