Matplotlib - Guide rapide

Matplotlib est l'un des packages Python les plus populaires utilisés pour la visualisation de données. Il s'agit d'une bibliothèque multiplateforme permettant de créer des tracés 2D à partir de données dans des tableaux. Matplotlib est écrit en Python et utilise NumPy, l'extension de mathématiques numériques de Python. Il fournit une API orientée objet qui aide à incorporer des tracés dans des applications à l'aide de boîtes à outils d'interface graphique Python telles que PyQt, WxPythonotTkinter. Il peut être utilisé dans les shells Python et IPython, les notebooks Jupyter et les serveurs d'applications Web également.

Matplotlib a une interface procédurale appelée Pylab, qui est conçue pour ressembler à MATLAB, un langage de programmation propriétaire développé par MathWorks. Matplotlib avec NumPy peut être considéré comme l'équivalent open source de MATLAB.

Matplotlib a été initialement écrit par John D. Hunter en 2003. La version stable actuelle est la 2.2.0 publiée en janvier 2018.

Matplotlib et ses packages de dépendances sont disponibles sous la forme de packages wheel sur les référentiels de packages Python standard et peuvent être installés sur les systèmes Windows, Linux ainsi que MacOS à l'aide du gestionnaire de packages pip.

pip3 install matplotlib

Les versions d'Incase Python 2.7 ou 3.4 ne sont pas installées pour tous les utilisateurs, les packages redistribuables Microsoft Visual C ++ 2008 (64 bits ou 32 bits pour Python 2.7) ou Microsoft Visual C ++ 2010 (64 bits ou 32 bits pour Python 3.4) doivent être installés.

Si vous utilisez Python 2.7 sur un Mac, exécutez la commande suivante -

xcode-select –install

Lors de l'exécution de la commande ci-dessus, le sous-processus32 - une dépendance, peut être compilé.

Sur les versions extrêmement anciennes de Linux et Python 2.7, vous devrez peut-être installer la version principale de subprocess32.

Matplotlib nécessite un grand nombre de dépendances -

Python (> = 2,7 ou> = 3,4)
NumPy
setuptools
dateutil
pyparsing
libpng
pytz
FreeType
cycler
six

En option, vous pouvez également installer un certain nombre de packages pour activer de meilleures boîtes à outils d'interface utilisateur.

tk
PyQt4
PyQt5
pygtk
wxpython
pycairo
Tornado

Pour une meilleure prise en charge du format de sortie d'animation et des formats de fichier image, LaTeX, etc., vous pouvez installer ce qui suit -

_mpeg/avconv
ImageMagick
Oreiller (> = 2.0)
LaTeX et GhostScript (pour le rendu de texte avec LaTeX).
LaTeX et GhostScript (pour le rendu de texte avec LaTeX).

Anaconda est une distribution gratuite et open source des langages de programmation Python et R pour le traitement de données à grande échelle, l'analyse prédictive et le calcul scientifique. La distribution rend la gestion et le déploiement des packages simples et faciles. Matplotlib et de nombreux autres outils de science (données) utiles font partie de la distribution. Les versions de packages sont gérées par le système de gestion de packages Conda. L'avantage d'Anaconda est que vous avez accès à plus de 720 packages qui peuvent être facilement installés avec Conda d'Anaconda, un gestionnaire de packages, de dépendances et d'environnement.

La distribution Anaconda est disponible pour installation à https://www.anaconda.com/download/. Pour l'installation sous Windows, des binaires 32 et 64 bits sont disponibles -

https://repo.continuum.io/archive/Anaconda3-5.1.0-Windows-x86.exe

https://repo.continuum.io/archive/Anaconda3-5.1.0-Windows-x86_64.exe

L'installation est un processus basé sur un assistant assez simple. Vous pouvez choisir entre l'ajout d'Anaconda dans la variable PATH et l'enregistrement d'Anaconda comme votre Python par défaut.

Pour l'installation sous Linux, téléchargez les programmes d'installation pour les programmes d'installation 32 bits et 64 bits à partir de la page de téléchargement -

https://repo.continuum.io/archive/Anaconda3-5.1.0-Linux-x86.sh

https://repo.continuum.io/archive/Anaconda3-5.1.0-Linux-x86_64.sh

Maintenant, exécutez la commande suivante à partir du terminal Linux -

$ bash Anaconda3-5.0.1-Linux-x86_64.sh

Canopy et ActiveState sont les choix les plus recherchés pour Windows, macOS et les plates-formes Linux courantes. Les utilisateurs Windows peuvent trouver une option dans WinPython.

Jupyter est un acronyme qui signifie Julia, Python et R. Ces langages de programmation ont été les premiers langages cibles de l'application Jupyter, mais de nos jours, la technologie du notebook prend également en charge de nombreux autres langages.

En 2001, Fernando Pérez a commencé à développer Ipython. IPython est un shell de commande pour le calcul interactif dans plusieurs langages de programmation, initialement développé pour Python.

Considérez les fonctionnalités suivantes fournies par IPython -

Shells interactifs (basés sur le terminal et sur Qt).
Un bloc-notes basé sur un navigateur avec prise en charge du code, du texte, des expressions mathématiques, des tracés en ligne et d'autres médias.
Prise en charge de la visualisation interactive des données et de l'utilisation des boîtes à outils GUI.
Interprètes flexibles et intégrables à charger dans ses propres projets.

En 2014, Fernando Pérez a annoncé un projet dérivé d'IPython appelé Project Jupyter. IPython continuera d'exister en tant que shell Python et noyau pour Jupyter, tandis que le notebook et d'autres parties indépendantes du langage d'IPython se déplaceront sous le nom Jupyter. Jupyter a ajouté la prise en charge de Julia, R, Haskell et Ruby.

