Custom tick formatters in Matplotlib - Deep Dive

Overview - Custom tick formatters

What is it?

Custom tick formatters let you control how numbers or labels appear on the axes of a plot. Instead of default numbers, you can show dates, percentages, or any text you want. This helps make charts easier to understand and more meaningful. You create a small function or use built-in tools to change the tick labels.

Why it matters

Without custom tick formatters, charts can show confusing or unhelpful numbers that make it hard to read data. Custom formatting makes visuals clearer and more professional. It helps people quickly grasp the story behind the data, which is important in reports, presentations, or dashboards.

Where it fits

Before learning custom tick formatters, you should know how to create basic plots and understand axes and ticks in matplotlib. After this, you can learn about advanced axis control, interactive plots, and styling for publication-quality visuals.

Mental Model

Core Idea

Custom tick formatters transform raw axis values into readable labels that match your data story.

Think of it like...

It's like choosing how to label the hours on a clock: you can show numbers, words like 'noon', or even icons to make telling time easier.

Axis with ticks:
┌─────────────────────────┐
│                         │
│    ┌─┬─┬─┬─┬─┬─┬─┬─┐    │
│    │ │ │ │ │ │ │ │ │    │
│    0 1 2 3 4 5 6 7 8    │
│                         │
└─────────────────────────┘

Custom formatter changes labels:
0 → 'Start'
1 → '10%'
2 → '20%'
... etc.

Build-Up - 7 Steps

1

Foundation

Understanding basic ticks and labels

Concept: Learn what ticks and tick labels are in a plot and how matplotlib shows them by default.

In matplotlib, ticks are marks on the axis showing positions. Tick labels are the numbers or text shown at these marks. By default, matplotlib chooses where to put ticks and what numbers to show. For example, on a plot from 0 to 10, ticks might be at 0, 2, 4, 6, 8, 10 with labels showing those numbers.

Result

You see a plot with axes labeled by default numbers at regular intervals.

Knowing the difference between ticks (positions) and tick labels (text) is key to customizing how your plot communicates data.

2

Foundation

Using built-in tick formatters

Concept: Matplotlib provides ready-made formatters for common label styles like percentages or dates.

You can import formatters like PercentFormatter or DateFormatter from matplotlib.ticker. For example, PercentFormatter multiplies numbers by 100 and adds a % sign. You apply these formatters to an axis to change how labels appear without writing your own code.

Result

The axis labels change to show percentages or formatted dates automatically.

Built-in formatters save time and ensure consistent formatting for common cases.

3

Intermediate

Creating simple custom formatter functions

🤔Before reading on: do you think a custom formatter function must return a string or can it return a number? Commit to your answer.

Concept: You can write your own function that takes a tick value and returns a string label.

Define a function that receives a tick value and position, then returns a string. For example, a function that converts numbers to words or adds units. Then use FuncFormatter from matplotlib.ticker to apply it to an axis. This lets you fully control label text.

Result

Axis labels show your custom text instead of default numbers.

Understanding that tick formatters are just functions mapping values to strings unlocks full control over axis labels.

4

Intermediate

Applying custom formatters to different axes

🤔Before reading on: can you apply different custom formatters to x and y axes independently? Commit to yes or no.

Concept: You can assign different formatters to x-axis and y-axis separately to customize each axis independently.

Use ax.xaxis.set_major_formatter() and ax.yaxis.set_major_formatter() to set different formatters. For example, x-axis can show dates while y-axis shows percentages or custom text. This flexibility helps tailor each axis to its data type.

Result

Plot shows different label styles on x and y axes as specified.

Knowing axes are independent lets you create clearer, more informative plots by customizing each axis separately.

5

Intermediate

Handling minor ticks with custom formatters

Concept: Besides major ticks, matplotlib has minor ticks that can also be formatted separately.

You can set formatters for minor ticks using ax.xaxis.set_minor_formatter() or ax.yaxis.set_minor_formatter(). This is useful when minor ticks need labels or special formatting, like showing smaller units or extra detail.

Result

Minor ticks display labels formatted differently or more detailed than major ticks.

Customizing minor ticks enhances plot detail and precision when needed.

6

Advanced

Using classes for complex tick formatting

🤔Before reading on: do you think a class-based formatter can maintain state between calls? Commit to yes or no.

Concept: You can create a class with a __call__ method to format ticks, allowing state or configuration to persist.

Define a class with __call__(self, x, pos) method that returns a string. This lets you keep counters, caches, or complex logic inside the formatter. Then pass an instance of this class to FuncFormatter. This approach is powerful for advanced formatting needs.

Result

Axis labels reflect complex, stateful formatting logic.

Using classes for formatters enables advanced, reusable, and stateful label formatting beyond simple functions.

7

Expert

Optimizing performance for large plots

🤔Before reading on: do you think tick formatters are called for every pixel or only for visible ticks? Commit to your answer.

Concept: Tick formatters are called only for visible ticks, but inefficient formatter code can slow down rendering on large plots.

When plotting large datasets or interactive zooming, formatters run often. Writing fast, simple formatter functions avoids lag. Avoid heavy computations or slow string operations inside formatters. Cache results if possible. This keeps plots responsive.

