libreria - plot() python

¿Cambiar la "frecuencia de tic" en el eje x o y en matplotlib?

Question

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

Decir

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

y

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

Entonces yo haría:

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

y las marcas de los ejes x se trazan en intervalos de 5. ¿Hay alguna forma de hacer que muestre intervalos de 1?

Answer 1

Aquí hay una implementación pura de python de la funcionalidad deseada que maneja cualquier serie numérica (int o float) con valores positivos, negativos o mixtos:

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)

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]

Y uso de la 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()

Answer 2

Desarrollé una solución poco elegante. Tenga en cuenta que tenemos el eje X y también una lista de etiquetas para cada punto en X.

Ejemplo:

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''] Digamos que quiero mostrar etiquetas de ticks solo para ''feb'' y ''jun''

xlabelsnew = [] for i in xlabels: if i not in [''feb'',''jun'']: i = '' '' xlabelsnew.append(i) else: xlabelsnew.append(i) Bien, ahora tenemos una lista falsa de etiquetas. Primero, trazamos la versión original.

plt.plot(x,y) plt.xticks(range(0,len(x)),xlabels,rotation=45) plt.show() Ahora, la versión modificada.

plt.plot(x,y)
plt.xticks(range(0,len(x)),xlabelsnew,rotation=45)
plt.show()

Answer 3

En caso de que alguien esté interesado en una sola línea general, simplemente obtenga los ticks actuales y utilícelos para establecer los nuevos ticks muestreando cada otro tick.

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

Answer 4

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 las garrapatas de esta manera es que ya no se disfruta de la actualización automática de la escala máxima automática después de una línea adicional. Entonces hazlo

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

y ejecute de nuevo la función reajustar.

Answer 5

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

¿La forma más limpia de ocultar cada enésima etiqueta en la barra de colores de 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.

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

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)

Answer 6

Me gusta esta solución (del libro de recetas de Matplotlib Plotting ):

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 espacio entre ticker.MultipleLocater() a través del número que se le da a ticker.MultipleLocater() , permite la determinación automática de límites y es fácil de leer más adelante.

Answer 7

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)

Hay varios tipos diferentes de localizadores dependiendo de sus necesidades.

Answer 8

Podría 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()

(Se utilizó np.arange lugar de la función de range de Python en caso de que min(x) y max(x) sean flotantes en lugar de ints).

La función plt.plot (o ax.plot ) establecerá automáticamente los límites predeterminados de x e y . Si desea mantener esos límites y simplemente cambiar el tamaño de las marcas, entonces 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 debería 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()

Answer 9

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

Esto funciono para mi

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

length = 5