Step 1: Find Available Fonts on Your System

Before you can change the font, you need to know which fonts Matplotlib can actually see. The default font is often 'DejaVu Sans', which is fine but very common. To make your plots stand out, you'll want to choose something else. You can get a list of all the fonts Matplotlib recognizes on your computer.

To do this, you can run a short piece of Python code. This code imports the necessary part of Matplotlib called font_manager and then prints out a list of the font family names it finds.

import matplotlib.font_manager as fm
font_list = sorted([f.name for f in fm.fontManager.ttflist])
print(font_list)

Run this code. You will see a long list of font names printed out, such as 'Arial', 'Calibri', 'Courier New', and many others. Pick a font name from this list for the next steps. Make sure you copy the name exactly as it appears.

Step 2: Change the Font Globally with rcParams

The most common and powerful way to change the font is to set it for your entire script. This means every plot you create in that script will automatically use your chosen font for titles, labels, and ticks. This is done using Matplotlib's runtime configuration parameters, or rcParams for short.

Think of rcParams as a big dictionary of settings that control how your plots look. We're going to change the 'font.family' setting.

At the top of your Python script, right after you import Matplotlib, add the following lines. Replace 'Georgia' with the font name you chose in Step 1.

import matplotlib.pyplot as plt
plt.rcParams['font.family'] = 'Georgia'

Now, any plot you create will use the Georgia font. For example:

plt.figure()
plt.plot([0, 1], [0, 1])
plt.title('This is a Title in Georgia')
plt.xlabel('X-axis Label')
plt.ylabel('Y-axis Label')
plt.show()

When you run this, you should see that all the text on the plot has changed from the default to Georgia. This method is great for keeping a consistent style across a report or project.

Step 3: Change the Font for a Single Text Element

Sometimes, you don't want to change the font for the entire plot. You might want to make only the title stand out with a different font, size, or style. You can do this by passing a dictionary of font properties directly to the function that creates the text.

This is often done using the fontdict argument, which is available for functions like plt.title(), plt.xlabel(), and plt.ylabel(). Inside this dictionary, you can specify the font family, size, weight (like 'bold'), and style (like 'italic').

Here’s an example where we set the title to 'Times New Roman' and make it bold, while the rest of the plot uses the default font.

import matplotlib.pyplot as plt

title_font = {'family': 'Times New Roman', 'weight': 'bold', 'size': 16}

plt.figure()
plt.plot([0, 1], [0, 1])
plt.title('A Special Title', fontdict=title_font)
plt.xlabel('Default Font Label')
plt.show()

In this code, we first create a dictionary called title_font to hold our desired settings. Then, we pass it to plt.title() using fontdict=title_font. This gives you precise control over individual parts of your plot.

Step 4: Use Generic Font Families for Portability

What happens if you send your code to someone who doesn't have the 'Georgia' font installed? Matplotlib will show an error or fall back to its default font. To avoid this, you can use generic family names. These are 'serif' (like Times New Roman), 'sans-serif' (like Arial or Helvetica), and 'monospace' (like Courier).

When you set the font family to a generic name, Matplotlib will look for the best available font in that category on the current system. This makes your code more portable and less likely to break on different computers.

You can specify a list of fonts, starting with your most desired one and ending with a generic family as a fallback.

import matplotlib.pyplot as plt
plt.rcParams['font.family'] = 'sans-serif'
plt.rcParams['font.sans-serif'] = ['Verdana', 'Arial', 'DejaVu Sans']

In this example, we tell Matplotlib to use a sans-serif font. Then we give it a priority list: first, try to find and use 'Verdana'. If that's not available, try 'Arial'. If that also fails, use 'DejaVu Sans'. This is a very robust way to manage fonts.

Step 5: Use a Custom Font from a File

If you have a special font for your company or project that isn't installed on your system (for example, one you downloaded from Google Fonts), you can still use it. You just need to tell Matplotlib where to find the font file (usually a .ttf or .otf file).

You do this using the FontProperties object from the font manager. You create an instance of this object and pass the path to your font file. Then, you can use this object in the fontproperties argument of your text functions.

Let's say you have a font file named 'MyCustomFont.ttf' in the same folder as your script.

import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties

font_path = './MyCustomFont.ttf'
custom_font = FontProperties(fname=font_path)

plt.figure()
plt.plot([0, 1], [0, 1])
plt.title('Title in a Custom Font', fontproperties=custom_font, size=20)
plt.xlabel('X-axis in a Custom Font', fontproperties=custom_font, size=12)
plt.show()

This method is perfect for ensuring your visualisations have a unique and consistent brand identity, even if the font isn't widely available.

Step 6: Clear and Rebuild the Font Cache

This is the most important troubleshooting step for fonts in Matplotlib. As mentioned earlier, Matplotlib keeps a cache file of all the fonts it knows about to speed things up. If you install a new font on your system or add a custom font file, Matplotlib won't see it until this cache is updated.

If you've tried to use a new font and it's not working, or you get a "font not found" warning, you almost certainly need to rebuild the cache.

To do this, you need to run a simple piece of code. Important: After running this code, you must restart your Python session. If you're in a Jupyter Notebook, this means restarting the kernel. If you're running a script, just close the terminal and open a new one.

import matplotlib.font_manager
matplotlib.font_manager._rebuild()

After running this and restarting, Matplotlib will rescan your system for fonts, find the new one you installed, and your previous code should now work correctly. Do this anytime you make changes to the fonts on your computer.

Step 7: Make Permanent Font Changes with matplotlibrc

If you find yourself changing the font in every single script, you can make the change permanent by editing the Matplotlib configuration file, called matplotlibrc. This sets the default for your entire system, so you don't have to add the `rcParams` line to your code ever again.

First, you need to find where this file is located. You can find the path by running this code:

import matplotlib
print(matplotlib.matplotlib_fname())

This will print a file path. Navigate to that location on your computer and open the `matplotlibrc` file with a plain text editor (like Notepad or TextEdit). If the file doesn't exist, you can create it. Look for the line that starts with #font.family. The '#' symbol means the line is a comment and is currently ignored.

To set your new default font, remove the '#' at the beginning of the line and change the value. For example, to make 'Georgia' the default:

Change this:
#font.family: sans-serif

To this:
font.family: Georgia

Save the file. Now, every Matplotlib plot you create on your computer will use Georgia as the default font, without you needing to add any extra code. This is the ultimate "set it and forget it" solution.