Result

Plots render smoothly even with custom formatting on large or interactive data.

Understanding formatter call frequency guides writing efficient code that scales well in real-world applications.

Under the Hood

Matplotlib's axis objects hold lists of tick positions. When drawing, matplotlib calls the formatter function or object for each tick position to get the label string. This happens during the rendering phase. The formatter receives the tick value and position index, then returns a string. The axis then draws this string at the tick location.

Why designed this way?

This design separates data (tick positions) from presentation (labels), allowing flexible label customization without changing data. Using callable formatters lets users provide any logic for labels. It also supports built-in formatters for common cases, balancing ease and power.

┌───────────────┐
│ Axis object   │
│ ┌───────────┐ │
│ │ Tick list │ │
│ └───────────┘ │
│       │       │
│       ▼       │
│ ┌───────────┐ │
│ │ Formatter │ │
│ │ (func or  │ │
│ │  callable)│ │
│ └───────────┘ │
│       │       │
│       ▼       │
│ Label strings │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does changing tick labels change the data values on the plot? Commit yes or no.

Common Belief: Changing tick labels changes the actual data values or scale on the plot.

Reality: Tick formatters only change how labels look; the underlying data and scale remain the same.

Why it matters: Confusing labels with data can lead to wrong conclusions or attempts to fix data by changing labels.

Quick: Can you use any function as a tick formatter without wrapping it? Commit yes or no.

Common Belief: Any function that returns a string can be directly assigned as a tick formatter.

Reality: Matplotlib requires formatters to accept two arguments (value and position), so simple functions need wrapping with FuncFormatter.

Why it matters: Not wrapping functions correctly causes errors or no label changes, frustrating beginners.

Quick: Do minor ticks always have labels by default? Commit yes or no.

Common Belief: Minor ticks show labels automatically like major ticks.

Reality: Minor ticks usually do not show labels unless explicitly formatted and enabled.

Why it matters: Expecting minor tick labels without setup leads to confusion about missing labels.

Quick: Does using a class-based formatter always improve performance? Commit yes or no.

Common Belief: Class-based formatters are faster than function-based ones.

Reality: Performance depends on code inside the formatter, not whether it is a class or function.

Why it matters: Misunderstanding this can lead to unnecessary complexity without speed benefits.

Expert Zone

1

Custom formatters can be combined with locator objects to control both tick positions and labels precisely.

2

Formatter functions can access external state or data to create dynamic labels that change with plot updates or user interaction.

3

Using caching inside formatters avoids repeated expensive computations when ticks don't change between redraws.

When NOT to use

Avoid custom tick formatters when default labels are clear and sufficient; over-formatting can confuse viewers. For very complex axis labeling, consider using annotations or interactive tooltips instead.

Production Patterns

Professionals use custom formatters to localize numbers (currency, units), format dates in time series, or create multi-line labels. They combine formatters with styling and interactive features for dashboards and reports.

Connections

String formatting

Custom tick formatters rely on string formatting techniques to convert numbers to readable text.

Mastering string formatting in programming helps create flexible and clear tick labels.

Human-computer interaction (HCI)

Custom tick formatting improves how users perceive and understand data visualizations.

Good label design is a key part of making data accessible and intuitive, a core HCI goal.

Localization and internationalization

Custom tick formatters can adapt labels to different languages, units, or cultural formats.

Understanding localization helps create visuals that communicate effectively worldwide.

Common Pitfalls

#1 Formatter function returns a number instead of a string.

Wrong approach:

def formatter(x, pos):
return x * 100 # returns number, not string
ax.xaxis.set_major_formatter(FuncFormatter(formatter))

Correct approach:

def formatter(x, pos):
return f'{x * 100:.0f}%' # returns string with %
ax.xaxis.set_major_formatter(FuncFormatter(formatter))

Root cause:

Tick labels must be strings; returning numbers causes matplotlib to fail or show default labels.

#2 Assigning a simple function without two arguments as formatter directly.

Wrong approach:

def simple_formatter(x):
return f'{x:.2f}'
ax.xaxis.set_major_formatter(simple_formatter) # wrong, missing pos argument

Correct approach:

from matplotlib.ticker import FuncFormatter

def simple_formatter(x, pos):
return f'{x:.2f}'
ax.xaxis.set_major_formatter(FuncFormatter(simple_formatter))

Root cause:

Matplotlib expects formatter functions to accept two arguments; missing pos causes errors.

#3 Expecting minor ticks to show labels without enabling them.

Wrong approach:

ax.minorticks_on()
# but no formatter set for minor ticks, so no labels appear

Correct approach:

ax.minorticks_on()
ax.xaxis.set_minor_formatter(FuncFormatter(lambda x, pos: f'{x:.1f}'))

Root cause:

Minor ticks need explicit formatters to display labels; turning them on alone is not enough.

Key Takeaways

Custom tick formatters let you change how axis labels appear without altering the data.

They work by mapping tick values to strings using functions or callable objects.

Built-in formatters cover common cases, but writing your own gives full control.

Formatter functions must accept two arguments: the tick value and its position.

Efficient formatter code is important for smooth plotting, especially with large or interactive data.