Estou tentando corrigir como python plota meus dados.

Dizer

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

e

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

Então eu faria:

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

e os ticks do eixo x são plotados em intervalos de 5. Existe uma maneira de mostrar intervalos de 1?

Você pode definir explicitamente onde deseja marcar as marcas plt.xticks:

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

Por exemplo,

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.arangefoi usada em vez da rangefunção do Python apenas por precaução min(x)e max(x)são flutuadores em vez de ints.)

A função plt.plot(ou ax.plot) definirá automaticamente o padrão xe os ylimites. Se você deseja manter esses limites e apenas alterar o tamanho das etapas das marcas de escala, poderá ax.get_xlim()descobrir quais limites o Matplotlib já definiu.

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

O formatador de ticks padrão deve fazer um trabalho decente, arredondando os valores de ticks para um número razoável de dígitos significativos. No entanto, se você deseja ter mais controle sobre o formato, pode definir seu próprio formatador. Por exemplo,

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

Aqui está um exemplo executável:

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

Outra abordagem é definir o localizador de eixos:

import matplotlib.ticker as plticker

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

Existem vários tipos diferentes de localizador, dependendo de suas necessidades.

Aqui está um exemplo completo:

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

Gosto desta solução (do 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()

Esta solução fornece controle explícito do espaçamento dos ticks através do número indicado ticker.MultipleLocater(), permite a determinação automática de limites e é fácil de ler posteriormente.

Caso alguém esteja interessado em uma única linha geral, basta obter os ticks atuais e usá-lo para definir os novos ticks, amostrando todos os outros ticks.

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

Isso é um pouco hacky, mas de longe o exemplo mais limpo / fácil de entender que eu encontrei para fazer isso. É de uma resposta no SO aqui:

A maneira mais limpa de ocultar todos os enésimos rótulos de marcadores na barra de cores matplotlib?

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

Em seguida, você pode fazer um loop sobre os rótulos, definindo-os como visíveis ou não, dependendo da densidade desejada.

edit: note que, às vezes, o matplotlib define rótulos == '', portanto, pode parecer que um rótulo não está presente, quando na verdade está e simplesmente não está exibindo nada. Para garantir que você esteja percorrendo rótulos visíveis reais, tente:

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)

Este é um tópico antigo, mas tropeço nele de vez em quando e faço essa função. É muito conveniente:

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)

Uma ressalva de controlar os ticks dessa maneira é que não se desfruta mais da atualização automagic interativa da escala máxima após uma linha adicionada. Então faça

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

e execute a função de reajuste novamente.

Eu desenvolvi uma solução deselegante. Considere que temos o eixo X e também uma lista de rótulos para cada ponto em 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()

se você quiser apenas definir o espaçamento como um liner simples, com um mínimo de clichê:

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

também funciona facilmente para pequenos ticks:

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

um pouco de boca cheia, mas bastante compacto

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

plt.xticks(xmarks)

Isso funcionou para mim

se você quiser carrapatos entre [1,5] (1 e 5 inclusive), substitua

length = 5

Implementação Pure Python

Abaixo está uma implementação python pura da funcionalidade desejada que lida com qualquer série numérica (int ou float) com valores positivos, negativos ou mistos e permite ao usuário especificar o tamanho da etapa desejada:

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)

Saída de amostra

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

Uso da amostra

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

Observe que o eixo x tem valores inteiros todos uniformemente espaçados por 5, enquanto o eixo y tem um intervalo diferente (o matplotlibcomportamento padrão, porque os ticks não foram especificados).