[PYTHON] [matplotlib] Fonction d'exemple de création de graphique pour les articles scientifiques

0. Introduction

Cet article est une fonction à usage général pour créer des graphiques à l'aide de matplotlib de python et une brève explication de celui-ci. Afin d'augmenter la polyvalence, nous avons imaginé des moyens de ** répondre autant que possible à l'augmentation des légendes avec des fonctions itératives **. De plus, étant donné que pandas.dataframe, qui est souvent utilisé dans le traitement des données, est utilisé, il est facile de l'utiliser tel quel pour les données après calcul.

Le style de graphique du format dont l'auteur avait besoin est décrit. (Je l'ajouterai régulièrement) Cet article est destiné aux présentations de recherche et aux soumissions d'articles par des ingénieurs en sciences et en génie, en supposant que les résultats de nombreux paramètres sont supprimés et que les graphiques sont visualisés côte à côte.

1. Préparation

1.1. Construction de l'environnement

Depuis le 04/04/2020, le dernier environnement python3-Anaconda est supposé. Il existe de nombreuses façons d'installer python sur le net, mais Anaconda est recommandé car il suffit de cliquer dessus. Vérifiez que le chemin passe.

L'éditeur utilise Visual Studio Code. J'utilisais PyCharm avant, mais je l'ai changé parce que je voulais utiliser le même éditeur que les autres langues. La commande de formatage automatique est pratique. (Maj + Alt + F) Référence: Exécution de python3 avec du code VS (windows10)

1.2. Importation de packages

Importez ce dont vous avez besoin. Autre que matplotlib, j'utilise numpy et pandas pour le moment. matplotlib utilise uniquement pyplot

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

1.3. Préparation des échantillons de données

Préparez des exemples de données à utiliser dans cet article. Le dataframe est plus facile à gérer en tant que données car il peut être tabulé à la fois, mais lors de la création d'un graphique, la liste peut être définie plus finement, de sorte qu'elle peut être renvoyée dans la liste une par une. La gestion des dataframes et la lecture et l'écriture de fichiers seront à nouveau résumées quelque part.

Pour le moment, j'ai créé une liste puis généré df. Comme il est difficile de voir à moins qu'il ne soit vertical lors de la sortie de csv ou excel, les lignes et les colonnes sont converties.

A = np.linspace(0, 1)
B = [x**2 for x in A]
C = [np.cos(2*np.pi*x) for x in A]
S = [np.sin(2*np.pi*x) for x in A]
E = np.random.rand(len(A))/20+0.1
df = pd.DataFrame([A, B, C, S, E], index=[
                  "x", "squarex", "cosx", "sinx", "error"]).T

1.4. Ajuster le style du graphique

Réglez-le pour qu'il ressemble à un papier. Vous pouvez changer la valeur par défaut avec rcParams```, alors changez-la comme suit. Surtout si vous changez la police, l'échelle, le cadre de la légende, etc., cela ressemble à ça. Pour les chiffres anglais, la police doit être Times New Roman pour le moment.

Voici les exemples de données préparés ci-dessus, tracés de manière appropriée après vérification de la trame de données. df.plot () '' `` fait un graphique de plusieurs légendes avec l'index comme axe des x. C'est étonnamment facile, mais je ne l'utiliserai plus car c'est un peu difficile à régler.

plt.rcParams['font.family'] = 'Times New Roman'
plt.rcParams['font.size'] = 10  #À la taille dont vous avez besoin
plt.rcParams['xtick.direction'] = 'in'  # in or out
plt.rcParams['ytick.direction'] = 'in'
plt.rcParams['axes.xmargin'] = 0.01
plt.rcParams['axes.ymargin'] = 0.01
plt.rcParams["legend.fancybox"] = False  #Angle rond OFF
plt.rcParams["legend.framealpha"] = 1  #Spécifiez la transparence, pas de remplissage avec 0
plt.rcParams["legend.edgecolor"] = 'black'  #Changer la couleur des bords

df = df.set_index("x")
df.plot()
plt.legend()
plt.show()

Le résultat de sortie est le suivant. Figure_1.png

1.5. À propos de la notation LaTeX

En python, vous pouvez facilement écrire une formule en notation LaTeX avec r '$ ~~ $' `` (décrit dans ~~). Lors de l'affichage dans un graphique, je pense que cela est souvent pris en compte lorsque je veux utiliser des exposants, des indices et des lettres grecques dans les étiquettes, plutôt que d'écrire activement des formules. Voir Officiel pour la notation. La police de formule par défaut est dejavusans, mais comme le corps sans empattement est désagréable, il est recommandé de le changer en stix comme suit.

plt.rcParams["mathtext.fontset"] = "stix" #Faites-en une police stix