Pour démarrer le notebook Jupyter, ouvrez le navigateur Anaconda (une interface utilisateur graphique de bureau incluse dans Anaconda qui vous permet de lancer des applications et de gérer facilement les packages, les environnements et les canaux Conda sans avoir besoin d'utiliser des commandes de ligne de commande).

Navigator affiche les composants installés dans la distribution.

Lancez Jupyter Notebook à partir du navigateur -

Vous verrez l'ouverture de l'application dans le navigateur Web à l'adresse suivante - http://localhost:8888.

Vous voudrez probablement commencer par créer un nouveau cahier. Vous pouvez facilement le faire en cliquant sur le "bouton Nouveau" dans l'onglet "Fichiers". Vous voyez que vous avez la possibilité de créer un fichier texte normal, un dossier et un terminal. Enfin, vous verrez également l'option de créer un notebook Python 3.

Un nouveau carnet sans titre avec le .ipynbL'extension (signifie le notebook IPython) s'affiche dans le nouvel onglet du navigateur.

matplotlib.pyplotest une collection de fonctions de style de commande qui permettent à Matplotlib de fonctionner comme MATLAB. Chaque fonction Pyplot modifie une figure. Par exemple, une fonction crée une figure, une zone de traçage dans une figure, trace des lignes dans une zone de traçage, décore le tracé avec des étiquettes, etc.

Types de parcelles

Sr.Non	Description de la fonction
1	Bar Créez un graphique à barres.
2	Barh Créez un graphique à barres horizontales.
3	Boxplot Faites une boîte et un diagramme de moustaches.
4	Hist Tracez un histogramme.
5	hist2d Créez un histogramme 2D.
6	Pie Tracez un graphique à secteurs.
sept	Plot Tracez des lignes et / ou des marqueurs sur les axes.
8	Polar Faites un tracé polaire.
9	Scatter Faites un nuage de points de x par rapport à y.
dix	Stackplot Dessine un tracé de surface empilée.
11	Stem Créez un tracé de tige.
12	Step Faites un diagramme en étapes.
13	Quiver Tracez un champ de flèches en 2D.

Fonctions d'image

Sr.Non	Description de la fonction
1	Imread Lire une image d'un fichier dans un tableau.
2	Imsave Enregistrez un tableau sous forme de fichier image.
3	Imshow Affichez une image sur les axes.

Fonctions de l'axe

Sr.Non	Description de la fonction
1	Axes Ajoutez des axes à la figure.
2	Text Ajoutez du texte aux axes.
3	Title Définissez un titre des axes actuels.
4	Xlabel Définissez l'étiquette de l'axe x de l'axe actuel.
5	Xlim Obtenez ou définissez les limites x des axes actuels.
6	Xscale .
sept	Xticks Obtenez ou définissez les limites x des emplacements et des étiquettes de graduation actuels.
8	Ylabel Définit le libellé de l'axe y de l'axe actuel.
9	Ylim Obtenez ou définissez les limites y des axes actuels.
dix	Yscale Définissez la mise à l'échelle de l'axe y.
11	Yticks Obtenez ou définissez les limites y des emplacements et des étiquettes de graduation actuels.

Fonctions de la figure

Sr.Non	Description de la fonction
1	Figtext Ajoutez du texte à la figure.
2	Figure Crée une nouvelle figure.
3	Show Affichez une figure.
4	Savefig Enregistrez la figure actuelle.
5	Close Fermez une fenêtre de figure.

Dans ce chapitre, nous allons apprendre à créer un tracé simple avec Matplotlib.

Nous allons maintenant afficher un tracé linéaire simple de l'angle en radians par rapport à sa valeur sinusoïdale dans Matplotlib. Pour commencer, le module Pyplot du package Matplotlib est importé, avec un alias plt par convention.

import matplotlib.pyplot as plt

Ensuite, nous avons besoin d'un tableau de nombres à tracer. Diverses fonctions de tableau sont définies dans la bibliothèque NumPy qui est importée avec l'alias np.

import numpy as np

Nous obtenons maintenant l'objet ndarray d'angles compris entre 0 et 2π en utilisant la fonction arange () de la bibliothèque NumPy.

x = np.arange(0, math.pi*2, 0.05)

L'objet ndarray sert de valeurs sur l'axe des x du graphique. Les valeurs sinusoïdales correspondantes des angles en x à afficher sur l'axe y sont obtenues par l'instruction suivante -

y = np.sin(x)

Les valeurs de deux tableaux sont tracées à l'aide de la fonction plot ().

plt.plot(x,y)

Vous pouvez définir le titre du tracé et les étiquettes des axes x et y.

You can set the plot title, and labels for x and y axes.
plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')

La fenêtre du visualiseur de tracé est appelée par la fonction show () -

plt.show()

Le programme complet est le suivant -

from matplotlib import pyplot as plt
import numpy as np
import math #needed for definition of pi
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)
plt.plot(x,y)
plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')
plt.show()

Lorsque la ligne de code ci-dessus est exécutée, le graphique suivant s'affiche -

Maintenant, utilisez le notebook Jupyter avec Matplotlib.

Lancez le notebook Jupyter à partir du navigateur Anaconda ou de la ligne de commande comme décrit précédemment. Dans la cellule d'entrée, entrez les instructions d'importation pour Pyplot et NumPy -

from matplotlib import pyplot as plt
import numpy as np

Pour afficher les sorties de tracé dans le bloc-notes lui-même (et non dans le visualiseur séparé), entrez l'instruction magique suivante -

%matplotlib inline

Obtenez x comme objet ndarray contenant des angles en radians entre 0 et 2π, et y comme valeur sinusoïdale de chaque angle -

import math
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)

Définissez des étiquettes pour les axes x et y ainsi que le titre du tracé -

plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')

