Künstler-Tutorial

Verwendung von Künstlerobjekten zur Darstellung auf der Leinwand.

Es gibt drei Ebenen der Matplotlib-API.

• die matplotlib.backend_bases.FigureCanvas ist der Bereich, auf den die Abbildung gezeichnet wird

• die matplotlib.backend_bases.Renderer ist das Objekt, das weiß, wie auf der matplotlib.backend_bases.FigureCanvas gezeichnet wird

• und der matplotlib.artist.Artist ist das Objekt, das weiß, wie ein Renderer verwendet wird, um auf die Leinwand zu malen.

Die matplotlib.backend_bases.FigureCanvas und matplotlib.backend_bases.Renderer kümmern sich um alle Details der Kommunikation mit Benutzeroberflächen-Toolkits wie wxPython oder Zeichensprachen wie PostScript®, und die Artist kümmert sich um alle High-Level-Konstrukte wie die Darstellung und Anordnung der Abbildung, des Textes und der Linien. Der typische Benutzer wird 95 % seiner Zeit mit den Artists verbringen.

Es gibt zwei Arten von Artists: Primitive und Container. Die Primitiven stellen die Standard-Grafikobjekte dar, die wir auf unsere Leinwand malen möchten: Line2D, Rectangle, Text, AxesImage usw., und die Container sind Orte, um sie zu platzieren (Axis, Axes und Figure). Der Standardgebrauch besteht darin, eine Figure-Instanz zu erstellen, die Figure zu verwenden, um eine oder mehrere Axes-Instanzen zu erstellen, und die Hilfsmethoden der Axes-Instanz zu verwenden, um die primitiven Objekte zu erstellen. Im folgenden Beispiel erstellen wir eine Figure-Instanz mit matplotlib.pyplot.figure(), was eine Komfortmethode zur Instanziierung von Figure-Instanzen und deren Verbindung mit Ihrem Benutzeroberflächen- oder Zeichen-Toolkit FigureCanvas ist. Wie wir unten diskutieren werden, ist dies nicht notwendig – Sie können direkt mit PostScript, PDF Gtk+ oder wxPython FigureCanvas-Instanzen arbeiten, Ihre Figures direkt instanziieren und sie selbst verbinden – aber da wir uns hier auf die Artist API konzentrieren, werden wir pyplot einige dieser Details für uns erledigen lassen

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(2, 1, 1) # two rows, one column, first plot

Die Axes ist wahrscheinlich die wichtigste Klasse in der Matplotlib-API, und diejenige, mit der Sie am häufigsten arbeiten werden. Dies liegt daran, dass die Axes der Zeichenbereich ist, in den die meisten Objekte hineinkommen, und die Axes viele spezielle Hilfsmethoden (plot(), text(), hist(), imshow()) zum Erstellen der gängigsten Grafikprimitive (Line2D, Text, Rectangle, AxesImage) besitzt. Diese Hilfsmethoden nehmen Ihre Daten (z. B. numpy-Arrays und Zeichenketten) und erstellen bei Bedarf primitive Artist-Instanzen (z. B. Line2D), fügen sie den relevanten Containern hinzu und zeichnen sie, wenn sie angefordert werden. Wenn Sie eine Axes an einer beliebigen Stelle erstellen möchten, verwenden Sie einfach die Methode add_axes(), die eine Liste von [left, bottom, width, height]-Werten in 0-1 relativ zur Abbildung verwendet

fig2 = plt.figure()
ax2 = fig2.add_axes([0.15, 0.1, 0.7, 0.3])

Wenn wir mit unserem Beispiel fortfahren

import numpy as np
t = np.arange(0.0, 1.0, 0.01)
s = np.sin(2*np.pi*t)
line, = ax.plot(t, s, color='blue', lw=2)

In diesem Beispiel ist ax die Axes-Instanz, die durch den fig.add_subplot-Aufruf oben erstellt wurde, und wenn Sie ax.plot aufrufen, erstellt diese eine Line2D-Instanz und fügt sie der Axes hinzu. In der interaktiven IPython-Sitzung unten sehen Sie, dass die Liste Axes.lines die Länge eins hat und dieselbe Linie enthält, die von dem line, = ax.plot...-Aufruf zurückgegeben wurde

In [101]: ax.lines[0]
Out[101]: <matplotlib.lines.Line2D at 0x19a95710>

In [102]: line
Out[102]: <matplotlib.lines.Line2D at 0x19a95710>

