Personnaliser les visualisations Matplotlib avec des marqueurs

Introduction

Matplotlib est une bibliothèque Python populaire utilisée pour créer des visualisations, y compris des graphiques, des diagrammes et des tracés. L'un des composants clés de Matplotlib sont les marqueurs, qui sont utilisés pour représenter les points de données sur un tracé. Les marqueurs sont disponibles en diverses formes, tailles et styles, et peuvent être personnalisés pour correspondre à un ensemble de données spécifique. Dans ce laboratoire, vous allez apprendre à utiliser les marqueurs Matplotlib pour créer des visualisations personnalisées qui communiquent efficacement vos données.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet d'étude pour accéder au carnet Jupyter Notebook pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limites du carnet Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Marqueurs non remplis

Les marqueurs non remplis sont de couleur unique. Le code suivant montre comment créer des marqueurs non remplis :

unfilled_markers = [m for m, func in Line2D.markers.items()
                    if func!= 'nothing' and m not in Line2D.filled_markers]

for ax, markers in zip(axs, split_list(unfilled_markers)):
    for y, marker in enumerate(markers):
        ax.text(-0.5, y, repr(marker), **text_style)
        ax.plot([y] * 3, marker=marker, **marker_style)
    format_axes(ax)

Marqueurs remplis

Les marqueurs remplis sont l'opposé des marqueurs non remplis. Le code suivant montre comment créer des marqueurs remplis :

fig, axs = plt.subplots(ncols=2)
fig.suptitle('Filled markers', fontsize=14)
for ax, markers in zip(axs, split_list(Line2D.filled_markers)):
    for y, marker in enumerate(markers):
        ax.text(-0.5, y, repr(marker), **text_style)
        ax.plot([y] * 3, marker=marker, **marker_style)
    format_axes(ax)

Styles de remplissage des marqueurs

La couleur de bord et la couleur de remplissage des marqueurs remplis peuvent être spécifiées séparément. De plus, le fillstyle peut être configuré pour être non rempli, entièrement rempli ou rempli à moitié dans diverses directions. Les styles de remplissage à moitié utilisent markerfacecoloralt comme couleur de remplissage secondaire. Le code suivant montre comment créer des styles de remplissage de marqueurs :

fig, ax = plt.subplots()
fig.suptitle('Marker fillstyle', fontsize=14)
fig.subplots_adjust(left=0.4)

filled_marker_style = dict(marker='o', linestyle=':', markersize=15,
                           color='darkgrey',
                           markerfacecolor='tab:blue',
                           markerfacecoloralt='lightsteelblue',
                           markeredgecolor='brown')

for y, fill_style in enumerate(Line2D.fillStyles):
    ax.text(-0.5, y, repr(fill_style), **text_style)
    ax.plot([y] * 3, fillstyle=fill_style, **filled_marker_style)
format_axes(ax)

Marqueurs créés à partir de symboles TeX

Utilisez :ref:MathText <mathtext> pour utiliser des symboles de marqueurs personnalisés, comme par exemple "$\u266B$". Pour une vue d'ensemble des symboles de police STIX, consultez le tableau de caractères STIX <http://www.stixfonts.org/allGlyphs.html>_. Consultez également le :doc:/gallery/text_labels_and_annotations/stix_fonts_demo.

fig, ax = plt.subplots()
fig.suptitle('Mathtext markers', fontsize=14)
fig.subplots_adjust(left=0.4)

marker_style.update(markeredgecolor="none", markersize=15)
markers = ["$1$", r"$\frac{1}{2}$", "$f$", "$\u266B$", r"$\mathcal{A}$"]

for y, marker in enumerate(markers):
    ## Escape dollars so that the text is written "as is", not as mathtext.
    ax.text(-0.5, y, repr(marker).replace("$", r"\$"), **text_style)
    ax.plot([y] * 3, marker=marker, **marker_style)
format_axes(ax)

Marqueurs créés à partir de chemins

N'importe quel ~.path.Path peut être utilisé comme marqueur. L'exemple suivant montre deux chemins simples, star et circle, et un chemin plus élaboré d'un cercle avec une étoile découpée à l'intérieur.

import numpy as np

import matplotlib.path as mpath

star = mpath.Path.unit_regular_star(6)
circle = mpath.Path.unit_circle()
## concatenate the circle with an internal cutout of the star
cut_star = mpath.Path(
    vertices=np.concatenate([circle.vertices, star.vertices[::-1,...]]),
    codes=np.concatenate([circle.codes, star.codes]))