Enfin, exécutez la fonction plot () pour générer l'affichage de l'onde sinusoïdale dans le notebook (pas besoin d'exécuter la fonction show ()) -

plt.plot(x,y)

Après l'exécution de la dernière ligne de code, la sortie suivante s'affiche -

PyLab est une interface procédurale de la bibliothèque de traçage orientée objet Matplotlib. Matplotlib est le package complet; matplotlib.pyplot est un module de Matplotlib; et PyLab est un module qui s'installe avec Matplotlib.

PyLab est un module pratique qui importe en bloc matplotlib.pyplot (pour le traçage) et NumPy (pour les mathématiques et l'utilisation de tableaux) dans un seul espace de nom. Bien que de nombreux exemples utilisent PyLab, il n'est plus recommandé.

Tracé de base

Le traçage des courbes se fait avec la commande plot. Il faut une paire de tableaux (ou séquences) de même longueur -

from numpy import *
from pylab import *
x = linspace(-3, 3, 30)
y = x**2
plot(x, y)
show()

La ligne de code ci-dessus génère la sortie suivante -

Pour tracer des symboles plutôt que des lignes, fournissez un argument de chaîne supplémentaire.

symboles	-, -, -.,,. ,,, o, ^, v, <,>, s, +, x, D, d, 1, 2, 3, 4, h, H, p, \| , _
couleurs	b, g, r, c, m, y, k, w

Maintenant, envisagez d'exécuter le code suivant -

from pylab import *
x = linspace(-3, 3, 30)
y = x**2
plot(x, y, 'r.')
show()

Il trace les points rouges comme indiqué ci-dessous -

Les tracés peuvent être superposés. Utilisez simplement les multiples commandes de tracé. Utilisez clf () pour effacer le tracé.

from pylab import *
plot(x, sin(x))
plot(x, cos(x), 'r-')
plot(x, -sin(x), 'g--')
show()

La ligne de code ci-dessus génère la sortie suivante -

Bien qu'il soit facile de générer rapidement des graphiques avec matplotlib.pyplotmodule, l'utilisation d'une approche orientée objet est recommandée car elle donne plus de contrôle et de personnalisation de vos tracés. La plupart des fonctions sont également disponibles dansmatplotlib.axes.Axes classe.

L'idée principale derrière l'utilisation de la méthode orientée objet plus formelle est de créer des objets figure, puis d'appeler simplement des méthodes ou des attributs hors de cet objet. Cette approche permet de mieux gérer un canevas contenant plusieurs tracés.

Dans l'interface orientée objet, Pyplot n'est utilisé que pour quelques fonctions telles que la création de figures, et l'utilisateur crée et garde explicitement la trace des objets figure et axes. À ce niveau, l'utilisateur utilise Pyplot pour créer des figures, et à travers ces figures, un ou plusieurs objets axes peuvent être créés. Ces objets axes sont ensuite utilisés pour la plupart des actions de traçage.

Pour commencer, nous créons une instance de figure qui fournit un canevas vide.

fig = plt.figure()

Ajoutez maintenant des axes à la figure. leadd_axes()La méthode nécessite un objet liste de 4 éléments correspondant à gauche, bas, largeur et hauteur de la figure. Chaque nombre doit être compris entre 0 et 1 -

ax=fig.add_axes([0,0,1,1])

Définir des étiquettes pour les axes x et y ainsi que le titre -

ax.set_title("sine wave")
ax.set_xlabel('angle')
ax.set_ylabel('sine')

Appelez la méthode plot () de l'objet axes.

ax.plot(x,y)

Si vous utilisez le notebook Jupyter, la directive en ligne% matplotlib doit être émise; la fonction otherwistshow () du module pyplot affiche le tracé.

Pensez à exécuter le code suivant -

from matplotlib import pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.plot(x,y)
ax.set_title("sine wave")
ax.set_xlabel('angle')
ax.set_ylabel('sine')
plt.show()

Production

La ligne de code ci-dessus génère la sortie suivante -

Le même code lorsqu'il est exécuté dans le notebook Jupyter montre la sortie comme indiqué ci-dessous -

le matplotlib.figuremodule contient la classe Figure. Il s'agit d'un conteneur de niveau supérieur pour tous les éléments de tracé. L'objet Figure est instancié en appelant lefigure() fonction du module pyplot -

fig = plt.figure()

Le tableau suivant montre les paramètres supplémentaires -

Figsize	(largeur, hauteur) tuple en pouces
Dpi	Points par pouces
Couleur du visage	Figure patch couleur faciale
Edgecolor	Couleur du bord du patch de la figure
Largeur de ligne	Largeur de ligne de bord

L'objet Axes est la région de l'image avec l'espace de données. Une figure donnée peut contenir plusieurs axes, mais un objet Axes donné ne peut être que dans une seule figure. Les axes contiennent deux (ou trois dans le cas de 3D) objets Axis. La classe Axes et ses fonctions membres sont le principal point d'entrée pour travailler avec l'interface OO.

L'objet Axes est ajouté à la figure en appelant la méthode add_axes (). Il renvoie l'objet axes et ajoute un axe à la position rect [gauche, bas, largeur, hauteur] où toutes les quantités sont en fractions de largeur et de hauteur de la figure.

Paramètre

Voici le paramètre de la classe Axes -

rect - Une séquence de 4 longueurs de quantités [gauche, bas, largeur, hauteur].

ax=fig.add_axes([0,0,1,1])

Les fonctions membres suivantes de la classe axes ajoutent différents éléments au tracé -

Légende

le legend()La méthode de classe des axes ajoute une légende à la figure du tracé. Il faut trois paramètres -

ax.legend(handles, labels, loc)

Où labels est une séquence de chaînes et gère une séquence d'instances Line2D ou Patch. loc peut être une chaîne ou un entier spécifiant l'emplacement de la légende.

Chaîne de localisation	Le code d'emplacement
Meilleur	0
En haut à droite	1
en haut à gauche	2
en bas à gauche	3
en bas à droite	4
Droite	5
Centre gauche	6
Centre droit	sept
centre inférieur	8
centre supérieur	9
Centre	dix

axes.plot ()

Il s'agit de la méthode de base de la classe d'axes qui trace les valeurs d'un tableau par rapport à un autre sous forme de lignes ou de marqueurs. La méthode plot () peut avoir un argument de chaîne de format facultatif pour spécifier la couleur, le style et la taille de la ligne et du marqueur.

Codes couleurs

Personnage	Couleur
«b»	Bleu
'g'	vert
«r»	rouge
«b»	Bleu
«c»	Cyan
«m»	Magenta
«y»	Jaune
«k»	Noir
«b»	Bleu
«w»	blanc

Codes marqueurs

Personnage	La description
'.'	Marqueur de point
«o»	Marqueur de cercle
'X'	Marqueur X
'RÉ'	Marqueur diamant
«H»	Marqueur hexagonal
's'	Marqueur carré
'+'	Marqueur Plus

Styles de ligne

Personnage	La description
'-'	Ligne continue
'-'	Ligne pointillée
'-.'	Ligne pointillée
':'	Ligne pointillée
«H»	Marqueur hexagonal

L'exemple suivant montre les dépenses publicitaires et les chiffres de vente de la télévision et du smartphone sous la forme de tracés linéaires. La ligne représentant la télévision est une ligne continue avec des marqueurs de couleur jaune et carrés, tandis que la ligne de smartphone est une ligne en pointillé avec une couleur verte et un marqueur de cercle.

import matplotlib.pyplot as plt
y = [1, 4, 9, 16, 25,36,49, 64]
x1 = [1, 16, 30, 42,55, 68, 77,88]
x2 = [1,6,12,18,28, 40, 52, 65]
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
l1 = ax.plot(x1,y,'ys-') # solid line with yellow colour and square marker
l2 = ax.plot(x2,y,'go--') # dash line with green colour and circle marker
ax.legend(labels = ('tv', 'Smartphone'), loc = 'lower right') # legend placed at lower right
ax.set_title("Advertisement effect on sales")
ax.set_xlabel('medium')
ax.set_ylabel('sales')
plt.show()

Lorsque la ligne de code ci-dessus est exécutée, elle produit le tracé suivant -

Dans ce chapitre, nous allons apprendre à créer plusieurs sous-graphiques sur le même canevas.

le subplot()La fonction renvoie l'objet axes à une position de grille donnée. La signature d'appel de cette fonction est -

plt.subplot(subplot(nrows, ncols, index)

Dans la figure courante, la fonction crée et renvoie un objet Axes, à l'index de position d'une grille de nrows par ncolsaxes. Les index vont de 1 à nrows * ncols, incrémentés dans l'ordre des lignes principales. Les nrows, ncols et index sont tous inférieurs à 10. Les index peuvent également être donnés sous la forme d'un seul, concaténé, à trois chiffres.

Par exemple, sous-tracé (2, 3, 3) et sous-tracé (233) créent tous deux des axes dans le coin supérieur droit de la figure actuelle, occupant la moitié de la hauteur de la figure et un tiers de la largeur de la figure.

La création d'un sous-tracé supprimera tout sous-tracé préexistant qui le chevauche au-delà du partage d'une limite.

import matplotlib.pyplot as plt
# plot a line, implicitly creating a subplot(111)
plt.plot([1,2,3])
# now create a subplot which represents the top plot of a grid with 2 rows and 1 column.
#Since this subplot will overlap the first, the plot (and its axes) previously 
created, will be removed
plt.subplot(211)
plt.plot(range(12))
plt.subplot(212, facecolor='y') # creates 2nd subplot with yellow background
plt.plot(range(12))

La ligne de code ci-dessus génère la sortie suivante -

La fonction add_subplot () de la classe figure n'écrasera pas le tracé existant -

import matplotlib.pyplot as plt
fig = plt.figure()
ax1 = fig.add_subplot(111)
ax1.plot([1,2,3])
ax2 = fig.add_subplot(221, facecolor='y')
ax2.plot([1,2,3])

Lorsque la ligne de code ci-dessus est exécutée, elle génère la sortie suivante -

Vous pouvez ajouter un tracé d'insertion dans la même figure en ajoutant un autre objet axes dans le même canevas de figure.

import matplotlib.pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
fig=plt.figure()
axes1 = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # main axes
axes2 = fig.add_axes([0.55, 0.55, 0.3, 0.3]) # inset axes
y = np.sin(x)
axes1.plot(x, y, 'b')
axes2.plot(x,np.cos(x),'r')
axes1.set_title('sine')
axes2.set_title("cosine")
plt.show()

Lors de l'exécution de la ligne de code ci-dessus, la sortie suivante est générée -

L'API pyplot de Matplotlib a une fonction pratique appelée subplots () qui agit comme un wrapper utilitaire et aide à créer des mises en page communes de sous-graphiques, y compris l'objet de figure englobant, en un seul appel.

Plt.subplots(nrows, ncols)

Les deux arguments entiers de cette fonction spécifient le nombre de lignes et de colonnes de la grille de sous-tracé. La fonction renvoie un objet figure et un tuple contenant des objets axes égaux à nrows * ncols. Chaque objet axes est accessible par son index. Ici, nous créons un sous-graphique de 2 lignes par 2 colonnes et affichons 4 graphiques différents dans chaque sous-graphique.

import matplotlib.pyplot as plt
fig,a =  plt.subplots(2,2)
import numpy as np
x = np.arange(1,5)
a[0][0].plot(x,x*x)
a[0][0].set_title('square')
a[0][1].plot(x,np.sqrt(x))
a[0][1].set_title('square root')
a[1][0].plot(x,np.exp(x))
a[1][0].set_title('exp')
a[1][1].plot(x,np.log10(x))
a[1][1].set_title('log')
plt.show()

La ligne de code ci-dessus génère la sortie suivante -

Cette fonction donne plus de flexibilité dans la création d'un objet axes à un emplacement spécifique de la grille. Il permet également à l'objet axes d'être étalé sur plusieurs lignes ou colonnes.

Plt.subplot2grid(shape, location, rowspan, colspan)

Dans l'exemple suivant, une grille 3X3 de l'objet figure est remplie d'objets axes de différentes tailles dans des étendues de ligne et de colonne, chacun affichant un tracé différent.

import matplotlib.pyplot as plt
a1 = plt.subplot2grid((3,3),(0,0),colspan = 2)
a2 = plt.subplot2grid((3,3),(0,2), rowspan = 3)
a3 = plt.subplot2grid((3,3),(1,0),rowspan = 2, colspan = 2)
import numpy as np
x = np.arange(1,10)
a2.plot(x, x*x)
a2.set_title('square')
a1.plot(x, np.exp(x))
a1.set_title('exp')
a3.plot(x, np.log(x))
a3.set_title('log')
plt.tight_layout()
plt.show()

Lors de l'exécution du code de ligne ci-dessus, la sortie suivante est générée -

La fonction grid () de l'objet axes active ou désactive la visibilité de la grille à l'intérieur de la figure. Vous pouvez également afficher les graduations majeures / mineures (ou les deux) de la grille. De plus, les propriétés de couleur, de style de ligne et de largeur de ligne peuvent être définies dans la fonction grid ().

import matplotlib.pyplot as plt
import numpy as np
fig, axes = plt.subplots(1,3, figsize = (12,4))
x = np.arange(1,11)
axes[0].plot(x, x**3, 'g',lw=2)
axes[0].grid(True)
axes[0].set_title('default grid')
axes[1].plot(x, np.exp(x), 'r')
axes[1].grid(color='b', ls = '-.', lw = 0.25)
axes[1].set_title('custom grid')
axes[2].plot(x,x)
axes[2].set_title('no grid')
fig.tight_layout()
plt.show()

Parfois, un ou quelques points sont beaucoup plus grands que la masse des données. Dans un tel cas, l'échelle d'un axe doit être définie comme logarithmique plutôt que sur l'échelle normale. C'est l'échelle logarithmique. Dans Matplotlib, c'est possible en définissant la propriété xscale ou vscale de l'objet axes sur 'log'.

Il est également parfois nécessaire d'afficher une distance supplémentaire entre les numéros d'axe et l'étiquette d'axe. La propriété labelpad de l'un des axes (x ou y ou les deux) peut être définie sur la valeur souhaitée.

Les deux fonctionnalités ci-dessus sont illustrées à l'aide de l'exemple suivant. La sous-parcelle de droite a une échelle logarithmique et celle de gauche a son axe x avec une étiquette à plus de distance.

import matplotlib.pyplot as plt
import numpy as np
fig, axes = plt.subplots(1, 2, figsize=(10,4))
x = np.arange(1,5)
axes[0].plot( x, np.exp(x))
axes[0].plot(x,x**2)
axes[0].set_title("Normal scale")
axes[1].plot (x, np.exp(x))
axes[1].plot(x, x**2)
axes[1].set_yscale("log")
axes[1].set_title("Logarithmic scale (y)")
axes[0].set_xlabel("x axis")
axes[0].set_ylabel("y axis")
axes[0].xaxis.labelpad = 10
axes[1].set_xlabel("x axis")
axes[1].set_ylabel("y axis")
plt.show()

Les épines des axes sont les lignes reliant les graduations des axes délimitant les limites de la zone de tracé. L'objet axes a des épines situées en haut, en bas, à gauche et à droite.

Chaque dos peut être formaté en spécifiant sa couleur et sa largeur. Toute arête peut être rendue invisible si sa couleur est définie sur aucune.

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.spines['bottom'].set_color('blue')
ax.spines['left'].set_color('red')
ax.spines['left'].set_linewidth(2)
ax.spines['right'].set_color(None)
ax.spines['top'].set_color(None)
ax.plot([1,2,3,4,5])
plt.show()

Matplotlib arrive automatiquement aux valeurs minimales et maximales des variables à afficher le long des axes x, y (et z en cas de tracé 3D) d'un tracé. Cependant, il est possible de définir les limites explicitement en utilisantset_xlim() et set_ylim() les fonctions.

Dans le graphique suivant, les limites de mise à l'échelle automatique des axes x et y sont affichées -

import matplotlib.pyplot as plt
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
import numpy as np
x = np.arange(1,10)
a1.plot(x, np.exp(x))
a1.set_title('exp')
plt.show()

Maintenant, nous formalisons les limites sur l'axe x en (0 à 10) et l'axe y (0 à 10000) -

import matplotlib.pyplot as plt
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
import numpy as np
x = np.arange(1,10)
a1.plot(x, np.exp(x),'r')
a1.set_title('exp')
a1.set_ylim(0,10000)
a1.set_xlim(0,10)
plt.show()

Les graduations sont les marqueurs indiquant les points de données sur les axes. Matplotlib a jusqu'à présent - dans tous nos exemples précédents - repris automatiquement la tâche d'espacement des points sur l'axe. Les localisateurs de graduations et les formateurs par défaut de Matplotlib sont conçus pour être généralement suffisants dans de nombreuses situations courantes. La position et les étiquettes des tiques peuvent être explicitement mentionnées pour répondre à des exigences spécifiques.

le xticks() et yticks()function prend un objet de liste comme argument. Les éléments de la liste indiquent les positions sur l'action correspondante où les graduations seront affichées.

ax.set_xticks([2,4,6,8,10])

Cette méthode marquera les points de données aux positions données avec des graduations.

De même, les étiquettes correspondant aux graduations peuvent être définies par set_xlabels() et set_ylabels() fonctions respectivement.

ax.set_xlabels([‘two’, ‘four’,’six’, ‘eight’, ‘ten’])

Cela affichera les étiquettes de texte sous les marqueurs sur l'axe x.

L'exemple suivant montre l'utilisation de graduations et d'étiquettes.

import matplotlib.pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
fig = plt.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # main axes
y = np.sin(x)
ax.plot(x, y)
ax.set_xlabel(‘angle’)
ax.set_title('sine')
ax.set_xticks([0,2,4,6])
ax.set_xticklabels(['zero','two','four','six'])
ax.set_yticks([-1,0,1])
plt.show()

Il est jugé utile d'avoir deux axes x ou y dans une figure. Moreso, lors du traçage de courbes avec différentes unités ensemble. Matplotlib prend en charge cela avec les fonctions twinx et twiny.

Dans l'exemple suivant, le graphique a deux axes y, l'un montrant exp (x) et l'autre affichant le log (x) -

import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
x = np.arange(1,11)
a1.plot(x,np.exp(x))
a1.set_ylabel('exp')
a2 = a1.twinx()
a2.plot(x, np.log(x),'ro-')
a2.set_ylabel('log')
fig.legend(labels = ('exp','log'),loc='upper left')
plt.show()

Un graphique à barres ou un graphique à barres est un graphique ou un graphique qui présente des données catégoriques avec des barres rectangulaires avec des hauteurs ou des longueurs proportionnelles aux valeurs qu'elles représentent. Les barres peuvent être tracées verticalement ou horizontalement.

Un graphique à barres montre des comparaisons entre des catégories discrètes. Un axe du graphique montre les catégories spécifiques comparées et l'autre axe représente une valeur mesurée.

L'API Matplotlib fournit le bar()fonction qui peut être utilisée dans l'utilisation du style MATLAB ainsi que dans l'API orientée objet. La signature de la fonction bar () à utiliser avec l'objet axes est la suivante -

ax.bar(x, height, width, bottom, align)

La fonction crée un graphique à barres avec le rectangle lié de taille (x −width = 2; x + width = 2; bottom; bottom + height).

Les paramètres de la fonction sont -

X	séquence de scalaires représentant les coordonnées x des barres. align des contrôles si x est le centre de la barre (par défaut) ou le bord gauche.
la taille	scalaire ou séquence de scalaires représentant la (les) hauteur (s) des barres.
largeur	scalaire ou de type tableau, facultatif. la (les) largeur (s) des barres par défaut 0.8
bas	scalaire ou de type tableau, facultatif. la (les) coordonnée (s) y des barres par défaut Aucune.
aligner	{'center', 'edge'}, facultatif, par défaut 'center'

La fonction renvoie un objet conteneur Matplotlib avec toutes les barres.

Voici un exemple simple du diagramme à barres Matplotlib. Il montre le nombre d'étudiants inscrits à divers cours offerts dans un institut.

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
langs = ['C', 'C++', 'Java', 'Python', 'PHP']
students = [23,17,35,29,12]
ax.bar(langs,students)
plt.show()

Lors de la comparaison de plusieurs quantités et lors du changement d'une variable, nous pourrions vouloir un diagramme à barres où nous avons des barres d'une couleur pour une valeur de quantité.

On peut tracer plusieurs histogrammes en jouant avec l'épaisseur et les positions des barres. La variable de données contient trois séries de quatre valeurs. Le script suivant affichera trois graphiques à barres de quatre barres. Les barres auront une épaisseur de 0,25 unités. Chaque graphique à barres sera décalé de 0,25 unité par rapport au précédent. L'objet de données est un multidict contenant le nombre d'étudiants passés dans trois branches d'une école d'ingénieurs au cours des quatre dernières années.

import numpy as np
import matplotlib.pyplot as plt
data = [[30, 25, 50, 20],
[40, 23, 51, 17],
[35, 22, 45, 19]]
X = np.arange(4)
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.bar(X + 0.00, data[0], color = 'b', width = 0.25)
ax.bar(X + 0.25, data[1], color = 'g', width = 0.25)
ax.bar(X + 0.50, data[2], color = 'r', width = 0.25)

Le graphique à barres empilées empile des barres qui représentent différents groupes les uns sur les autres. La hauteur de la barre résultante montre le résultat combiné des groupes.

Le paramètre inférieur facultatif du pyplot.bar()La fonction vous permet de spécifier une valeur de départ pour une barre. Au lieu de passer de zéro à une valeur, il ira du bas vers la valeur. Le premier appel à pyplot.bar () trace les barres bleues. Le deuxième appel à pyplot.bar () trace les barres rouges, avec le bas des barres bleues en haut des barres rouges.

import numpy as np
import matplotlib.pyplot as plt
N = 5
menMeans = (20, 35, 30, 35, 27)
womenMeans = (25, 32, 34, 20, 25)
ind = np.arange(N) # the x locations for the groups
width = 0.35
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.bar(ind, menMeans, width, color='r')
ax.bar(ind, womenMeans, width,bottom=menMeans, color='b')
ax.set_ylabel('Scores')
ax.set_title('Scores by group and gender')
ax.set_xticks(ind, ('G1', 'G2', 'G3', 'G4', 'G5'))
ax.set_yticks(np.arange(0, 81, 10))
ax.legend(labels=['Men', 'Women'])
plt.show()

Un histogramme est une représentation précise de la distribution des données numériques. Il s'agit d'une estimation de la distribution de probabilité d'une variable continue. C'est une sorte de graphique à barres.

Pour créer un histogramme, procédez comme suit:

Bin la plage de valeurs.
Divisez toute la plage de valeurs en une série d'intervalles.
Comptez le nombre de valeurs comprises dans chaque intervalle.

Les classes sont généralement spécifiées comme des intervalles consécutifs et sans chevauchement d'une variable.

le matplotlib.pyplot.hist()function trace un histogramme. Il calcule et dessine l'histogramme de x.

Paramètres

Le tableau suivant répertorie les paramètres d'un histogramme -

X	tableau ou séquence de tableaux
bacs	entier ou séquence ou 'auto', facultatif
paramètres facultatifs
intervalle	La plage inférieure et supérieure des bacs.
densité	Si True, le premier élément du tuple de retour sera les décomptes normalisés pour former une densité de probabilité
cumulatif	Si True, alors un histogramme est calculé où chaque casier donne les nombres dans ce casier plus tous les casiers pour des valeurs plus petites.
histtype	Le type d'histogramme à dessiner. La valeur par défaut est «bar» «bar» est un histogramme de type barre traditionnel. Si plusieurs données sont fournies, les barres sont disposées côte à côte. «barstacked» est un histogramme de type barre où plusieurs données sont empilées les unes sur les autres. 'step' génère un tracé linéaire par défaut non rempli. 'stepfilled' génère un tracé linéaire qui est rempli par défaut.

L'exemple suivant trace un histogramme des notes obtenues par les élèves d'une classe. Quatre bacs, 0-25, 26-50, 51-75 et 76-100 sont définis. L'histogramme montre le nombre d'élèves appartenant à cette plage.

from matplotlib import pyplot as plt
import numpy as np
fig,ax = plt.subplots(1,1)
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
ax.hist(a, bins = [0,25,50,75,100])
ax.set_title("histogram of result")
ax.set_xticks([0,25,50,75,100])
ax.set_xlabel('marks')
ax.set_ylabel('no. of students')
plt.show()

Le tracé apparaît comme indiqué ci-dessous -

Un graphique à secteurs ne peut afficher qu'une seule série de données. Les graphiques à secteurs montrent la taille des éléments (appelée coin) dans une série de données, proportionnelle à la somme des éléments. Les points de données dans un graphique à secteurs sont affichés sous forme de pourcentage de l'ensemble du secteur.

L'API Matplotlib a un pie()fonction qui génère un diagramme à secteurs représentant des données dans un tableau. La surface fractionnaire de chaque coin est donnée parx/sum(x). Si sum (x) <1, alors les valeurs de x donnent directement l'aire fractionnaire et le tableau ne sera pas normalisé. La tarte résultante aura un coin vide de taille 1 - somme (x).

Le graphique à secteurs est optimal si la figure et les axes sont carrés ou si l'aspect Axes est égal.

Paramètres

Le tableau suivant répertorie les paramètres d'un graphique à secteurs -

X	comme un tableau. Les tailles de coin.
Étiquettes	liste. Une séquence de chaînes fournissant les étiquettes pour chaque coin.
Couleurs	Une séquence de matplotlibcolorargs à travers laquelle le graphique circulaire passera. Si aucun, utilisera les couleurs du cycle actuellement actif.
Autopct	chaîne, utilisée pour étiqueter les coins avec leur valeur numérique. L'étiquette sera placée à l'intérieur du coin. La chaîne de format sera fmt% pct.

Le code suivant utilise la fonction pie () pour afficher le diagramme circulaire de la liste des étudiants inscrits à divers cours de langage informatique. Le pourcentage proportionnel est affiché à l'intérieur du coin respectif à l'aide deautopct paramètre défini sur% 1,2f%.

from matplotlib import pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.axis('equal')
langs = ['C', 'C++', 'Java', 'Python', 'PHP']
students = [23,17,35,29,12]
ax.pie(students, labels = langs,autopct='%1.2f%%')
plt.show()

Les nuages de points sont utilisés pour tracer des points de données sur les axes horizontal et vertical afin de montrer à quel point une variable est affectée par une autre. Chaque ligne de la table de données est représentée par un marqueur dont la position dépend de ses valeurs dans les colonnes définies sur les axes X et Y. Une troisième variable peut être définie pour correspondre à la couleur ou à la taille des marqueurs, ajoutant ainsi une autre dimension au tracé.

Le script ci-dessous trace un diagramme de dispersion de la fourchette de notes par rapport aux grades des garçons et des filles dans deux couleurs différentes.

import matplotlib.pyplot as plt
girls_grades = [89, 90, 70, 89, 100, 80, 90, 100, 80, 34]
boys_grades = [30, 29, 49, 48, 100, 48, 38, 45, 20, 30]
grades_range = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
fig=plt.figure()
ax=fig.add_axes([0,0,1,1])
ax.scatter(grades_range, girls_grades, color='r')
ax.scatter(grades_range, boys_grades, color='b')
ax.set_xlabel('Grades Range')
ax.set_ylabel('Grades Scored')
ax.set_title('scatter plot')
plt.show()

Les tracés de contour (parfois appelés tracés de niveau) sont un moyen de montrer une surface tridimensionnelle sur un plan bidimensionnel. Il trace graphiquement deux variables prédictives XY sur l'axe des y et une variable de réponse Z sous forme de contours. Ces contours sont parfois appelés les z-slices ou les valeurs d'iso-réponse.

Un tracé de contour est approprié si vous voulez voir comment la aleur Z change en fonction de deux entrées X et Y, telles que Z = f (X, Y). Une ligne de contour ou isoligne d'une fonction de deux variables est une courbe le long de laquelle la fonction a une valeur constante.

Les variables indépendantes x et y sont généralement limitées à une grille régulière appelée meshgrid. Le numpy.meshgrid crée une grille rectangulaire à partir d'un tableau de valeurs x et d'un tableau de valeurs y.

L'API Matplotlib contient des fonctions contour () et contourf () qui dessinent respectivement des lignes de contour et des contours remplis. Les deux fonctions nécessitent trois paramètres x, y et z.

import numpy as np
import matplotlib.pyplot as plt
xlist = np.linspace(-3.0, 3.0, 100)
ylist = np.linspace(-3.0, 3.0, 100)
X, Y = np.meshgrid(xlist, ylist)
Z = np.sqrt(X**2 + Y**2)
fig,ax=plt.subplots(1,1)
cp = ax.contourf(X, Y, Z)
fig.colorbar(cp) # Add a colorbar to a plot
ax.set_title('Filled Contours Plot')
#ax.set_xlabel('x (cm)')
ax.set_ylabel('y (cm)')
plt.show()

Un tracé de carquois affiche les vecteurs de vitesse sous forme de flèches avec des composantes (u, v) aux points (x, y).

quiver(x,y,u,v)

La commande ci-dessus trace les vecteurs sous forme de flèches aux coordonnées spécifiées dans chaque paire d'éléments correspondants en x et y.

Paramètres

Le tableau suivant répertorie les différents paramètres du tracé Quiver -

X	Tableau 1D ou 2D, séquence. Les coordonnées x des emplacements des flèches
y	Tableau 1D ou 2D, séquence. Les coordonnées y des emplacements des flèches
u	Tableau 1D ou 2D, séquence. Les composantes x des vecteurs flèches
v	Tableau 1D ou 2D, séquence. Les composantes y des vecteurs flèches
c	Tableau 1D ou 2D, séquence. Les couleurs de la flèche

Le code suivant dessine un tracé de carquois simple -

import matplotlib.pyplot as plt
import numpy as np
x,y = np.meshgrid(np.arange(-2, 2, .2), np.arange(-2, 2, .25))
z = x*np.exp(-x**2 - y**2)
v, u = np.gradient(z, .2, .2)
fig, ax = plt.subplots()
q = ax.quiver(x,y,u,v)
plt.show()

Une boîte à moustaches, également connue sous le nom de graphique à moustaches, affiche un résumé d'un ensemble de données contenant le minimum, le premier quartile, la médiane, le troisième quartile et le maximum. Dans une boîte à moustaches, nous dessinons une boîte du premier quartile au troisième quartile. Une ligne verticale traverse la case à la médiane. Les moustaches vont de chaque quartile au minimum ou au maximum.

Créons les données pour les boxplots. Nous utilisons lenumpy.random.normal()fonction pour créer les fausses données. Il prend trois arguments, la moyenne et l'écart type de la distribution normale et le nombre de valeurs souhaitées.

np.random.seed(10)
collectn_1 = np.random.normal(100, 10, 200)
collectn_2 = np.random.normal(80, 30, 200)
collectn_3 = np.random.normal(90, 20, 200)
collectn_4 = np.random.normal(70, 25, 200)

La liste des tableaux que nous avons créés ci-dessus est la seule entrée requise pour créer le boxplot. En utilisant ledata_to_plot ligne de code, nous pouvons créer le boxplot avec le code suivant -

fig = plt.figure()
# Create an axes instance
ax = fig.add_axes([0,0,1,1])
# Create the boxplot
bp = ax.boxplot(data_to_plot)
plt.show()

La ligne de code ci-dessus générera la sortie suivante -

Les graphiques violon sont similaires aux boîtes à moustaches, sauf qu'ils montrent également la densité de probabilité des données à des valeurs différentes. Ces graphiques comprennent un marqueur pour la médiane des données et une boîte indiquant l'intervalle interquartile, comme dans les boîtes à moustaches standard. Une estimation de la densité du noyau est superposée à cette boîte à moustaches. Comme les boîtes à moustaches, les graphiques en violon sont utilisés pour représenter la comparaison d'une distribution variable (ou distribution d'échantillons) entre différentes «catégories».

Une intrigue de violon est plus informative qu'une simple boîte à moustaches. En fait, alors qu'une boîte à moustaches ne montre que des statistiques récapitulatives telles que les plages moyenne / médiane et interquartile, la courbe violon montre la distribution complète des données.

import matplotlib.pyplot as plt

np.random.seed(10)
collectn_1 = np.random.normal(100, 10, 200)
collectn_2 = np.random.normal(80, 30, 200)
collectn_3 = np.random.normal(90, 20, 200)
collectn_4 = np.random.normal(70, 25, 200)

## combine these different collections into a list
data_to_plot = [collectn_1, collectn_2, collectn_3, collectn_4]

# Create a figure instance
fig = plt.figure()

# Create an axes instance
ax = fig.add_axes([0,0,1,1])

# Create the boxplot
bp = ax.violinplot(data_to_plot)
plt.show()

Même si Matplotlib a été initialement conçu avec uniquement le traçage bidimensionnel à l'esprit, certains utilitaires de traçage tridimensionnel ont été construits au-dessus de l'affichage bidimensionnel de Matplotlib dans les versions ultérieures, pour fournir un ensemble d'outils pour la visualisation de données en trois dimensions. Les tracés tridimensionnels sont activés en important lemplot3d toolkit, inclus avec le package Matplotlib.

Un axe tridimensionnel peut être créé en passant le mot-clé projection = '3d' à l'une des routines de création d'axes normaux.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.axes(projection='3d')
z = np.linspace(0, 1, 100)
x = z * np.sin(20 * z)
y = z * np.cos(20 * z)
ax.plot3D(x, y, z, 'gray')
ax.set_title('3D line plot')
plt.show()

Nous pouvons maintenant tracer une variété de types de tracés en trois dimensions. Le tracé tridimensionnel le plus élémentaire est un3D line plotcréé à partir d'ensembles de triplets (x, y, z). Cela peut être créé à l'aide de la fonction ax.plot3D.

3D scatter plot est généré en utilisant le ax.scatter3D fonction.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.axes(projection='3d')
z = np.linspace(0, 1, 100)
x = z * np.sin(20 * z)
y = z * np.cos(20 * z)
c = x + y
ax.scatter(x, y, z, c=c)
ax.set_title('3d Scatter plot')
plt.show()

le ax.contour3D()La fonction crée un tracé de contour en trois dimensions. Il nécessite que toutes les données d'entrée soient sous la forme de grilles régulières bidimensionnelles, les données Z étant évaluées à chaque point. Ici, nous allons montrer un diagramme de contour tridimensionnel d'une fonction sinusoïdale tridimensionnelle.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
def f(x, y):
   return np.sin(np.sqrt(x ** 2 + y ** 2))
	
x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)

X, Y = np.meshgrid(x, y)
Z = f(X, Y)

fig = plt.figure()
ax = plt.axes(projection='3d')
ax.contour3D(X, Y, Z, 50, cmap='binary')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
ax.set_title('3D contour')
plt.show()

Le tracé filaire prend une grille de valeurs et la projette sur la surface tridimensionnelle spécifiée, et peut rendre les formes tridimensionnelles résultantes assez faciles à visualiser. leplot_wireframe() la fonction est utilisée à cette fin -

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
def f(x, y):
   return np.sin(np.sqrt(x ** 2 + y ** 2))
	
x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)