Wenn Sie nachfolgende Aufrufe von ax.plot durchführen (und der Haltezustand "on" ist, was der Standard ist), werden zusätzliche Linien zur Liste hinzugefügt. Sie können eine Linie später entfernen, indem Sie ihre remove-Methode aufrufen

line = ax.lines[0]
line.remove()

Die Achsen haben auch Hilfsmethoden, um die Ticks, Tick-Beschriftungen und Achsenbeschriftungen der x- und y-Achse zu konfigurieren und zu dekorieren

xtext = ax.set_xlabel('my xdata')  # returns a Text instance
ytext = ax.set_ylabel('my ydata')

Wenn Sie ax.set_xlabel aufrufen, gibt er die Informationen an die Text-Instanz der XAxis weiter. Jede Axes-Instanz enthält eine XAxis und eine YAxis-Instanz, die für die Anordnung und Zeichnung der Ticks, Tick-Beschriftungen und Achsenbeschriftungen zuständig sind.

Versuchen Sie, die untenstehende Abbildung zu erstellen.

import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure()
fig.subplots_adjust(top=0.8)
ax1 = fig.add_subplot(211)
ax1.set_ylabel('Voltage [V]')
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 einen Matplotlib Artist dargestellt, und jeder hat eine umfangreiche Liste von Eigenschaften, um sein Erscheinungsbild zu konfigurieren. Die Abbildung selbst enthält ein Rectangle genau in der Größe der Abbildung, das Sie zur Einstellung der Hintergrundfarbe und Transparenz der Abbildungen verwenden können. Ebenso hat die Begrenzungsbox jedes Axes (die typische weiße Box mit schwarzen Rändern im typischen Matplotlib-Plot) eine Rectangle-Instanz, die Farbe, Transparenz und andere Eigenschaften der Achsen bestimmt. Diese Instanzen werden als Mitgliedsvariablen Figure.patch und Axes.patch gespeichert ("Patch" ist ein Name, der von MATLAB übernommen wurde und ein 2D-"Flicken" von Farbe auf der Abbildung ist, z. B. Rechtecke, Kreise und Polygone). Jeder Matplotlib Artist hat die folgenden Eigenschaften

Eigenschaft	Beschreibung
alpha	Die Transparenz – ein Skalar von 0-1
animated	Ein Boolescher Wert, der zur Erleichterung des animierten Zeichnens verwendet wird
Achsen	Die Achsen, zu denen der Künstler gehört, möglicherweise None
clip_box	Die Begrenzungsbox, die den Künstler beschneidet
clip_on	Ob das Beschneiden aktiviert ist
clip_path	Der Pfad, auf den der Künstler beschnitten wird
enthält	Eine Pick-Funktion, um zu testen, ob der Künstler den Pick-Punkt enthält
figure	Die Abbildungsinanz, zu der der Künstler gehört, möglicherweise None
label	Eine Textbeschriftung (z. B. für die automatische Beschriftung)
picker	Ein Python-Objekt, das das Picking von Objekten steuert
transform	Die Transformation
visible	Ein Boolescher Wert, ob der Künstler gezeichnet werden soll
zorder	Eine Zahl, die die Zeichenreihenfolge bestimmt
rasterized	Boolesch; Wandelt Vektoren in Rastergrafiken um (für Kompression & EPS-Transparenz)

Jede der Eigenschaften wird mit einem altmodischen Setter oder Getter abgerufen (ja, wir wissen, dass das Pythonistas irritiert und wir planen, direkten Zugriff über Eigenschaften oder Traits zu unterstützen, aber das wurde noch nicht getan). Zum Beispiel, um die aktuelle Alpha zu halbieren

a = o.get_alpha()
o.set_alpha(0.5*a)

Wenn Sie mehrere Eigenschaften auf einmal festlegen möchten, können Sie auch die Methode set mit Schlüsselwortargumenten verwenden. Zum Beispiel

o.set(alpha=0.5, zorder=2)

Wenn Sie interaktiv in der Python-Shell arbeiten, ist eine praktische Methode, die Artist-Eigenschaften zu inspizieren, die Funktion matplotlib.artist.getp() (einfach getp() in pyplot) zu verwenden, die die Eigenschaften und ihre Werte auflistet. Dies funktioniert auch für von Artist abgeleitete Klassen, z. B. Figure und Rectangle. Hier sind die oben genannten Figure-Rechteck-Eigenschaften

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 aller Klassen enthalten auch die Artist-Eigenschaften, sodass Sie die interaktive "Hilfe" oder das matplotlib.artist für eine Liste der Eigenschaften eines bestimmten Objekts konsultieren können.

