This module contains classes to support completely configurable tick locating and formatting. Although the locators know nothing about major or minor ticks, they are used by the Axis class to support major and minor tick locating and formatting. Generic tick locators and formatters are provided, as well as domain specific custom ones.
The default formatter identifies when the xdata being plotted is a small range on top of a large offset. To reduce the chances that the ticklabels overlap, the ticks are labeled as deltas from a fixed offset. For example:
ax.plot(np.arange(2000, 2010), range(10))
will have tick of 09 with an offset of +2e3. If this is not desired turn off the use of the offset on the default formatter:
ax.get_xaxis().get_major_formatter().set_useOffset(False)
set the rcParam axes.formatter.useoffset=False
to turn it off globally, or set a different formatter.
The Locator class is the base class for all tick locators. The locators handle autoscaling of the view limits based on the data limits, and the choosing of tick locations. A useful semiautomatic tick locator is MultipleLocator
. It is initialized with a base, e.g., 10, and it picks axis limits and ticks that are multiples of that base.
The Locator subclasses defined here are
AutoLocator
MaxNLocator
with simple defaults. This is the default tick locator for most plotting.MaxNLocator
LinearLocator
LogLocator
MultipleLocator
FixedLocator
IndexLocator
x = range(len(y))
).NullLocator
SymmetricalLogLocator
LogLocator
for the part outside of the threshold and adds 0 if inside the limits.LogitLocator
OldAutoLocator
MultipleLocator
and dynamically reassign it for intelligent ticking during navigation.AutoMinorLocator
There are a number of locators specialized for date locations  see the dates
module.
You can define your own locator by deriving from Locator. You must override the __call__
method, which returns a sequence of locations, and you will probably want to override the autoscale method to set the view limits from the data limits.
If you want to override the default locator, use one of the above or a custom locator and pass it to the x or y axis instance. The relevant methods are:
ax.xaxis.set_major_locator(xmajor_locator) ax.xaxis.set_minor_locator(xminor_locator) ax.yaxis.set_major_locator(ymajor_locator) ax.yaxis.set_minor_locator(yminor_locator)
The default minor locator is NullLocator
, i.e., no minor ticks on by default.
Tick formatting is controlled by classes derived from Formatter. The formatter operates on a single tick value and returns a string to the axis.
NullFormatter
IndexFormatter
FixedFormatter
FuncFormatter
StrMethodFormatter
format
method.FormatStrFormatter
ScalarFormatter
LogFormatter
LogFormatterExponent
exponent = log_base(value)
.LogFormatterMathtext
exponent = log_base(value)
using Math text.LogFormatterSciNotation
LogitFormatter
EngFormatter
PercentFormatter
You can derive your own formatter from the Formatter base class by simply overriding the __call__
method. The formatter class has access to the axis view and data limits.
To control the major and minor tick label formats, use one of the following methods:
ax.xaxis.set_major_formatter(xmajor_formatter) ax.xaxis.set_minor_formatter(xminor_formatter) ax.yaxis.set_major_formatter(ymajor_formatter) ax.yaxis.set_minor_formatter(yminor_formatter)
See Major and minor ticks for an example of setting major and minor ticks. See the matplotlib.dates
module for more information and examples of using date locators and formatters.
class matplotlib.ticker.TickHelper
[source]
Bases: object
axis = None
create_dummy_axis(self, **kwargs)
[source]
set_axis(self, axis)
[source]
set_bounds(self, vmin, vmax)
[source]
set_data_interval(self, vmin, vmax)
[source]
set_view_interval(self, vmin, vmax)
[source]
class matplotlib.ticker.Formatter
[source]
Bases: matplotlib.ticker.TickHelper
Create a string based on a tick value and location.
fix_minus(self, s)
[source]
Some classes may want to replace a hyphen for minus with the proper unicode symbol (U+2212) for typographical correctness. The default is to not replace it.
Note, if you use this method, e.g., in format_data()
or call, you probably don't want to use it for format_data_short()
since the toolbar uses this for interactive coord reporting and I doubt we can expect GUIs across platforms will handle the unicode correctly. So for now the classes that override fix_minus()
should have an explicit format_data_short()
method
format_data(self, value)
[source]
Returns the full string representation of the value with the position unspecified.
format_data_short(self, value)
[source]
Return a short string version of the tick value.
Defaults to the positionindependent long value.
format_ticks(self, values)
[source]
Return the tick labels for all the ticks at once.
get_offset(self)
[source]
locs = []
set_locs(self, locs)
[source]
class matplotlib.ticker.FixedFormatter(seq)
[source]
Bases: matplotlib.ticker.Formatter
Return fixed strings for tick labels based only on position, not value.
Set the sequence of strings that will be used for labels.
get_offset(self)
[source]
set_offset_string(self, ofs)
[source]
class matplotlib.ticker.NullFormatter
[source]
Bases: matplotlib.ticker.Formatter
Always return the empty string.
class matplotlib.ticker.FuncFormatter(func)
[source]
Bases: matplotlib.ticker.Formatter
Use a userdefined function for formatting.
The function should take in two inputs (a tick value x
and a position pos
), and return a string containing the corresponding tick label.
class matplotlib.ticker.FormatStrFormatter(fmt)
[source]
Bases: matplotlib.ticker.Formatter
Use an oldstyle ('%' operator) format string to format the tick.
The format string should have a single variable format (%) in it. It will be applied to the value (not the position) of the tick.
class matplotlib.ticker.StrMethodFormatter(fmt)
[source]
Bases: matplotlib.ticker.Formatter
Use a newstyle format string (as used by str.format()
) to format the tick.
The field used for the value must be labeled x
and the field used for the position must be labeled pos
.
class matplotlib.ticker.ScalarFormatter(useOffset=None, useMathText=None, useLocale=None)
[source]
Bases: matplotlib.ticker.Formatter
Format tick values as a number.
Tick value is interpreted as a plain old number. If useOffset==True
and the data range is much smaller than the data average, then an offset will be determined such that the tick labels are meaningful. Scientific notation is used for data < 10^n
or data >= 10^m
, where n
and m
are the power limits set using set_powerlimits((n,m))
. The defaults for these are controlled by the axes.formatter.limits
rc parameter.
fix_minus(self, s)
[source]
Replace hyphens with a unicode minus.
format_data(self, value)
[source]
Return a formatted string representation of a number.
format_data_short(self, value)
[source]
Return a short formatted string representation of a number.
get_offset(self)
[source]
Return scientific notation, plus offset.
get_useLocale(self)
[source]
get_useMathText(self)
[source]
get_useOffset(self)
[source]
pprint_val(self, x)
[source]
[Deprecated]
Deprecated since version 3.1:
set_locs(self, locs)
[source]
Set the locations of the ticks.
set_powerlimits(self, lims)
[source]
Sets size thresholds for scientific notation.
Parameters: 


