Changer la "fréquence de TIC" sur l'axe x ou y dans matplotlib?

une autre approche consiste à placer le Localisateur d'axe:

import matplotlib.ticker as plticker

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

il existe plusieurs types de localisateurs selon vos besoins.

j'aime cette solution (à partir de la Matplotlib Tracé livre de cuisine ):

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

cette solution vous donne le contrôle explicite de l'espacement des tiques via le nombre donné à ticker.MultipleLocater() , permet la détermination automatique de la limite, et est facile à lire plus tard.

si quelqu'un est intéressé par une doublure générale, il suffit d'obtenir les tiques actuelles et de l'utiliser pour régler les nouvelles tiques en échantillonnant toutes les autres tiques.

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

C'est un peu hacky, mais de loin l'exemple le plus propre/le plus facile à comprendre que j'ai trouvé pour faire ceci. C'est d'une réponse sur Ainsi ici:

la façon la plus propre de cacher chaque étiquette de nième tique dans matplotlib colorbar?

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

ensuite, vous pouvez boucler les étiquettes en les fixant à visible ou non en fonction de la densité que vous voulez.

edit: notez que parfois matplotlib définit des étiquettes == '' , de sorte qu'il pourrait ressembler à une étiquette n'est pas présent, alors qu'en fait il est et ne montre tout simplement rien. Pour vous assurer que vous êtes en boucle à travers les étiquettes visibles réelles, vous pouvez essayer:

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)

C'est un vieux sujet, mais je trébuche sur cela de temps en temps et fait cette fonction. C'est très pratique:

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)

une mise en garde pour contrôler les tiques comme celle-ci est que l'on ne profite plus de la mise à jour automatique interactive de Max scale après une ligne ajoutée. Alors faites

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

et relancer la fonction de réajustement.

j'ai développé une solution inélégante. Considérons que nous avons l'axe des X et aussi une liste d'étiquettes pour chaque point dans X.

Exemple:

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

Disons que je veux montrer les étiquettes des tiques seulement pour "feb" et "jun"

xlabelsnew = []
for i in xlabels:
    if i not in ['feb','jun']:
        i = ' '
        xlabelsnew.append(i)
    else:
        xlabelsnew.append(i)

Bien, maintenant on a une fausse liste d'étiquettes. Tout d'abord, nous avons tracé la version originale.

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

Maintenant, la version modifiée.

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

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

plt.xticks(xmarks)

cela a fonctionné pour moi

si vous voulez des tiques entre [1,5] (1 et 5 inclusivement) remplacer

length = 5

voici une implémentation python pure de la fonctionnalité désirée qui gère n'importe quelle série numérique (int ou float) avec des valeurs positives, négatives ou mixtes:

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)

Sortie De L'Échantillon:

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

Et Utilisation De L'Échantillon:

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