Dessiner un tableau de caractères avec Matplotlib

Introduction

Matplotlib est une bibliothèque populaire de visualisation de données en Python. Elle fournit un support de police grâce à la bibliothèque FreeType. Dans ce laboratoire, nous allons apprendre à tracer un tableau de caractères des 255 premiers caractères d'une police donnée à l'aide de Axes.table de Matplotlib.

Conseils sur la VM

Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de 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églerons rapidement le problème pour vous.

Afficher les glyphes d'une police

Dans cette étape, nous allons définir une fonction print_glyphs qui affiche tous les glyphes d'un fichier de police donné sur la sortie standard.

import os
import unicodedata
import matplotlib.font_manager as fm
from matplotlib.ft2font import FT2Font

def print_glyphs(path):
    """
    Affiche tous les glyphes du fichier de police donné sur la sortie standard.

    Paramètres
    ----------
    path : str ou None
        Le chemin vers le fichier de police. Si None, utilise la police par défaut de Matplotlib.
    """
    if path is None:
        path = fm.findfont(fm.FontProperties())  ## La police par défaut.

    font = FT2Font(path)

    charmap = font.get_charmap()
    max_indices_len = len(str(max(charmap.values())))

    print("La police contient les glyphes suivants :")
    for char_code, glyph_index in charmap.items():
        char = chr(char_code)
        name = unicodedata.name(
                char,
                f"{char_code:#x} ({font.get_glyph_name(glyph_index)})")
        print(f"{glyph_index:>{max_indices_len}} {char} {name}")

Dessiner un tableau de caractères

Dans cette étape, nous allons définir une fonction draw_font_table qui dessine un tableau de caractères des 255 premiers caractères de la police donnée.

import os
from pathlib import Path
import unicodedata
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
from matplotlib.ft2font import FT2Font

def draw_font_table(path):
    """
    Dessine un tableau de caractères des 255 premiers caractères de la police donnée.

    Paramètres
    ----------
    path : str ou None
        Le chemin vers le fichier de police. Si None, utilise la police par défaut de Matplotlib.
    """
    if path is None:
        path = fm.findfont(fm.FontProperties())  ## La police par défaut.

    font = FT2Font(path)

    ## Obtenir la table de caractères de la police
    codes = font.get_charmap().items()

    ## Créer les étiquettes et les cellules du tableau
    labelc = [f"{i:X}" for i in range(16)]
    labelr = [f"{i:02X}" for i in range(0, 16*16, 16)]
    chars = [["" for c in range(16)] for r in range(16)]

    for char_code, glyph_index in codes:
        if char_code >= 256:
            continue
        row, col = divmod(char_code, 16)
        chars[row][col] = chr(char_code)

    ## Dessiner le tableau à l'aide de Axes.table de Matplotlib
    fig, ax = plt.subplots(figsize=(8, 4))
    ax.set_title(os.path.basename(path))
    ax.set_axis_off()

    table = ax.table(
        cellText=chars,
        rowLabels=labelr,
        colLabels=labelc,
        rowColours=["palegreen"] * 16,
        colColours=["palegreen"] * 16,
        cellColours=[[".95" for c in range(16)] for r in range(16)],
        cellLoc='center',
        loc='upper left',
    )

    ## Définir la police des cellules du tableau comme étant la police du chemin donné
    for key, cell in table.get_celld().items():
        row, col = key
        if row > 0 and col > -1:  ## Attention à l'indexation particulière du tableau...
            cell.set_text_props(font=Path(path))

    fig.tight_layout()
    plt.show()

Afficher le tableau de caractères

Dans cette étape, nous allons utiliser argparse pour analyser le chemin vers le fichier de police à partir des arguments de ligne de commande. Ensuite, nous appellerons print_glyphs pour afficher tous les glyphes du fichier de police et draw_font_table pour dessiner le tableau de caractères des 255 premiers caractères de la police.

if __name__ == "__main__":
    from argparse import ArgumentParser

    parser = ArgumentParser(description="Afficher un tableau de caractères.")
    parser.add_argument("path", nargs="?", help="Chemin vers le fichier de police.")
    parser.add_argument("--print-all", action="store_true",
                        help="En outre, afficher tous les caractères sur la sortie standard.")
    args = parser.parse_args()

    if args.print_all:
        print_glyphs(args.path)
    draw_font_table(args.path)

Sommaire

Dans ce laboratoire, nous avons appris à tracer un tableau de caractères des 255 premiers caractères d'un fichier de police à l'aide de Axes.table de Matplotlib. Nous avons défini des fonctions pour afficher tous les glyphes d'un fichier de police et pour dessiner le tableau de caractères. Nous avons également utilisé argparse pour analyser le chemin vers le fichier de police à partir des arguments de ligne de commande.