Ich habe versucht zusammenzufassen, wie man Matplotlib von Python verwendet

Einführung

Dieses Mal werde ich zusammenfassen, wie man matplotlib benutzt.

Viele Leute haben zusammengefasst, wie man Matplotlib benutzt, daher ist es vielleicht nicht neu, aber ich würde es begrüßen, wenn Sie mit mir auskommen könnten.

Der vorherige Artikel fasste die Verwendung von Numpy und Pandas zusammen. Bitte überprüfen Sie ihn, wenn Sie möchten.

Ich habe Pythons Numpy zusammengefasst Ich habe versucht zusammenzufassen, wie Pandas in Python verwendet werden

Beim Schreiben dieses Artikels waren die folgenden Artikel sehr hilfreich.

Grundkenntnisse über Matplotlib, die ich früh kennenlernen wollte, oder die Geschichte eines Künstlers, der das Erscheinungsbild anpassen kann

Über den Stil von Matplotlib

Es gibt zwei Arten von Matplotlib.

Eine Pyplot-Schnittstelle, die mit allen "plt. Irgendwie" ausgeführt werden kann, und eine objektorientierte Schnittstelle, die mit "ax.plot" geschrieben wird, nachdem "fig" und "ax" definiert wurden.

Sehen wir uns ein konkretes Beispiel an.

Pyplot-Schnittstelle

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 1, 100)
y = x ** 2
plt.plot(x, y)
plt.show()

Objektorientierte Schnittstelle

x = np.linspace(0, 1, 100)
y = x ** 2
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(x, y)
plt.show()

Wenn Sie eine objektorientierte Schnittstelle verwenden, müssen Sie die folgende hierarchische Struktur verstehen. Wie Sie sehen können, gibt es eine hierarchische Struktur, in der das "Achsenobjekt" innerhalb des "Figurenobjekts" existiert. Das heißt, der obige Code erstellt ein Figurenobjekt mit "fig = plt.figure ()" und ein Achsenobjekt mit "ax = fig.add_subplot (111)".

Denken Sie als Bild daran, dass das Figurenobjekt wie ein Browserfenster und das Achsenobjekt wie eine Browserregisterkarte ist.

Zeichnen Sie mehrere Diagramme

Gehen Sie beim Zeichnen mehrerer Diagramme wie folgt vor.

x_1 = np.linspace(0, 1, 100)
y_1 = x_1
x_2 = np.linspace(0, 1, 100)
y_2 = x_2 ** 2
x_3 = np.linspace(0, 1, 100)
y_3 = x_3 ** 3
x_4 = np.linspace(0, 1, 100)
y_4 = x_4 ** 4
fig = plt.figure()

ax_1 = fig.add_subplot(221)
ax_2 = fig.add_subplot(222)
ax_3 = fig.add_subplot(223)
ax_4 = fig.add_subplot(224)

ax_1.plot(x_1, y_1)
ax_2.plot(x_2, y_2)
ax_3.plot(x_3, y_3)
ax_4.plot(x_4, y_4)

plt.show()

In einem Figurenobjekt werden vier Achsenobjekte erstellt.

Das Argument von "add_subplot ()" ist "(Zeile, Spalte, Nummer)", und im obigen Beispiel werden Daten von 2 Zeilen und 2 Spalten generiert und Achsenobjekte werden der Reihe nach generiert.

x = np.linspace(0, 1, 100)
y = x ** 2
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111)
ax.plot(x, y)
plt.show()

fig, axes = plt.subplots(2, 2, figsize=(20, 12))
plt.show()

print(axes)
print(axes.shape)

Beim Erstellen eines Figurenobjekts können Sie die Größe des Diagramms anpassen, indem Sie figsize als Argument übergeben. Gleichzeitige Erzeugung von Figur und Axtobjekt Bisher wurde das Figurenobjekt und anschließend das dazugehörige Axtobjekt erstellt. Das Figurenobjekt und das Axtobjekt können jedoch gleichzeitig wie unten gezeigt erstellt werden. Da wir noch nichts geplottet haben, haben wir ein leeres Feld wie das obige erstellt. Werfen wir einen Blick auf den Inhalt der Daten. Wie Sie sehen können, enthält das Achsenobjekt 2x2 Daten. Jedes entspricht den obigen vier Diagrammen. Sie können es wie folgt zeichnen:

