Comment tracer des axes logarithmiques dans Matplotlib

Utilisez set_xscale() ou set_yscale() pour choisir indépendamment l’échelle de chaque axe. Pour appliquer une échelle logarithmique aux deux axes, utilisez loglog(). Les fonctions semilogx() et semilogy() appliquent respectivement une échelle logarithmique à l’axe des x ou à celui des y. Un axe logarithmique espace ses graduations en puissances de dix : des données couvrant plusieurs ordres de grandeur restent ainsi lisibles au lieu de s’entasser dans la décade la plus basse d’un axe linéaire.
Tous les exemples de code ci-dessous ont été exécutés avec succès.

Fonctions set_xscale() ou set_yscale()

Appelez set_xscale("log") pour appliquer une échelle logarithmique à l’axe des x, set_yscale("log") pour l’axe des y, ou les deux pour les appliquer aux deux axes. Les deux appels étant indépendants, vous pouvez convertir un seul axe et laisser l’autre linéaire.

Pour rendre seul l’axe des x logarithmique, tracez les données comme d’habitude, puis appelez set_xscale("log") sur les axes :

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

fig, ax = plt.subplots()
ax.plot(x, y, marker="o")
ax.set_xscale("log")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Le résultat affiché confirme que seul l’axe des x a changé : x-axis: log, y-axis: linear. Les graduations de décade à 1, 10, 100 et 1000 sont régulièrement espacées, alors que les valeurs elles-mêmes sont multipliées par dix à chaque pas.

Pour rendre seul l’axe des y logarithmique, appelez plutôt set_yscale("log") et laissez l’axe des x inchangé :

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

fig, ax = plt.subplots()
ax.plot(x, y, marker="o")
ax.set_yscale("log")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Cette fois, la sortie indique x-axis: linear, y-axis: log, et c’est l’axe des y qui porte les graduations de décade régulièrement espacées.

L’interface à états de pyplot propose la même modification via les fonctions de premier niveau plt.xscale() et plt.yscale(), qui agissent sur les axes courants. La variante yscale() du même graphique se présente ainsi :

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

plt.plot(x, y, marker="o")
plt.yscale("log")
plt.xlabel("x")
plt.ylabel("y")
ax = plt.gca()
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close()

Le résultat est le même axe des y logarithmique ; les méthodes de l’objet axes sont généralement plus claires dans les programmes qui conservent une référence ax explicite, car les axes cibles sont nommés dans l’appel au lieu d’être déduits de la figure courante.

Cet exemple complet trace des données numériques positives et applique une échelle logarithmique aux deux axes.

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

fig, ax = plt.subplots()
ax.plot(x, y, marker="o")
ax.set_xscale("log")
ax.set_yscale("log")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

La sortie indique désormais x-axis: log, y-axis: log, et des rapports égaux occupent des distances égales sur les deux axes.

Une échelle log standard représente les valeurs positives. Si vos données contiennent des valeurs signées, utilisez symlog pour l’axe concerné, par exemple ax.set_yscale("symlog") ; cette échelle peut représenter des valeurs de part et d’autre de zéro. La dernière section revient sur ce cas avec un exemple vérifié.

Fonctions semilogx() ou semilogy()

Utilisez semilogx() lorsque l’axe des x doit être logarithmique et celui des y linéaire. Utilisez semilogy() pour obtenir un axe des y logarithmique et un axe des x linéaire. Ces deux fonctions prennent les données x et y en arguments, ce qui rend l’échelle choisie explicite dans l’appel de tracé. Si les deux axes doivent être logarithmiques, utilisez loglog() ou combinez semilogx() et semilogy() sur les mêmes axes.

L’appel semilogx() ci-dessous trace les données et définit l’axe des x logarithmique en une seule étape :

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

fig, ax = plt.subplots()
ax.semilogx(x, y, marker="o", label="logarithmic x")
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.legend()
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

