Próbuję naprawić sposób, w jaki Python drukuje moje dane.

Mówić

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

i

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

Potem zrobiłbym:

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

a tyknięcia na osi x są wykreślane w odstępach 5. Czy istnieje sposób, aby pokazywał odstępy 1?

Możesz jawnie ustawić miejsce, w którym chcesz zaznaczyć znaczniki plt.xticks:

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

Na przykład,

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.arangezostał użyty zamiast rangefunkcji Pythona na wszelki wypadek min(x)i max(x)są zmiennoprzecinkowe zamiast ints.)

Funkcja plt.plot(lub ax.plot) automatycznie ustawi domyślne xi ylimity. Jeśli chcesz zachować te limity i po prostu zmienić rozmiar znaczników, możesz użyć, ax.get_xlim()aby dowiedzieć się, jakie limity Matplotlib już ustawił.

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

Domyślny formatyzator tików powinien wykonać przyzwoitą robotę zaokrąglając wartości tików do rozsądnej liczby cyfr znaczących. Jeśli jednak chcesz mieć większą kontrolę nad formatem, możesz zdefiniować własny formatyzator. Na przykład,

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

Oto możliwy do uruchomienia przykład:

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

Innym podejściem jest ustawienie lokalizatora osi:

import matplotlib.ticker as plticker

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

Istnieje kilka różnych rodzajów lokalizatora w zależności od potrzeb.

Oto pełny przykład:

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

Podoba mi się to rozwiązanie (z 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()

To rozwiązanie daje ci wyraźną kontrolę odstępów między tyknięciami za pomocą podanej liczby ticker.MultipleLocater(), pozwala na automatyczne określenie limitu i jest łatwe do odczytania później.

W przypadku, gdy ktoś jest zainteresowany ogólną linią pojedynczą, po prostu pobierz bieżące tiki i użyj go do ustawienia nowych tików, próbkując co drugi tik.

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

Jest to nieco zuchwałe, ale zdecydowanie najczystszy / najłatwiejszy do zrozumienia przykład, jaki to zrobiłem. Oto odpowiedź na SO tutaj:

Najczystszy sposób na ukrycie każdej n-tej etykiety kleszczowej w pasku kolorów Matplotlib?

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

Następnie możesz zapętlić etykiety, ustawiając je na widoczne lub nie, w zależności od żądanej gęstości.

edit: zauważ, że czasami matplotlib ustawia etykiety == '', więc może wyglądać na to, że etykieta nie jest obecna, podczas gdy w rzeczywistości jest i po prostu nic nie wyświetla. Aby mieć pewność, że przeglądasz rzeczywiste widoczne etykiety, możesz spróbować:

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)

To jest stary temat, ale od czasu do czasu potykam się o to i stworzyłem tę funkcję. To bardzo wygodne:

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)

Jednym z ostrzeżeń związanych z kontrolowaniem taktów jest to, że nie cieszy się już interaktywną automatyczną aktualizacją maksymalnej skali po dodaniu linii. Więc zrób

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

i ponownie uruchom funkcję resadjust.

Opracowałem nieeleganckie rozwiązanie. Rozważ, że mamy oś X, a także listę etykiet dla każdego punktu w X.

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

jeśli chcesz tylko ustawić odstęp prostą wkładką z minimalną płytą grzewczą:

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

działa również łatwo w przypadku drobnych kleszczy:

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

trochę kęs, ale dość kompaktowy

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

plt.xticks(xmarks)

To zadziałało dla mnie

jeśli chcesz zaznaczyć od [1,5] (od 1 do 5 włącznie), zamień

length = 5

Implementacja Pure Python

Poniżej znajduje się czysta implementacja żądanej funkcjonalności w języku Python, która obsługuje dowolne szeregi liczbowe (int lub float) o wartościach dodatnich, ujemnych lub mieszanych i pozwala użytkownikowi określić żądany rozmiar kroku:

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)

Przykładowe dane wyjściowe

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

Przykładowe użycie

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

Zauważ, że oś x ma wartości całkowite równomiernie rozmieszczone o 5, podczas gdy oś y ma inny przedział ( matplotlibzachowanie domyślne, ponieważ tiki nie zostały określone).