Objektcontainer

Nachdem wir nun wissen, wie wir die Eigenschaften eines bestimmten Objekts, das wir konfigurieren möchten, inspizieren und festlegen können, müssen wir wissen, wie wir an dieses Objekt gelangen. Wie in der Einleitung erwähnt, gibt es zwei Arten von Objekten: Primitiven und Container. Die Primitiven sind normalerweise die Dinge, die Sie konfigurieren möchten (die Schriftart einer Text-Instanz, die Breite einer Line2D), obwohl die Container auch einige Eigenschaften haben – zum Beispiel ist der Axes Artist ein Container, der viele der Primitiven in Ihrem Plot enthält, aber er hat auch Eigenschaften wie die xscale, um zu steuern, ob die x-Achse 'linear' oder 'log' ist. In diesem Abschnitt werden wir prüfen, wo die verschiedenen Containerobjekte die Artists speichern, auf die Sie zugreifen möchten.

Figurencontainer

Der oberste Container Artist ist die matplotlib.figure.Figure, und sie enthält alles in der Abbildung. Der Hintergrund der Abbildung ist ein Rectangle, der in Figure.patch gespeichert ist. Wenn Sie Subplots (add_subplot()) und Achsen (add_axes()) zur Abbildung hinzufügen, werden diese an die Figure.axes angehängt. 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]: <Axes:>

In [160]: print(fig.axes)
[<Axes:>, <matplotlib.axes._axes.Axes object at 0x7f0768702be0>]

Da die Abbildung das Konzept der "aktuellen Achse" beibehält (siehe Figure.gca und Figure.sca), um die Pylab/Pyplot-Zustandsmaschine zu unterstützen, 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 Methode Axes.remove zum Löschen verwenden. Sie können jedoch frei über die Liste der Achsen iterieren oder sie indizieren, um auf Axes-Instanzen zuzugreifen, die Sie anpassen möchten. Hier ist ein Beispiel, das alle Achsengitter einschaltet

for ax in fig.axes:
    ax.grid(True)

Die Abbildung hat auch ihre eigenen Attribute images, lines, patches und text, die Sie zum direkten Hinzufügen von Primitiven verwenden können. Dabei ist das Standardkoordinatensystem für die Figure einfach in Pixeln (was normalerweise nicht erwünscht ist). Wenn Sie stattdessen Abbildungsebene-Methoden zum Hinzufügen von Künstlern verwenden (z. B. mit Figure.text zum Hinzufügen von Text), dann ist das Standardkoordinatensystem "Abbildungskoordinaten", wobei (0, 0) die untere linke Ecke der Abbildung und (1, 1) die obere rechte Ecke der Abbildung ist.

Wie bei allen Artists können Sie dieses Koordinatensystem steuern, indem Sie die Transform-Eigenschaft festlegen. Sie können explizit "Abbildungskoordinaten" verwenden, indem Sie die Artist-Transformation auf fig.transFigure setzen

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 Abbildung enthält

Abbildung Attribut	Beschreibung
Achsen	Eine Liste von Axes Instanzen
patch	Der Rectangle Hintergrund
images	Eine Liste von FigureImage Patches – nützlich für die rohe Pixelanzeige
legends	Eine Liste von Abbildungs- Legend Instanzen (unterschiedlich von Axes.get_legend())
lines	Eine Liste von Abbildungs- Line2D Instanzen (selten verwendet, siehe Axes.lines)
patches	Eine Liste von Abbildungs- Patchs (selten verwendet, siehe Axes.patches)
texts	Eine Liste von Abbildungs- Text Instanzen

Achsencontainer

Die matplotlib.axes.Axes ist das Zentrum des Matplotlib-Universums – sie enthält die überwiegende Mehrheit aller Artists, die in einer Abbildung verwendet werden, mit vielen Hilfsmethoden zum Erstellen und Hinzufügen dieser Artists zu sich selbst, sowie Hilfsmethoden zum Zugreifen und Anpassen der von ihr enthaltenen Artists. Wie die Figure enthält sie einen Patch matplotlib.axes.Axes.patch, der ein Rectangle für kartesische Koordinaten und ein Circle für Polarkoordinaten ist; dieser Patch bestimmt die Form, den Hintergrund und den Rand des Zeichenbereichs

