Ich versuche zu korrigieren, wie Python meine Daten zeichnet.

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 Ticks der x-Achse werden in Intervallen von 5 aufgezeichnet. Gibt es eine Möglichkeit, Intervalle von 1 anzuzeigen?

Sie können explizit festlegen, wo Sie Markierungen ankreuzen 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.arangewurde für alle rangeFälle anstelle von Pythons Funktion verwendet min(x)und max(x)ist Floats anstelle von Ints.)

Die plt.plot(oder ax.plot) Funktion legt automatisch Standardeinstellungen xund yGrenzwerte fest. Wenn Sie diese Grenzwerte beibehalten und nur die Schrittweite der Häkchen ändern möchten, können Sie ermitteln ax.get_xlim(), 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 gute Arbeit leisten und die Tick-Werte auf eine sinnvolle Anzahl signifikanter 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()

Ein anderer Ansatz besteht darin, den Achsen-Locator einzustellen:

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

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 des Tick-Abstands über die angegebene Nummer ticker.MultipleLocater(), ermöglicht die automatische Grenzwertbestimmung und ist später leicht abzulesen.

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

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

Dies ist ein bisschen hackig, aber bei weitem das sauberste / am einfachsten zu verstehende Beispiel, das ich dafür gefunden habe. Es ist von einer Antwort auf SO hier:

Der sauberste Weg, jedes n-te Häkchen in der Matplotlib-Farbleiste zu verstecken?

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

Anschließend können Sie die Beschriftungen durchlaufen und sie je nach gewünschter Dichte als sichtbar oder nicht sichtbar festlegen.

Bearbeiten: Beachten Sie, dass matplotlib manchmal Beschriftungen == setzt '', sodass es möglicherweise so aussieht, als ob eine Beschriftung nicht vorhanden ist, obwohl sie tatsächlich nichts anzeigt. Um sicherzustellen, dass Sie die tatsächlich sichtbaren 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)

Dies ist ein altes Thema, aber ich stolpere hin und wieder darüber und habe diese Funktion gemacht. Es 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 solcher Zecken 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 Resadjust-Funktion erneut aus.

Ich habe eine unelegante Lösung entwickelt. Bedenken Sie, dass wir die X-Achse und auch eine Liste von Beschriftungen für jeden Punkt in X 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()

Wenn Sie nur den Abstand auf einen einfachen Einzeiler mit minimaler Boilerplate einstellen möchten:

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

funktioniert auch leicht bei kleinen Zecken:

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

ein bisschen mundvoll, aber ziemlich kompakt

xmarks=[i for i in range(1,length+1,1)]

plt.xticks(xmarks)

Das hat bei mir funktioniert

Wenn Sie Ticks zwischen [1,5] (einschließlich 1 und 5) wünschen, ersetzen Sie diese

length = 5

Reine Python-Implementierung

Im Folgenden finden Sie eine reine Python-Implementierung der gewünschten Funktionalität, die alle numerischen Reihen (int oder float) mit positiven, negativen oder gemischten Werten verarbeitet und es dem Benutzer ermöglicht, die gewünschte Schrittgröße anzugeben:

import math

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
    """
    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]

Beispielnutzung

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

Beachten Sie, dass die x-Achse ganzzahlige Werte hat, die alle gleichmäßig um 5 voneinander beabstandet sind, während die y-Achse ein anderes Intervall hat (das matplotlibStandardverhalten, da die Häkchen nicht angegeben wurden).