it-swarm.com.de

Ändern der "Tick-Frequenz" auf der X- oder Y-Achse in Matplotlib?

Ich versuche zu korrigieren, wie python meine Daten plottet.

Sagen

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

und

y = [0,1,2,3,4]

Dann würde ich tun:

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

und die Häkchen der x-Achse werden in Intervallen von 5 aufgetragen. Gibt es eine Möglichkeit, Intervalle von 1 anzuzeigen?

382
Dax Feliz

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

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 der range -Funktion von Python verwendet, nur für den Fall, dass min(x) und max(x) Floats anstelle von Ints sind.)


Die Funktion plt.plot (oder ax.plot) setzt automatisch die Standardgrenzwerte x und y. Wenn Sie diese Grenzwerte beibehalten und nur die Schrittweite der Teilstriche ändern möchten, können Sie mit ax.get_xlim() ermitteln, welche Grenzwerte Matplotlib bereits festgelegt hat.

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

Der Standard-Tick-Formatierer sollte die Tick-Werte auf eine vernünftige Anzahl von signifikanten Stellen runden. 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()
466
unutbu

Ein anderer Ansatz ist das Setzen des Achslokalisierers:

import matplotlib.ticker as plticker

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

Abhängig von Ihren Anforderungen gibt es verschiedene Arten von Ortungsgeräten.

Hier ist ein vollständiges Beispiel:

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) # this locator puts ticks at regular intervals
ax.xaxis.set_major_locator(loc)
plt.show()
168
robochat

Ich mag diese Lösung (aus dem Matplotlib Plotting Cookbook ):

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 eine explizite Kontrolle über den Tick-Abstand über die Nummer, die ticker.MultipleLocater() zugewiesen wurde, ermöglicht die automatische Grenzwertermittlung und ist später leicht abzulesen.

98
jthomas

Wenn sich jemand für einen allgemeinen Einzeiler interessiert, holen Sie sich einfach die aktuellen Ticks und setzen Sie die neuen Ticks, indem Sie jeden zweiten Tick abtasten.

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

Das ist ein bisschen abgedreht, aber mit Abstand das sauberste/am einfachsten zu verstehende Beispiel, das ich dafür gefunden habe. Es ist aus einer Antwort auf SO hier:

Der sauberste Weg, um jedes n-te Häkchen in der matplotlib-Farbleiste auszublenden?

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

Anschließend können Sie die Beschriftungen in einer Schleife übergehen und sie je nach gewünschter Dichte entweder sichtbar oder nicht sichtbar machen.

edit: beachte, dass matplotlib manchmal labels == '' setzt, so dass es so aussehen kann, als ob ein label nicht vorhanden ist, obwohl es tatsächlich ist und einfach nichts anzeigt. Um sicherzustellen, dass Sie tatsächlich sichtbare Beschriftungen 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)
27
choldgraf

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

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 dieser Ticks ist, dass die interaktive automatische Aktualisierung der maximalen Skalierung nach einer hinzugefügten Zeile nicht länger Spaß macht. Dann mach

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

und führen Sie die Funktion zum erneuten Einstellen erneut aus.

14
Tompa

Ich entwickelte eine unelegante Lösung. Bedenken Sie, dass wir für jeden Punkt in X die X-Achse und auch eine Liste von Beschriftungen haben.

import matplotlib.pyplot as plt

x = [0,1,2,3,4,5]
y = [10,20,15,18,7,19]
xlabels = ['jan','feb','mar','apr','may','jun']
xlabelsnew = []
for i in xlabels:
    if i not in ['feb','jun']:
        i = ' '
        xlabelsnew.append(i)
    else:
        xlabelsnew.append(i)
plt.plot(x,y)
plt.xticks(range(0,len(x)),xlabels,rotation=45)
plt.show()
plt.plot(x,y)
plt.xticks(range(0,len(x)),xlabelsnew,rotation=45)
plt.show()
8
Deninhos
xmarks=[i for i in range(1,length+1,1)]

plt.xticks(xmarks)

Das hat bei mir funktioniert

wenn Sie Häkchen zwischen [1,5] (1 und 5 einschließlich) möchten, ersetzen Sie

length = 5
2
Piyush Gupta

Hier ist eine reine python Implementierung der gewünschten Funktionalität, die alle numerischen Reihen (int oder float) mit positiven, negativen oder gemischten Werten verarbeitet:

def computeTicks (x, step = 5):
    """
    Computes domain with given step encompassing series x
    @ params
    x    - Required - A list-like object of integers or floats
    step - Optional - Tick frequency
    """
    import math as Math
    xMax, xMin = Math.ceil(max(x)), Math.floor(min(x))
    dMax, dMin = xMax + abs((xMax % step) - step) + (step if (xMax % step != 0) else 0), xMin - abs((xMin % step))
    return range(dMin, dMax, step)

Beispielausgabe:

# Negative to Positive
series = [-2, 18, 24, 29, 43]
print(list(computeTicks(series)))

[-5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45]

# Negative to 0
series = [-30, -14, -10, -9, -3, 0]
print(list(computeTicks(series)))

[-30, -25, -20, -15, -10, -5, 0]

# 0 to Positive
series = [19, 23, 24, 27]
print(list(computeTicks(series)))

[15, 20, 25, 30]

# Floats
series = [1.8, 12.0, 21.2]
print(list(computeTicks(series)))

[0, 5, 10, 15, 20, 25]

# Step – 100
series = [118.3, 293.2, 768.1]
print(list(computeTicks(series, step = 100)))

[100, 200, 300, 400, 500, 600, 700, 800]

Und beispielgebrauch:

import matplotlib.pyplot as plt

x = [0,5,9,10,15]
y = [0,1,2,3,4]
plt.plot(x,y)
plt.xticks(computeTicks(x))
plt.show()
1
Greenstick