Améliorer la taille/l'espacement des sous-parcelles avec de nombreuses sous-parcelles dans le matplotlib
très similaire à cette question mais avec la différence que mon chiffre peut être aussi grand qu'il doit être.
je dois générer un tas entier de parcelles empilées verticalement dans matplotlib. Le résultat sera sauvegardé en utilisant figsave et visualisé sur une page web, donc je ne me soucie pas de la taille de l'image finale tant que les sous-lots sont espacés de sorte qu'ils ne se chevauchent pas.
peu importe la taille que je permets à la figure d'être, les sous-lots toujours semblent se chevaucher.
mon code ressemble actuellement à
import matplotlib.pyplot as plt
import my_other_module
titles, x_lists, y_lists = my_other_module.get_data()
fig = plt.figure(figsize=(10,60))
for i, y_list in enumerate(y_lists):
plt.subplot(len(titles), 1, i)
plt.xlabel("Some X label")
plt.ylabel("Some Y label")
plt.title(titles[i])
plt.plot(x_lists[i],y_list)
fig.savefig('out.png', dpi=100)
6 réponses
essayez d'utiliser plt.tight_layout
comme exemple rapide:
import matplotlib.pyplot as plt
fig, axes = plt.subplots(nrows=4, ncols=4)
fig.tight_layout() # Or equivalently, "plt.tight_layout()"
plt.show()
Sans Disposition Serrée
vous pouvez utiliser plt.subplots_adjust pour changer l'espacement entre les sous-lots (source)
appel de la signature:
subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=None)
les significations des paramètres (et les valeurs par défaut suggérées) sont:
left = 0.125 # the left side of the subplots of the figure
right = 0.9 # the right side of the subplots of the figure
bottom = 0.1 # the bottom of the subplots of the figure
top = 0.9 # the top of the subplots of the figure
wspace = 0.2 # the amount of width reserved for blank space between subplots
hspace = 0.2 # the amount of height reserved for white space between subplots
les valeurs par défaut réelles sont contrôlées par le fichier rc
j'ai trouvé que subplots_adjust(hspace = 0.001) est ce qui a fini par fonctionner pour moi. Quand j'utilise space = None, Il y a encore de l'espace blanc entre chaque parcelle. Le fixer à quelque chose de très proche de zéro semble toutefois les forcer à s'aligner. Ce que j'ai téléchargé ici n'est pas le plus élégant morceau de code, mais vous pouvez voir comment l'hspace fonctionne.
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as tic
fig = plt.figure()
x = np.arange(100)
y = 3.*np.sin(x*2.*np.pi/100.)
for i in range(5):
temp = 510 + i
ax = plt.subplot(temp)
plt.plot(x,y)
plt.subplots_adjust(hspace = .001)
temp = tic.MaxNLocator(3)
ax.yaxis.set_major_locator(temp)
ax.set_xticklabels(())
ax.title.set_visible(False)
plt.show()
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(10,60))
plt.subplots_adjust( ... )
Le plt.sous-plots_adjust méthode:
def subplots_adjust(*args, **kwargs):
"""
call signature::
subplots_adjust(left=None, bottom=None, right=None, top=None,
wspace=None, hspace=None)
Tune the subplot layout via the
:class:`matplotlib.figure.SubplotParams` mechanism. The parameter
meanings (and suggested defaults) are::
left = 0.125 # the left side of the subplots of the figure
right = 0.9 # the right side of the subplots of the figure
bottom = 0.1 # the bottom of the subplots of the figure
top = 0.9 # the top of the subplots of the figure
wspace = 0.2 # the amount of width reserved for blank space between subplots
hspace = 0.2 # the amount of height reserved for white space between subplots
The actual defaults are controlled by the rc file
"""
fig = gcf()
fig.subplots_adjust(*args, **kwargs)
draw_if_interactive()
ou
fig = plt.figure(figsize=(10,60))
fig.subplots_adjust( ... )
la taille de l'image Compte.
" j'ai essayé de jouer avec hspace, mais l'augmenter semble seulement rendre tous les graphiques plus petits sans résoudre le problème de chevauchement."
ainsi pour faire plus d'espace blanc et garder la taille de la sous-parcelle de l'image totale doit être plus grand.
vous pouvez essayer le sous-plot_tool ()
plt.subplot_tool()
similaire à tight_layout matplotlib maintenant (à partir de la version 2.2) fournit contrained_layout . Contrairement à tight_layout , qui peut être appelé à tout moment dans le code pour une disposition optimisée unique, constrained_layout est une propriété, qui peut être active et optimisera la disposition avant chaque étape de dessin.
par conséquent, il doit être activé avant ou pendant la création de sous-parcelles. Cela peut arriver comme argument à figure(contrained_layout=True) ou subplots(constrained_layout=True) .
exemple:
import matplotlib.pyplot as plt
fig, axes = plt.subplots(4,4, constrained_layout=True)
plt.show()
peut aussi bien être défini via rcParams
plt.rcParams['figure.constrained_layout.use'] = True
voir la quoi de neuf? et le Guide de mise en page tronqué