X, Y = np.meshgrid(x, y)
Z = f(X, Y)

fig = plt.figure()
ax = plt.axes(projection='3d')
ax.plot_wireframe(X, Y, Z, color='black')
ax.set_title('wireframe')
plt.show()

La ligne de code ci-dessus générera la sortie suivante -

Le graphique de surface montre une relation fonctionnelle entre une variable dépendante désignée (Y) et deux variables indépendantes (X et Z). Le tracé est un tracé associé au tracé de contour. Un tracé de surface ressemble à un tracé filaire, mais chaque face du filaire est un polygone rempli. Cela peut faciliter la perception de la topologie de la surface visualisée. leplot_surface() fonction x, y et z comme arguments.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
x = np.outer(np.linspace(-2, 2, 30), np.ones(30))
y = x.copy().T # transpose
z = np.cos(x ** 2 + y ** 2)

fig = plt.figure()
ax = plt.axes(projection='3d')

ax.plot_surface(x, y, z,cmap='viridis', edgecolor='none')
ax.set_title('Surface plot')
plt.show()

La ligne de code ci-dessus générera la sortie suivante -

Matplotlib a une prise en charge étendue du texte, y compris la prise en charge des expressions mathématiques, TrueTypeprise en charge des sorties raster et vectorielles, du texte séparé par une nouvelle ligne avec des rotations arbitraires et prise en charge d'unicode. Matplotlib inclut son propre matplotlib.font_manager qui implémente un algorithme de recherche de polices multi-plateforme compatible W3C.

