Estoy tratando de arreglar cómo Python traza mis datos.

Decir

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

y

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

Entonces haría:

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

y los ticks del eje x se trazan en intervalos de 5. ¿Hay alguna manera de hacer que muestre intervalos de 1?

Puede establecer explícitamente dónde desea marcar las marcas con plt.xticks:

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

Por ejemplo,

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.arangese utilizó en lugar de la rangefunción de Python por si acaso min(x)y max(x)son flotantes en lugar de int.)

La función plt.plot(o ax.plot) establecerá automáticamente valores predeterminados xy ylímites. Si desea mantener esos límites, y simplemente cambiar el tamaño de paso de las marcas de verificación, puede usar ax.get_xlim()para descubrir qué límites ya ha establecido Matplotlib.

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

El formateador de tick predeterminado debe hacer un trabajo decente redondeando los valores de tick a un número razonable de dígitos significativos. Sin embargo, si desea tener más control sobre el formato, puede definir su propio formateador. Por ejemplo,

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

Aquí hay un ejemplo ejecutable:

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

Otro enfoque es establecer el localizador de ejes:

import matplotlib.ticker as plticker

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

Existen varios tipos diferentes de localizador según sus necesidades.

Aquí hay un ejemplo 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()

Me gusta esta solución (del 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 solución le brinda un control explícito del espaciado de ticks a través del número dado ticker.MultipleLocater(), permite la determinación automática de límites y es fácil de leer más adelante.

En caso de que alguien esté interesado en una línea general, simplemente obtenga los ticks actuales y úselos para configurar los nuevos ticks probando cada otro tick.

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

Esto es un poco hacky, pero con mucho el ejemplo más limpio / fácil de entender que he encontrado para hacer esto. Es de una respuesta en SO aquí:

¿Es la forma más limpia de ocultar cada enésima etiqueta en la barra de colores matplotlib?

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

Luego, puede recorrer las etiquetas configurándolas como visibles o no, según la densidad que desee.

editar: tenga en cuenta que a veces matplotlib establece etiquetas == '', por lo que puede parecer que una etiqueta no está presente, cuando de hecho lo está y simplemente no muestra nada. Para asegurarte de que estás recorriendo las etiquetas visibles reales, puedes intentar:

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 es un tema antiguo, pero me tropiezo con esto de vez en cuando e hice esta función. Es muy 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)

Una advertencia de controlar los ticks como este es que ya no se disfruta de la actualización automática interactiva de la escala máxima después de una línea adicional. Entonces hazlo

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

y ejecute la función de reajuste nuevamente.

Desarrollé una solución poco elegante. Considere que tenemos el eje X y también una lista de etiquetas para cada punto en 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()

si solo desea establecer el espacio en un revestimiento simple con un mínimo de repetitivo:

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

También funciona fácilmente para garrapatas menores:

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

un poco bocado, pero bastante compacto

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

plt.xticks(xmarks)

Esto funciono para mi

si desea marcar entre [1,5] (1 y 5 inclusive), reemplace

length = 5

Implementación de Python puro

A continuación se muestra una implementación de Python pura de la funcionalidad deseada que maneja cualquier serie numérica (int o flotante) con valores positivos, negativos o mixtos y permite al usuario especificar el tamaño de paso deseado:

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)

Salida de muestra

# 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 de muestra

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 el eje x tiene valores enteros todos espaciados uniformemente por 5, mientras que el eje y tiene un intervalo diferente (el matplotlibcomportamiento predeterminado, porque no se especificaron los ticks).