ax = fig.add_subplot()
rect = ax.patch  # a Rectangle instance
rect.set_facecolor('green')

Wenn Sie eine Plot-Methode aufrufen, z. B. die kanonische plot und Arrays oder Listen von Werten übergeben, erstellt die Methode eine matplotlib.lines.Line2D-Instanz, aktualisiert die Linie mit allen als Schlüsselwortargumente übergebenen Line2D-Eigenschaften, fügt die Linie zu den Axes hinzu und 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)

plot gibt eine Liste von Linien 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 Variable line. Die Linie wurde der Liste Axes.lines hinzugefügt

In [229]: print(ax.lines)
[<matplotlib.lines.Line2D at 0xd378b0c>]

Ähnlich werden Methoden, die Patches erstellen, wie z. B. bar(), die eine Liste von Rechtecken erstellen, die Patches zur Liste Axes.patches hinzufügen

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 keine Objekte direkt zu den Listen Axes.lines oder Axes.patches hinzufügen, da die Axes beim Erstellen und Hinzufügen eines Objekts einige Dinge tun muss

• Es setzt die Eigenschaften figure und axes des Artist;

• Es setzt die Standard- Axes-Transformation (es sei denn, eine ist bereits gesetzt);

• Es inspiziert die vom Artist enthaltenen Daten, um die Datenstrukturen zur automatischen Skalierung zu aktualisieren, damit die Ansichtsgrenzen angepasst werden können, um die geplotteten Daten einzuschließen.

Sie können jedoch Objekte selbst erstellen und sie mit Hilfsmethoden wie add_line und add_patch direkt zu den Axes hinzufügen. 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 Axes-Hilfsmethoden zum Erstellen primitiver Artists und zum Hinzufügen zu ihren jeweiligen Containern. Die folgende Tabelle fasst eine kleine Auswahl davon zusammen, die Arten von Artist, die sie erstellen, und wo sie sie speichern

Achsen Hilfsmethode	Artist	Container
annotate - Textanmerkungen	Annotation	ax.texts
bar - Balkendiagramme	Rectangle	ax.patches
errorbar - Fehlerbalkendiagramme	Line2D und Rectangle	ax.lines und ax.patches
fill - gemeinsam genutzte Fläche	Polygon	ax.patches
hist - Histogramme	Rectangle	ax.patches
imshow - Bilddaten	AxesImage	ax.images
legend - Achsenlegende	Legende	ax.get_legend()
plot - xy plots	Line2D	ax.lines
scatter - scatter charts	PolyCollection	ax.collections
text - text	Text	ax.texts

Zusätzlich zu all diesen Artists enthält die Axes zwei wichtige Artist-Container: die XAxis und YAxis, die das Zeichnen der Ticks und Labels übernehmen. Diese sind als Instanzvariablen matplotlib.axes.Axes.xaxis und matplotlib.axes.Axes.yaxis gespeichert. Die XAxis- und YAxis-Container werden unten näher erläutert, aber beachten Sie, dass die Axes viele Hilfsmethoden enthält, die Aufrufe an die Axis-Instanzen weiterleiten, sodass Sie oft nicht direkt mit ihnen arbeiten müssen, es sei denn, Sie möchten das. Sie können beispielsweise die Schriftfarbe der XAxis-Ticklabels über die Axes-Hilfsmethode festlegen

ax.tick_params(axis='x', labelcolor='orange')

Unten finden Sie eine Zusammenfassung der Artists, die die Axes enthält

Axes-Attribut	Beschreibung
artists	Eine ArtistList von Artist-Instanzen
patch	Rectangle-Instanz für den Axes-Hintergrund
collections	Eine ArtistList von Collection-Instanzen
images	Eine ArtistList von AxesImage
lines	Eine ArtistList von Line2D-Instanzen
patches	Eine ArtistList von Patch-Instanzen
texts	Eine ArtistList von Text-Instanzen
xaxis	Eine matplotlib.axis.XAxis-Instanz
yaxis	Eine matplotlib.axis.YAxis-Instanz

Die Legende kann über get_legend abgerufen werden,

Axis-Container