La fonction renvoie la ligne tracée, et les axes indiquent ensuite x-axis: log, y-axis: linear, exactement comme avec l’appel explicite set_xscale("log") de la première section.

Combiner les deux fonctions sur les mêmes axes produit une échelle logarithmique sur les deux axes. Gardez à l’esprit qu’une échelle appartient aux axes, et non à une seule ligne tracée : dès que semilogy() définit l’axe des y, cette échelle s’applique à toutes les séries que contiennent les axes, y compris celle tracée plus tôt par semilogx().

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]
y2 = [3, 8, 30, 120]

fig, ax = plt.subplots()
ax.semilogx(x, y, marker="o", label="first series")
ax.semilogy(x, y2, marker="s", label="second series")
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.legend()
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Les deux séries se retrouvent sur des axes x et y logarithmiques, et la sortie confirme l’état final : x-axis: log, y-axis: log.

Fonction loglog()

Utilisez loglog() lorsque les deux axes doivent avoir une échelle logarithmique. Cette fonction trace les données x et y fournies et applique une échelle logarithmique standard aux deux axes. Voici un exemple complet avec des valeurs numériques positives :

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 5, 20, 80]

fig, ax = plt.subplots()
ax.loglog(x, y, marker="o")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Le résultat rendu correspond à la combinaison set_xscale("log") plus set_yscale("log") de la première section ; loglog() intègre simplement le choix d’échelle dans l’appel de tracé lui-même.

Valeurs non positives et noms d’échelle invalides

Deux choses surprennent régulièrement les utilisateurs d’axes logarithmiques, et il vaut mieux les connaître avant de déboguer un graphique d’aspect incorrect. D’abord, le nom d’échelle est validé immédiatement : une faute de frappe comme ax.set_yscale("logg") lève ValueError: 'logg' is not a valid value for scale. Did you mean one of: 'log', 'logit', 'symlog'? (message capturé tel quel sous Matplotlib 3.11). L’erreur cite les valeurs acceptées, de sorte qu’une faute de frappe échoue immédiatement au lieu de produire silencieusement un axe linéaire.

Ensuite, une échelle logarithmique ne peut représenter ni zéro ni les valeurs négatives, et ce cas ne lève aucune erreur. Matplotlib écarte silencieusement les points non positifs : ils sont masqués du dessin, les segments de ligne qui passeraient par eux disparaissent, et les limites de l’axe ne couvrent que les valeurs positives. L’exemple ci-dessous trace y = [2, 0, -5, 80] sur un axe des y logarithmique :

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 0, -5, 80]

fig, ax = plt.subplots()
ax.plot(x, y, marker="o")
ax.set_yscale("log")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

L’appel se termine normalement et indique y-axis: log, mais seuls les points à y = 2 et y = 80 peuvent apparaître ; dans l’exécution vérifiée, les limites résultantes de l’axe des y allaient d’environ 1,66 à 96,2, ne couvrant que les données positives. Si une série semble perdre des points après le passage d’un axe en log, vérifiez l’absence de zéros et de valeurs négatives dans les données avant de soupçonner le code de tracé.

Lorsque les données contiennent réellement des valeurs signées, l’échelle symlog (logarithme symétrique) est l’alternative appropriée : elle applique une échelle logarithmique loin de zéro et une échelle linéaire dans une petite région autour de zéro, de sorte que chaque point reste visible.

import matplotlib.pyplot as plt

x = [1, 10, 100, 1000]
y = [2, 0, -5, 80]

fig, ax = plt.subplots()
ax.plot(x, y, marker="o")
ax.set_yscale("symlog")
ax.set_xlabel("x")
ax.set_ylabel("y")
print(f"x-axis: {ax.get_xscale()}, y-axis: {ax.get_yscale()}")
plt.close(fig)

Les quatre points, y compris 0 et -5, sont tracés sur l’axe des y symlog. Utilisez-la chaque fois que le signe des valeurs porte une information ; gardez l’échelle log simple pour les données positives par nature, comme les comptages, les tailles et les mesures physiques.