L'utilisateur a beaucoup de contrôle sur les propriétés du texte (taille de la police, poids de la police, emplacement et couleur du texte, etc.). Matplotlib implémente un grand nombre de symboles et de commandes mathématiques TeX.

La liste de commandes suivante est utilisée pour créer du texte dans l'interface Pyplot -

texte	Ajoutez du texte à un emplacement arbitraire des axes.
annoter	Ajoutez une annotation, avec une flèche facultative, à un emplacement arbitraire des axes.
xlabel	Ajoutez une étiquette à l'axe des x des axes.
ylabel	Ajoutez une étiquette à l'axe y des axes.
Titre	Ajoutez un titre aux axes.
figtext	Ajoutez du texte à un emplacement arbitraire de la figure.
sous-titre	Ajoutez un titre à la figure.

Toutes ces fonctions créent et renvoient un matplotlib.text.Text() exemple.

Les scripts suivants démontrent l'utilisation de certaines des fonctions ci-dessus -

import matplotlib.pyplot as plt
fig = plt.figure()

ax = fig.add_axes([0,0,1,1])

ax.set_title('axes title')
ax.set_xlabel('xlabel')
ax.set_ylabel('ylabel')
ax.text(3, 8, 'boxed italics text in data coords', style='italic', 
bbox = {'facecolor': 'red'})
ax.text(2, 6, r'an equation: $E = mc^2$', fontsize = 15)
ax.text(4, 0.05, 'colored text in axes coords',
verticalalignment = 'bottom', color = 'green', fontsize = 15)
ax.plot([2], [1], 'o')
ax.annotate('annotate', xy = (2, 1), xytext = (3, 4),
arrowprops = dict(facecolor = 'black', shrink = 0.05))
ax.axis([0, 10, 0, 10])
plt.show()

