Comment changer la taille de la police sur un tracé matplotlib

542

Comment change-t-on la taille de la police pour tous les éléments (ticks, étiquettes, titre) sur un tracé matplotlib?

Je sais comment changer la taille des étiquettes des ticks, cela se fait avec:

import matplotlib 
matplotlib.rc('xtick', labelsize=20) 
matplotlib.rc('ytick', labelsize=20)

Mais comment change-t-on le reste?

python matplotlib font-size

— Herman Schaaf
source

631

De la documentation de matplotlib ,

font = {'family' : 'normal',
        'weight' : 'bold',
        'size'   : 22}

matplotlib.rc('font', **font)

Cela définit la police de tous les éléments sur la police spécifiée par l'objet kwargs, font .

Alternativement, vous pouvez également utiliser la rcParams updateméthode comme suggéré dans cette réponse :

matplotlib.rcParams.update({'font.size': 22})

ou

import matplotlib.pyplot as plt
plt.rcParams.update({'font.size': 22})

Vous pouvez trouver une liste complète des propriétés disponibles sur la page Customizing matplotlib .

— Herman Schaaf
source

2

agréable, sauf qu'il remplace toute propriété de police trouvée sur son chemin è_é

— yota

2

Où puis - je trouver plus d' options pour les éléments tels que 'family', 'weight'etc.?

— haccks

2

@HermanSchaaf; J'ai déjà visité cette page. Je voudrais savoir toutes les options 'family'comme 'normal', 'sans-serif', etc.

— haccks

77

Comme beaucoup de gens commencent par import matplotlib.pyplot as plt, vous pouvez vous signaler que pyplota rcaussi bien. Vous pouvez le faire plt.rc(...sans avoir à modifier vos importations.

— LondonRob

21

Pour les impatients: la taille de police par défaut est 10, comme dans le deuxième lien.

— FvD

304

Si vous êtes un maniaque du contrôle comme moi, vous pouvez définir explicitement toutes vos tailles de police:

import matplotlib.pyplot as plt

SMALL_SIZE = 8
MEDIUM_SIZE = 10
BIGGER_SIZE = 12

plt.rc('font', size=SMALL_SIZE)          # controls default text sizes
plt.rc('axes', titlesize=SMALL_SIZE)     # fontsize of the axes title
plt.rc('axes', labelsize=MEDIUM_SIZE)    # fontsize of the x and y labels
plt.rc('xtick', labelsize=SMALL_SIZE)    # fontsize of the tick labels
plt.rc('ytick', labelsize=SMALL_SIZE)    # fontsize of the tick labels
plt.rc('legend', fontsize=SMALL_SIZE)    # legend fontsize
plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title

Notez que vous pouvez également définir les tailles appelant la rcméthode sur matplotlib:

import matplotlib

SMALL_SIZE = 8
matplotlib.rc('font', size=SMALL_SIZE)
matplotlib.rc('axes', titlesize=SMALL_SIZE)

# and so on ...

— Pedro M Duarte
source

9

J'ai essayé plusieurs des réponses. Celui-ci est le meilleur, au moins dans les cahiers Jupyter. Copiez simplement le bloc ci-dessus en haut et personnalisez les trois constantes de taille de police.

— fviktor

3

D'accord avec fvitkor, c'est la meilleure réponse!

— SeF

9

Pour moi, la taille du titre n'a pas fonctionné. J'ai utilisé:plt.rc('axes', titlesize=BIGGER_SIZE)

— Fernando Irarrázaval G

1

Je pense que vous pouvez combiner tous les paramètres du même objet sur une seule ligne. Par exemple,plt.rc('axes', titlesize=SMALL_SIZE, labelsize=MEDIUM_SIZE)

— BallpointBen

198

matplotlib.rcParams.update({'font.size': 22})

— Marius Retegan
source

1

Dans le cas où cette solution ne fonctionne que si je crée un premier tracé, puis "mettre à jour" comme suggéré, ce qui conduit à une taille de police mise à jour pour les nouveaux chiffres. Peut-être que le premier complot est nécessaire pour initialiser rcParams ...

— Songio

191

Si vous souhaitez modifier la taille de police pour un tracé spécifique qui a déjà été créé, essayez ceci:

import matplotlib.pyplot as plt

ax = plt.subplot(111, xlabel='x', ylabel='y', title='title')
for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +
             ax.get_xticklabels() + ax.get_yticklabels()):
    item.set_fontsize(20)