x_1 = np.linspace(0, 1, 100)
y_1 = x_1
x_2 = np.linspace(0, 1, 100)
y_2 = x_2 ** 2
x_3 = np.linspace(0, 1, 100)
y_3 = x_3 ** 3
x_4 = np.linspace(0, 1, 100)
y_4 = x_4 ** 4
fig, axes = plt.subplots(2, 2, figsize=(20, 12))
axes[0][0].plot(x_1, y_1)
axes[0][1].plot(x_2, y_2)
axes[1][0].plot(x_3, y_3)
axes[1][1].plot(x_4, y_4)

plt.show()

Konvertieren Sie Achsen in ein eindimensionales Array

Da Achsen zweidimensionale Daten sind, ist es schwierig, mit einer for-Anweisung zu drehen.

Durch die Konvertierung in ein eindimensionales Array mit ravel () ist es einfacher, mit einer for-Anweisung zu drehen. Siehe das folgende Beispiel.

fig, axes = plt.subplots(2, 2, figsize=(20, 12))
one_dimension_axes = axes.ravel()
x = np.linspace(0, 1, 100)
for i, ax in enumerate(one_dimension_axes):
    ax.plot(x, x ** (i+1))

plt.show()

Zeichnen Sie mehrere Linien

Sie können mehrere Linien zeichnen, indem Sie auf demselben Axtobjekt zeichnen.

fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111)
x_1 = np.linspace(0, 1, 100)
y_1 = x_1
x_2 = np.linspace(0, 1, 100)
y_2 = x_2 ** 2
ax.plot(x_1, y_1)
ax.plot(x_2, y_2)
plt.show()

Legen Sie den Titel, die Achse und die Legende fest.

fig = plt.figure()
ax = fig.add_subplot(111)
x_1 = np.linspace(0, 1, 100)
y_1 = x_1
x_2 = np.linspace(0, 1, 100)
y_2 = x_2 ** 2
ax.plot(x_1, y_1, label='y=x')
ax.plot(x_2, y_2, label='$y=x^2$')
ax.set_xlabel('x_value')
ax.set_ylabel('y_value')
plt.legend(loc='best')
plt.show()

Sie können auch eine Beschriftung mit plt.xlabel usw. erstellen, aber dieses Mal habe ich die Beschriftung mit set_xlabel festgelegt, um anzuzeigen, dass die Beschriftung zum Achsenobjekt gehört.

Die Beschriftung wird im Achsenobjekt unter dem Achsenobjekt gespeichert.

Lassen Sie uns ein Achsenobjekt erstellen und die darin enthaltene Beschriftungsvariable überprüfen.

xax = ax.xaxis
yax = ax.yaxis
print(xax.label)
print(yax.label)

Text(0.5, 0, 'x_value') Text(0, 0.5, 'y_value')

Ändern Sie die Farbe / Dicke / den Stil der Linie

Weitere Informationen zu Farben finden Sie im Artikel hier.

fig = plt.figure()
ax = fig.add_subplot(111)
x_1 = np.linspace(0, 1, 100)
y_1 = x_1
x_2 = np.linspace(0, 1, 100)
y_2 = x_2 ** 2
ax.plot(x_1, y_1, label='y=x', color='r', linewidth=2, linestyle='solid')
ax.plot(x_2, y_2, label='$y=x^2$', color='g', linewidth=2, linestyle='dashed')
ax.set_xlabel('x_value')
ax.set_ylabel('y_value')
plt.legend(loc='best')
plt.show()

Sie können die Farbe und den Stil ändern, indem Sie das Argument von "ax.plot" wie oben beschrieben angeben.

So zeichnen Sie ein Diagramm mit zwei Achsen links und rechts