La ligne de code ci-dessus générera la sortie suivante -

Vous pouvez utiliser un sous-ensemble TeXmarkup dans n'importe quelle chaîne de texte Matplotlib en le plaçant dans une paire de signes dollar ($).

# math text
plt.title(r'$\alpha > \beta$')

Pour créer des indices et des exposants, utilisez les symboles «_» et «^» -

r'$\alpha_i> \beta_i$'

import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0.0, 2.0, 0.01)
s = np.sin(2*np.pi*t)

plt.plot(t,s)
plt.title(r'$\alpha_i> \beta_i$', fontsize=20)

plt.text(0.6, 0.6, r'$\mathcal{A}\mathrm{sin}(2 \omega t)$', fontsize = 20)
plt.text(0.1, -0.5, r'$\sqrt{2}$', fontsize=10)
plt.xlabel('time (s)')
plt.ylabel('volts (mV)')
plt.show()

La ligne de code ci-dessus générera la sortie suivante -

Le module image du package Matplotlib fournit les fonctionnalités requises pour le chargement, le redimensionnement et l'affichage de l'image.

Le chargement des données d'image est pris en charge par la bibliothèque Pillow. Nativement, Matplotlib ne prend en charge que les images PNG. Les commandes ci-dessous retombent sur Pillow si la lecture native échoue.