— ryggyr
source

1

Mon but était d'avoir la police des étiquettes xy, des ticks et des titres de tailles différentes. Une version modifiée de cela a si bien fonctionné pour moi.

— Ébe Isaac

6

Pour obtenir également les légendes, utilisez ax.legend (). Get_texts (). Testé sur Matplotlib 1.4.

— James S.

Cela répond le plus directement à la question. Je vous remercie.

— jimh

Pourrait avoir besoin d'un ax=plt.gca()si le tracé a été créé sans définir d'axe.

— dylnan

@JamesS. Utilisez plutôt ax.get_legend().get_texts(), car ax.legend()redessine toute la légende avec des paramètres par défaut en plus de renvoyer la valeur de ax.get_legend().

— Guimoute

69

Mise à jour: Voir le bas de la réponse pour une façon légèrement meilleure de le faire.
Mise à jour n ° 2: j'ai également découvert la modification des polices de titre de légende.
Mise à jour # 3: il y a un bogue dans Matplotlib 2.0.0 qui fait que les étiquettes de tick pour les axes logarithmiques reviennent à la police par défaut. Devrait être corrigé dans 2.0.1 mais j'ai inclus la solution de contournement dans la 2ème partie de la réponse.

Cette réponse s'adresse à toute personne essayant de modifier toutes les polices, y compris pour la légende, et à toute personne essayant d'utiliser des polices et des tailles différentes pour chaque chose. Il n'utilise pas rc (ce qui ne semble pas fonctionner pour moi). C'est assez lourd mais je n'ai pas pu me familiariser avec une autre méthode personnellement. Il combine essentiellement la réponse de ryggyr ici avec d'autres réponses sur SO.

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

# Set the font dictionaries (for plot title and axis titles)
title_font = {'fontname':'Arial', 'size':'16', 'color':'black', 'weight':'normal',
              'verticalalignment':'bottom'} # Bottom vertical alignment for more space
axis_font = {'fontname':'Arial', 'size':'14'}

# Set the font properties (for use in legend)   
font_path = 'C:\Windows\Fonts\Arial.ttf'
font_prop = font_manager.FontProperties(fname=font_path, size=14)

ax = plt.subplot() # Defines ax variable by creating an empty plot

# Set the tick labels font
for label in (ax.get_xticklabels() + ax.get_yticklabels()):
    label.set_fontname('Arial')
    label.set_fontsize(13)

x = np.linspace(0, 10)
y = x + np.random.normal(x) # Just simulates some data

plt.plot(x, y, 'b+', label='Data points')
plt.xlabel("x axis", **axis_font)
plt.ylabel("y axis", **axis_font)
plt.title("Misc graph", **title_font)
plt.legend(loc='lower right', prop=font_prop, numpoints=1)
plt.text(0, 0, "Misc text", **title_font)
plt.show()

L'avantage de cette méthode est qu'en ayant plusieurs dictionnaires de polices, vous pouvez choisir différentes polices / tailles / poids / couleurs pour les différents titres, choisir la police pour les étiquettes de coche et choisir la police pour la légende, le tout indépendamment.

MISE À JOUR:

J'ai élaboré une approche légèrement différente et moins encombrée qui supprime les dictionnaires de polices et autorise toutes les polices de votre système, même les polices .otf. Pour avoir des polices distinctes pour chaque chose, il suffit d'écrire plus de variables font_pathet de les font_propaimer.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.font_manager as font_manager
import matplotlib.ticker
# Workaround for Matplotlib 2.0.0 log axes bug https://github.com/matplotlib/matplotlib/issues/8017 :
matplotlib.ticker._mathdefault = lambda x: '\\mathdefault{%s}'%x 