Die Instanzen von matplotlib.axis.Axis übernehmen das Zeichnen der Ticklinien, der Gitterlinien, der Tickbeschriftungen und der Achsenbeschriftung. Sie können die linken und rechten Ticks für die y-Achse separat konfigurieren, und die oberen und unteren Ticks für die x-Achse separat. Die Axis speichert auch die Daten- und Ansichtsintervalle, die für Autoskalierung, Schwenken und Zoomen verwendet werden, sowie die Instanzen von Locator und Formatter, die steuern, wo die Ticks platziert werden und wie sie als Strings dargestellt werden.

Jedes Axis-Objekt enthält ein Attribut label (dies ist, was pyplot in Aufrufen von xlabel und ylabel modifiziert) sowie eine Liste von Haupt- und Nebenticks. Die Ticks sind Instanzen von axis.XTick und axis.YTick, die die eigentlichen Linien- und Textprimitiven enthalten, die die Ticks und Tickbeschriftungen rendern. Da die Ticks dynamisch bei Bedarf erstellt werden (z. B. beim Schwenken und Zoomen), sollten Sie auf die Listen der Haupt- und Nebenticks über ihre Zugriffsermittlungsmethoden axis.Axis.get_major_ticks und axis.Axis.get_minor_ticks zugreifen. Obwohl die Ticks alle Primitiven enthalten und unten behandelt werden, verfügen Axis-Instanzen über Zugriffsermittlungsmethoden, die die Ticklinien, Tickbeschriftungen, Tickpositionen usw. zurückgeben.

fig, ax = plt.subplots()
axis = ax.xaxis
axis.get_ticklocs()

array([0. , 0.2, 0.4, 0.6, 0.8, 1. ])

axis.get_ticklabels()

[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 Ticklinien wie Beschriftungen gibt, da standardmäßig Ticklinien oben und unten vorhanden sind, aber nur Tickbeschriftungen unterhalb der x-Achse; dies kann jedoch angepasst werden.

axis.get_ticklines()

<a list of 12 Line2D ticklines objects>

Und mit den oben genannten Methoden erhalten Sie standardmäßig nur Listen von Hauptticks zurück, aber Sie können auch nach den Nebenticks 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 Zugriffsermittlungsmethoden der Axis (diese haben entsprechende Setter, wo sinnvoll, wie z. B. set_major_formatter().)

Axis-Zugriffsermittlungsmethode	Beschreibung
get_scale	Die Skala der Achse, z. B. 'log' oder 'linear'
get_view_interval	Die Intervallinstanz der Achsenansichtslimits
get_data_interval	Die Intervallinstanz der Achsendatenlimits
get_gridlines	Eine Liste von Gitterlinien für die Achse
get_label	Die Achsenbeschriftung - eine Text-Instanz
get_offset_text	Der Achsen-Offset-Text - eine Text-Instanz
get_ticklabels	Eine Liste von Text-Instanzen - Schlüsselwort minor=True|False
get_ticklines	Eine Liste von Line2D-Instanzen - Schlüsselwort minor=True|False
get_ticklocs	Eine Liste von Tickpositionen - Schlüsselwort minor=True|False
get_major_locator	Die ticker.Locator-Instanz für Hauptticks
get_major_formatter	Die ticker.Formatter-Instanz für Hauptticks
get_minor_locator	Die ticker.Locator-Instanz für Nebenticks
get_minor_formatter	Die ticker.Formatter-Instanz für Nebenticks
get_major_ticks	Eine Liste von Tick-Instanzen für Hauptticks
get_minor_ticks	Eine Liste von Tick-Instanzen für Nebenticks
grid	Schaltet das Gitter für die Haupt- oder Nebenticks ein oder aus

Hier ist ein Beispiel, nicht wegen seiner Schönheit empfohlen, das die Eigenschaften von Axes und Ticks 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()

Tick-Container

Die matplotlib.axis.Tick ist das letzte Container-Objekt in unserer Abstammung von der Figure zur Axes zur Axis zur Tick. Die Tick enthält die Tick- und Gitterlinieninstanzen sowie die Labelinstanzen für die oberen und unteren Ticks. Jedes davon ist direkt als Attribut der Tick zugänglich.

Tick-Attribut	Beschreibung
tick1line	Eine Line2D-Instanz
tick2line	Eine Line2D-Instanz
gridline	Eine Line2D-Instanz
label1	Eine Text-Instanz
label2	Eine Text-Instanz

Hier ist ein Beispiel, das den Formatter für die rechten Ticks mit Dollarzeichen setzt und sie auf der rechten Seite der y-Achse grün färbt.

import matplotlib.pyplot as plt
import numpy as np

# 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()