L'image utilisée dans cet exemple est un fichier PNG, mais gardez à l'esprit cette exigence Pillow pour vos propres données. leimread() La fonction est utilisée pour lire les données d'image dans un ndarray objet de float32 dtype.

import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np
img = mpimg.imread('mtplogo.png')

En supposant que l'image suivante nommée comme mtplogo.png est présent dans le répertoire de travail courant.

Tout tableau contenant des données d'image peut être enregistré dans un fichier disque en exécutant le imsave()fonction. Ici, une version inversée verticalement du fichier png d'origine est enregistrée en donnant le paramètre d'origine comme inférieur.

plt.imsave("logo.png", img, cmap = 'gray', origin = 'lower')

La nouvelle image apparaît comme ci-dessous si elle est ouverte dans une visionneuse d'images.

Pour dessiner l'image sur la visionneuse Matplotlib, exécutez le imshow() fonction.

imgplot = plt.imshow(img)

Le package matplotlib est construit sur un cadre de transformation pour se déplacer facilement entre les systèmes de coordonnées. Quatre systèmes de coordonnées peuvent être utilisés. Les systèmes sont décrits brièvement dans le tableau ci-dessous -

Coordonner	Objet de transformation	La description
Les données	ax.transData	Le système de coordonnées des données terrestres de l'utilisateur. contrôlé par xlim et ylim
Haches	ax.transAxes	Le système de coordonnées des axes. (0,0) est en bas à gauche et (1,1) en haut à droite des axes.
Figure	fig.transFigure	Le système de coordonnées de la figure. (0,0) est en bas à gauche et (1,1) en haut à droite de la figure
afficher	Aucun	Il s'agit du système de coordonnées des pixels de l'affichage. (0,0) est le coin inférieur gauche et (largeur, hauteur) est le coin supérieur droit de l'affichage en pixels. Alternativement, (matplotlib.transforms.IdentityTransform ()) peut être utilisé à la place de None.

Prenons l'exemple suivant -

axes.text(x,y,"my label")

Le texte est placé à la position théorique d'un point de données (x, y). On parlerait ainsi de "coordonnées de données".

À l'aide d'autres objets de transformation, le placement peut être contrôlé. Par exemple, si le test ci-dessus doit être placé au centre du système de coordonnées des axes, exécutez la ligne de code suivante -

axes.text(0.5, 0.5, "middle of graph", transform=axes.transAxes)

Ces transformations peuvent être utilisées pour tout type d'objets Matplotlib. La transformation par défaut pourax.text est ax.transData et la transformation par défaut pour fig.text est fig.transFigure.

Le système de coordonnées des axes est extrêmement utile lorsque vous placez du texte dans vos axes. Vous voudrez peut-être souvent une bulle de texte à un emplacement fixe; par exemple, dans le coin supérieur gauche du volet des axes et que cet emplacement reste fixe lorsque vous effectuez un panoramique ou un zoom.