Matplotlib - Kurzanleitung
Matplotlib ist eines der beliebtesten Python-Pakete für die Datenvisualisierung. Es ist eine plattformübergreifende Bibliothek zum Erstellen von 2D-Plots aus Daten in Arrays. Matplotlib ist in Python geschrieben und verwendet NumPy, die numerische Mathematikerweiterung von Python. Es bietet eine objektorientierte API, mit der Diagramme mithilfe von Python-GUI-Toolkits wie PyQt, WxPythonotTkinter in Anwendungen eingebettet werden können. Es kann auch in Python- und IPython-Shells, Jupyter-Notebooks und Webanwendungsservern verwendet werden.
Matplotlib verfügt über eine prozedurale Schnittstelle namens Pylab, die MATLAB ähnelt, einer von MathWorks entwickelten proprietären Programmiersprache. Matplotlib kann zusammen mit NumPy als Open-Source-Äquivalent von MATLAB angesehen werden.
Matplotlib wurde ursprünglich von John D. Hunter im Jahr 2003 geschrieben. Die aktuelle stabile Version ist 2.2.0 und wurde im Januar 2018 veröffentlicht.
Matplotlib und seine Abhängigkeitspakete sind in Form von Radpaketen in den Standard-Python-Paketrepositorys verfügbar und können mit dem pip-Paketmanager auf Windows-, Linux- und MacOS-Systemen installiert werden.
pip3 install matplotlibWenn Python 2.7- oder 3.4-Versionen nicht für alle Benutzer installiert sind, müssen die weiterverteilbaren Pakete Microsoft Visual C ++ 2008 (64 Bit oder 32 Bit für Python 2.7) oder Microsoft Visual C ++ 2010 (64 Bit oder 32 Bit für Python 3.4) installiert werden.
Wenn Sie Python 2.7 auf einem Mac verwenden, führen Sie den folgenden Befehl aus:
xcode-select –installBei Ausführung des obigen Befehls kann der Unterprozess 32 - eine Abhängigkeit - kompiliert werden.
Unter extrem alten Versionen von Linux und Python 2.7 müssen Sie möglicherweise die Master-Version von subprocess32 installieren.
Matplotlib erfordert eine große Anzahl von Abhängigkeiten -
- Python (> = 2,7 oder> = 3,4)
- NumPy
- setuptools
- dateutil
- pyparsing
- libpng
- pytz
- FreeType
- cycler
- six
Optional können Sie auch eine Reihe von Paketen installieren, um bessere Toolkits für die Benutzeroberfläche zu ermöglichen.
- tk
- PyQt4
- PyQt5
- pygtk
- wxpython
- pycairo
- Tornado
Zur besseren Unterstützung des Animationsausgabeformats und der Bilddateiformate, LaTeX usw. können Sie Folgendes installieren:
- _mpeg/avconv
- ImageMagick
- Kissen (> = 2,0)
- LaTeX und GhostScript (zum Rendern von Text mit LaTeX).
- LaTeX und GhostScript (zum Rendern von Text mit LaTeX).
Anaconda ist eine kostenlose Open-Source-Distribution der Programmiersprachen Python und R für umfangreiche Datenverarbeitung, prädiktive Analyse und wissenschaftliches Rechnen. Die Verteilung macht die Paketverwaltung und -bereitstellung einfach und unkompliziert. Matplotlib und viele andere nützliche (daten-) wissenschaftliche Tools sind Teil der Distribution. Paketversionen werden vom Paketverwaltungssystem Conda verwaltet. Der Vorteil von Anaconda besteht darin, dass Sie Zugriff auf über 720 Pakete haben, die mit Anacondas Conda, einem Paket-, Abhängigkeits- und Umgebungsmanager, einfach installiert werden können.
Die Anaconda-Distribution kann unter installiert werden https://www.anaconda.com/download/. Für die Installation unter Windows stehen 32- und 64-Bit-Binärdateien zur Verfügung -
https://repo.continuum.io/archive/Anaconda3-5.1.0-Windows-x86.exe
https://repo.continuum.io/archive/Anaconda3-5.1.0-Windows-x86_64.exe
Die Installation ist ein ziemlich einfacher, auf Assistenten basierender Prozess. Sie können zwischen dem Hinzufügen von Anaconda in der PATH-Variablen und dem Registrieren von Anaconda als Standard-Python wählen.
Laden Sie für die Installation unter Linux Installationsprogramme für 32-Bit- und 64-Bit-Installationsprogramme von der Downloadseite herunter.
https://repo.continuum.io/archive/Anaconda3-5.1.0-Linux-x86.sh
https://repo.continuum.io/archive/Anaconda3-5.1.0-Linux-x86_64.sh
Führen Sie nun den folgenden Befehl vom Linux-Terminal aus aus:
$ bash Anaconda3-5.0.1-Linux-x86_64.shCanopy und ActiveState sind die gefragtesten Optionen für Windows-, MacOS- und gängige Linux-Plattformen. Die Windows-Benutzer finden eine Option in WinPython.
Jupyter ist ein loses Akronym, das Julia, Python und R bedeutet. Diese Programmiersprachen waren die ersten Zielsprachen der Jupyter-Anwendung, aber heutzutage unterstützt die Notebook-Technologie auch viele andere Sprachen.
Im Jahr 2001 begann Fernando Pérez mit der Entwicklung von Ipython. IPython ist eine Befehlsshell für interaktives Rechnen in mehreren Programmiersprachen, die ursprünglich für Python entwickelt wurde.
Berücksichtigen Sie die folgenden von IPython bereitgestellten Funktionen:
Interaktive Shells (terminal und Qt-basiert).
Ein browserbasiertes Notizbuch mit Unterstützung für Code, Text, mathematische Ausdrücke, Inline-Diagramme und andere Medien.
Unterstützung für interaktive Datenvisualisierung und Verwendung von GUI-Toolkits.
Flexible, einbettbare Dolmetscher zum Laden in eigene Projekte.
2014 kündigte Fernando Pérez ein Spin-off-Projekt von IPython mit dem Namen Project Jupyter an. IPython wird weiterhin als Python-Shell und Kernel für Jupyter existieren, während das Notebook und andere sprachunabhängige Teile von IPython unter dem Namen Jupyter verschoben werden. Jupyter fügte Unterstützung für Julia, R, Haskell und Ruby hinzu.
Öffnen Sie zum Starten des Jupyter-Notizbuchs den Anaconda-Navigator (eine in Anaconda enthaltene grafische Desktop-Benutzeroberfläche, mit der Sie Anwendungen starten und Conda-Pakete, -Umgebungen und -Kanäle einfach verwalten können, ohne Befehlszeilenbefehle verwenden zu müssen).
Navigator zeigt die installierten Komponenten in der Distribution an.
Starten Sie Jupyter Notebook über den Navigator -
Sie sehen die Anwendungsöffnung im Webbrowser unter der folgenden Adresse: http://localhost:8888.
Sie möchten wahrscheinlich zunächst ein neues Notizbuch erstellen. Sie können dies einfach tun, indem Sie auf der Registerkarte "Dateien" auf die Schaltfläche "Neu" klicken. Sie sehen, dass Sie die Option haben, eine normale Textdatei, einen Ordner und ein Terminal zu erstellen. Zuletzt sehen Sie auch die Option, ein Python 3-Notizbuch zu erstellen.
Ein neues Notizbuch ohne Titel mit dem .ipynbDie Erweiterung (steht für das IPython-Notizbuch) wird auf der neuen Registerkarte des Browsers angezeigt.
matplotlib.pyplotist eine Sammlung von Befehlsstilfunktionen, mit denen Matplotlib wie MATLAB funktioniert. Jede Pyplot-Funktion ändert eine Figur. Beispielsweise erstellt eine Funktion eine Figur, einen Plotbereich in einer Figur, zeichnet einige Linien in einem Plotbereich, verziert den Plot mit Beschriftungen usw.
Arten von Grundstücken
| Sr.Nr. | Bedienungsanleitung |
|---|---|
| 1 | Bar Machen Sie ein Balkendiagramm. |
| 2 | Barh Erstellen Sie ein horizontales Balkendiagramm. |
| 3 | Boxplot Machen Sie einen Box- und Whisker-Plot. |
| 4 | Hist Zeichnen Sie ein Histogramm. |
| 5 | hist2d Erstellen Sie ein 2D-Histogramm. |
| 6 | Pie Zeichnen Sie ein Kreisdiagramm. |
| 7 | Plot Zeichnen Sie Linien und / oder Markierungen zu den Achsen. |
| 8 | Polar Machen Sie eine polare Handlung .. |
| 9 | Scatter Machen Sie ein Streudiagramm von x gegen y. |
| 10 | Stackplot Zeichnet ein gestapeltes Flächendiagramm. |
| 11 | Stem Erstellen Sie ein Stammdiagramm. |
| 12 | Step Machen Sie eine Schrittdarstellung. |
| 13 | Quiver Zeichnen Sie ein 2-D-Feld von Pfeilen. |
Bildfunktionen
| Sr.Nr. | Bedienungsanleitung |
|---|---|
| 1 | Imread Lesen Sie ein Bild aus einer Datei in ein Array. |
| 2 | Imsave Speichern Sie ein Array wie in der Bilddatei. |
| 3 | Imshow Zeigen Sie ein Bild auf den Achsen an. |
Achsenfunktionen
| Sr.Nr. | Bedienungsanleitung |
|---|---|
| 1 | Axes Fügen Sie der Figur Achsen hinzu. |
| 2 | Text Fügen Sie den Achsen Text hinzu. |
| 3 | Title Legen Sie einen Titel für die aktuellen Achsen fest. |
| 4 | Xlabel Legen Sie die x-Achsenbeschriftung der aktuellen Achse fest. |
| 5 | Xlim Abrufen oder Festlegen der x-Grenzwerte der aktuellen Achsen. |
| 6 | Xscale . |
| 7 | Xticks Abrufen oder Festlegen der x-Grenzwerte der aktuellen Tick-Positionen und Beschriftungen. |
| 8 | Ylabel Legen Sie die Beschriftung der y-Achse der aktuellen Achse fest. |
| 9 | Ylim Abrufen oder Festlegen der y-Grenzen der aktuellen Achsen. |
| 10 | Yscale Stellen Sie die Skalierung der y-Achse ein. |
| 11 | Yticks Abrufen oder Festlegen der y-Grenzwerte der aktuellen Tick-Positionen und Beschriftungen. |
Abbildung Funktionen
| Sr.Nr. | Bedienungsanleitung |
|---|---|
| 1 | Figtext Fügen Sie der Abbildung Text hinzu. |
| 2 | Figure Erstellt eine neue Figur. |
| 3 | Show Zeigen Sie eine Figur an. |
| 4 | Savefig Speichern Sie die aktuelle Zahl. |
| 5 | Close Schließen Sie ein Figurenfenster. |
In diesem Kapitel erfahren Sie, wie Sie mit Matplotlib ein einfaches Diagramm erstellen.
Wir werden nun ein einfaches Liniendiagramm des Winkels im Bogenmaß gegen seinen Sinuswert in Matplotlib anzeigen. Zunächst wird das Pyplot-Modul aus dem Matplotlib-Paket importiert, wobei üblicherweise ein Alias plt verwendet wird.
import matplotlib.pyplot as pltAls nächstes benötigen wir eine Reihe von Zahlen zum Zeichnen. In der NumPy-Bibliothek, die mit dem Alias np importiert wird, sind verschiedene Array-Funktionen definiert.
import numpy as npWir erhalten nun das ndarray-Objekt mit Winkeln zwischen 0 und 2π unter Verwendung der Funktion arange () aus der NumPy-Bibliothek.
x = np.arange(0, math.pi*2, 0.05)Das ndarray-Objekt dient als Werte auf der x-Achse des Diagramms. Die entsprechenden Sinuswerte der Winkel in x, die auf der y-Achse angezeigt werden sollen, werden durch die folgende Anweisung erhalten:
y = np.sin(x)Die Werte von zwei Arrays werden mit der Funktion plot () gezeichnet.
plt.plot(x,y)Sie können den Plottitel und Beschriftungen für die x- und y-Achse festlegen.
You can set the plot title, and labels for x and y axes.
plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')Das Plot-Viewer-Fenster wird von der Funktion show () aufgerufen -
plt.show()Das komplette Programm ist wie folgt -
from matplotlib import pyplot as plt
import numpy as np
import math #needed for definition of pi
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)
plt.plot(x,y)
plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')
plt.show()Wenn die obige Codezeile ausgeführt wird, wird das folgende Diagramm angezeigt:
Verwenden Sie jetzt das Jupyter-Notizbuch mit Matplotlib.
Starten Sie das Jupyter-Notizbuch wie zuvor beschrieben über den Anaconda-Navigator oder die Befehlszeile. Geben Sie in die Eingabezelle Importanweisungen für Pyplot und NumPy ein -
from matplotlib import pyplot as plt
import numpy as npGeben Sie die folgende magische Anweisung ein, um die Plotausgaben im Notebook selbst (und nicht im separaten Viewer) anzuzeigen:
%matplotlib inlineErhalten Sie x als ndarray-Objekt mit Winkeln im Bogenmaß zwischen 0 und 2π und y als Sinuswert für jeden Winkel -
import math
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)Legen Sie Beschriftungen für die x- und y-Achse sowie den Plottitel fest -
plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')Führen Sie abschließend die Funktion plot () aus, um die Sinuswellenanzeige im Notebook zu generieren (die show () -Funktion muss nicht ausgeführt werden) -
plt.plot(x,y)Nach der Ausführung der letzten Codezeile wird die folgende Ausgabe angezeigt:
PyLab ist eine prozedurale Schnittstelle zur objektorientierten Plotbibliothek von Matplotlib. Matplotlib ist das ganze Paket; matplotlib.pyplot ist ein Modul in Matplotlib; und PyLab ist ein Modul, das neben Matplotlib installiert wird.
PyLab ist ein praktisches Modul, das matplotlib.pyplot (zum Plotten) und NumPy (zum Rechnen und Arbeiten mit Arrays) in einem einzigen Namensraum als Massenimport importiert. Obwohl viele Beispiele PyLab verwenden, wird es nicht mehr empfohlen.
Grundlegende Darstellung
Das Zeichnen von Kurven erfolgt mit dem Befehl plot. Es werden zwei Arrays (oder Sequenzen) gleicher Länge benötigt -
from numpy import *
from pylab import *
x = linspace(-3, 3, 30)
y = x**2
plot(x, y)
show()Die obige Codezeile generiert die folgende Ausgabe:
Geben Sie ein zusätzliches Zeichenfolgenargument an, um Symbole anstelle von Linien zu zeichnen.
| Symbole | -, -, -. ,,. ,,, o, ^, v, <,>, s, +, x, D, d, 1, 2, 3, 4, h, H, p, | , _ |
| Farben | b, g, r, c, m, y, k, w |
Ziehen Sie nun in Betracht, den folgenden Code auszuführen:
from pylab import *
x = linspace(-3, 3, 30)
y = x**2
plot(x, y, 'r.')
show()Es zeichnet die roten Punkte wie unten gezeigt auf -
Grundstücke können überlagert werden. Verwenden Sie einfach die mehreren Plotbefehle. Verwenden Sie clf (), um den Plot zu löschen.
from pylab import *
plot(x, sin(x))
plot(x, cos(x), 'r-')
plot(x, -sin(x), 'g--')
show()Die obige Codezeile generiert die folgende Ausgabe:
Während es einfach ist, schnell Diagramme mit dem zu erstellen matplotlib.pyplotModul wird die Verwendung eines objektorientierten Ansatzes empfohlen, da dies eine bessere Kontrolle und Anpassung Ihrer Diagramme ermöglicht. Die meisten Funktionen sind auch in der verfügbarmatplotlib.axes.Axes Klasse.
Die Hauptidee hinter der Verwendung der formaleren objektorientierten Methode besteht darin, Figurenobjekte zu erstellen und dann einfach Methoden oder Attribute von diesem Objekt aufzurufen. Dieser Ansatz hilft beim Umgang mit einer Leinwand mit mehreren Plots.
In der objektorientierten Oberfläche wird Pyplot nur für einige Funktionen wie die Figurenerstellung verwendet, und der Benutzer erstellt explizit Figuren- und Achsenobjekte und verfolgt diese. Auf dieser Ebene verwendet der Benutzer Pyplot, um Figuren zu erstellen, und durch diese Figuren können ein oder mehrere Achsenobjekte erstellt werden. Diese Achsenobjekte werden dann für die meisten Plotaktionen verwendet.
Zunächst erstellen wir eine Figureninstanz, die eine leere Leinwand bereitstellt.
fig = plt.figure()Fügen Sie nun Achsen zur Figur hinzu. Dasadd_axes()Methode erfordert ein Listenobjekt von 4 Elementen, die links, unten, Breite und Höhe der Figur entsprechen. Jede Zahl muss zwischen 0 und 1 liegen -
ax=fig.add_axes([0,0,1,1])Beschriftungen für x- und y-Achse sowie Titel festlegen -
ax.set_title("sine wave")
ax.set_xlabel('angle')
ax.set_ylabel('sine')Rufen Sie die plot () -Methode des Achsenobjekts auf.
ax.plot(x,y)Wenn Sie ein Jupyter-Notizbuch verwenden, muss die Inline-Direktive% matplotlib ausgegeben werden. Die otherwistshow () -Funktion des Pyplot-Moduls zeigt den Plot an.
Ziehen Sie in Betracht, den folgenden Code auszuführen:
from matplotlib import pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.plot(x,y)
ax.set_title("sine wave")
ax.set_xlabel('angle')
ax.set_ylabel('sine')
plt.show()Ausgabe
Die obige Codezeile generiert die folgende Ausgabe:
Der gleiche Code, der in Jupyter Notebook ausgeführt wird, zeigt die Ausgabe wie unten gezeigt -
Das matplotlib.figureModul enthält die Figure-Klasse. Es ist ein Container der obersten Ebene für alle Plotelemente. Das Figure-Objekt wird durch Aufrufen von instanziiertfigure() Funktion aus dem Pyplot-Modul -
fig = plt.figure()Die folgende Tabelle zeigt die zusätzlichen Parameter -
| Figsize | (Breite, Höhe) Tupel in Zoll |
| Dpi | Punkte pro Zoll |
| Gesichtsfarbe | Figur Patch Gesichtsfarbe |
| Kantenfarbe | Abbildung Patch Kantenfarbe |
| Linienbreite | Kantenlinienbreite |
Das Achsenobjekt ist der Bereich des Bildes mit dem Datenraum. Eine bestimmte Figur kann viele Achsen enthalten, aber ein bestimmtes Achsenobjekt kann sich nur in einer Figur befinden. Die Achsen enthalten zwei (oder drei im Fall von 3D) Achsenobjekte. Die Axes-Klasse und ihre Elementfunktionen sind der primäre Einstiegspunkt für die Arbeit mit der OO-Schnittstelle.
Das Axes-Objekt wird der Figur durch Aufrufen der Methode add_axes () hinzugefügt. Es gibt das Achsenobjekt zurück und fügt eine Achse an der Position rect [links, unten, Breite, Höhe] hinzu, an der alle Größen in Bruchteilen von Figurenbreite und -höhe angegeben sind.
Parameter
Es folgt der Parameter für die Axes-Klasse -
rect - Eine 4-Längen-Sequenz von [links, unten, Breite, Höhe] Mengen.
ax=fig.add_axes([0,0,1,1])Die folgenden Elementfunktionen der Achsenklasse fügen dem Diagramm verschiedene Elemente hinzu:
Legende
Das legend()Die Methode der Achsenklasse fügt der Plotfigur eine Legende hinzu. Es werden drei Parameter benötigt -
ax.legend(handles, labels, loc)Wobei Beschriftungen eine Folge von Zeichenfolgen sind und eine Folge von Line2D- oder Patch-Instanzen verarbeiten. loc kann eine Zeichenfolge oder eine Ganzzahl sein, die den Legendenort angibt.
| Standortzeichenfolge | Standortcode |
|---|---|
| Beste | 0 |
| oben rechts | 1 |
| Oben links | 2 |
| Unten links | 3 |
| rechts unten | 4 |
| Recht | 5 |
| Mitte links | 6 |
| Mitte rechts | 7 |
| untere Mitte | 8 |
| obere Mitte | 9 |
| Center | 10 |
axes.plot ()
Dies ist die grundlegende Methode der Achsenklasse, bei der die Werte eines Arrays gegenüber einem anderen als Linien oder Markierungen dargestellt werden. Die plot () -Methode kann ein optionales Formatzeichenfolgenargument haben, um Farbe, Stil und Größe der Linie und des Markers anzugeben.
Farbcodes
| Charakter | Farbe |
|---|---|
| 'b' | Blau |
| 'G' | Grün |
| 'r' | rot |
| 'b' | Blau |
| 'c' | Cyan |
| bin | Magenta |
| 'y' | Gelb |
| 'k' | Schwarz |
| 'b' | Blau |
| 'w' | Weiß |
Markierungscodes
| Charakter | Beschreibung |
|---|---|
| '.' | Punktmarkierung |
| 'Ö' | Kreismarkierung |
| 'x' | X-Marker |
| 'D' | Diamantmarker |
| 'H' | Sechseckmarker |
| 's' | Quadratische Markierung |
| '+' | Plus Marker |
Linienstile
| Charakter | Beschreibung |
|---|---|
| '-' | Durchgezogene Linie |
| '-' | Gestrichelte Linie |
| '-.' | Strichpunktlinie |
| ':' | Gepunktete Linie |
| 'H' | Sechseckmarker |
Das folgende Beispiel zeigt die Werbekosten und Verkaufszahlen von TV und Smartphone in Form von Liniendiagrammen. Die Linie, die das Fernsehen darstellt, ist eine durchgezogene Linie mit gelben und quadratischen Markierungen, während die Smartphone-Linie eine gestrichelte Linie mit grüner Farbe und Kreismarkierungen ist.
import matplotlib.pyplot as plt
y = [1, 4, 9, 16, 25,36,49, 64]
x1 = [1, 16, 30, 42,55, 68, 77,88]
x2 = [1,6,12,18,28, 40, 52, 65]
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
l1 = ax.plot(x1,y,'ys-') # solid line with yellow colour and square marker
l2 = ax.plot(x2,y,'go--') # dash line with green colour and circle marker
ax.legend(labels = ('tv', 'Smartphone'), loc = 'lower right') # legend placed at lower right
ax.set_title("Advertisement effect on sales")
ax.set_xlabel('medium')
ax.set_ylabel('sales')
plt.show()Wenn die obige Codezeile ausgeführt wird, wird das folgende Diagramm erstellt:
In diesem Kapitel erfahren Sie, wie Sie mehrere Unterzeichnungen auf derselben Leinwand erstellen.
Das subplot()Die Funktion gibt das Achsenobjekt an einer bestimmten Gitterposition zurück. Die Anrufsignatur dieser Funktion lautet -
plt.subplot(subplot(nrows, ncols, index)In der aktuellen Abbildung erstellt die Funktion ein Axes-Objekt und gibt es am Positionsindex eines Rasters von nrows by ncolsaxes zurück. Die Indizes reichen von 1 bis nrows * ncols und werden in der Reihenfolge der Hauptzeilen inkrementiert. Innrows, ncols und index sind alle kleiner als 10. Die Indizes können auch als einzelne, verkettete dreistellige Nummer angegeben werden.
Zum Beispiel erzeugen Unterzeichnung (2, 3, 3) und Unterzeichnung (233) beide Achsen in der oberen rechten Ecke der aktuellen Figur, die die Hälfte der Figurenhöhe und ein Drittel der Figurenbreite einnehmen.
Durch das Erstellen eines Unterplots werden alle bereits vorhandenen Unterplots gelöscht, die sich über die gemeinsame Nutzung einer Grenze hinaus mit diesen überschneiden.
import matplotlib.pyplot as plt
# plot a line, implicitly creating a subplot(111)
plt.plot([1,2,3])
# now create a subplot which represents the top plot of a grid with 2 rows and 1 column.
#Since this subplot will overlap the first, the plot (and its axes) previously
created, will be removed
plt.subplot(211)
plt.plot(range(12))
plt.subplot(212, facecolor='y') # creates 2nd subplot with yellow background
plt.plot(range(12))Die obige Codezeile generiert die folgende Ausgabe:
Die Funktion add_subplot () der Figurenklasse überschreibt das vorhandene Diagramm nicht -
import matplotlib.pyplot as plt
fig = plt.figure()
ax1 = fig.add_subplot(111)
ax1.plot([1,2,3])
ax2 = fig.add_subplot(221, facecolor='y')
ax2.plot([1,2,3])Wenn die obige Codezeile ausgeführt wird, wird die folgende Ausgabe generiert:
Sie können ein Einfügungsdiagramm in derselben Figur hinzufügen, indem Sie ein weiteres Achsenobjekt in derselben Zeichenfläche hinzufügen.
import matplotlib.pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
fig=plt.figure()
axes1 = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # main axes
axes2 = fig.add_axes([0.55, 0.55, 0.3, 0.3]) # inset axes
y = np.sin(x)
axes1.plot(x, y, 'b')
axes2.plot(x,np.cos(x),'r')
axes1.set_title('sine')
axes2.set_title("cosine")
plt.show()Bei Ausführung der obigen Codezeile wird die folgende Ausgabe generiert:
Die Pyplot-API von Matplotlib verfügt über eine praktische Funktion namens subplots (), die als Utility-Wrapper fungiert und beim Erstellen allgemeiner Layouts von Unterplots, einschließlich des einschließenden Figurenobjekts, in einem einzigen Aufruf hilft.
Plt.subplots(nrows, ncols)Die beiden ganzzahligen Argumente für diese Funktion geben die Anzahl der Zeilen und Spalten des Unterplotrasters an. Die Funktion gibt ein Figurenobjekt und ein Tupel zurück, das Achsenobjekte enthält, die nrows * ncols entsprechen. Auf jedes Achsenobjekt kann über seinen Index zugegriffen werden. Hier erstellen wir eine Unterzeichnung von 2 Zeilen mal 2 Spalten und zeigen 4 verschiedene Darstellungen in jeder Unterzeichnung an.
import matplotlib.pyplot as plt
fig,a = plt.subplots(2,2)
import numpy as np
x = np.arange(1,5)
a[0][0].plot(x,x*x)
a[0][0].set_title('square')
a[0][1].plot(x,np.sqrt(x))
a[0][1].set_title('square root')
a[1][0].plot(x,np.exp(x))
a[1][0].set_title('exp')
a[1][1].plot(x,np.log10(x))
a[1][1].set_title('log')
plt.show()Die obige Codezeile generiert die folgende Ausgabe:
Diese Funktion bietet mehr Flexibilität beim Erstellen eines Achsenobjekts an einer bestimmten Stelle des Gitters. Außerdem kann das Achsenobjekt über mehrere Zeilen oder Spalten verteilt werden.
Plt.subplot2grid(shape, location, rowspan, colspan)Im folgenden Beispiel wird ein 3X3-Raster des Figurenobjekts mit Achsenobjekten unterschiedlicher Größe in Zeilen- und Spaltenbereichen gefüllt, die jeweils ein anderes Diagramm zeigen.
import matplotlib.pyplot as plt
a1 = plt.subplot2grid((3,3),(0,0),colspan = 2)
a2 = plt.subplot2grid((3,3),(0,2), rowspan = 3)
a3 = plt.subplot2grid((3,3),(1,0),rowspan = 2, colspan = 2)
import numpy as np
x = np.arange(1,10)
a2.plot(x, x*x)
a2.set_title('square')
a1.plot(x, np.exp(x))
a1.set_title('exp')
a3.plot(x, np.log(x))
a3.set_title('log')
plt.tight_layout()
plt.show()Bei Ausführung des obigen Zeilencodes wird die folgende Ausgabe generiert:
Die Funktion grid () des Achsenobjekts setzt die Sichtbarkeit des Gitters innerhalb der Figur auf Ein oder Aus. Sie können auch Haupt- / Neben- (oder beide) Häkchen des Rasters anzeigen. Zusätzlich können in der Funktion grid () die Eigenschaften Farbe, Linienstil und Linienbreite festgelegt werden.
import matplotlib.pyplot as plt
import numpy as np
fig, axes = plt.subplots(1,3, figsize = (12,4))
x = np.arange(1,11)
axes[0].plot(x, x**3, 'g',lw=2)
axes[0].grid(True)
axes[0].set_title('default grid')
axes[1].plot(x, np.exp(x), 'r')
axes[1].grid(color='b', ls = '-.', lw = 0.25)
axes[1].set_title('custom grid')
axes[2].plot(x,x)
axes[2].set_title('no grid')
fig.tight_layout()
plt.show()
Manchmal sind ein oder mehrere Punkte viel größer als der Großteil der Daten. In einem solchen Fall muss der Maßstab einer Achse als logarithmisch und nicht als normaler Maßstab eingestellt werden. Dies ist die logarithmische Skala. In Matplotlib ist es möglich, die xscale- oder vscale-Eigenschaft des Achsenobjekts auf 'log' zu setzen.
Manchmal muss auch ein zusätzlicher Abstand zwischen den Achsnummern und der Achsenbeschriftung angegeben werden. Die Labelpad-Eigenschaft einer der Achsen (x oder y oder beide) kann auf den gewünschten Wert eingestellt werden.
Beide oben genannten Funktionen werden anhand des folgenden Beispiels demonstriert. Das Unterplot auf der rechten Seite hat eine logarithmische Skala und eines auf der linken Seite hat eine x-Achse mit einer Beschriftung in größerem Abstand.
import matplotlib.pyplot as plt
import numpy as np
fig, axes = plt.subplots(1, 2, figsize=(10,4))
x = np.arange(1,5)
axes[0].plot( x, np.exp(x))
axes[0].plot(x,x**2)
axes[0].set_title("Normal scale")
axes[1].plot (x, np.exp(x))
axes[1].plot(x, x**2)
axes[1].set_yscale("log")
axes[1].set_title("Logarithmic scale (y)")
axes[0].set_xlabel("x axis")
axes[0].set_ylabel("y axis")
axes[0].xaxis.labelpad = 10
axes[1].set_xlabel("x axis")
axes[1].set_ylabel("y axis")
plt.show()
Achsenstacheln sind die Linien, die Achsenmarkierungen verbinden, die die Grenzen des Plotbereichs abgrenzen. Das Achsenobjekt hat oben, unten, links und rechts Stacheln.
Jeder Rücken kann durch Angabe von Farbe und Breite formatiert werden. Jede Kante kann unsichtbar gemacht werden, wenn ihre Farbe auf keine gesetzt ist.
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.spines['bottom'].set_color('blue')
ax.spines['left'].set_color('red')
ax.spines['left'].set_linewidth(2)
ax.spines['right'].set_color(None)
ax.spines['top'].set_color(None)
ax.plot([1,2,3,4,5])
plt.show()
Matplotlib ermittelt automatisch die Minimal- und Maximalwerte von Variablen, die entlang der x-, y- (und z-Achse im Fall eines 3D-Diagramms) eines Diagramms angezeigt werden sollen. Es ist jedoch möglich, die Grenzwerte explizit mithilfe von festzulegenset_xlim() und set_ylim() Funktionen.
In der folgenden Darstellung sind die automatisch skalierten Grenzen der x- und y-Achse dargestellt:
import matplotlib.pyplot as plt
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
import numpy as np
x = np.arange(1,10)
a1.plot(x, np.exp(x))
a1.set_title('exp')
plt.show()
Jetzt formatieren wir die Grenzen für die x-Achse auf (0 bis 10) und die y-Achse (0 bis 10000) -
import matplotlib.pyplot as plt
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
import numpy as np
x = np.arange(1,10)
a1.plot(x, np.exp(x),'r')
a1.set_title('exp')
a1.set_ylim(0,10000)
a1.set_xlim(0,10)
plt.show()
Häkchen sind die Markierungen, die Datenpunkte auf Achsen bezeichnen. Bisher hat Matplotlib - in all unseren vorherigen Beispielen - automatisch die Aufgabe übernommen, Punkte auf der Achse zu beabstanden. Die Standard-Tick-Locators und -Formatierer von Matplotlib sind so konzipiert, dass sie in vielen gängigen Situationen im Allgemeinen ausreichen. Position und Beschriftung von Zecken können explizit angegeben werden, um bestimmten Anforderungen zu entsprechen.
Das xticks() und yticks()Funktion nimmt ein Listenobjekt als Argument. Die Elemente in der Liste bezeichnen die Positionen der entsprechenden Aktion, an denen Ticks angezeigt werden.
ax.set_xticks([2,4,6,8,10])Diese Methode markiert die Datenpunkte an den angegebenen Positionen mit Häkchen.
Ebenso können Beschriftungen, die Häkchen entsprechen, durch gesetzt werden set_xlabels() und set_ylabels() Funktionen jeweils.
ax.set_xlabels([‘two’, ‘four’,’six’, ‘eight’, ‘ten’])Dadurch werden die Textbeschriftungen unter den Markierungen auf der x-Achse angezeigt.
Das folgende Beispiel zeigt die Verwendung von Häkchen und Beschriftungen.
import matplotlib.pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
fig = plt.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # main axes
y = np.sin(x)
ax.plot(x, y)
ax.set_xlabel(‘angle’)
ax.set_title('sine')
ax.set_xticks([0,2,4,6])
ax.set_xticklabels(['zero','two','four','six'])
ax.set_yticks([-1,0,1])
plt.show()
Es wird als nützlich angesehen, zwei x- oder y-Achsen in einer Figur zu haben. Moreso, wenn Kurven mit verschiedenen Einheiten zusammen gezeichnet werden. Matplotlib unterstützt dies mit den Twinx- und Twiny-Funktionen.
Im folgenden Beispiel hat das Diagramm zwei y-Achsen, von denen eine exp (x) und die andere log (x) zeigt.
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
x = np.arange(1,11)
a1.plot(x,np.exp(x))
a1.set_ylabel('exp')
a2 = a1.twinx()
a2.plot(x, np.log(x),'ro-')
a2.set_ylabel('log')
fig.legend(labels = ('exp','log'),loc='upper left')
plt.show()
Ein Balkendiagramm oder Balkendiagramm ist ein Diagramm oder ein Diagramm, das kategoriale Daten mit rechteckigen Balken mit Höhen oder Längen darstellt, die proportional zu den Werten sind, die sie darstellen. Die Balken können vertikal oder horizontal gezeichnet werden.
Ein Balkendiagramm zeigt Vergleiche zwischen diskreten Kategorien. Eine Achse des Diagramms zeigt die spezifischen Kategorien, die verglichen werden, und die andere Achse repräsentiert einen gemessenen Wert.
Die Matplotlib-API bietet die bar()Funktion, die im MATLAB-Stil verwendet werden kann, sowie objektorientierte API. Die Signatur der Funktion bar (), die mit dem Achsenobjekt verwendet werden soll, lautet wie folgt:
ax.bar(x, height, width, bottom, align)Die Funktion erstellt ein Balkendiagramm mit dem gebundenen Rechteck der Größe (x - Breite = 2; x + Breite = 2; Boden; Boden + Höhe).
Die Parameter für die Funktion sind -
| x | Folge von Skalaren, die die x-Koordinaten der Balken darstellen. Steuerelemente ausrichten, wenn x die Balkenmitte (Standard) oder der linke Rand ist. |
| Höhe | Skalar oder Folge von Skalaren, die die Höhe (n) der Balken darstellen. |
| Breite | skalar oder arrayartig, optional. Die Breite (n) der Balken beträgt standardmäßig 0,8 |
| Unterseite | skalar oder arrayartig, optional. Die y-Koordinate (n) der Balken sind standardmäßig Keine. |
| ausrichten | {'center', 'edge'}, optional, Standard 'center' |
Die Funktion gibt ein Matplotlib-Containerobjekt mit allen Balken zurück.
Es folgt ein einfaches Beispiel für das Matplotlib-Balkendiagramm. Es zeigt die Anzahl der Studenten, die für verschiedene Kurse an einem Institut eingeschrieben sind.
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
langs = ['C', 'C++', 'Java', 'Python', 'PHP']
students = [23,17,35,29,12]
ax.bar(langs,students)
plt.show()
Wenn Sie mehrere Größen vergleichen und eine Variable ändern, möchten wir möglicherweise ein Balkendiagramm, in dem Balken einer Farbe für einen Mengenwert vorhanden sind.
Wir können mehrere Balkendiagramme zeichnen, indem wir mit der Dicke und den Positionen der Balken spielen. Die Datenvariable enthält drei Reihen von vier Werten. Das folgende Skript zeigt drei Balkendiagramme mit vier Balken. Die Stäbe haben eine Dicke von 0,25 Einheiten. Jedes Balkendiagramm wird gegenüber dem vorherigen um 0,25 Einheiten verschoben. Das Datenobjekt ist ein Multidikt, das die Anzahl der Studenten enthält, die in den letzten vier Jahren in drei Zweigen einer Ingenieurschule bestanden haben.
import numpy as np
import matplotlib.pyplot as plt
data = [[30, 25, 50, 20],
[40, 23, 51, 17],
[35, 22, 45, 19]]
X = np.arange(4)
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.bar(X + 0.00, data[0], color = 'b', width = 0.25)
ax.bar(X + 0.25, data[1], color = 'g', width = 0.25)
ax.bar(X + 0.50, data[2], color = 'r', width = 0.25)
Das gestapelte Balkendiagramm stapelt Balken, die verschiedene Gruppen übereinander darstellen. Die Höhe des resultierenden Balkens zeigt das kombinierte Ergebnis der Gruppen.
Der optionale untere Parameter des pyplot.bar()Mit dieser Funktion können Sie einen Startwert für einen Balken angeben. Anstatt von Null zu einem Wert zu laufen, wird von unten nach dem Wert gewechselt. Der erste Aufruf von pyplot.bar () zeichnet die blauen Balken. Beim zweiten Aufruf von pyplot.bar () werden die roten Balken dargestellt, wobei sich der untere Rand der blauen Balken oben auf den roten Balken befindet.
import numpy as np
import matplotlib.pyplot as plt
N = 5
menMeans = (20, 35, 30, 35, 27)
womenMeans = (25, 32, 34, 20, 25)
ind = np.arange(N) # the x locations for the groups
width = 0.35
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.bar(ind, menMeans, width, color='r')
ax.bar(ind, womenMeans, width,bottom=menMeans, color='b')
ax.set_ylabel('Scores')
ax.set_title('Scores by group and gender')
ax.set_xticks(ind, ('G1', 'G2', 'G3', 'G4', 'G5'))
ax.set_yticks(np.arange(0, 81, 10))
ax.legend(labels=['Men', 'Women'])
plt.show()
Ein Histogramm ist eine genaue Darstellung der Verteilung numerischer Daten. Es ist eine Schätzung der Wahrscheinlichkeitsverteilung einer kontinuierlichen Variablen. Es ist eine Art Balkendiagramm.
Gehen Sie folgendermaßen vor, um ein Histogramm zu erstellen:
- Bin der Wertebereich.
- Teilen Sie den gesamten Wertebereich in eine Reihe von Intervallen ein.
- Zählen Sie, wie viele Werte in jedes Intervall fallen.
Die Bins werden normalerweise als aufeinanderfolgende, nicht überlappende Intervalle einer Variablen angegeben.
Das matplotlib.pyplot.hist()Funktion zeichnet ein Histogramm. Es berechnet und zeichnet das Histogramm von x.
Parameter
In der folgenden Tabelle sind die Parameter für ein Histogramm aufgeführt.
| x | Array oder Folge von Arrays |
| Behälter | Ganzzahl oder Sequenz oder 'Auto', optional |
| optionale Parameter | |
| Angebot | Der untere und obere Bereich der Behälter. |
| Dichte | Wenn True, sind die Zählungen, die zur Bildung einer Wahrscheinlichkeitsdichte normalisiert wurden, das erste Element des Rückgabetupels |
| kumulativ | Wenn True, wird ein Histogramm berechnet, in dem jeder Bin die Anzahl in diesem Bin plus alle Bins für kleinere Werte angibt. |
| Histtyp | Die Art des zu zeichnenden Histogramms. Standard ist 'bar'
|
Das folgende Beispiel zeigt ein Histogramm der Noten, die von Schülern einer Klasse erhalten wurden. Es sind vier Fächer 0-25, 26-50, 51-75 und 76-100 definiert. Das Histogramm zeigt die Anzahl der Schüler, die in diesen Bereich fallen.
from matplotlib import pyplot as plt
import numpy as np
fig,ax = plt.subplots(1,1)
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
ax.hist(a, bins = [0,25,50,75,100])
ax.set_title("histogram of result")
ax.set_xticks([0,25,50,75,100])
ax.set_xlabel('marks')
ax.set_ylabel('no. of students')
plt.show()Das Diagramm wird wie folgt angezeigt:
Ein Kreisdiagramm kann nur eine Reihe von Daten anzeigen. Kreisdiagramme zeigen die Größe von Elementen (Keil genannt) in einer Datenreihe, proportional zur Summe der Elemente. Die Datenpunkte in einem Kreisdiagramm werden als Prozentsatz des gesamten Kreises angezeigt.
Matplotlib API hat eine pie()Funktion, die ein Kreisdiagramm generiert, das Daten in einem Array darstellt. Die Bruchfläche jedes Keils ist gegeben durchx/sum(x). Wenn die Summe (x) <1 ist, geben die Werte von x die Bruchfläche direkt an und das Array wird nicht normalisiert. Der resultierende Kuchen hat einen leeren Keil der Größe 1 - Summe (x).
Das Kreisdiagramm sieht am besten aus, wenn die Figur und die Achsen quadratisch sind oder der Achsenaspekt gleich ist.
Parameter
In der folgenden Tabelle sind die Parameter für ein Kreisdiagramm aufgeführt.
| x | Array-ähnlich. Die Keilgrößen. |
| Etiketten | Liste. Eine Folge von Zeichenfolgen, die die Beschriftungen für jeden Keil bereitstellen. |
| Farben | Eine Folge von Matplotlibcolorargs, durch die das Kreisdiagramm läuft. Wenn Keine, werden die Farben im aktuell aktiven Zyklus verwendet. |
| Autopct | Zeichenfolge, mit der die Keile mit ihrem numerischen Wert beschriftet werden. Das Etikett wird innerhalb des Keils platziert. Die Formatzeichenfolge lautet fmt% pct. |
Der folgende Code verwendet die Funktion pie (), um das Kreisdiagramm der Liste der Schüler anzuzeigen, die für verschiedene Computersprachkurse eingeschrieben sind. Der anteilige Prozentsatz wird mit Hilfe von innerhalb des jeweiligen Keils angezeigtautopct Parameter, der auf% 1.2f% gesetzt ist.
from matplotlib import pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.axis('equal')
langs = ['C', 'C++', 'Java', 'Python', 'PHP']
students = [23,17,35,29,12]
ax.pie(students, labels = langs,autopct='%1.2f%%')
plt.show()
Streudiagramme werden verwendet, um Datenpunkte auf der horizontalen und vertikalen Achse zu zeichnen, um zu zeigen, wie stark eine Variable von einer anderen beeinflusst wird. Jede Zeile in der Datentabelle wird durch eine Markierung dargestellt, deren Position von ihren Werten in den auf der X- und Y-Achse festgelegten Spalten abhängt. Eine dritte Variable kann so eingestellt werden, dass sie der Farbe oder Größe der Markierungen entspricht, wodurch dem Diagramm eine weitere Dimension hinzugefügt wird.
Das folgende Skript zeigt ein Streudiagramm des Notenbereichs gegenüber den Noten von Jungen und Mädchen in zwei verschiedenen Farben.
import matplotlib.pyplot as plt
girls_grades = [89, 90, 70, 89, 100, 80, 90, 100, 80, 34]
boys_grades = [30, 29, 49, 48, 100, 48, 38, 45, 20, 30]
grades_range = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
fig=plt.figure()
ax=fig.add_axes([0,0,1,1])
ax.scatter(grades_range, girls_grades, color='r')
ax.scatter(grades_range, boys_grades, color='b')
ax.set_xlabel('Grades Range')
ax.set_ylabel('Grades Scored')
ax.set_title('scatter plot')
plt.show()
Konturdiagramme (manchmal auch als Ebenendiagramme bezeichnet) sind eine Möglichkeit, eine dreidimensionale Oberfläche in einer zweidimensionalen Ebene darzustellen. Es werden zwei Prädiktorvariablen XY auf der y-Achse und eine Antwortvariable Z als Konturen grafisch dargestellt. Diese Konturen werden manchmal als Z-Slices oder Iso-Response-Werte bezeichnet.
Ein Konturdiagramm ist geeignet, wenn Sie sehen möchten, wie sich der Wert Z in Abhängigkeit von zwei Eingängen X und Y ändert, sodass Z = f (X, Y). Eine Konturlinie oder Isolinie einer Funktion zweier Variablen ist eine Kurve, entlang der die Funktion einen konstanten Wert hat.
Die unabhängigen Variablen x und y sind normalerweise auf ein reguläres Gitter namens Meshgrid beschränkt. Das numpy.meshgrid erstellt ein rechteckiges Gitter aus einem Array von x-Werten und einem Array von y-Werten.
Die Matplotlib-API enthält die Funktionen contour () und contourf (), mit denen Konturlinien bzw. gefüllte Konturen gezeichnet werden. Beide Funktionen benötigen drei Parameter x, y und z.
import numpy as np
import matplotlib.pyplot as plt
xlist = np.linspace(-3.0, 3.0, 100)
ylist = np.linspace(-3.0, 3.0, 100)
X, Y = np.meshgrid(xlist, ylist)
Z = np.sqrt(X**2 + Y**2)
fig,ax=plt.subplots(1,1)
cp = ax.contourf(X, Y, Z)
fig.colorbar(cp) # Add a colorbar to a plot
ax.set_title('Filled Contours Plot')
#ax.set_xlabel('x (cm)')
ax.set_ylabel('y (cm)')
plt.show()
Ein Köcherplot zeigt die Geschwindigkeitsvektoren als Pfeile mit Komponenten (u, v) an den Punkten (x, y) an.
quiver(x,y,u,v)Der obige Befehl zeichnet Vektoren als Pfeile an den Koordinaten auf, die in jedem entsprechenden Elementpaar in x und y angegeben sind.
Parameter
In der folgenden Tabelle sind die verschiedenen Parameter für das Köcher-Diagramm aufgeführt.
| x | 1D- oder 2D-Array, Sequenz. Die x-Koordinaten der Pfeilpositionen |
| y | 1D- oder 2D-Array, Sequenz. Die y-Koordinaten der Pfeilpositionen |
| u | 1D- oder 2D-Array, Sequenz. Die x-Komponenten der Pfeilvektoren |
| v | 1D- oder 2D-Array, Sequenz. Die y-Komponenten der Pfeilvektoren |
| c | 1D- oder 2D-Array, Sequenz. Die Pfeilfarben |
Der folgende Code zeichnet einen einfachen Köcherplot -
import matplotlib.pyplot as plt
import numpy as np
x,y = np.meshgrid(np.arange(-2, 2, .2), np.arange(-2, 2, .25))
z = x*np.exp(-x**2 - y**2)
v, u = np.gradient(z, .2, .2)
fig, ax = plt.subplots()
q = ax.quiver(x,y,u,v)
plt.show()
Ein Box-Plot, das auch als Whisker-Plot bezeichnet wird, zeigt eine Zusammenfassung eines Datensatzes an, der das Minimum, das erste Quartil, den Median, das dritte Quartil und das Maximum enthält. In einem Boxplot zeichnen wir eine Box vom ersten bis zum dritten Quartil. Eine vertikale Linie verläuft im Median durch das Feld. Die Whisker gehen von jedem Quartil zum Minimum oder Maximum.
Lassen Sie uns die Daten für die Boxplots erstellen. Wir nehmen dasnumpy.random.normal()Funktion zum Erstellen der gefälschten Daten. Es werden drei Argumente benötigt, Mittelwert und Standardabweichung der Normalverteilung und die Anzahl der gewünschten Werte.
np.random.seed(10)
collectn_1 = np.random.normal(100, 10, 200)
collectn_2 = np.random.normal(80, 30, 200)
collectn_3 = np.random.normal(90, 20, 200)
collectn_4 = np.random.normal(70, 25, 200)Die Liste der Arrays, die wir oben erstellt haben, ist die einzige erforderliche Eingabe zum Erstellen des Boxplots. Verwendung derdata_to_plot Codezeile können wir das Boxplot mit dem folgenden Code erstellen -
fig = plt.figure()
# Create an axes instance
ax = fig.add_axes([0,0,1,1])
# Create the boxplot
bp = ax.boxplot(data_to_plot)
plt.show()Die obige Codezeile generiert die folgende Ausgabe:
Violin-Plots ähneln Box-Plots, zeigen jedoch auch die Wahrscheinlichkeitsdichte der Daten bei verschiedenen Werten. Diese Diagramme enthalten eine Markierung für den Median der Daten und ein Feld, das den Interquartilbereich angibt, wie in den Standardfelddiagrammen. Diesem Boxplot ist eine Schätzung der Kerneldichte überlagert. Geigenplots werden wie Box-Plots verwendet, um den Vergleich einer variablen Verteilung (oder Stichprobenverteilung) über verschiedene "Kategorien" darzustellen.
Eine Geigenhandlung ist informativer als eine einfache Boxhandlung. Während ein Box-Plot nur zusammenfassende Statistiken wie Mittelwert / Median und Interquartilbereiche zeigt, zeigt das Violin-Plot die vollständige Verteilung der Daten.
import matplotlib.pyplot as plt
np.random.seed(10)
collectn_1 = np.random.normal(100, 10, 200)
collectn_2 = np.random.normal(80, 30, 200)
collectn_3 = np.random.normal(90, 20, 200)
collectn_4 = np.random.normal(70, 25, 200)
## combine these different collections into a list
data_to_plot = [collectn_1, collectn_2, collectn_3, collectn_4]
# Create a figure instance
fig = plt.figure()
# Create an axes instance
ax = fig.add_axes([0,0,1,1])
# Create the boxplot
bp = ax.violinplot(data_to_plot)
plt.show()
Obwohl Matplotlib ursprünglich nur für zweidimensionales Plotten konzipiert wurde, wurden in späteren Versionen einige dreidimensionale Plot-Dienstprogramme auf Matplotlibs zweidimensionaler Anzeige aufgebaut, um eine Reihe von Werkzeugen für die dreidimensionale Datenvisualisierung bereitzustellen. Dreidimensionale Diagramme werden durch Importieren von aktiviertmplot3d toolkit, im Matplotlib-Paket enthalten.
Eine dreidimensionale Achse kann erstellt werden, indem das Schlüsselwort projection = '3d' an eine der normalen Routinen zur Achsenerstellung übergeben wird.
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.axes(projection='3d')
z = np.linspace(0, 1, 100)
x = z * np.sin(20 * z)
y = z * np.cos(20 * z)
ax.plot3D(x, y, z, 'gray')
ax.set_title('3D line plot')
plt.show()Wir können jetzt eine Vielzahl von dreidimensionalen Diagrammtypen zeichnen. Die grundlegendste dreidimensionale Darstellung ist a3D line ploterstellt aus Mengen von (x, y, z) Tripeln. Dies kann mit der Funktion ax.plot3D erstellt werden.
3D scatter plot wird mit dem generiert ax.scatter3D Funktion.
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.axes(projection='3d')
z = np.linspace(0, 1, 100)
x = z * np.sin(20 * z)
y = z * np.cos(20 * z)
c = x + y
ax.scatter(x, y, z, c=c)
ax.set_title('3d Scatter plot')
plt.show()
Das ax.contour3D()Funktion erstellt dreidimensionales Konturdiagramm. Alle Eingabedaten müssen in Form von zweidimensionalen regulären Gittern vorliegen, wobei die Z-Daten an jedem Punkt ausgewertet werden. Hier zeigen wir ein dreidimensionales Konturdiagramm einer dreidimensionalen Sinusfunktion.
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
def f(x, y):
return np.sin(np.sqrt(x ** 2 + y ** 2))
x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.contour3D(X, Y, Z, 50, cmap='binary')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
ax.set_title('3D contour')
plt.show()
Das Wireframe-Diagramm nimmt ein Wertegitter und projiziert es auf die angegebene dreidimensionale Oberfläche. Dadurch können die resultierenden dreidimensionalen Formen sehr einfach visualisiert werden. Dasplot_wireframe() Funktion wird für den Zweck verwendet -
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
def f(x, y):
return np.sin(np.sqrt(x ** 2 + y ** 2))
x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.plot_wireframe(X, Y, Z, color='black')
ax.set_title('wireframe')
plt.show()Die obige Codezeile generiert die folgende Ausgabe:
Das Oberflächendiagramm zeigt eine funktionale Beziehung zwischen einer bestimmten abhängigen Variablen (Y) und zwei unabhängigen Variablen (X und Z). Das Diagramm ist ein Begleitdiagramm zum Konturdiagramm. Ein Flächendiagramm ähnelt einem Drahtgitterdiagramm, aber jede Fläche des Drahtgitters ist ein gefülltes Polygon. Dies kann die Wahrnehmung der Topologie der zu visualisierenden Oberfläche unterstützen. Dasplot_surface() Funktion x, y und z als Argumente.
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
x = np.outer(np.linspace(-2, 2, 30), np.ones(30))
y = x.copy().T # transpose
z = np.cos(x ** 2 + y ** 2)
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.plot_surface(x, y, z,cmap='viridis', edgecolor='none')
ax.set_title('Surface plot')
plt.show()Die obige Codezeile generiert die folgende Ausgabe:
Matplotlib bietet umfangreiche Textunterstützung, einschließlich Unterstützung für mathematische Ausdrücke. TrueTypeUnterstützung für Raster- und Vektorausgaben, durch Zeilenumbrüche getrennten Text mit beliebigen Drehungen und Unicode-Unterstützung. Matplotlib enthält einen eigenen matplotlib.font_manager, der einen plattformübergreifenden, W3C-kompatiblen Algorithmus zum Auffinden von Schriftarten implementiert.
Der Benutzer hat viel Kontrolle über die Texteigenschaften (Schriftgröße, Schriftgröße, Textposition und -farbe usw.). Matplotlib implementiert eine große Anzahl von TeX-Mathematiksymbolen und -befehlen.
Die folgende Befehlsliste wird zum Erstellen von Text in der Pyplot-Oberfläche verwendet:
| Text | Fügen Sie Text an einer beliebigen Stelle der Achsen hinzu. |
| kommentieren | Fügen Sie an einer beliebigen Stelle der Achsen eine Anmerkung mit einem optionalen Pfeil hinzu. |
| xlabel | Fügen Sie der x-Achse der Achsen eine Beschriftung hinzu. |
| ylabel | Fügen Sie der y-Achse der Achse eine Beschriftung hinzu. |
| Titel | Fügen Sie den Achsen einen Titel hinzu. |
| figtext | Fügen Sie an einer beliebigen Stelle der Abbildung Text hinzu. |
| suptitle | Fügen Sie der Abbildung einen Titel hinzu. |
Alle diese Funktionen erstellen und geben a zurück matplotlib.text.Text() Beispiel.
Die folgenden Skripte demonstrieren die Verwendung einiger der oben genannten Funktionen -
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.set_title('axes title')
ax.set_xlabel('xlabel')
ax.set_ylabel('ylabel')
ax.text(3, 8, 'boxed italics text in data coords', style='italic',
bbox = {'facecolor': 'red'})
ax.text(2, 6, r'an equation: $E = mc^2$', fontsize = 15)
ax.text(4, 0.05, 'colored text in axes coords',
verticalalignment = 'bottom', color = 'green', fontsize = 15)
ax.plot([2], [1], 'o')
ax.annotate('annotate', xy = (2, 1), xytext = (3, 4),
arrowprops = dict(facecolor = 'black', shrink = 0.05))
ax.axis([0, 10, 0, 10])
plt.show()Die obige Codezeile generiert die folgende Ausgabe:
Sie können eine Teilmenge von TeXmarkup in jeder Matplotlib-Textzeichenfolge verwenden, indem Sie sie in ein Paar Dollarzeichen ($) einfügen.
# math text
plt.title(r'$\alpha > \beta$')Verwenden Sie die Symbole '_' und '^', um tiefgestellte und hochgestellte Zeichen zu erstellen.
r'$\alpha_i> \beta_i$'
import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0.0, 2.0, 0.01)
s = np.sin(2*np.pi*t)
plt.plot(t,s)
plt.title(r'$\alpha_i> \beta_i$', fontsize=20)
plt.text(0.6, 0.6, r'$\mathcal{A}\mathrm{sin}(2 \omega t)$', fontsize = 20)
plt.text(0.1, -0.5, r'$\sqrt{2}$', fontsize=10)
plt.xlabel('time (s)')
plt.ylabel('volts (mV)')
plt.show()Die obige Codezeile generiert die folgende Ausgabe:
Das Bildmodul im Matplotlib-Paket bietet Funktionen, die zum Laden, Neuskalieren und Anzeigen von Bildern erforderlich sind.
Das Laden von Bilddaten wird von der Pillow-Bibliothek unterstützt. Matplotlib unterstützt von Haus aus nur PNG-Bilder. Die unten gezeigten Befehle greifen auf Pillow zurück, wenn der native Lesevorgang fehlschlägt.
Das in diesem Beispiel verwendete Bild ist eine PNG-Datei. Beachten Sie jedoch diese Kissenanforderung für Ihre eigenen Daten. Dasimread() Funktion wird verwendet, um Bilddaten in einem zu lesen ndarray Objekt vom Typ float32 dtype.
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np
img = mpimg.imread('mtplogo.png')Angenommen, das folgende Bild heißt mtplogo.png ist im aktuellen Arbeitsverzeichnis vorhanden.
Jedes Array, das Bilddaten enthält, kann durch Ausführen von auf einer Festplattendatei gespeichert werden imsave()Funktion. Hier wird eine vertikal gespiegelte Version der ursprünglichen PNG-Datei gespeichert, indem der Ursprungsparameter als niedriger angegeben wird.
plt.imsave("logo.png", img, cmap = 'gray', origin = 'lower')Das neue Bild wird wie folgt angezeigt, wenn es in einem Bildbetrachter geöffnet wird.
Führen Sie die folgenden Schritte aus, um das Bild im Matplotlib-Viewer zu zeichnen imshow() Funktion.
imgplot = plt.imshow(img)Das matplotlib-Paket basiert auf einem Transformationsframework, um problemlos zwischen Koordinatensystemen wechseln zu können. Es können vier Koordinatensysteme verwendet werden. Die Systeme werden in der folgenden Tabelle kurz beschrieben -
| Koordinate | Transformationsobjekt | Beschreibung |
|---|---|---|
| Daten | ax.transData | Das Benutzerlanddaten-Koordinatensystem. gesteuert von xlim und ylim |
| Achsen | ax.transAxes | Das Koordinatensystem der Achsen. (0,0) ist unten links und (1,1) ist oben rechts von den Achsen. |
| Zahl | fig.transFigure | Das Koordinatensystem der Figur. (0,0) ist unten links und (1,1) ist oben rechts in der Figur |
| Anzeige | Keiner | Dies ist das Pixelkoordinatensystem der Anzeige. (0,0) ist unten links und (Breite, Höhe) oben rechts in Pixel. Alternativ kann anstelle von None die Datei (matplotlib.transforms.IdentityTransform ()) verwendet werden. |
Betrachten Sie das folgende Beispiel -
axes.text(x,y,"my label")Der Text wird an der theoretischen Position eines Datenpunkts (x, y) platziert. Wir würden also von "Datenkoordinaten" sprechen.
Mit anderen Transformationsobjekten kann die Platzierung gesteuert werden. Wenn der obige Test beispielsweise in der Mitte des Achsenkoordinatensystems platziert werden soll, führen Sie die folgende Codezeile aus:
axes.text(0.5, 0.5, "middle of graph", transform=axes.transAxes)Diese Transformationen können für jede Art von Matplotlib-Objekten verwendet werden. Die Standardtransformation fürax.text ist ax.transData und die Standardtransformation für fig.text ist fig.transFigure.
Das Achsenkoordinatensystem ist äußerst nützlich, wenn Sie Text in Ihre Achsen einfügen. Möglicherweise möchten Sie häufig eine Textblase an einem festen Ort. Beispiel: Oben links im Achsenbereich bleibt diese Position beim Schwenken oder Zoomen unverändert.