Matplotlib - fixation de l'axe x de l'échelle et autoscale de l'axe y

Je voudrais parcelle seulement une partie de la matrice, la fixation de x, mais y laisser une partie autoscale. J'ai essayé comme indiqué ci-dessous, mais il ne fonctionne pas.

Des suggestions?

import numpy as np
import matplotlib.pyplot as plt

data=[np.arange(0,101,1),300-0.1*np.arange(0,101,1)]

plt.figure()

plt.scatter(data[0], data[1])
plt.xlim([50,100])
plt.autoscale(enable=True, axis='y')

plt.show()

OriginalL'auteur Pygmalion | 2015-04-05

matplotlib python

6

Mise à l'échelle automatique utilise toujours la gamme complète des données, de sorte que l'axe des y est mis à l'échelle par la pleine mesure de l'axe des données, et pas seulement ce qui est à l'intérieur de la x-limites.

Si vous souhaitez afficher un sous-ensemble de données, alors il est probablement plus facile de ne tracer que ce sous-ensemble:
```
import numpy as np
import matplotlib.pyplot as plt

x, y = np.arange(0,101,1) ,300 - 0.1*np.arange(0,101,1)
mask = (x >= 50) & (x <= 100)

fig, ax = plt.subplots()
ax.scatter(x[mask], y[mask])

plt.show()
```
J'ai aussi eu cette idée mais je ne savais pas que faire des sous-ensemble était si simple en Python 🙂

OriginalL'auteur Joe Kington
15

Tout Joe Kingston Portant propose certainement la réponse la plus sensée lorsqu'il recommande que seules les données nécessaires à l'être tracée, il y a des situations où il serait préférable de tracer toutes les données et de zoomer à une certaine section. En outre, il serait agréable d'avoir un "autoscale_y" fonction qui exige que les axes de l'objet (c'est à dire, contrairement à la réponse ici, ce qui nécessite l'utilisation directe des données.)

Ici est une fonction qui recadre l'axe y sur la base des données qui est dans le visible, x-région:
```
def autoscale_y(ax,margin=0.1):
    """This function rescales the y-axis based on the data that is visible given the current xlim of the axis.
    ax -- a matplotlib axes object
    margin -- the fraction of the total height of the y-data to pad the upper and lower ylims"""

    import numpy as np

    def get_bottom_top(line):
        xd = line.get_xdata()
        yd = line.get_ydata()
        lo,hi = ax.get_xlim()
        y_displayed = yd[((xd>lo) & (xd<hi))]
        h = np.max(y_displayed) - np.min(y_displayed)
        bot = np.min(y_displayed)-margin*h
        top = np.max(y_displayed)+margin*h
        return bot,top

    lines = ax.get_lines()
    bot,top = np.inf, -np.inf

    for line in lines:
        new_bot, new_top = get_bottom_top(line)
        if new_bot < bot: bot = new_bot
        if new_top > top: top = new_top

    ax.set_ylim(bot,top)
```
C'est quelque chose d'un hack, et ne sera probablement pas travailler dans de nombreuses situations, mais pour un tracé simple, il fonctionne bien.

Voici un exemple simple d'utilisation de cette fonction:
```
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-100,100,1000)
y = x**2 + np.cos(x)*100

fig,axs = plt.subplots(1,2,figsize=(8,5))

for ax in axs:
    ax.plot(x,y)
    ax.plot(x,y*2)
    ax.plot(x,y*10)
    ax.set_xlim(-10,10)

autoscale_y(axs[1])

axs[0].set_title('Rescaled x-axis')
axs[1].set_title('Rescaled x-axis\nand used "autoscale_y"')

plt.show()
```
C'est super, mais il échoue si la parcelle a axhline (le)s en elle. Je vais essayer de régler ça parce que c'est exactement ce que je veux.
J'ai remplacé y_displayed = yd[((xd>=lo) & (xd<=hi))] avec if len(xd)==2 et xd[0]==0,0 et xd[1]==1.0: y_displayed=yd #cas particulier de la poignée axhline d'autre: y_displayed = yd[((xd>=lo) & (xd<=hi))]
Oui c'est dommage qu'il n'y a pas autoscale_axis, probablement, il sera peut-être déjà mis en œuvre dans la récente mise à jour de matplotlib. Merci pour votre contribution, je l'utilise et fonctionne très bien! Toutefois, même lorsque vous n'en voulez tracer l'ensemble de la gamme de valeurs et ensuite effectuer un zoom avant, @Joe Kinton 's solution est plus simple, en traçant l'ensemble de la gamme sur le panneau de gauche et le masqué valeurs sur la droite.
Vraiment sympa solution! Cela nécessite juste une modification mineure si l'axe des x est un datetime: xd = [dt.toordinal() for dt in line.get_xdata()]
Pour toute personne intéressée, j'ai adapté cette fonction sur n'importe quel axe: gist.github.com/ArcturusB/613eaba080a50385fa29e2eff8fe203f.

OriginalL'auteur DanHickstein

Vous devez vous connecter pour publier un commentaire.