# Set the font properties (can use more variables for more fonts)
font_path = 'C:\Windows\Fonts\AGaramondPro-Regular.otf'
font_prop = font_manager.FontProperties(fname=font_path, size=14)

ax = plt.subplot() # Defines ax variable by creating an empty plot

# Define the data to be plotted
x = np.linspace(0, 10)
y = x + np.random.normal(x)
plt.plot(x, y, 'b+', label='Data points')

for label in (ax.get_xticklabels() + ax.get_yticklabels()):
    label.set_fontproperties(font_prop)
    label.set_fontsize(13) # Size here overrides font_prop

plt.title("Exponentially decaying oscillations", fontproperties=font_prop,
          size=16, verticalalignment='bottom') # Size here overrides font_prop
plt.xlabel("Time", fontproperties=font_prop)
plt.ylabel("Amplitude", fontproperties=font_prop)
plt.text(0, 0, "Misc text", fontproperties=font_prop)

lgd = plt.legend(loc='lower right', prop=font_prop) # NB different 'prop' argument for legend
lgd.set_title("Legend", prop=font_prop)

plt.show()

J'espère que c'est une réponse complète

— binaryfunt
source

40

Voici une approche totalement différente qui fonctionne étonnamment bien pour changer les tailles de police:

Changez la taille de la figure !

J'utilise habituellement du code comme celui-ci:

import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure(figsize=(4,3))
ax = fig.add_subplot(111)
x = np.linspace(0,6.28,21)
ax.plot(x, np.sin(x), '-^', label="1 Hz")
ax.set_title("Oscillator Output")
ax.set_xlabel("Time (s)")
ax.set_ylabel("Output (V)")
ax.grid(True)
ax.legend(loc=1)
fig.savefig('Basic.png', dpi=300)

Plus la taille de la figure est petite, plus la police est grande par rapport au tracé . Cela améliore également les marqueurs. Remarque J'ai également défini le dpiou le point par pouce. J'ai appris cela en postant le forum AMTA (American Modeling Teacher of America). Exemple du code ci-dessus:

— Prof Huster
source

7

Pour éviter que l'étiquette de l'axe ne soit coupée, enregistrez la figure avec l' bbox_inchesargument fig.savefig('Basic.png', bbox_inches="tight")

— Paw

Et si je ne sauvegarde PAS le chiffre? Je trace dans Juypter Notebook et les étiquettes d'axe résultantes sont coupées.

— Zythyr

Merci! Souligner les paramètres dpi m'a été extrêmement utile pour préparer des versions imprimables de mes tracés sans avoir à ajuster toutes les tailles de ligne, les tailles de police, etc.

— ybull

27

Utilisation plt.tick_params(labelsize=14)

— Andrey Nikishaev
source

4

Merci pour l'extrait de code, qui pourrait fournir une aide immédiate limitée. Une explication appropriée améliorerait considérablement sa valeur à long terme en décrivant pourquoi il s'agit d'une bonne solution au problème, et la rendrait plus utile aux futurs lecteurs ayant d'autres questions similaires. Veuillez modifier votre réponse pour ajouter des explications, y compris les hypothèses que vous avez faites.

— sepehr

22

Vous pouvez utiliser plt.rcParams["font.size"]pour la mise font_sizeen matplotlibet vous pouvez également utiliser plt.rcParams["font.family"]pour la mise font_familyen matplotlib. Essayez cet exemple:

import matplotlib.pyplot as plt
plt.style.use('seaborn-whitegrid')

label = [1,2,3,4,5,6,7,8]
x = [0.001906,0.000571308,0.0020305,0.0037422,0.0047095,0.000846667,0.000819,0.000907]
y = [0.2943301,0.047778308,0.048003167,0.1770876,0.532489833,0.024611333,0.157498667,0.0272095]