En guise de mise en garde, si vous la laissez telle quelle, la formule sera écrite en petits caractères (ou plutôt en épaisseur standard). Toutes les valeurs par défaut de matplotlib sont en gras, ce qui le rend un peu inconfortable en termes de conception. Si vous êtes curieux, vous pouvez faire de votre mieux pour que tout soit plus fin en utilisant ici.

Enfin, si vous souhaitez utiliser la formule littéralement, il peut être gênant si la valeur par défaut est fine italique, donc en procédant comme suit, vous pouvez l'appliquer dans le même état que le texte ordinaire.

plt.rcParams['mathtext.default']= 'default' #Faites-en le texte par défaut

Avec les paramètres jusqu'à ce point, l'indice est trop élevé et l'indice est trop faible, donc je pense que vous devriez le corriger. Référence: Résolution du problème selon lequel l'indice est trop élevé et l'indice est trop faible dans matplotlib

1.6. Précautions

Après cela, dans cet article, je vais dessiner un graphique avec une interface orientée objet. Ça s'appelle hache. ~~. Veuillez voir celui qui explique correctement la théorie. Référence: Connaissance de base de matplotlib que je voulais connaître très tôt, ou l'histoire d'un artiste qui peut ajuster l'apparence

2. Légendes multiples (1 axe)

2.1. Aperçu

2.2. Fonctions

multiLegend


def multiLegend(df, x, y_list):
    c_list = ["k", "r", "b", "g", "c", "m", "y"]
    l_list = ["-","--","-.","."]
    fig, ax = plt.subplots(figsize=(5, 5))
    plt.subplots_adjust(top=0.95, right=0.95)
    for i in range(len(y_list)):
        y = y_list[i]
        ax.plot(df[x], df[y], linestyle=l_list[i], color=c_list[i], label=y)
    yLabel = ', '.join(y_list)
    ax.set_ylabel(yLabel)
    ax.set_xlabel(x)
    plt.legend()
    plt.show()
    return

2.3. Résultat de l'exécution

multiLegned(df, "x", ["squarex", "cosx", "sinx"])

Figure_3.png

3. Légendes multiples (2 axes)

3.1. Aperçu

3.2. Fonctions

multiLegend2


def multiLegend2(df, x, y1_list, y2_list=None):
    # y2_Si vous n'entrez pas de liste, ce ne sera pas 2 axes
    c_list = ["k", "r", "b", "g", "c", "m", "y"]
    l_list = ["-", "--", "-.", "."]
    fig, ax1 = plt.subplots(figsize=(5.5, 5))
    j = 0
    for y in y1_list:
        ax1.plot(df[x], df[y], linestyle=l_list[j],
                      color=c_list[j], label=y)
        j += 1
    ax1.legend(loc='lower left')
    ax1.set_xlabel(x)
    ax1.set_ylabel(', '.join(y1_list))
    if len(y2_list) != None:
        ax2 = ax1.twinx()
        for y in y2_list:
            ax2.plot(df[x], df[y], linestyle=l_list[j],
                         color=c_list[j], label=y)
            j += 1
        ax2.legend(loc='upper right')
        ax2.set_ylabel(', '.join(y2_list))
    plt.tight_layout()
    plt.show()
    return

3.3. Résultat de l'exécution

multiLegend2(df, "x", ["squarex", "cosx"], ["sinx"])

Figure_1.png

4. Graphique multi-axes

4.1. Aperçu

4.2. Fonctions

multiAxes


def multiAxes(df, x, y_list):
    c_list = ["k", "r", "b", "g", "c", "m", "y"]
    l_list = ["-","--","-.","."]
    fig, ax0 = plt.subplots(figsize=(6, 5))
    plt.subplots_adjust(top=0.95, right=0.95-(len(y_list)-1)*0.1) #Ajustez ici si ça change
    axes = [ax0]  #Faire le nombre d'axes pour les variables
    p_list = []  #Conteneur pour tracés pour variables
    for i in range(len(y_list)):
        y = y_list[i]
        if i != 0:
            axes.append(ax0.twinx())
            axes[i].spines["right"].set_position(("axes", 1+(i-1)*0.2)) #Ajustez ici si ça change
        p, = axes[i].plot(df[x], df[y], linestyle=l_list[i], color=c_list[i], label=y)
        p_list.append(p)
        axes[i].set_ylabel(y_list[i], color=c_list[i])
        axes[i].yaxis.label.set_color(c_list[i])
        axes[i].spines['right'].set_color(c_list[i])
        axes[i].tick_params(axis='y', colors=c_list[i])
    axes[0].set_xlabel(x)
    plt.legend(p_list,y_list)
    plt.show()
    return

4.3. Résultat de l'exécution

multiAxes(df, "x", ["squarex", "cosx", "sinx"])

