5 Best Ways to Set the Y-Axis in Radians in a Python Plot

💡 Problem Formulation: When visualizing data with trigonometric functions in Python, setting the y-axis to radians can improve readability and interpretation. For example, if you’re plotting a sine wave, the input might range from 0 to 2π, and you’d want the y-axis to display these values in radians to match the x-axis scale.

Method 1: Using Matplotlib Ticker

This method involves the matplotlib library’s matplotlib.ticker module, which allows you to customize the tick marks and labels on a plot. By changing the y-axis formatter, you can set it to display values in radians.

Here’s an example:

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

# Define a formatter function
def radian_formatter(x, pos):
    return r'${0}\pi$'.format(x/np.pi)

plt.plot(np.linspace(0, 2*np.pi, 100), np.sin(np.linspace(0, 2*np.pi, 100)))
plt.gca().yaxis.set_major_formatter(FuncFormatter(radian_formatter))
plt.show()

The output is a plot with the y-axis tick labels formatted to display in radians.

This code snippet creates a sine wave plot. The radian_formatter function formats the tick labels as multiples of π. The FuncFormatter takes this function and applies it to the y-axis using the set_major_formatter method.

Method 2: Tweaking the Scale Using NumPy

NumPy’s vectorized operations can be used to convert y-axis values to radians before plotting. This is a preprocessing step that can be applied when you have control over the data before plotting.

Here’s an example:

import matplotlib.pyplot as plt
import numpy as np

y_values = np.linspace(0, 2*np.pi, 100)
plt.plot(np.linspace(0, 2*np.pi, 100), np.sin(y_values))
plt.yticks(np.arange(-1, 1.5, 0.5), [r'${0}\pi$'.format(i) for i in np.arange(-1, 1.5, 0.5)])
plt.show()

The output is a plot with custom y-axis tick labels set in radians.

In this example, we manipulate the yticks directly. We use NumPy to create an array of y-axis values and assign these as tick marks on the plot. Each tick label is formatted as a multiple of π.

Method 3: Custom Ticks Using OOP Interface

The Object-Oriented Programming (OOP) interface in matplotlib allows for more granular control over plot elements. By using the set_yticks and set_yticklabels methods on the axis object, custom ticks in radians can be set.

Here’s an example:

import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots()
ax.plot(np.linspace(0, 2*np.pi, 100), np.sin(np.linspace(0, 2*np.pi, 100)))
ax.set_yticks(np.arange(-1, 2, 0.5))
ax.set_yticklabels([r'${0}\pi$'.format(y/np.pi) for y in np.arange(-1, 2, 0.5)])
plt.show()

The output is a more customizable plot with hand-picked y-axis tick labels set to radians.

The OOP approach provides better control over the axes. This code sets y-axis ticks and labels to radians manually by creating a list of the desired tick positions and their corresponding formatted labels.

Method 4: Using AxesGrid Toolkit

The AxesGrid toolkit in Matplotlib provides tools for layouting multiple axes. It can be overkill for simple plots but is useful for complex figure layouts. We can still use it to define custom y-axis tick labels in radians.

Here’s an example:

from mpl_toolkits.axes_grid1 import AxesGrid
import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure(figsize=(6, 6))
grid = AxesGrid(fig, 111, nrows_ncols=(1, 1), axes_pad=0.5, label_mode="L",
                share_all=True, cbar_location="right", cbar_mode="single")

for ax in grid:
    ax.plot(np.linspace(0, 2*np.pi, 100), np.sin(np.linspace(0, 2*np.pi, 100)))
    ax.set_yticks(np.arange(-1, 2, 0.5))
    ax.set_yticklabels([f'{y/np.pi:.1f}π' for y in np.arange(-1, 2, 0.5)])

plt.show()

The output displays a plot with the y-axis in radians utilising the AxesGrid toolkit’s layout capabilities.

This snippet demonstrates a complex approach, where an AxesGrid is created to manage the plot’s layout. The ticks and labels on the y-axis are then set similar to the previous example but within this structured grid layout.

Bonus One-Liner Method 5: Lambda Formatter Function

For a quick and concise solution, a lambda function can be used with Matplotlib’s FuncFormatter. This one-liner method is elegant when you need to quickly set the y-axis format without external functions.

Here’s an example:

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

plt.plot(np.linspace(0, 2*np.pi, 100), np.sin(np.linspace(0, 2*np.pi, 100)))
plt.gca().yaxis.set_major_formatter(FuncFormatter(lambda x, _: f'{x/np.pi:.1f}π'))
plt.show()

The output is a plot with the y-axis labels formatted in radians using a lambda function.

This method employs a concise lambda function directly within the FuncFormatter. This simple approach provides inline formatting of tick labels as multiples of π without needing a separate function definition.

Summary/Discussion

• Method 1: Using Matplotlib Ticker. Offers a balance between customizability and simplicity. Requires a bit of boilerplate code.
• Method 2: Tweaking the Scale Using NumPy. Great for preprocessing data. May not be as dynamic as other methods.
• Method 3: Custom Ticks Using OOP Interface. Provides fine control. Slightly more verbose and complex for beginners.
• Method 4: Using AxesGrid Toolkit. Suited for complex figures and multiple plots. Overly complex for simple plotting needs.
• Bonus Method 5: Lambda Formatter Function. Quick and straightforward. Lacks some readability and flexibility of a defined formatter function.