plt.ylabel('eigen centrality')
plt.xlabel('betweenness centrality')
plt.text(0.001906, 0.2943301, '1 ', ha='right', va='center')
plt.text(0.000571308, 0.047778308, '2 ', ha='right', va='center')
plt.text(0.0020305, 0.048003167, '3 ', ha='right', va='center')
plt.text(0.0037422, 0.1770876, '4 ', ha='right', va='center')
plt.text(0.0047095, 0.532489833, '5 ', ha='right', va='center')
plt.text(0.000846667, 0.024611333, '6 ', ha='right', va='center')
plt.text(0.000819, 0.157498667, '7 ', ha='right', va='center')
plt.text(0.000907, 0.0272095, '8 ', ha='right', va='center')
plt.rcParams["font.family"] = "Times New Roman"
plt.rcParams["font.size"] = "50"
plt.plot(x, y, 'o', color='blue')

— hamed baziyad
source

10

Voici ce que j'utilise généralement dans Jupyter Notebook:

# Jupyter Notebook settings

from IPython.core.display import display, HTML
display(HTML("<style>.container { width:95% !important; }</style>"))
%autosave 0
%matplotlib inline
%load_ext autoreload
%autoreload 2

from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"


# Imports for data analysis
import pandas as pd
import matplotlib.pyplot as plt
pd.set_option('display.max_rows', 2500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.max_colwidth', 2000)
pd.set_option('display.width', 2000)
pd.set_option('display.float_format', lambda x: '%.3f' % x)

#size=25
size=15
params = {'legend.fontsize': 'large',
          'figure.figsize': (20,8),
          'axes.labelsize': size,
          'axes.titlesize': size,
          'xtick.labelsize': size*0.75,
          'ytick.labelsize': size*0.75,
          'axes.titlepad': 25}
plt.rcParams.update(params)

— stackoverflowuser2010
source

8

Sur la base des éléments ci-dessus:

import matplotlib.pyplot as plt
import matplotlib.font_manager as fm

fontPath = "/usr/share/fonts/abc.ttf"
font = fm.FontProperties(fname=fontPath, size=10)
font2 = fm.FontProperties(fname=fontPath, size=24)

fig = plt.figure(figsize=(32, 24))
fig.text(0.5, 0.93, "This is my Title", horizontalalignment='center', fontproperties=font2)

plot = fig.add_subplot(1, 1, 1)

plot.xaxis.get_label().set_fontproperties(font)
plot.yaxis.get_label().set_fontproperties(font)
plot.legend(loc='upper right', prop=font)

for label in (plot.get_xticklabels() + plot.get_yticklabels()):
    label.set_fontproperties(font)

— nvd
source

5

Ceci est une extension de la réponse de Marius Retegan . Vous pouvez créer un fichier JSON séparé avec toutes vos modifications et le charger avec rcParams.update. Les modifications s'appliqueront uniquement au script actuel. Donc

import json
from matplotlib import pyplot as plt, rcParams

s = json.load(open("example_file.json")
rcParams.update(s)

et enregistrez ce 'example_file.json' dans le même dossier.

{
  "lines.linewidth": 2.0,
  "axes.edgecolor": "#bcbcbc",
  "patch.linewidth": 0.5,
  "legend.fancybox": true,
  "axes.color_cycle": [
    "#348ABD",
    "#A60628",
    "#7A68A6",
    "#467821",
    "#CF4457",
    "#188487",
    "#E24A33"
  ],
  "axes.facecolor": "#eeeeee",
  "axes.labelsize": "large",
  "axes.grid": true,
  "patch.edgecolor": "#eeeeee",
  "axes.titlesize": "x-large",
  "svg.fonttype": "path",
  "examples.directory": ""
}

— Michael H.
source

4

Je suis totalement d'accord avec le professeur Huster que la façon la plus simple de procéder est de changer la taille de la figure, ce qui permet de conserver les polices par défaut. J'ai juste dû compléter cela avec une option bbox_inches lors de l'enregistrement de la figure au format PDF car les étiquettes d'axe ont été coupées.

import matplotlib.pyplot as plt
plt.figure(figsize=(4,3))
plt.savefig('Basic.pdf', bbox_inches='tight')