# 5 Best Ways to Set Axis Ticks in Multiples of Pi in Python Matplotlib

Rate this post

π‘ Problem Formulation: When plotting mathematical functions in Python using Matplotlib, setting axis ticks in multiples of Ο (pi) enhances the readability of graphs involving trigonometric functions. Users seek methods to adjust the axis ticks to display values like Ο/2, Ο, 3Ο/2, etc. For example, instead of seeing 1.57 on the x-axis, the user would prefer to see Ο/2, thus requiring customized axis ticks.

## Method 1: Using MultipleLocator and FuncFormatter

This method involves using Matplotlib’s MultipleLocator to specify the tick frequency and FuncFormatter to format the ticks in multiples of Ο. With MultipleLocator, you can set the spacing between ticks, and FuncFormatter allows for custom tick label formatting.

Here’s an example:

import matplotlib.pyplot as plt
from matplotlib.ticker import MultipleLocator, FuncFormatter
import numpy as np

plt.figure()
ax = plt.subplot(111)

def format_fn(tick_val, tick_pos):
if int(tick_val) == 0:
return "0"
elif int(tick_val) in np.arange(1, 2*np.pi, step=1):
return r'$\%d\pi$' % tick_val
else:
return r'$\%d\pi/2$' % (tick_val*2)

ax.xaxis.set_major_locator(MultipleLocator(base=np.pi / 2))
ax.xaxis.set_major_formatter(FuncFormatter(format_fn))

x = np.linspace(-2*np.pi, 2*np.pi, 100)
y = np.sin(x)
ax.plot(x, y)

plt.show()

The output is a plot with x-axis ticks labeled in multiples of Ο/2 (-2Ο, -3Ο/2, -Ο, …, 2Ο).

This code creates a sine wave and formats the x-axis ticks using the MultipleLocator to set the tick spacing to Ο/2 and the FuncFormatter to display the ticks as multiples of Ο. Custom logic in format_fn helps ensure the ticks are labeled correctly, considering both full Ο and half Ο increments.

## Method 2: Using Matplotlib’s Ticker Module

Matplotlib’s ticker module provides a function FormatStrFormatter, which can be used directly to format tick labels. This method lets you specify a string format for the ticks, useful for simple tick structures.

Here’s an example:

import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import numpy as np

x = np.linspace(0, 4 * np.pi, 100)
y = np.sin(x)

fig, ax = plt.subplots()
ax.plot(x, y)
ax.xaxis.set_major_formatter(ticker.FormatStrFormatter('%g $\pi$'))
ax.xaxis.set_major_locator(ticker.MultipleLocator(base=np.pi))

plt.show()

The output is a plot with x-axis ticks labeled in Ο increments (Ο, 2Ο, 3Ο, 4Ο).

The code snippet uses ticker.FormatStrFormatter to set the format of the ticks to be in multiples of Ο, where ‘%g’ is a placeholder for the tick value divided by Ο. The ticker.MultipleLocator is set with a base of Ο, thus placing a tick at every Ο interval on the x-axis.

## Method 3: Custom Tick Formatter Function

Creating a custom tick formatter function provides the most flexibility. This function can take in a tick value and return a string for the label. You can pair this with a custom locator or use the default locators.

Here’s an example:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-np.pi, np.pi, 100)
y = np.sin(x)

fig, ax = plt.subplots()
ax.plot(x, y)

def custom_formatter(x, pos):
if x == 0:
return "0"
den = int(np.pi / np.abs(x))
num = int(abs(x) / np.pi)
if den == 1:
return r'${}\pi$'.format(num * np.sign(x))
return r'$\frac{{{}{}\pi}}{{{}}}$'.format('' if num == 1 else num, '-' if x < 0 else '', den)

ax.xaxis.set_major_formatter(plt.FuncFormatter(custom_formatter))

plt.show()

The output is a sine wave plot with correctly formatted tick labels as multiples of Ο on the x-axis, including proper fractions for non-integer multiples.

The example illustrates the use of a custom function, custom_formatter, to define the label formatting for the x-axis ticks. This function accounts for zero, negative values, and fractional multiples of Ο to create precise tick labels suitable for any trigonometric plot.

## Method 4: Setting Tick Labels Manually

If the range of the x-axis is fixed and known, you can manually set the tick locations and labels. This method gives you direct control over the ticks and labels but is less flexible if the axis range changes.

Here’s an example:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-2 * np.pi, 2 * np.pi, 100)
y = np.sin(x)

ticks = [-2 * np.pi, -np.pi, 0, np.pi, 2 * np.pi]
tick_labels = [r"$-2\pi$", r"$-\pi$", "0", r"$\pi$", r"$2\pi$"]

fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_xticks(ticks)
ax.set_xticklabels(tick_labels)

plt.show()

The output is a plot with manually set x-axis ticks at every Ο increment, including -2Ο, -Ο, 0, Ο, and 2Ο, as specified in the tick_labels list.

This code directly sets the x-axis ticks using set_xticks and set_xticklabels to the desired positions and labels. The list of tick positions and corresponding tick labels are predefined, which simplifies the process but loses dynamism in the plot scaling.

## Bonus One-Liner Method 5: Using Numpy and List Comprehensions

This one-liner solution combines the power of NumPy for calculations and list comprehensions for building label lists, offering a quick and compact way to set custom tick labels for a fixed range.

Here’s an example:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-2 * np.pi, 2 * np.pi, 100)
y = np.sin(x)
fig, ax = plt.subplots()
ax.plot(x, y)

ticks = np.arange(-2 * np.pi, 2.01 * np.pi, np.pi / 2)
tick_labels = [f"${'{:.0f}'.format(n) if n % 1 else '{:.0f}'.format(n/np.pi)+'\pi'}$" for n in ticks/np.pi]

ax.set_xticks(ticks)
ax.set_xticklabels(tick_labels)

plt.show()

The output is a sine wave graph with x-axis ticks set at Ο/2 increments along the axis, with labels represented in terms of Ο.

This method demonstrates the terseness and elegance of Python list comprehensions for creating formatted label strings, combined with NumPy’s array operations to calculate the actual tick positions along the axis.

## Summary/Discussion

Method 1: Using MultipleLocator and FuncFormatter. Ideal for dynamic plots with scale changes. Requires writing a custom formatter function. Method 2: Matplotlib’s Ticker Module. Simpler for basic tick structures. Less flexible for more complex tick labels. Method 3: Custom Tick Formatter Function. Offers maximum customization capability. May require more complex logic for different situations. Method 4: Setting Tick Labels Manually. Works well for static plots with known ranges. Lacks flexibility and can be impractical for dynamic ranges. Method 5: NumPy and List Comprehensions. A concise one-liner suitable for fixed ranges. Not as flexible or readable as other methods for dynamic scaling.