Step 1: Get Your Matplotlib Project Ready

Before you can change any fonts, you need to open your Python environment and import the Matplotlib library. This is the first step for any project that uses Matplotlib to create plots.

Start by creating a new Python file or opening your existing script. At the very top, add the necessary import statements.

import matplotlib.pyplot as plt import numpy as np

This line is important for font management, especially if you add new fonts

from matplotlib import font_manager

Step 2: Check Which Fonts Are Available on Your System

It's a good idea to know which fonts Matplotlib can currently access. This helps prevent errors if you try to use a font that isn't installed or registered with Matplotlib's font system. You can list all the font families Matplotlib knows about.

Add the following code to your script and run it:

# This command rebuilds Matplotlib's font cache. # Do this if you've recently installed new fonts on your system. font_manager._rebuild()

Get a list of all available font families

available_fonts = sorted([f.name for f in font_manager.fontManager.ttflist]) print(“Available Fonts:”) for font in available_fonts: print(f”- {font}“)

This code first tells Matplotlib to rebuild its list of fonts. This is crucial if you've installed new fonts on your computer since the last time you ran Matplotlib. Then, it collects all font names and prints them out. Look through this list to confirm the name of the font you want to use, paying close attention to spelling and capitalization.

Step 3: Change the Global Font Family for All Text

The easiest way to change fonts across your entire Matplotlib plot is to modify the global settings, known as `rcParams` (runtime parameters). This will affect all text elements unless they are specifically overridden later.

You can set the main font family using `font.family`. Matplotlib often groups fonts into general categories like 'serif', 'sans-serif', 'monospace', 'cursive', and 'fantasy'. When you set `font.family` to one of these, Matplotlib will use the first available font from a list associated with that family.

For example, to use a sans-serif font:

# Example: Set a global sans-serif font plt.rcParams['font.family'] = 'sans-serif' plt.rcParams['font.sans-serif'] = ['Helvetica', 'Arial', 'Liberation Sans'] # Fallback order

Here, Matplotlib will try to find 'Helvetica' first. If 'Helvetica' isn't available, it will try 'Arial', then 'Liberation Sans', and so on. You can replace these with font names you found in Step 2.

To use a specific font directly, you can list it as the only option in the family list, or set `font.family` to the font name if it's not a generic family:

# Example: Set a specific global font (e.g., 'Times New Roman' or 'Consolas') plt.rcParams['font.family'] = 'serif' # Or 'monospace' plt.rcParams['font.serif'] = ['Times New Roman', 'DejaVu Serif', 'Computer Modern Roman']

Or, if you want to force a specific font as the only option:

plt.rcParams[‘font.family’] = ‘monospace’

plt.rcParams[‘font.monospace’] = [‘Consolas’]

After setting these parameters, any new plot you create will use these font settings for all text.

Step 4: Change Font Size and Weight Globally

Besides the font family, you might want to change the size and weight (boldness) of all text in your plots. This can also be done using `rcParams`.

You can set a global `font.size` for all text and `font.weight` for boldness. Common weights are 'normal', 'bold', 'light', or numerical values.

# Set global font size plt.rcParams['font.size'] = 12

Set global font weight (e.g., ‘normal’, ‘bold’, ‘light’)

plt.rcParams[‘font.weight’] = ‘normal’

For specific elements, you can also set sizes

plt.rcParams[‘axes.labelsize’] = 14 # Size for x and y axis labels

plt.rcParams[‘xtick.labelsize’] = 10 # Size for x-axis tick labels

plt.rcParams[‘ytick.labelsize’] = 10 # Size for y-axis tick labels

plt.rcParams[‘legend.fontsize’] = 12 # Size for legend text

plt.rcParams[‘figure.titlesize’] = 16 # Size for figure titles

Adjust the `font.size` to a value that makes your plot text readable without being too large or too small. Experiment with `font.weight` to see what looks best for your data visualization.