Figure_2.png

5. Graphique secondaire multiple

5.1. Aperçu

5.2. Fonctions

multiPlots


def multiPlots(df, x, y_list):
    c_list = ["k", "r", "b", "g", "c", "m", "y"]
    l_list = ["-","--","-.","."]
    fig, axes = plt.subplots(len(y_list), 1, sharex="all", figsize=(4, 2*len(y_list)))
    for i in range(len(y_list)):
        y = y_list[i]
        axes[i].plot(df[x], df[y], linestyle=l_list[i], color=c_list[i], label=y)
        axes[i].set_ylabel(y_list[i], color=c_list[i])
        axes[i].yaxis.label.set_color(c_list[i])
        axes[i].spines['left'].set_color(c_list[i])
        axes[i].tick_params(axis='y', colors=c_list[i])
        if i == len(y_list)-1:
            axes[i].set_xlabel(x)
    plt.tight_layout()
    plt.show()
    return

5.3. Résultat de l'exécution

multiPlots(df, "x", ["squarex", "cosx", "sinx"])

Figure_4.png

6. Échantillons multiples

6.1. Aperçu

6.2. Fonctions

multiData


def multiData(df_list, x, y1, y2=None):
    l_list = ["-", "--", "-.", "."]
    fig, ax1 = plt.subplots(figsize=(5.25, 5))
    p_list = []  #Conteneur pour tracés pour variables
    labels = []
    for i in range(len(df_list)):
        df = df_list[i]
        p, = ax1.plot(df[x], df[y1], linestyle=l_list[i], color="k")
        labels.append(y1+'-data'+str(i+1))
        p_list.append(p)
    ax1.set_xlabel(x)
    ax1.set_ylabel(y1)
    if y2 != None:
        ax2 = ax1.twinx()
        for i in range(len(df_list)):
            df = df_list[i]
            p, = ax2.plot(df[x], df[y2], linestyle=l_list[i], color="b")
            labels.append(y2+'-data'+str(i+1))
            p_list.append(p)
        ax2.set_ylabel(y2, color = "b")
        ax2.yaxis.label.set_color("b")
        ax2.spines['right'].set_color("b")
        ax2.tick_params(axis='y', colors="b")
    plt.legend(p_list, labels)
    plt.tight_layout()
    plt.show()
    return

6.3. Résultat de l'exécution

A_2 = np.linspace(1, 2)
B_2 = [x**2 for x in A_2]
C_2 = [np.cos(2*np.pi*x) for x in A_2]
df_2 = pd.DataFrame([A_2, B_2, C_2], index=["x", "squarex", "cosx"]).T
A_3 = np.linspace(2, 3)
B_3 = [x**2 for x in A_3]
C_3 = [np.cos(2*np.pi*x) for x in A_3]
df_3 = pd.DataFrame([A_3, B_3, C_3], index=["x", "squarex", "cosx"]).T

multiData([df, df_2, df_3], "x", "squarex", "cosx")

Figure_2.png

7. 1 axe avec erreur

7.1. Aperçu

7.2. Fonctions

multiLegend_wError


def multiLegend_wError(df, x, y_list, y_error_list):
    c_list = ["k", "r", "b", "g", "c", "m", "y"]
    l_list = ["-", "--", "-.", "."]
    fig, ax = plt.subplots(figsize=(5, 5))
    plt.subplots_adjust(top=0.95, right=0.95)
    for i in range(len(y_list)):
        y = y_list[i]
        y_error = y_error_list[i]
        ax.plot(df[x], df[y], linestyle=l_list[i], color=c_list[i], label=y)
        ax.fill_between(df[x], df[y]+df[y_error], df[y]-df[y_error], facecolor=c_list[i], edgecolor=None, alpha=0.3)
    yLabel = ', '.join(y_list)
    ax.set_ylabel(yLabel)
    ax.set_xlabel(x)
    plt.legend()
    plt.show()
    return

7.3. Résultat de l'exécution

multiLegend_wError(df, "x", ["squarex", "cosx", "sinx"], ["error", "error", "error"])

Figure_1.png

8. Conclusion

Dans cet article, j'ai résumé les fonctions de sortie de graphique pour les articles scientifiques et technologiques que j'ai réellement utilisées avec matplotlib. Lors de la création d'une version de publication, chaque étiquette d'axe est créée à la main, mais je fais également une liste et la lis dans l'instruction for. Cette fois, j'ai utilisé le nom d'étiquette du dataframe pour éviter de le rendre difficile à voir.

Nous le mettrons à jour régulièrement, alors faites attention.

Recommended Posts

[matplotlib] Fonction d'exemple de création de graphique pour les articles scientifiques
4 techniques de création de diagrammes pour papiers et supports de présentation avec matplotlib