Tutoriel de visualisation Pcolor de Matplotlib

Introduction

Ce tutoriel est une introduction à l'utilisation de Pcolor dans Matplotlib. Pcolor vous permet de générer des graphiques de type image 2D, et nous allons vous montrer comment l'utiliser dans Matplotlib.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limites de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous réglerons rapidement le problème pour vous.

Simple démonstration de Pcolor

La première étape est de créer une simple démonstration de Pcolor. Cela vous montrera comment créer un graphique Pcolor de base.

Z = np.random.rand(6, 10)

fig, (ax0, ax1) = plt.subplots(2, 1)

c = ax0.pcolor(Z)
ax0.set_title('par défaut : pas de bords')

c = ax1.pcolor(Z, edgecolors='k', linewidths=4)
ax1.set_title('bords épais')

fig.tight_layout()
plt.show()

Comparaison de Pcolor avec des fonctions similaires

La deuxième étape est de comparer Pcolor avec des fonctions similaires, telles que Pcolormesh, Imshow et Pcolorfast. Cela vous aidera à comprendre les différences entre ces fonctions et quand utiliser chacune d'entre elles.

## rendant ces valeurs plus petites pour augmenter la résolution
dx, dy = 0.15, 0.05

## générer 2 grilles 2D pour les bornes x et y
y, x = np.mgrid[-3:3+dy:dy, -3:3+dx:dx]
z = (1 - x/2 + x**5 + y**3) * np.exp(-x**2 - y**2)
## x et y sont des bornes, donc z devrait être la valeur *à l'intérieur* de ces bornes.
## Par conséquent, supprimer la dernière valeur du tableau z.
z = z[:-1, :-1]
z_min, z_max = -abs(z).max(), abs(z).max()

fig, axs = plt.subplots(2, 2)

ax = axs[0, 0]
c = ax.pcolor(x, y, z, cmap='RdBu', vmin=z_min, vmax=z_max)
ax.set_title('pcolor')
fig.colorbar(c, ax=ax)

ax = axs[0, 1]
c = ax.pcolormesh(x, y, z, cmap='RdBu', vmin=z_min, vmax=z_max)
ax.set_title('pcolormesh')
fig.colorbar(c, ax=ax)

ax = axs[1, 0]
c = ax.imshow(z, cmap='RdBu', vmin=z_min, vmax=z_max,
              extent=[x.min(), x.max(), y.min(), y.max()],
              interpolation='proche', origine='inférieure', aspect='auto')
ax.set_title('image (proche, aspect="auto")')
fig.colorbar(c, ax=ax)

ax = axs[1, 1]
c = ax.pcolorfast(x, y, z, cmap='RdBu', vmin=z_min, vmax=z_max)
ax.set_title('pcolorfast')
fig.colorbar(c, ax=ax)

fig.tight_layout()
plt.show()

Pcolor avec une échelle logarithmique

La troisième étape est de créer un graphique Pcolor avec une échelle logarithmique. Cela est utile lorsque vous avez des données avec une large plage de valeurs.

N = 100
X, Y = np.meshgrid(np.linspace(-3, 3, N), np.linspace(-2, 2, N))

## Une bosse basse avec une pointe sortante.
## Nécessite d'avoir l'axe z/couleur sur une échelle logarithmique, afin que nous voyions à la fois la bosse et la pointe.
## Une échelle linéaire ne montre que la pointe.
Z1 = np.exp(-X**2 - Y**2)
Z2 = np.exp(-(X * 10)**2 - (Y * 10)**2)
Z = Z1 + 50 * Z2

fig, (ax0, ax1) = plt.subplots(2, 1)

c = ax0.pcolor(X, Y, Z, shading='auto',
               norm=LogNorm(vmin=Z.min(), vmax=Z.max()), cmap='PuBu_r')
fig.colorbar(c, ax=ax0)

c = ax1.pcolor(X, Y, Z, cmap='PuBu_r', shading='auto')
fig.colorbar(c, ax=ax1)

plt.show()

Sommaire

Ce tutoriel vous a montré comment utiliser Pcolor dans Matplotlib. Nous avons commencé par une simple démonstration de Pcolor, puis comparé Pcolor avec des fonctions similaires telles que Pcolormesh et Imshow. Enfin, nous avons créé un graphique Pcolor avec une échelle logarithmique.