Step 5: Override Global Settings for Specific Text Elements

Sometimes you need a different font, size, or weight for a particular part of your plot, like the title or a specific label, without changing everything else. Matplotlib functions that add text to a plot often have `fontdict` or individual `fontname`, `fontsize`, `fontweight` arguments.

Here's how to change the font for titles, axis labels, and legend text specifically:

# Generate some example data x = np.linspace(0, 10, 100) y = np.sin(x)

plt.figure(figsize=(8, 6)) plt.plot(x, y, label=‘Sine Wave’)

Change font for the plot title

plt.title(‘My Custom Plot Title’, fontname=‘Times New Roman’, # Use a specific font fontsize=18, fontweight=‘bold’, color=‘navy’)

Change font for the X-axis label

plt.xlabel(‘X-axis Values’, fontname=‘Arial’, # Another font example fontsize=14, fontweight=‘light’, color=‘darkgreen’)

Change font for the Y-axis label

plt.ylabel(‘Y-axis Values’, fontname=‘Verdana’, fontsize=14, fontweight=‘normal’, color=‘purple’)

Change font for the legend text

plt.legend(prop={‘family’: ‘monospace’, ‘size’: 10, ‘weight’: ‘bold’})

plt.grid(True) plt.show()

In this example, `plt.title()`, `plt.xlabel()`, and `plt.ylabel()` all take `fontname`, `fontsize`, and `fontweight` arguments. For `plt.legend()`, you pass a dictionary to the `prop` argument to customize its font properties.

Step 6: Use Fonts from a File (Advanced)

What if the font you want to use isn't installed on your system, or you want to ensure your plot looks the same on any computer without needing to install the font? You can load a font directly from a `.ttf` (TrueType Font) or `.otf` (OpenType Font) file.

First, place your font file (e.g., `MyCustomFont.ttf`) in the same directory as your Python script, or provide its full path.

from matplotlib import font_manager, pyplot as plt import numpy as np

Path to your custom font file

font_path = ‘path/to/your/MyCustomFont.ttf’ # Change this to your actual path

Add the font to Matplotlib’s font manager

custom_font_properties = font_manager.FontProperties(fname=font_path)

Example plot

x = np.linspace(0, 10, 100) y = np.cos(x)

plt.figure(figsize=(8, 6)) plt.plot(x, y)

Use the custom font for the title

plt.title(‘Plot with Custom Font’, fontproperties=custom_font_properties, fontsize=16)

Use the custom font for labels (example: x-label)

plt.xlabel(‘Custom X-axis’, fontproperties=custom_font_properties, fontsize=12)

plt.grid(True) plt.show()

By creating a `FontProperties` object from your font file, you can then pass this object to the `fontproperties` argument of Matplotlib functions that accept it, like `plt.title()`, `plt.xlabel()`, `plt.ylabel()`, and `plt.text()`. This ensures the plot uses your exact font, regardless of whether it's globally installed.

Step 7: Reset Matplotlib Settings to Default

If you've made a lot of changes to `rcParams` and want to go back to Matplotlib's default settings, you can easily reset them. This is useful when starting a new plot or when troubleshooting font issues.

To reset all `rcParams` to their default values, use `plt.rcParams.update(plt.rcParamsDefault)`:

# Make some changes (for demonstration) plt.rcParams['font.family'] = 'serif' plt.rcParams['font.size'] = 16

This will reset all Matplotlib’s runtime parameters to their factory defaults

plt.rcParams.update(plt.rcParamsDefault)

Now, any new plot will use Matplotlib’s original default fonts and sizes.

print(plt.rcParams[‘font.family’]) # Will show the default, e.g., ‘sans-serif’

print(plt.rcParams[‘font.size’]) # Will show the default, e.g., 10.0

After running `plt.rcParams.update(plt.rcParamsDefault)`, any subsequent plots will revert to the default Matplotlib styling, including its default font choices and sizes.