[PYTHON] [matplotlib] Beispielfunktion zur Erstellung von Graphen für wissenschaftliche Arbeiten

0. Einleitung

Dieser Artikel ist eine Allzweckfunktion zum Erstellen von Diagrammen mit matplotlib von Python und einer kurzen Erläuterung. Um die Vielseitigkeit zu erhöhen, haben wir Wege entwickelt, um ** auf die Zunahme von Legenden mit iterativen Funktionen so weit wie möglich zu reagieren **. Da pandas.dataframe, das häufig in der Datenverarbeitung verwendet wird, verwendet wird, ist es auch einfach, es wie für Daten nach der Berechnung zu verwenden.

Der Diagrammstil des vom Autor benötigten Formats wird beschrieben. (Ich werde es regelmäßig hinzufügen) Dieser Artikel ist für Forschungspräsentationen und Beiträge von Wissenschafts- und Technikingenieuren gedacht, vorausgesetzt, die Ergebnisse vieler Parameter werden gelöscht und Diagramme nebeneinander angezeigt.

1. Vorbereitung

1.1. Umweltbau

Ab dem 04.04.2020 wird die neueste Python3-Anaconda-Umgebung angenommen. Es gibt viele Möglichkeiten, Python im Internet zu installieren, aber Anaconda wird empfohlen, da Sie nur darauf klicken müssen. Überprüfen Sie den Pfad, damit er passiert.

Der Editor verwendet Visual Studio Code. Früher habe ich PyCharm verwendet, aber ich habe es geändert, weil ich denselben Editor wie andere Sprachen verwenden wollte. Der automatische Formatierungsbefehl ist praktisch. (Umschalt + Alt + F) Referenz: Python3 mit VS-Code ausführen (Windows 10)

1.2 Pakete importieren

Importieren Sie, was Sie brauchen. Abgesehen von Matplotlib benutze ich vorerst Numpy und Pandas. matplotlib verwendet nur Pyplot

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

1.3 Vorbereitung der Probendaten

Bereiten Sie Beispieldaten für die Verwendung in diesem Artikel vor. Der Datenrahmen ist einfacher als Daten zu handhaben, da er sofort tabellarisch dargestellt werden kann. Wenn jedoch tatsächlich ein Diagramm erstellt wird, kann die Liste feiner festgelegt werden, sodass sie nacheinander in die Liste zurückgegeben werden kann. Der Umgang mit Datenrahmen sowie das Lesen und Schreiben von Dateien werden noch einmal zusammengefasst.

Vorerst habe ich eine Liste erstellt und dann df generiert. Da es schwer zu erkennen ist, wenn es bei der Ausgabe von CSV oder Excel vertikal ist, werden die Zeilen und Spalten konvertiert.

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 Anpassen des Diagrammstils

Stellen Sie es so ein, dass es wie ein Papier aussieht. Sie können den Standardwert mit `` `rcParams``` ändern, also ändern Sie ihn wie folgt. Besonders wenn Sie die Schriftart, den Maßstab, den Legendenrahmen usw. ändern, sieht es so aus. Für englische Figuren sollte die Schrift vorerst Times New Roman sein.

Das Folgende sind die oben vorbereiteten Beispieldaten, die nach Überprüfung des Datenrahmens entsprechend aufgezeichnet wurden. `df.plot ()` erstellt ein Diagramm mehrerer Legenden mit dem Index als x-Achse. Es ist überraschend einfach, aber ich werde es nicht mehr verwenden, weil es etwas schwierig ist, es anzupassen.

plt.rcParams['font.family'] = 'Times New Roman'
plt.rcParams['font.size'] = 10  #Auf die Größe, die Sie brauchen
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  #Rundwinkel AUS
plt.rcParams["legend.framealpha"] = 1  #Geben Sie Transparenz an, keine Füllung mit 0
plt.rcParams["legend.edgecolor"] = 'black'  #Kantenfarbe ändern

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

Das Ausgabeergebnis ist wie folgt. Figure_1.png

1.5 Informationen zur LaTeX-Notation

