Matplotlib fill_between

Matplotlib est un magnifique package de visualisation Python pour les graphiques de tableau 2D. Matplotlib est un package d'analyse visuelle multiplateforme basé sur des structures de données et destiné à fonctionner avec la plate-forme Scipy dans son ensemble. Pour couvrir l'espace ou l'espace entre deux pentes, utilisez Matplotlib.pypllot.Fonction entre (). Les arcs sont déterminés par deux sommets (x, y1) et (x, y2).

Un ou plusieurs graphiques vectoriels représentant les parties occupées sont formées à cause de cela. L'argument «où» pourrait être utilisé pour couvrir des sections particulières uniquement. Les coins intègrent immédiatement les sommets fournis par défaut. Matplotlib est un package graphique pour le langage Python avec Numpy, et c'est la version améliorée mathématique Python Quantitative.

Dans cet article, nous vous montrerons comment remplir le gradient Matplotlib avec un schéma de couleurs différent en utilisant la technique de remplissage Matplotlib _between ().

Fonction et couleur Matplotlib Fill_between ():

La méthode fill_between () est utilisée pour ombrer l'espace ou la partie entre deux lignes horizontales ou verticales. Les lignes sont spécifiées par certaines coordonnées définies, qui créent une ou plusieurs formes polygonales représentant la région remplie du graphique.

Dans ce scénario, nous explorerons comment insérer des couleurs dans la partie spécifiée de la figure.

Importer Matplotlib.pypllot comme plt
Importer Numpy comme NP
def fill_example ():
PLT.Titre ('Figure')
x_array = np.lispace (0, 20 * np.PI, 200)
print ('x_array:', x_array)
print ('len (x_array):', Len (x_array))
y_array = np.péché (x_array)
print ('y_array:', y_array)
PLT.tracé (x_array, y_array)
PLT.remplir (x_array, y_array, 'g')
PLT.montrer()
Si __Name__ == '__MAIN__':
fill_example ()

Dans cet exemple, nous importerons la bibliothèque Numpy et Matplotlib.bibliothèque pypllot. Ensuite, nous définissons la fonction fill_example (). Nous avons spécifié l'étiquette du tracé en utilisant le PLT.Titre () Méthode. Ici, nous donnons la balise «figure» au tracé. Nous déclarons un ensemble de données pour X_Array.

De plus, nous créons de nombreux éléments, et ces éléments sont stockés dans ce tableau. Nous utilisons la fonction print () pour imprimer le tableau. La fonction Len () est fournie comme un paramètre à la méthode print () sur la ligne suivante. Nous devons définir les valeurs du tableau de l'axe y.

De même, nous appelons également la fonction print () pour y_array. Nous fournissons ces deux tableaux au pli.Fonction de tracé () pour afficher les courbes. Cette fonction contient trois paramètres. Ici, nous avons spécifié la couleur que nous voulions être remplie dans la courbe. Par conséquent, on nous donne une couleur «g» qui représente les courbes vertes.

La fonction plt.fill () est appelé pour obtenir la liste des arguments. Après avoir appelé PLT.show () fonction, le graphique s'affiche.

Nous obtenons le graphique avec la balise 'Figure' au centre en exécutant le code comme mentionné ci-dessus.

Matplotlib fill_between () appliqué sur deux lignes:

Dans cette étape, nous remarquerons comment utiliser Python pour remplir la région d'un graphique avec l'ombre de notre désir à travers Matplotlib. Nous devons fournir un paramètre de couleur à la méthode fill_between () et spécifier la teinte pour accomplir cela. Ici, nous utilisons également le paramètre 'alpha.'

Importer Matplotlib.pypllot comme plt
Importer Numpy comme NP
x = np.Arange (0,20,0.5)
b1 = 5 - 3 * x
b2 = 4 - 0.8 * x
b3 = 0.1 fois
b4 = np.minimum (b1, b2)
PLT.Ylim (0, 4)
PLT.Terrain (x, b1,
x, b2,
x, b3)
PLT.fill_between (x, b2, b4, color = 'rouge',
alpha = 1.0)
PLT.montrer()

Au début du code, nous intégrons Matplotlib.packages pypllot et numpy. Nous déclarons la variable «x» et spécifions différentes valeurs. À cette fin, nous appelons la fonction arrange () de la bibliothèque Numpy.

Nous devons maintenant définir les points pour démontrer les lignes sur le graphique. Nous indiquons le bord supérieur de l'ombrage en appelant le NP.Fonction minimum (). En plus de cela, nous définissons les valeurs de la limite Y. Ceci est également fait par la fonction plt.ylim ().

Maintenant, nous utilisons le PLT. Plot () Fonction pour dessiner les lignes. Il contient différents paramètres. En fin de compte, nous décidons des lignes dans lesquelles nous voulons l'ombrage ou le remplissage. Donc, pour accomplir cela, nous définissons le PLT.Fill_between (), et la couleur que nous voulons être remplie est «rouge» dans ce cas.

Par conséquent, nous avons passé la couleur comme paramètre de cette fonction. Nous avons également spécifié la taille de la partie ombrée en passant l'argument «alpha» à la fonction plt.fill_between (). Pour visualiser la figure que nous utilisons PLT.Show () Fonctionnalité.

Fonction Matplotlib Fill_between () Utilisation d'échelle de journal:

Ici, nous allons apprendre le processus de remplissage de la partie sous la pente par échelle logarithmique. Pour faire une échelle logarithmique, nous devons modifier la mesure des axes pour enregistrer.

Importer Matplotlib.pypllot comme plt
Importer Numpy comme NP
a = np.lispace (-3, 3, 50)
b = np.péché (a)
PLT.Terrain (A, B)
PLT.fill_between (a, b)
PLT.xscale ('log')
PLT.yscale ('log')
PLT.montrer()

La partie la plus importante du code est d'inclure les bibliothèques. Chaque bibliothèque a son objectif. Matplotlib.Pyplot est importé pour des visualisations graphiques et la bibliothèque Numpy est importée pour les mathématiques et travaille avec des ensembles de données. À l'étape suivante, nous définissons les dimensions de données en utilisant la bibliothèque Numpy.

Donc pour cela, nous faisons deux variables distinctes. Le NP.La fonction linspace () est appelée pour déclarer les points de données de l'axe X. Nous utilisons le PLT.Plot () Fonction pour dessiner les ensembles de données de l'axe X et de l'axe Y. Maintenant fill_between () est appelée pour remplir la partie entre les courbures du graphique. De plus, pour développer une échelle logarithmique, nous devons d'abord appliquer le PLT.Fonction Scale ('Log') pour l'ensemble de données de l'axe X. Et puis, nous appliquons la même fonction à l'ensemble de données de l'axe Y.

En exécutant cette étape, nous pouvions définir l'échelle des deux axes. En fin de compte, nous appelons le PLT.show () Fonction pour présenter le graphique.

Conclusion:

Dans cet article, nous avons traversé différentes méthodes avec leurs exemples de remplissage de la région de graphique entre les lignes. Nous utilisons la fonction fill_between () à cet effet. Nous avons examiné comment ombrer la partie du graphique en utilisant une échelle logarithmique. De même, nous voyons comment remplir la partie entre deux lignes en utilisant l'alpha. Et en outre, nous voyons la méthode de spécification de la couleur de la partie ombrée du graphique.