Ändern der Tickfrequenz auf der x- oder y-Achse

Question 1

Ich versuche zu beheben, wie Python meine Daten darstellt. Sagen:

x = [0,5,9,10,15]
y = [0,1,2,3,4]

matplotlib.pyplot.plot(x,y)
matplotlib.pyplot.show()

Die Ticks der x-Achse werden in Intervallen von 5 dargestellt. Gibt es eine Möglichkeit, Intervalle von 1 anzuzeigen?

Question 2

Sie können explizit festlegen, wo Sie Markierungen mit markieren möchten plt.xticks:

plt.xticks(np.arange(min(x), max(x)+1, 1.0))

Zum Beispiel,

import numpy as np
import matplotlib.pyplot as plt

x = [0,5,9,10,15]
y = [0,1,2,3,4]
plt.plot(x,y)
plt.xticks(np.arange(min(x), max(x)+1, 1.0))
plt.show()

(np.arange wurde anstelle von Python verwendet range Funktion für alle Fälle min(x) und max(x) sind Floats statt Ints.)

Das plt.plot (oder ax.plot)-Funktion wird automatisch die Standardeinstellung festlegen x und y Grenzen. Wenn Sie diese Grenzen beibehalten und einfach die Schrittweite der Häkchen ändern möchten, können Sie verwenden ax.get_xlim() um herauszufinden, welche Grenzen Matplotlib bereits gesetzt hat.

start, end = ax.get_xlim()
ax.xaxis.set_ticks(np.arange(start, end, stepsize))

Der Standard-Tick-Formatierer sollte gute Arbeit leisten, indem er die Tick-Werte auf eine vernünftige Anzahl signifikanter Stellen rundet. Wenn Sie jedoch mehr Kontrolle über das Format haben möchten, können Sie Ihren eigenen Formatierer definieren. Zum Beispiel,

ax.xaxis.set_major_formatter(ticker.FormatStrFormatter('%0.1f'))

Hier ist ein lauffähiges Beispiel:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker

x = [0,5,9,10,15]
y = [0,1,2,3,4]
fig, ax = plt.subplots()
ax.plot(x,y)
start, end = ax.get_xlim()
ax.xaxis.set_ticks(np.arange(start, end, 0.712123))
ax.xaxis.set_major_formatter(ticker.FormatStrFormatter('%0.1f'))
plt.show()

Question 3

Another approach is to set the axis locator:

import matplotlib.ticker as plticker

loc = plticker.MultipleLocator(base=1.0) # this locator puts ticks at regular intervals
ax.xaxis.set_major_locator(loc)

There are several different types of locator depending upon your needs.

Here is a full example:

import matplotlib.pyplot as plt
import matplotlib.ticker as plticker

x = [0,5,9,10,15]

y = [0,1,2,3,4]
fig, ax = plt.subplots() ax.plot(x,y) loc = plticker.MultipleLocator(base=1.0) # Dieser Locator setzt Ticks in regelmäßigen Abständen ax.xaxis.set_major_locator(loc) plt.show()

Question 4

Ich mag diese Lösung (von der Matplotlib-Plotting-Kochbuch):

import matplotlib.pyplot as plt
import matplotlib.ticker as ticker

x = [0,5,9,10,15]
y = [0,1,2,3,4]

tick_spacing = 1

fig, ax = plt.subplots(1,1)
ax.plot(x,y)
ax.xaxis.set_major_locator(ticker.MultipleLocator(tick_spacing))
plt.show()

Diese Lösung gibt Ihnen die explizite Kontrolle über den Tick-Abstand über die angegebene Zahl ticker.MultipleLocater()ermöglicht eine automatische Limitbestimmung und ist später gut ablesbar.

Question 5

Falls jemand an einem allgemeinen Einzeiler interessiert ist, holen Sie sich einfach die aktuellen Ticks und verwenden Sie sie, um die neuen Ticks zu setzen, indem Sie jeden zweiten Tick abtasten.

ax.set_xticks(ax.get_xticks()[::2])

Question 6

Dies ist ein bisschen hacky, aber bei weitem das sauberste / am einfachsten zu verstehende Beispiel, das ich gefunden habe, um dies zu tun. Es ist aus einer Antwort auf SO hier:

Der sauberste Weg, jedes n-te Tick-Label in der Matplotlib-Farbleiste auszublenden?

for label in ax.get_xticklabels()[::2]:
    label.set_visible(False)

Dann können Sie die Etiketten durchlaufen, um sie je nach gewünschter Dichte sichtbar oder nicht sichtbar zu machen.

Bearbeiten: Beachten Sie, dass Matplotlib manchmal Labels == setzt '', so dass es so aussehen könnte, als ob ein Etikett nicht vorhanden ist, obwohl es tatsächlich vorhanden ist und einfach nichts anzeigt. Um sicherzustellen, dass Sie tatsächlich sichtbare Labels durchlaufen, können Sie Folgendes versuchen:

visible_labels = [lab for lab in ax.get_xticklabels() if lab.get_visible() is True and lab.get_text() != '']
plt.setp(visible_labels[::2], visible=False)

Question 7

Wenn Sie nur den Abstand festlegen möchten, verwenden Sie einen einfachen Einzeiler mit minimalem Textbaustein:

plt.gca().xaxis.set_major_locator(plt.MultipleLocator(1))

funktioniert auch problemlos für kleinere Ticks:

plt.gca().xaxis.set_minor_locator(plt.MultipleLocator(1))

ein bisschen wie ein Schluck, aber ziemlich kompakt

Question 8

Das ist ein altes Thema, aber ich stolpere hin und wieder darüber und habe diese Funktion gemacht. Es ist sehr bequem:

import matplotlib.pyplot as pp
import numpy as np

def resadjust(ax, xres=None, yres=None):
    """
    Send in an axis and I fix the resolution as desired.
    """

    if xres:
        start, stop = ax.get_xlim()
        ticks = np.arange(start, stop + xres, xres)
        ax.set_xticks(ticks)
    if yres:
        start, stop = ax.get_ylim()
        ticks = np.arange(start, stop + yres, yres)
        ax.set_yticks(ticks)

Eine Einschränkung bei der Steuerung der Ticks auf diese Weise besteht darin, dass man die interaktive automatische Aktualisierung der maximalen Skalierung nach einer hinzugefügten Zeile nicht mehr genießt. Dann mach

gca().set_ylim(top=new_top) # for example

und führen Sie die Nachjustierungsfunktion erneut aus.