In Python können Sie einfach eine Formel in LaTeX-Notation mit `r '$ ~~ $'` (beschrieben in ~~) schreiben. Bei der Anzeige in einem Diagramm habe ich das Gefühl, dass es häufig erledigt wird, wenn ich hochgestellte, tiefgestellte und griechische Buchstaben in Etiketten verwenden möchte, anstatt aktiv Formeln zu schreiben. Notation finden Sie unter Offiziell. Die Standardeinstellung der Formelschriftart ist dejavusans. Da der serifenlose Körper jedoch unangenehm ist, wird empfohlen, ihn wie folgt in stix zu ändern.

plt.rcParams["mathtext.fontset"] = "stix" #Machen Sie es zu einer Stix-Schriftart

Wenn Sie es so lassen, wie es ist, wird die Formel als Kleingedrucktes (oder besser gesagt in Standarddicke) geschrieben. Alle Matplotlib-Standardeinstellungen sind fett gedruckt, was das Design etwas unangenehm macht. Wenn Sie neugierig sind, können Sie Ihr Bestes geben, um alles mit hier feiner zu machen.

Wenn Sie die Formel wörtlich verwenden möchten, kann es problematisch sein, wenn die Standardeinstellung fein kursiv ist. Wenn Sie also wie folgt vorgehen, können Sie sie im selben Zustand wie normaler Text anwenden.

plt.rcParams['mathtext.default']= 'default' #Machen Sie es zum Standardtext

Im bisherigen Stand der Einstellungen ist der Index zu hoch und der Index zu niedrig. Ich denke, Sie sollten ihn korrigieren. Referenz: Lösen des Problems, dass der Index in matplotlib zu hoch und der Index zu niedrig ist

1.6 Vorsichtsmaßnahmen

Danach werde ich in diesem Artikel ein Diagramm mit einer objektorientierten Oberfläche zeichnen. Es heißt Axt. ~~. Bitte wenden Sie sich an die Person, die die Theorie richtig erklärt. Referenz: Grundkenntnisse über Matplotlib, die ich früh kennenlernen wollte, oder die Geschichte eines Künstlers, der das Erscheinungsbild anpassen kann

2. Mehrere Legenden (1 Achse)

2.1. Übersicht

2.2 Funktionen

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. Ausführungsergebnis

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

Figure_3.png

3. Mehrere Legenden (2 Achsen)

3.1. Übersicht

3.2. Funktionen

multiLegend2


def multiLegend2(df, x, y1_list, y2_list=None):
    # y2_Wenn Sie keine Liste eingeben, sind es keine 2 Achsen
    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. Ausführungsergebnis

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

Figure_1.png

4. Mehrachsendiagramm

4.1 Übersicht

4.2. Funktionen

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) #Hier einstellen, wenn es sich verschiebt
    axes = [ax0]  #Legen Sie die Anzahl der Achsen für Variablen fest
    p_list = []  #Container für Diagramme für Variablen
    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)) #Hier einstellen, wenn es sich verschiebt
        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. Ausführungsergebnis

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

Figure_2.png

5. Mehrere Nebenhandlungen

5.1 Übersicht

5.2. Funktionen

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 Ausführungsergebnis

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

Figure_4.png

6. Mehrere Proben

6.1 Übersicht

6.2. Funktionen

multiData


def multiData(df_list, x, y1, y2=None):
    l_list = ["-", "--", "-.", "."]
    fig, ax1 = plt.subplots(figsize=(5.25, 5))
    p_list = []  #Container für Diagramme für Variablen
    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 Ausführungsergebnis

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 Achse mit Fehler

7.1. Übersicht

7.2. Funktionen

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. Ausführungsergebnis

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

Figure_1.png

8. Fazit

In diesem Artikel habe ich die Grafikausgabefunktionen für Wissenschafts- und Technologiepapiere zusammengefasst, die ich tatsächlich mit matplotlib verwendet habe. Bei der Erstellung einer Post-Version wird jede Achsenbeschriftung von Hand erstellt, aber ich erstelle auch eine Liste und lese sie in der for-Anweisung. Dieses Mal habe ich den Labelnamen des Datenrahmens verwendet, um zu vermeiden, dass er schwer zu erkennen ist.

Wir werden es regelmäßig aktualisieren, bitte seien Sie vorsichtig.

Recommended Posts

[matplotlib] Beispielfunktion zur Erstellung von Graphen für wissenschaftliche Arbeiten
4 Techniken zum Erstellen von Diagrammen für Papiere und Präsentationsmaterialien mit matplotlib