See also
set_scientific(self, b)
[source]
Turn scientific notation on or off.
See also
set_useLocale(self, val)
[source]
set_useMathText(self, val)
[source]
set_useOffset(self, val)
[source]
useLocale
useMathText
useOffset
class matplotlib.ticker.LogFormatter(base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
[source]
Bases: matplotlib.ticker.Formatter
Base class for formatting ticks on a log or symlog scale.
It may be instantiated directly, or subclassed.
Parameters: 


The set_locs
method must be called to enable the subsetting logic controlled by the minor_thresholds
parameter.
In some cases such as the colorbar, there is no distinction between major and minor ticks; the tick locations might be set manually, or by a locator that puts ticks at integer powers of base and at intermediate locations. For this situation, disable the minor_thresholds logic by using minor_thresholds=(np.inf, np.inf)
, so that all ticks will be labeled.
To disable labeling of minor ticks when 'labelOnlyBase' is False, use minor_thresholds=(0, 0)
. This is the default for the "classic" style.
To label a subset of minor ticks when the view limits span up to 2 decades, and all of the ticks when zoomed in to 0.5 decades or less, use minor_thresholds=(2, 0.5)
.
To label all minor ticks when the view limits span up to 1.5 decades, use minor_thresholds=(1.5, 1.5)
.
base(self, base)
[source]
Change the base for labeling.
Warning
Should always match the base used for LogLocator
format_data(self, value)
[source]
Returns the full string representation of the value with the position unspecified.
format_data_short(self, value)
[source]
Return a short formatted string representation of a number.
label_minor(self, labelOnlyBase)
[source]
Switch minor tick labeling on or off.
Parameters: 


pprint_val(self, *args, **kwargs)
[source]
[Deprecated]
Deprecated since version 3.1:
set_locs(self, locs=None)
[source]
Use axis view limits to control which ticks are labeled.
The locs parameter is ignored in the present algorithm.
class matplotlib.ticker.LogFormatterExponent(base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
[source]
Bases: matplotlib.ticker.LogFormatter
Format values for log axis using exponent = log_base(value)
.
class matplotlib.ticker.LogFormatterMathtext(base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
[source]
Bases: matplotlib.ticker.LogFormatter
Format values for log axis using exponent = log_base(value)
.
class matplotlib.ticker.IndexFormatter(labels)
[source]
Bases: matplotlib.ticker.Formatter
Format the position x to the nearest ith label where i = int(x + 0.5)
. Positions where i < 0
or i > len(list)
have no tick labels.
Parameters: 


class matplotlib.ticker.LogFormatterSciNotation(base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
[source]
Bases: matplotlib.ticker.LogFormatterMathtext
Format values following scientific notation in a logarithmic axis.
class matplotlib.ticker.LogitFormatter
[source]
Bases: matplotlib.ticker.Formatter
Probability formatter (using Math text).
format_data_short(self, value)
[source]
return a short formatted string representation of a number
class matplotlib.ticker.EngFormatter(unit='', places=None, sep=' ', *, usetex=None, useMathText=None)
[source]
Bases: matplotlib.ticker.Formatter
Formats axis values using engineering prefixes to represent powers of 1000, plus a specified unit, e.g., 10 MHz instead of 1e7.
Parameters: 


ENG_PREFIXES = {24: 'y', 21: 'z', 18: 'a', 15: 'f', 12: 'p', 9: 'n', 6: 'µ', 3: 'm', 0: '', 3: 'k', 6: 'M', 9: 'G', 12: 'T', 15: 'P', 18: 'E', 21: 'Z', 24: 'Y'}
fix_minus(self, s)
[source]
Replace hyphens with a unicode minus.
format_eng(self, num)
[source]
Formats a number in engineering notation, appending a letter representing the power of 1000 of the original number. Some examples:
>>> format_eng(0) # for self.places = 0 '0'
>>> format_eng(1000000) # for self.places = 1 '1.0 M'
>>> format_eng("1e6") # for self.places = 2 '1.00 µ'
get_useMathText(self)
[source]
get_usetex(self)
[source]
set_useMathText(self, val)
[source]
set_usetex(self, val)
[source]
useMathText
usetex
class matplotlib.ticker.PercentFormatter(xmax=100, decimals=None, symbol='%', is_latex=False)
[source]
Bases: matplotlib.ticker.Formatter
Format numbers as a percentage.
Parameters: 


convert_to_pct(self, x)
[source]
format_pct(self, x, display_range)
[source]
Formats the number as a percentage number with the correct number of decimals and adds the percent symbol, if any.
If self.decimals
is None
, the number of digits after the decimal point is set based on the display_range
of the axis as follows:
display_range  decimals  sample 
>50  0 
x = 34.5 => 35% 
>5  1 
x = 34.5 => 34.5% 
>0.5  2 
x = 34.5 => 34.50% 
...  ...  ... 
This method will not be very good for tiny axis ranges or extremely large ones. It assumes that the values on the chart are percentages displayed on a reasonable scale.
symbol
The configured percent symbol as a string.
If LaTeX is enabled via rcParams["text.usetex"]
, the special characters {'#', '$', '%', '&', '~', '_', '^', '\', '{', '}'}
are automatically escaped in the string.
class matplotlib.ticker.Locator
[source]
Bases: matplotlib.ticker.TickHelper
Determine the tick locations;
Note that the same locator should not be used across multiple Axis
because the locator stores references to the Axis data and view limits.
MAXTICKS = 1000
autoscale(self)
[source]
autoscale the view limits
nonsingular(self, v0, v1)
[source]
Expand a range as needed to avoid singularities.
pan(self, numsteps)
[source]
Pan numticks (can be positive or negative)
raise_if_exceeds(self, locs)
[source]
raise a RuntimeError if Locator attempts to create more than MAXTICKS locs
refresh(self)
[source]
refresh internal information based on current lim
set_params(self, **kwargs)
[source]
Do nothing, and raise a warning. Any locator class not supporting the set_params() function will call this.
tick_values(self, vmin, vmax)
[source]
Return the values of the located ticks given vmin and vmax.
Note
To get tick locations with the vmin and vmax values defined automatically for the associated axis
simply call the Locator instance:
>>> print(type(loc)) <type 'Locator'> >>> print(loc()) [1, 2, 3, 4]
view_limits(self, vmin, vmax)
[source]
Select a scale for the range from vmin to vmax.
Subclasses should override this method to change locator behaviour.
zoom(self, direction)
[source]
Zoom in/out on axis; if direction is >0 zoom in, else zoom out
class matplotlib.ticker.IndexLocator(base, offset)
[source]
Bases: matplotlib.ticker.Locator
Place a tick on every multiple of some base number of points plotted, e.g., on every 5th point. It is assumed that you are doing index plotting; i.e., the axis is 0, len(data). This is mainly useful for x ticks.
place ticks on the ith data points where (ioffset)%base==0
set_params(self, base=None, offset=None)
[source]
Set parameters within this locator
tick_values(self, vmin, vmax)
[source]
Return the values of the located ticks given vmin and vmax.
Note
To get tick locations with the vmin and vmax values defined automatically for the associated axis
simply call the Locator instance:
>>> print(type(loc)) <type 'Locator'> >>> print(loc()) [1, 2, 3, 4]
class matplotlib.ticker.FixedLocator(locs, nbins=None)
[source]
Bases: matplotlib.ticker.Locator
Tick locations are fixed. If nbins is not None, the array of possible positions will be subsampled to keep the number of ticks <= nbins +1. The subsampling will be done so as to include the smallest absolute value; for example, if zero is included in the array of possibilities, then it is guaranteed to be one of the chosen ticks.
set_params(self, nbins=None)
[source]
Set parameters within this locator.
tick_values(self, vmin, vmax)
[source]
" Return the locations of the ticks.
Note
Because the values are fixed, vmin and vmax are not used in this method.
class matplotlib.ticker.NullLocator
[source]
Bases: matplotlib.ticker.Locator
No ticks
tick_values(self, vmin, vmax)
[source]
" Return the locations of the ticks.
Note
Because the values are Null, vmin and vmax are not used in this method.
class matplotlib.ticker.LinearLocator(numticks=None, presets=None)
[source]
Bases: matplotlib.ticker.Locator
Determine the tick locations
The first time this function is called it will try to set the number of ticks to make a nice tick partitioning. Thereafter the number of ticks will be fixed so that interactive navigation will be nice
Use presets to set locs based on lom. A dict mapping vmin, vmax>locs
set_params(self, numticks=None, presets=None)
[source]
Set parameters within this locator.
tick_values(self, vmin, vmax)
[source]
Return the values of the located ticks given vmin and vmax.
Note
To get tick locations with the vmin and vmax values defined automatically for the associated axis
simply call the Locator instance:
>>> print(type(loc)) <type 'Locator'> >>> print(loc()) [1, 2, 3, 4]
view_limits(self, vmin, vmax)
[source]
Try to choose the view limits intelligently
class matplotlib.ticker.LogLocator(base=10.0, subs=(1.0, ), numdecs=4, numticks=None)
[source]
Bases: matplotlib.ticker.Locator
Determine the tick locations for log axes
Place ticks on the locations : subs[j] * base**i
Parameters: 


base(self, base)
[source]
set the base of the log scaling (major tick every base**i, i integer)
nonsingular(self, vmin, vmax)
[source]
Expand a range as needed to avoid singularities.
set_params(self, base=None, subs=None, numdecs=None, numticks=None)
[source]
Set parameters within this locator.
subs(self, subs)
[source]
set the minor ticks for the log scaling every base**i*subs[j]
tick_values(self, vmin, vmax)
[source]
Return the values of the located ticks given vmin and vmax.
Note
To get tick locations with the vmin and vmax values defined automatically for the associated axis
simply call the Locator instance:
>>> print(type(loc)) <type 'Locator'> >>> print(loc()) [1, 2, 3, 4]
view_limits(self, vmin, vmax)
[source]
Try to choose the view limits intelligently
class matplotlib.ticker.AutoLocator
[source]
Bases: matplotlib.ticker.MaxNLocator
Dynamically find major tick positions. This is actually a subclass of MaxNLocator
, with parameters nbins = 'auto' and steps = [1, 2, 2.5, 5, 10].
To know the values of the nonpublic parameters, please have a look to the defaults of MaxNLocator
.
class matplotlib.ticker.MultipleLocator(base=1.0)
[source]
Bases: matplotlib.ticker.Locator
Set a tick on each integer multiple of a base within the view interval.
set_params(self, base)
[source]
Set parameters within this locator.
tick_values(self, vmin, vmax)
[source]
Return the values of the located ticks given vmin and vmax.
Note
To get tick locations with the vmin and vmax values defined automatically for the associated axis
simply call the Locator instance:
>>> print(type(loc)) <type 'Locator'> >>> print(loc()) [1, 2, 3, 4]
view_limits(self, dmin, dmax)
[source]
Set the view limits to the nearest multiples of base that contain the data.
class matplotlib.ticker.MaxNLocator(*args, **kwargs)
[source]
Bases: matplotlib.ticker.Locator
Select no more than N intervals at nice locations.
Parameters: 


default_params = {'integer': False, 'min_n_ticks': 2, 'nbins': 10, 'prune': None, 'steps': None, 'symmetric': False}
set_params(self, **kwargs)
[source]
Set parameters for this locator.
Parameters: 


tick_values(self, vmin, vmax)
[source]
Return the values of the located ticks given vmin and vmax.
Note
To get tick locations with the vmin and vmax values defined automatically for the associated axis
simply call the Locator instance:
>>> print(type(loc)) <type 'Locator'> >>> print(loc()) [1, 2, 3, 4]
view_limits(self, dmin, dmax)
[source]
Select a scale for the range from vmin to vmax.
Subclasses should override this method to change locator behaviour.
class matplotlib.ticker.AutoMinorLocator(n=None)
[source]
Bases: matplotlib.ticker.Locator
Dynamically find minor tick positions based on the positions of major ticks. The scale must be linear with major ticks evenly spaced.
n is the number of subdivisions of the interval between major ticks; e.g., n=2 will place a single minor tick midway between major ticks.
If n is omitted or None, it will be set to 5 or 4.
tick_values(self, vmin, vmax)
[source]
Return the values of the located ticks given vmin and vmax.
Note
To get tick locations with the vmin and vmax values defined automatically for the associated axis
simply call the Locator instance:
>>> print(type(loc)) <type 'Locator'> >>> print(loc()) [1, 2, 3, 4]
class matplotlib.ticker.SymmetricalLogLocator(transform=None, subs=None, linthresh=None, base=None)
[source]
Bases: matplotlib.ticker.Locator
Determine the tick locations for symmetric log axes
place ticks on the location= base**i*subs[j]
set_params(self, subs=None, numticks=None)
[source]
Set parameters within this locator.
tick_values(self, vmin, vmax)
[source]
Return the values of the located ticks given vmin and vmax.
Note
To get tick locations with the vmin and vmax values defined automatically for the associated axis
simply call the Locator instance:
>>> print(type(loc)) <type 'Locator'> >>> print(loc()) [1, 2, 3, 4]
view_limits(self, vmin, vmax)
[source]
Try to choose the view limits intelligently
class matplotlib.ticker.LogitLocator(minor=False)
[source]
Bases: matplotlib.ticker.Locator
Determine the tick locations for logit axes
place ticks on the logit locations
nonsingular(self, vmin, vmax)
[source]
Expand a range as needed to avoid singularities.
set_params(self, minor=None)
[source]
Set parameters within this locator.
tick_values(self, vmin, vmax)
[source]
Return the values of the located ticks given vmin and vmax.
Note
To get tick locations with the vmin and vmax values defined automatically for the associated axis
simply call the Locator instance:
>>> print(type(loc)) <type 'Locator'> >>> print(loc()) [1, 2, 3, 4]
© 2012–2018 Matplotlib Development Team. All rights reserved.
Licensed under the Matplotlib License Agreement.
https://matplotlib.org/3.1.1/api/ticker_api.html