Das erste Diagramm kann auf die übliche Weise gezeichnet werden, und das zweite Diagramm kann mit einer mit twinx () generierten Axt gezeichnet werden, um ein Diagramm mit einer gemeinsamen x-Achse und einer anderen y-Achse zu zeichnen.

fig = plt.figure()
ax_1 = fig.add_subplot(111)
ax_2 = ax_1.twinx()
x = np.linspace(0, 5, 100)
y_1 = x
y_2 = x ** 2
ax_1.plot(x, y_1, label='y=x', color='r', linewidth=2, linestyle='solid')
ax_2.plot(x, y_2, label='$y=x^2$', color='g', linewidth=2, linestyle='dashed')
ax_1.set_xlabel('x_value')
ax_1.set_ylabel('y=x')
ax_2.set_ylabel('$y=x^2$')
fig.legend(loc='lower right')
plt.show()

Streudiagramm

Sie können Streuung anstelle von Plot verwenden, um ein Streudiagramm zu erstellen.

df = pd.DataFrame(data=np.random.randn(200, 2),
                  columns=['A', 'B'])
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(df['A'], df['B'])
plt.show()

Ändern Sie die Größe, den Stil und die Farbe von Punkten

Unten ist der Code.

df = pd.DataFrame(data=np.random.randn(200, 2),
                  columns=['A', 'B'])
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(df['A'], df['B'], s=100, c='r', alpha=0.5)
ax.set_xlabel('$x_0$', fontsize=10)
ax.set_ylabel('$x_1$', fontsize=10)
ax.set_title('title')
plt.show()

Die Größe des Punktes wird durch "s" in "Streuung" festgelegt, die Farbe wird durch "c" festgelegt und die Transparenz wird durch "alpha" festgelegt.

Ändern Sie die Größe und Farbe der Punkte entsprechend den Daten

Unten ist der Code.

df = pd.DataFrame(data=np.random.randn(200, 2),
                  columns=['A', 'B'])
df['data_size'] = np.random.randint(1, 100, 200)
fig = plt.figure()
ax = fig.add_subplot(111)
ax_cmap = ax.scatter(df['A'], df['B'], s=df['data_size']*10, c=df['data_size'], cmap='viridis', alpha=0.5)
fig.colorbar(ax_cmap)
ax.set_xlabel('$x_0$', fontsize=10)
ax.set_ylabel('$x_1$', fontsize=10)
ax.set_title('title')
plt.show()

data_size wird für c in ax.scatter angegeben, und viridis wird für cmap angegeben. viridis ist eine Farbkarte, die häufig in Matplotlib verwendet wird.

Sie können die richtige Farbleiste generieren, indem Sie das zuordnungsfähige Objekt, mit dem die Farbkarte erstellt wurde, an "fig.colorbar" übergeben.

Balkendiagramm

Erstellen Sie ein Balkendiagramm. Unten ist der Code.

df = pd.DataFrame({'C1': ['A', 'A', 'A', 'B', 'B', 'C'],
                   'C2': [1, 2, 4, 5, 7, 7],
                   'C3': [1, 12, 7, 4, 8, 9]})
fig = plt.figure()
ax = fig.add_subplot(111)
ax.bar(df['C1'].value_counts().index, df.groupby('C1').sum()['C2'])
plt.show()

Der Index A, B, C des C1-Elements wird von df ['C1']. Value_counts (). Index empfangen.

Mit df.groupby ('C1') gruppieren wir nach C1-Elementen, berechnen die Summe nach sum () und erhalten das C2-Element darin.

Erstellen Sie mehrere Balkendiagramme

Generieren Sie mehrere Diagramme wie folgt.

df = pd.DataFrame(data=100 * np.random.rand(5, 5), index=['A', 'B', 'C', 'D', 'E'],
                  columns=['C1', 'C2', 'C3', 'C4', 'C5'])

fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111)
x = np.arange(len(df))
bar_width = 0.4
ax.bar(x, df['C1'], color='b', width=bar_width, label='C1')
ax.bar(x + bar_width, df['C2'], color='r', width=bar_width, label='C2')
plt.xticks(x + bar_width/2, df.index, fontsize=20)
plt.legend()
plt.show()

Geben Sie als Argumente für "ax.bar" zuerst den Wert von x und dann den Wert von y an, färben Sie die Balkenfarbe, breiten Sie die Breite und beschriften Sie die Beschriftung.

xticks gab (x Koordinaten, Name, Schriftgröße = Zeichengröße) als Argumente an.

Histogramm

Unten ist der Code.

df = pd.DataFrame(data=np.random.randn(200), columns=['A'])
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111)
ax.hist(df['A'], bins=15, rwidth=0.8, color='b')
plt.show()

bins passt die Anzahl der Balken im Histogramm an.

Wärmekarte

Unten ist der Code.

df = pd.DataFrame(data=np.random.rand(5, 5), columns=['A', 'B', 'C', 'D', 'E'])
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111)
c_ax = ax.pcolor(df, cmap='Blues')
fig.colorbar(c_ax)
plt.show()

Sie können eine Heatmap erstellen, indem Sie "pcolor" verwenden.

Sie können einen Farbbalken hinzufügen, indem Sie den Rückgabewert übergeben, nachdem Sie "pcolor" an das Argument "fig.colorbar" verwendet haben.

Informationen zum Diagrammstil

Ich habe auf den Artikel [hier] verwiesen (https://qiita.com/MizugiwaHuyu/items/ee85861ff98c8c2c9dd0).

x = np.linspace(0, 1, 100)
y = x ** 3
plt.rcParams["font.family"] = "arial"      #Stellen Sie die gesamte Schriftart ein
plt.rcParams["xtick.direction"] = "in"               #Nach innen die x-Achsen-Skalierungslinie
plt.rcParams["ytick.direction"] = "in"               #Y-Achsen-Skalierungslinie nach innen
plt.rcParams["xtick.minor.visible"] = True           #Hinzufügen einer x-Achsen-Hilfsskala
plt.rcParams["ytick.minor.visible"] = True           #Hinzufügen einer Hilfsskala der y-Achse
plt.rcParams["xtick.major.width"] = 1.5              #Linienbreite der x-Achsen-Hauptskalenlinie
plt.rcParams["ytick.major.width"] = 1.5              #Linienbreite der Hauptskalenlinie der y-Achse
plt.rcParams["xtick.minor.width"] = 1.0              #Linienbreite der Hilfsskalenlinie der x-Achse
plt.rcParams["ytick.minor.width"] = 1.0              #Linienbreite der Hilfsskalenlinie der y-Achse
plt.rcParams["xtick.major.size"] = 10                #Länge der x-Achsen-Hauptskalenlinie
plt.rcParams["ytick.major.size"] = 10                #Länge der Hauptmaßstablinie der y-Achse
plt.rcParams["xtick.minor.size"] = 5                 #Länge der Hilfsskala der x-Achse
plt.rcParams["ytick.minor.size"] = 5                 #Länge der Hilfsskala der y-Achse
plt.rcParams["font.size"] = 14                       #Schriftgröße
plt.rcParams["axes.linewidth"] = 1.5                 #Gehäusedicke
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111)
ax.plot(x, y)
ax.set_xlabel('X')
ax.set_ylabel('Y')
fig.savefig('test_5.png', bbox_inches="tight", pad_inches=0.05)  #Bild speichern
plt.show()

Wie oben gezeigt, können Sie mit plt.rcParams das gesamte Diagramm formatieren. Mit fig.savefig ('test_5.png', bbox_inches =" tight ", pad_inches = 0.05) können Sie das Bild auch mit einem guten Gefühl speichern.

Am Ende

Das ist alles für diesen Artikel.

Sobald ich andere Funktionen finde, die ich häufig benutze, werde ich sie diesem Artikel hinzufügen.

Vielen Dank, dass Sie bisher bei uns geblieben sind.