Notiz
Klicken Sie hier , um den vollständigen Beispielcode herunterzuladen
Künstler-Tutorial #
Verwenden von Artist-Objekten zum Rendern auf der Leinwand.
Die Matplotlib-API besteht aus drei Schichten.
Das
matplotlib.backend_bases.FigureCanvasist der Bereich, auf den die Figur gezeichnet wirddas
matplotlib.backend_bases.Rendererist das Objekt, das weiß, wie man auf das zeichnetFigureCanvasund das
matplotlib.artist.Artistist das Objekt, das weiß, wie man einen Renderer verwendet, um auf die Leinwand zu malen.
Der FigureCanvasund
handhabt alle RendererDetails der Kommunikation mit Benutzeroberflächen-Toolkits wie wxPython oder Zeichensprachen wie PostScript®, und der Artisthandhabt alle High-Level-Konstrukte wie die Darstellung und Anordnung von Figuren, Text und Linien. Der typische Benutzer verbringt 95 % seiner Zeit damit, mit der Artists.
Es gibt zwei Arten von Artists: Primitive und Container. Die Grundelemente stellen die standardmäßigen grafischen Objekte dar, die wir auf unsere Leinwand malen möchten:
Line2D, Rectangle,
Text, AxesImage, usw., und die Container sind Orte, an denen sie platziert werden können ( Axis,
Axesund Figure). Die Standardverwendung besteht darin, eine FigureInstanz Figurezu erstellen, eine oder mehrere Instanzen zu erstellen Axesund
Subplotdie Hilfsmethoden der AxesInstanz zu verwenden, um die Primitive zu erstellen. Im folgenden Beispiel erstellen wir eine
FigureInstanz mit matplotlib.pyplot.figure(), einer bequemen Methode, um Instanzen zu instanziieren Figureund sie mit Ihrer Benutzeroberfläche oder Ihrem Zeichnungs-Toolkit zu verbindenFigureCanvas. Wie wir weiter unten besprechen werden, ist dies nicht notwendig – Sie können direkt mit PostScript-, PDF-Gtk+- oder wxPython- FigureCanvasInstanzen arbeiten, Ihre direkt instanziieren Figures
und sie selbst verbinden – aber da wir uns hier auf die
ArtistAPI konzentrieren, lassen wir pyploteinige behandeln dieser Details für uns:
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(2, 1, 1) # two rows, one column, first plot
Das Axesist wahrscheinlich die wichtigste Klasse in der Matplotlib-API und diejenige, mit der Sie die meiste Zeit arbeiten werden. Dies liegt daran, dass das Axesder Plotbereich ist, in den die meisten Objekte gehen, und das Axesviele spezielle Hilfsmethoden ( plot(),
text(),
hist(),
imshow()) hat, um die gebräuchlichsten grafischen Grundelemente ( Line2D,
Text,
Rectangle,
AxesImagebzw. ) zu erstellen. Diese Hilfsmethoden nehmen Ihre Daten (z. B. numpyArrays und Strings) und erstellen Artistnach Bedarf primitive Instanzen (z. B. Line2D), fügen sie den relevanten Containern hinzu und zeichnen sie, wenn sie angefordert werden. Die meisten von Ihnen sind wahrscheinlich mit dem vertraut Subplot, das nur ein Sonderfall eines ist Axes, das auf einem regelmäßigen Zeilen-für-Spalten-Raster von lebtSubplotInstanzen. Wenn Sie eine an einer beliebigen Stelle erstellen möchten Axes, verwenden Sie einfach die
add_axes()Methode, die eine Liste von Werten in 0-1 relativen Figurenkoordinaten verwendet:[left, bottom, width, height]
fig2 = plt.figure()
ax2 = fig2.add_axes([0.15, 0.1, 0.7, 0.3])
Weiter mit unserem Beispiel:
In diesem Beispiel axist die AxesInstanz, die durch den
fig.add_subplotobigen Aufruf erstellt wurde (denken Sie daran, dass Subplotes sich nur um eine Unterklasse von handelt
Axes), und wenn Sie aufrufen ax.plot, wird eine Line2DInstanz erstellt und der Axes. In der interaktiven IPython -
Sitzung unten können Sie sehen, dass die Axes.linesListe die Länge eins hat und dieselbe Zeile enthält, die vom Aufruf zurückgegeben wurde:line, = ax.plot...
In [101]: ax.lines[0]
Out[101]: <matplotlib.lines.Line2D at 0x19a95710>
In [102]: line
Out[102]: <matplotlib.lines.Line2D at 0x19a95710>
Wenn Sie weitere Anrufe an tätigen ax.plot(und der Haltestatus „Ein“ ist, was die Standardeinstellung ist), werden der Liste zusätzliche Leitungen hinzugefügt. Sie können eine Zeile später entfernen, indem Sie ihre removeMethode aufrufen:
The Axes verfügt auch über Hilfsmethoden zum Konfigurieren und Dekorieren der x-Achsen- und y-Achsen-Ticks, Tick-Beschriftungen und Achsenbeschriftungen:
xtext = ax.set_xlabel('my xdata') # returns a Text instance
ytext = ax.set_ylabel('my ydata')
Wenn Sie aufrufen ax.set_xlabel, übergibt es die Informationen über die Text
Instanz der XAxis. Jede Axes
Instanz enthält eine XAxisund eine
YAxisInstanz, die das Layout und das Zeichnen der Teilstriche, Teilstrichbeschriftungen und Achsenbeschriftungen handhaben.
Versuchen Sie, die folgende Abbildung zu erstellen.
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
fig.subplots_adjust(top=0.8)
ax1 = fig.add_subplot(211)
ax1.set_ylabel('volts')
ax1.set_title('a sine wave')
t = np.arange(0.0, 1.0, 0.01)
s = np.sin(2*np.pi*t)
line, = ax1.plot(t, s, color='blue', lw=2)
# Fixing random state for reproducibility
np.random.seed(19680801)
ax2 = fig.add_axes([0.15, 0.1, 0.7, 0.3])
n, bins, patches = ax2.hist(np.random.randn(1000), 50,
facecolor='yellow', edgecolor='yellow')
ax2.set_xlabel('time (s)')
plt.show()
Anpassen Ihrer Objekte #
Jedes Element in der Abbildung wird durch eine Matplotlib dargestellt
Artist, und jedes verfügt über eine umfangreiche Liste von Eigenschaften, um sein Erscheinungsbild zu konfigurieren. Die Figur selbst enthält eine
Rectanglegenau die Größe der Figur, mit der Sie Hintergrundfarbe und Transparenz der Figuren einstellen können. Ebenso hat jeder AxesBegrenzungsrahmen (der standardmäßige weiße Rahmen mit schwarzen Rändern im typischen Matplotlib-Plot) eine RectangleInstanz, die die Farbe, Transparenz und andere Eigenschaften der Achsen bestimmt. Diese Instanzen werden als Mitgliedsvariablen gespeichert Figure.patchund Axes.patch("Patch" ist ein Name von MATLAB geerbt und ist ein 2D-Farbfleck auf der Figur, zB Rechtecke, Kreise und Polygone) Jede Matplotlib Artisthat die folgenden Eigenschaften
Eigentum |
Beschreibung |
|---|---|
Alpha |
Die Transparenz - ein Skalar von 0-1 |
animiert |
Ein boolescher Wert, der verwendet wird, um animiertes Zeichnen zu erleichtern |
Achsen |
Die Äxte, in denen der Künstler lebt, möglicherweise keine |
clip_box |
Der Begrenzungsrahmen, der den Künstler beschneidet |
clip_on |
Ob Clipping aktiviert ist |
clip_path |
Der Pfad, auf den der Künstler zugeschnitten ist |
enthält |
Eine Auswahlfunktion, um zu testen, ob der Künstler den Auswahlpunkt enthält |
Zahl |
Die Figureninstanz, in der der Künstler lebt, möglicherweise Keine |
Etikett |
Eine Textbeschriftung (z. B. für die automatische Beschriftung) |
Pflücker |
Ein Python-Objekt, das die Objektauswahl steuert |
verwandeln |
Die Transformation |
sichtbar |
Ein boolescher Wert, ob der Künstler gezeichnet werden soll |
zorder |
Eine Zahl, die die Zeichnungsreihenfolge bestimmt |
gerastert |
Boolesch; Wandelt Vektoren in Rastergrafiken um (für Komprimierung & EPS-Transparenz) |
Auf jede der Eigenschaften wird mit einem altmodischen Setter oder Getter zugegriffen (ja, wir wissen, dass dies Pythonistas irritiert, und wir planen, den direkten Zugriff über Eigenschaften oder Eigenschaften zu unterstützen, aber das wurde noch nicht getan). Um beispielsweise das aktuelle Alpha mit der Hälfte zu multiplizieren:
a = o.get_alpha()
o.set_alpha(0.5*a)
Wenn Sie mehrere Eigenschaften auf einmal setzen möchten, können Sie die setMethode auch mit Schlüsselwortargumenten verwenden. Zum Beispiel:
o.set(alpha=0.5, zorder=2)
Wenn Sie interaktiv an der Python-Shell arbeiten, können Sie die ArtistEigenschaften bequem mit der
matplotlib.artist.getp()Funktion (einfach
getp()in Pyplot) überprüfen, die die Eigenschaften und ihre Werte auflistet. Dies funktioniert auch für Klassen, die von abgeleitet Artistsind, z . B. Figureund Rectangle. Hier sind die Figureoben erwähnten Rechteckeigenschaften:
In [149]: matplotlib.artist.getp(fig.patch)
agg_filter = None
alpha = None
animated = False
antialiased or aa = False
bbox = Bbox(x0=0.0, y0=0.0, x1=1.0, y1=1.0)
capstyle = butt
children = []
clip_box = None
clip_on = True
clip_path = None
contains = None
data_transform = BboxTransformTo( TransformedBbox( Bbox...
edgecolor or ec = (1.0, 1.0, 1.0, 1.0)
extents = Bbox(x0=0.0, y0=0.0, x1=640.0, y1=480.0)
facecolor or fc = (1.0, 1.0, 1.0, 1.0)
figure = Figure(640x480)
fill = True
gid = None
hatch = None
height = 1
in_layout = False
joinstyle = miter
label =
linestyle or ls = solid
linewidth or lw = 0.0
patch_transform = CompositeGenericTransform( BboxTransformTo( ...
path = Path(array([[0., 0.], [1., 0.], [1.,...
path_effects = []
picker = None
rasterized = None
sketch_params = None
snap = None
transform = CompositeGenericTransform( CompositeGenericTra...
transformed_clip_path_and_affine = (None, None)
url = None
verts = [[ 0. 0.] [640. 0.] [640. 480.] [ 0. 480....
visible = True
width = 1
window_extent = Bbox(x0=0.0, y0=0.0, x1=640.0, y1=480.0)
x = 0
xy = (0, 0)
y = 0
zorder = 1
Die Docstrings für alle Klassen enthalten auch die Artist
Eigenschaften, sodass Sie die interaktive "Hilfe" oder
matplotlib.artist für eine Auflistung der Eigenschaften für ein bestimmtes Objekt konsultieren können.
Objektcontainer #
Nachdem wir nun wissen, wie die Eigenschaften eines bestimmten Objekts, das wir konfigurieren möchten, untersucht und eingestellt werden, müssen wir wissen, wie wir an dieses Objekt gelangen. Wie in der Einleitung erwähnt, gibt es zwei Arten von Objekten: Primitive und Container. Die Grundelemente sind normalerweise die Dinge, die Sie konfigurieren möchten (die Schriftart einer Text
Instanz, die Breite eines Line2D), obwohl die Container auch einige Eigenschaften haben – zum Beispiel
ist das ein Container, der viele der Grundelemente in Ihrem Plot enthält, aber es hat auch Eigenschaften wie die um zu kontrollieren, ob die xaxis 'linear' oder 'log' ist. In diesem Abschnitt sehen wir uns an, wo die verschiedenen Containerobjekte das speichern , worauf Sie zugreifen möchten.Axes ArtistxscaleArtists
Figurenbehälter #
Der Container der obersten Ebene Artistist die
matplotlib.figure.Figure, und er enthält alles in der Abbildung. Der Hintergrund der Figur ist ein Bild,
Rectangledas in gespeichert ist
Figure.patch. Wenn Sie Subplots ( add_subplot()) und Achsen ( add_axes()) zur Abbildung hinzufügen, werden diese an die angehängt Figure.axes. Diese werden auch von den Methoden zurückgegeben, die sie erstellen:
In [156]: fig = plt.figure()
In [157]: ax1 = fig.add_subplot(211)
In [158]: ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.3])
In [159]: ax1
Out[159]: <AxesSubplot:>
In [160]: print(fig.axes)
[<AxesSubplot:>, <matplotlib.axes._axes.Axes object at 0x7f0768702be0>]
Da die Abbildung das Konzept der "aktuellen Achsen" (siehe
Figure.gcaund
Figure.sca) zur Unterstützung der pylab/pyplot-Zustandsmaschine beibehält, sollten Sie Achsen nicht direkt aus der Achsenliste einfügen oder entfernen, sondern stattdessen die
Methoden add_subplot()und
add_axes()zum Einfügen und die
Axes.removeMethode verwenden löschen. Es steht Ihnen jedoch frei, die Liste der Achsen zu durchlaufen oder zu indizieren, um Zugriff auf AxesInstanzen zu erhalten, die Sie anpassen möchten. Hier ist ein Beispiel, das alle Axes-Raster einschaltet:
for ax in fig.axes:
ax.grid(True)
Die Figur hat auch ihre eigenen Attribute images, lines, patchesund text
, die Sie verwenden können, um Primitive direkt hinzuzufügen. Wenn Sie dies tun, ist das Standardkoordinatensystem für Figureeinfach Pixel (was normalerweise nicht das ist, was Sie wollen). Wenn Sie stattdessen Methoden auf Abbildungsebene verwenden, um Künstler hinzuzufügen (z. B. Figure.textzum Hinzufügen von Text), dann ist das Standardkoordinatensystem "Abbildungskoordinaten", wobei (0, 0) die untere linke Seite der Abbildung ist und (1, 1 ) ist oben rechts in der Abbildung.
Wie bei allen Artists können Sie dieses Koordinatensystem steuern, indem Sie die Eigenschaft transform festlegen. Sie können "Figurenkoordinaten" explizit verwenden, indem Sie die ArtistTransformation auf setzen fig.transFigure:
import matplotlib.lines as lines
fig = plt.figure()
l1 = lines.Line2D([0, 1], [0, 1], transform=fig.transFigure, figure=fig)
l2 = lines.Line2D([0, 1], [1, 0], transform=fig.transFigure, figure=fig)
fig.lines.extend([l1, l2])
plt.show()
Hier ist eine Zusammenfassung der Künstler, die die Figur enthält
Abbildungsattribut |
Beschreibung |
|---|---|
Achsen |
Eine Liste von |
Patch |
Der |
Bilder |
Eine Liste von |
Legenden |
Eine Liste von Figure- |
Linien |
Eine Liste von Figure- |
Flecken |
Eine Liste von Abbildungen |
Texte |
|
Achsenbehälter #
Das matplotlib.axes.Axesist das Zentrum des Matplotlib-Universums – es enthält die überwiegende Mehrheit aller Artistsin einer Figur verwendeten Elemente mit vielen Hilfsmethoden, um diese zu erstellen und
Artistszu sich selbst hinzuzufügen, sowie Hilfsmethoden, um auf die Artistsdarin enthaltenen Elemente zuzugreifen und sie anzupassen. Wie das
Figureenthält es a
, was a
für kartesische Koordinaten und a
für Polarkoordinaten ist; Dieser Patch bestimmt die Form, den Hintergrund und den Rand des Plotbereichs:Patch
patchRectangleCircle
ax = fig.add_subplot()
rect = ax.patch # a Rectangle instance
rect.set_facecolor('green')
Wenn Sie eine Zeichenmethode aufrufen, z. B. die kanonische,
plotund Arrays oder Wertelisten übergeben, erstellt die Methode eine matplotlib.lines.Line2DInstanz, aktualisiert die Zeile mit allen Line2DEigenschaften, die als Schlüsselwortargumente übergeben werden, fügt die Zeile dem hinzu Axesund gibt sie an Sie zurück :
In [213]: x, y = np.random.rand(2, 100)
In [214]: line, = ax.plot(x, y, '-', color='blue', linewidth=2)
plotgibt eine Liste von Zeilen zurück, da Sie mehrere x, y-Paare zum Plotten übergeben können, und wir entpacken das erste Element der Liste der Länge eins in die Zeilenvariable. Die Zeile wurde der Liste hinzugefügt
Axes.lines:
In [229]: print(ax.lines)
[<matplotlib.lines.Line2D at 0xd378b0c>]
In ähnlicher Weise fügen Methoden, die Patches erstellen, wie das Erstellen
bar()einer Liste von Rechtecken, die Patches zur Axes.patchesListe hinzu:
In [233]: n, bins, rectangles = ax.hist(np.random.randn(1000), 50)
In [234]: rectangles
Out[234]: <BarContainer object of 50 artists>
In [235]: print(len(ax.patches))
Out[235]: 50
Sie sollten Objekte nicht direkt zu den Axes.linesoder Axes.patches
-Listen hinzufügen, da die Axesein paar Dinge tun muss, wenn sie ein Objekt erstellt und hinzufügt:
Es setzt die Eigenschaft
figureand von ;axesArtistEs legt die Standardtransformation
Axesfest (es sei denn, es ist bereits eine festgelegt);Es untersucht die Daten, die in enthalten
Artistsind, um die Datenstrukturen zu aktualisieren, die die automatische Skalierung steuern, sodass die Anzeigegrenzen so angepasst werden können, dass sie die gezeichneten Daten enthalten.
Sie können jedoch selbst Objekte erstellen und diese
Axesmithilfe von Hilfsmethoden wie add_lineund
direkt hinzufügen add_patch. Hier ist eine kommentierte interaktive Sitzung, die veranschaulicht, was vor sich geht:
In [262]: fig, ax = plt.subplots()
# create a rectangle instance
In [263]: rect = matplotlib.patches.Rectangle((1, 1), width=5, height=12)
# by default the axes instance is None
In [264]: print(rect.axes)
None
# and the transformation instance is set to the "identity transform"
In [265]: print(rect.get_data_transform())
IdentityTransform()
# now we add the Rectangle to the Axes
In [266]: ax.add_patch(rect)
# and notice that the ax.add_patch method has set the axes
# instance
In [267]: print(rect.axes)
Axes(0.125,0.1;0.775x0.8)
# and the transformation has been set too
In [268]: print(rect.get_data_transform())
CompositeGenericTransform(
TransformWrapper(
BlendedAffine2D(
IdentityTransform(),
IdentityTransform())),
CompositeGenericTransform(
BboxTransformFrom(
TransformedBbox(
Bbox(x0=0.0, y0=0.0, x1=1.0, y1=1.0),
TransformWrapper(
BlendedAffine2D(
IdentityTransform(),
IdentityTransform())))),
BboxTransformTo(
TransformedBbox(
Bbox(x0=0.125, y0=0.10999999999999999, x1=0.9, y1=0.88),
BboxTransformTo(
TransformedBbox(
Bbox(x0=0.0, y0=0.0, x1=6.4, y1=4.8),
Affine2D(
[[100. 0. 0.]
[ 0. 100. 0.]
[ 0. 0. 1.]])))))))
# the default axes transformation is ax.transData
In [269]: print(ax.transData)
CompositeGenericTransform(
TransformWrapper(
BlendedAffine2D(
IdentityTransform(),
IdentityTransform())),
CompositeGenericTransform(
BboxTransformFrom(
TransformedBbox(
Bbox(x0=0.0, y0=0.0, x1=1.0, y1=1.0),
TransformWrapper(
BlendedAffine2D(
IdentityTransform(),
IdentityTransform())))),
BboxTransformTo(
TransformedBbox(
Bbox(x0=0.125, y0=0.10999999999999999, x1=0.9, y1=0.88),
BboxTransformTo(
TransformedBbox(
Bbox(x0=0.0, y0=0.0, x1=6.4, y1=4.8),
Affine2D(
[[100. 0. 0.]
[ 0. 100. 0.]
[ 0. 0. 1.]])))))))
# notice that the xlimits of the Axes have not been changed
In [270]: print(ax.get_xlim())
(0.0, 1.0)
# but the data limits have been updated to encompass the rectangle
In [271]: print(ax.dataLim.bounds)
(1.0, 1.0, 5.0, 12.0)
# we can manually invoke the auto-scaling machinery
In [272]: ax.autoscale_view()
# and now the xlim are updated to encompass the rectangle, plus margins
In [273]: print(ax.get_xlim())
(0.75, 6.25)
# we have to manually force a figure draw
In [274]: fig.canvas.draw()
Es gibt viele, viele AxesHilfsmethoden zum Erstellen von Primitiven
Artistsund zum Hinzufügen zu ihren jeweiligen Containern. Die folgende Tabelle fasst eine kleine Auswahl von ihnen zusammen, die Arten, die Artistsie erstellen, und wo sie sie speichern
Axes-Hilfsmethode |
Künstler |
Container |
|---|---|---|
|
ax.texte |
|
|
ax.Patches |
|
|
Axtlinien und Axtpatches |
|
|
ax.Patches |
|
|
ax.Patches |
|
|
axtbilder |
|
|
ax.get_legend() |
|
|
Axtlinien |
|
|
axtsammlungen |
|
|
ax.texte |
Zusätzlich zu all diesen Artistsenthält der Axeszwei wichtige ArtistContainer: den XAxis
und YAxis, die das Zeichnen der Häkchen und Beschriftungen handhaben. Diese werden als Instanzvariablen
xaxisund
gespeichert yaxis. Die Container XAxisund YAxis
werden unten detailliert beschrieben, aber beachten Sie, dass der Axesviele Hilfsmethoden enthält, die Aufrufe an die
AxisInstanzen weiterleiten, sodass Sie oft nicht direkt mit ihnen arbeiten müssen, es sei denn, Sie möchten dies. Beispielsweise können Sie die Schriftfarbe der XAxisTicklabels mit der Hilfsmethode festlegen Axes:
ax.tick_params(axis='x', labelcolor='orange')
Nachfolgend finden Sie eine Zusammenfassung der Künstler, die das Axesenthält
Axes-Attribut |
Beschreibung |
|---|---|
Künstler |
Eine |
Patch |
|
Sammlungen |
Eine |
Bilder |
Ein |
Linien |
Eine |
Flecken |
Eine |
Texte |
Eine |
xaxis |
Eine |
yaxis |
Eine |
Auf die Legende kann zugegriffen werden durch get_legend,
Achscontainer #
Die matplotlib.axis.AxisInstanzen handhaben das Zeichnen der Strichlinien, der Rasterlinien, der Teilstrichbeschriftungen und der Achsenbeschriftung. Sie können die linken und rechten Teilstriche separat für die y-Achse und die oberen und unteren Teilstriche separat für die x-Achse konfigurieren. Der Axis
speichert auch die Daten und Anzeigeintervalle, die beim automatischen Skalieren, Schwenken und Zoomen verwendet werden, sowie die Locatorund
Formatter-Instanzen, die steuern, wo die Häkchen platziert und wie sie als Zeichenfolgen dargestellt werden.
Jedes AxisObjekt enthält ein labelAttribut (dies pyplotändert sich in Aufrufen von xlabelund
ylabel) sowie eine Liste von großen und kleinen Ticks. Die Ticks sind
axis.XTickund axis.YTick-Instanzen, die die eigentlichen Zeilen- und Textprimitive enthalten, die die Ticks und Ticklabels wiedergeben. Da die Ticks nach Bedarf dynamisch erstellt werden (z. B. beim Schwenken und Zoomen), sollten Sie auf die Listen der Haupt- und Nebenticks über ihre Zugriffsmethoden und
axis.Axis.get_major_tickszugreifen axis.Axis.get_minor_ticks. Obwohl die Ticks alle Primitiven enthalten und unten behandelt werden, Axis
haben Instanzen Zugriffsmethoden, die die Tick-Linien, Tick-Beschriftungen, Tick-Positionen usw. zurückgeben:
fig, ax = plt.subplots()
axis = ax.xaxis
axis.get_ticklocs()
array([0. , 0.2, 0.4, 0.6, 0.8, 1. ])
[Text(0.0, 0, '0.0'), Text(0.2, 0, '0.2'), Text(0.4, 0, '0.4'), Text(0.6000000000000001, 0, '0.6'), Text(0.8, 0, '0.8'), Text(1.0, 0, '1.0')]
Beachten Sie, dass es doppelt so viele Ticklines wie Beschriftungen gibt, da es standardmäßig Ticklinien oben und unten gibt, aber nur Tickbeschriftungen unter der X-Achse. Dies kann jedoch angepasst werden.
<a list of 12 Line2D ticklines objects>
Und mit den oben genannten Methoden erhalten Sie standardmäßig nur Listen mit großen Ticks zurück, aber Sie können auch nach den kleinen Ticks fragen:
axis.get_ticklabels(minor=True)
axis.get_ticklines(minor=True)
<a list of 0 Line2D ticklines objects>
Hier ist eine Zusammenfassung einiger nützlicher Zugriffsmethoden der Axis
(diese haben entsprechende Setter, wo sie nützlich sind, wie z. B.
set_major_formatter().)
Axis-Accessor-Methode |
Beschreibung |
|---|---|
Die Skalierung der Achse, z. B. „log“ oder „linear“. |
|
Die Intervallinstanz der Achsenansichtsgrenzen |
|
Die Intervallinstanz der Achsendatengrenzen |
|
Eine Liste mit Rasterlinien für die Achse |
|
Das Achsenlabel – eine |
|
Der Achsenversatztext – eine |
|
Eine Liste von |
|
Eine Liste von |
|
Eine Liste von Tick-Positionen – Schlüsselwort minor=True|False |
|
Die |
|
Die |
|
Die |
|
Die |
|
Eine Liste von |
|
Eine Liste von |
|
Schalten Sie das Raster für die großen oder kleinen Ticks ein oder aus |
Hier ist ein wegen seiner Schönheit nicht zu empfehlendes Beispiel, das die Axes- und Tick-Eigenschaften anpasst.
# plt.figure creates a matplotlib.figure.Figure instance
fig = plt.figure()
rect = fig.patch # a rectangle instance
rect.set_facecolor('lightgoldenrodyellow')
ax1 = fig.add_axes([0.1, 0.3, 0.4, 0.4])
rect = ax1.patch
rect.set_facecolor('lightslategray')
for label in ax1.xaxis.get_ticklabels():
# label is a Text instance
label.set_color('red')
label.set_rotation(45)
label.set_fontsize(16)
for line in ax1.yaxis.get_ticklines():
# line is a Line2D instance
line.set_color('green')
line.set_markersize(25)
line.set_markeredgewidth(3)
plt.show()
Zeckencontainer #
Das matplotlib.axis.Tickist das letzte Containerobjekt in unserem Abstieg vom Figurezum zum
Axeszum Axis
zum Tick. Das Tickenthält die Teilstrich- und Rasterlinieninstanzen sowie die Beschriftungsinstanzen für die oberen und unteren Teilstriche. Auf jedes davon kann direkt als Attribut der Tick.
Tick-Attribut |
Beschreibung |
|---|---|
tick1line |
Eine |
tick2line |
Eine |
Rasterlinie |
Eine |
Etikett1 |
Eine |
Etikett2 |
Eine |
Hier ist ein Beispiel, das den Formatierer für die rechten Ticks mit Dollarzeichen setzt und sie auf der rechten Seite der Y-Achse grün einfärbt.
import numpy as np
import matplotlib.pyplot as plt
# Fixing random state for reproducibility
np.random.seed(19680801)
fig, ax = plt.subplots()
ax.plot(100*np.random.rand(20))
# Use automatic StrMethodFormatter
ax.yaxis.set_major_formatter('${x:1.2f}')
ax.yaxis.set_tick_params(which='major', labelcolor='green',
labelleft=False, labelright=True)
plt.show()
Gesamtlaufzeit des Skripts: ( 0 Minuten 1,067 Sekunden)