fig, ax = plt.subplots()
fig.suptitle('Path markers', fontsize=14)
fig.subplots_adjust(left=0.4)

markers = {'star': star, 'circle': circle, 'cut_star': cut_star}

for y, (name, marker) in enumerate(markers.items()):
    ax.text(-0.5, y, name, **text_style)
    ax.plot([y] * 3, marker=marker, **marker_style)
format_axes(ax)

Modifications avancées de marqueurs avec Transform

Les marqueurs peuvent être modifiés en passant une transformation au constructeur MarkerStyle. L'exemple suivant montre comment une rotation fournie est appliquée à plusieurs formes de marqueurs.

common_style = {k: v for k, v in filled_marker_style.items() if k!= 'marker'}
angles = [0, 10, 20, 30, 45, 60, 90]

fig, ax = plt.subplots()
fig.suptitle('Rotated markers', fontsize=14)

ax.text(-0.5, 0, 'Filled marker', **text_style)
for x, theta in enumerate(angles):
    t = Affine2D().rotate_deg(theta)
    ax.plot(x, 0, marker=MarkerStyle('o', 'left', t), **common_style)

ax.text(-0.5, 1, 'Un-filled marker', **text_style)
for x, theta in enumerate(angles):
    t = Affine2D().rotate_deg(theta)
    ax.plot(x, 1, marker=MarkerStyle('1', 'left', t), **common_style)

ax.text(-0.5, 2, 'Equation marker', **text_style)
for x, theta in enumerate(angles):
    t = Affine2D().rotate_deg(theta)
    eq = r'$\frac{1}{x}$'
    ax.plot(x, 2, marker=MarkerStyle(eq, 'left', t), **common_style)

for x, theta in enumerate(angles):
    ax.text(x, 2.5, f"{theta}°", horizontalalignment="center")
format_axes(ax)

fig.tight_layout()

Définition du style de terminaison et du style de jonction des marqueurs

Les marqueurs ont des styles de terminaison et de jonction par défaut, mais ceux-ci peuvent être personnalisés lors de la création d'un MarkerStyle.

from matplotlib.markers import CapStyle, JoinStyle

marker_inner = dict(markersize=35,
                    markerfacecolor='tab:blue',
                    markerfacecoloralt='lightsteelblue',
                    markeredgecolor='brown',
                    markeredgewidth=8,
                    )

marker_outer = dict(markersize=35,
                    markerfacecolor='tab:blue',
                    markerfacecoloralt='lightsteelblue',
                    markeredgecolor='white',
                    markeredgewidth=1,
                    )

fig, ax = plt.subplots()
fig.suptitle('Marker CapStyle', fontsize=14)
fig.subplots_adjust(left=0.1)

for y, cap_style in enumerate(CapStyle):
    ax.text(-0.5, y, cap_style.name, **text_style)
    for x, theta in enumerate(angles):
        t = Affine2D().rotate_deg(theta)
        m = MarkerStyle('1', transform=t, capstyle=cap_style)
        ax.plot(x, y, marker=m, **marker_inner)
        ax.plot(x, y, marker=m, **marker_outer)
        ax.text(x, len(CapStyle) -.5, f'{theta}°', ha='center')
format_axes(ax)

Modification du style de jonction

Le style de jonction des marqueurs peut également être modifié de manière similaire.

fig, ax = plt.subplots()
fig.suptitle('Marker JoinStyle', fontsize=14)
fig.subplots_adjust(left=0.05)

for y, join_style in enumerate(JoinStyle):
    ax.text(-0.5, y, join_style.name, **text_style)
    for x, theta in enumerate(angles):
        t = Affine2D().rotate_deg(theta)
        m = MarkerStyle('*', transform=t, joinstyle=join_style)
        ax.plot(x, y, marker=m, **marker_inner)
        ax.text(x, len(JoinStyle) -.5, f'{theta}°', ha='center')
format_axes(ax)

plt.show()

Récapitulatif

Dans ce laboratoire, vous avez appris à utiliser les marqueurs de Matplotlib pour créer des visualisations personnalisées. Plus précisément, vous avez appris à créer des marqueurs non remplis et remplis, des styles de remplissage de marqueurs, des marqueurs créés à partir de symboles TeX, des marqueurs créés à partir de chemins, des modifications avancées de marqueurs avec transformée, et à définir le style de terminaison et le style de jonction des marqueurs. En utilisant ces techniques, vous pouvez créer des visualisations efficaces qui communiquent vos données avec clarté et précision.