Matplotlib tracer plusieurs lignes

Le module Matplotlib, la bibliothèque la plus utilisée pour l'analyse visuelle, est accessible à Python. Il propose de nombreux graphiques, méthodes et cadres complets pour une analyse efficace des données. Nous pourrions faire des visualisations 2D et 3D des ensembles de données à partir de divers domaines, y compris des ensembles, des tableaux et des valeurs numériques.

Il a un sous-module appelé pyplot et il propose plusieurs formes de graphiques, d'illustrations et de composants associés pour la visualisation des données. Un tracé de ligne est un graphique qui représente la relation entre deux variables indépendantes sur un axe X-Y. Nous allons discuter des méthodes pour afficher différentes lignes en utilisant Matplotlib dans ce tutoriel.

Utilisation de plusieurs modèles de lignes pour visualiser différentes lignes:

À l'aide de Matplotlib, nous pouvons même concevoir et créer de nombreuses lignes avec différents modèles de ligne. Des styles de ligne uniques pourraient être impliqués dans l'efficacité de la visualisation des données.

Importer Matplotlib.pypllot comme plt
Importer Numpy comme NP
a = [2,4,6,8,10]
b = [8,8,8,8,8]
PLT.tracé (a, b, label = "première ligne", linestyle = "-.")
PLT.tracé (b, a, label = "deuxième ligne", linestyle = "-")
PLT.Terrain (A, NP.sin (a), label = "troisième ligne", linestyle = ":")
PLT.complot (b, np.cos (a), label = "quatrième ligne", linestyle = "-")
PLT.légende()
PLT.montrer()

Au début du code, nous importons simplement deux bibliothèques Matplotlib.pypllot comme plt et un package numérique pour python nommé Numpy comme np. Nous aurons besoin de deux entrées en tant que données, chacune ayant deux variables distinctes (A et B), avant de présenter les lignes comme des constructions et des paramètres distincts pour les mêmes ensembles de données.

De plus, nous utiliserons le PLT.Fonction de tracé () pour générer plusieurs lignes. Il y a quatre paramètres impliqués dans ces fonctions. Le premier paramètre de la fonction contient le premier ensemble de données pour créer la ligne. Un autre ensemble de données est également fourni en tant que paramètre. Nous utilisons l'argument «étiquette» pour spécifier différentes balises des lignes tracées.

En plus de cela, nous devons énoncer différents modèles pour les lignes. Dans cet exemple, nous employons '-', '-', '-.', et': 'Styles de ligne. Nous appliquons le plt.Fonction légende (). Legend () est une méthode de la bibliothèque Matplotlib qui serait utilisée pour insérer une balise sur les plans. PLT.show () La fonction est appliquée pour visualiser le tracé.

Plusieurs lignes sont tracées avec une légende en Python:

En fournissant l'étiquette donnée aux lignes en raison de son identification dans le matplotlib.pypllot.Méthode de tracé (), nous ajouterons une étiquette au graphique pour distinguer de nombreuses lignes dans le tracé de Python avec Matplotlib.

Importer Matplotlib.pypllot comme plt
a1 = [150 250,350]
B1 = [250,100,350]
PLT.tracé (a1, b1, label = "première ligne")
A2 = [100 200,300]
B2 = [200 100,300]
PLT.tracé (a2, b2, label = "deuxième ligne")
PLT.xlabel ('x')
PLT.ylabel ('y')
PLT.Titre ('Figure')
PLT.légende()
PLT.montrer()

Ici, nous devons intégrer le package Matplotlib avant de démarrer le code. Pour définir les points de la première ligne, nous déclarons deux variables différentes, «A1» et «B1». Maintenant, nous devons tracer ces points, donc nous appelons le PLT.Fonction de tracé () pour la première ligne. Cette fonction contient trois arguments: les points de l'axe des x et de l'axe y, et le paramètre «étiquette» montre la légende de la première ligne.

De même, nous définissons des ensembles de données pour cette ligne. Ces ensembles de données sont stockés dans deux variables distinctes. Pour tracer les ensembles de données de la deuxième ligne, le PLT.La fonction PLOT () est définie. À l'intérieur de cette fonction, nous avons spécifié la balise pour la deuxième ligne.

Maintenant, nous utilisons deux fonctions distinctes pour définir l'étiquette de l'axe x et de l'axe y en conséquence. Nous définissons également l'étiquette de l'intrigue en appelant le PLT.Fonction Title (). Juste avant de présenter l'intrigue, nous exécutons le matplotlib.pypllot.Fonction légende (), qui ajouterait la légende à la figure puisque toutes les lignes sont affichées.

Dessinez différentes lignes de tracé ayant des échelles distinctes:

Nous avons souvent deux ensembles de données appropriées pour les lignes des graphiques; Cependant, leurs points de données sont radicalement différents, et faire une comparaison entre ces deux lignes est difficile. Nous dessinons la séquence exponentielle le long d'une échelle de journal dans cette étape, ce qui pourrait entraîner une ligne relativement horizontale car l'échelle Y se développera progressivement.

Importer Matplotlib.pypllot comme plt
Importer Numpy comme NP
linear_sequence = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
Exponentielle_Sequence = np.Exp (NP.lispace (0, 20, 20))
Fig, ax = plt.sous-intrigues ()
hache.tracé (linear_sequence, color = 'noir')
hache.tick_params (axe = 'y', labelcolor = 'noir')
ax1 = hache.Twinx ()
ax1.tracé (exponentielle_sidence, color = 'bleu')
ax1.set_yscale ('log')
ax1.tick_params (axe = 'y', labelcolor = 'bleu')
PLT.montrer()

Dans ce cas, développons une série de nombres en croissance exponentielle avec Numpy, puis affichons cette série à côté de l'autre séquence le long des mêmes axes, séquentiellement. Nous avons défini différentes valeurs pour l'ensemble de données Linear_Sequence et le jeu de données Exponential_Sequence.

Nous devons tracer la ligne des points pour la séquence linéaire en appelant la hache.Plot () Méthode. Et nous avons également spécifié la coloration des captions de tiques à la couleur noire. À cette fin, nous définissons la hache de la fonction.tick_params (). La hache.La méthode twinx () est appelée pour développer une nouvelle ligne de haches située dans la même position.

De même, nous dessinons la ligne pour une séquence exponentielle, et nous définissons également la couleur de cette ligne et de son étiquette. Si la première ligne contient une série de valeurs en expansion progressive et que la deuxième ligne a une série de nombres en augmentation linéaire, la première ligne peut avoir des nombres beaucoup plus importants que la deuxième ligne.

Nous avons en outre mis à jour la teinte des titres des tiques pour modifier la teinte des parcelles de ligne; Sinon, il serait difficile de prédire la ligne sur quel axe.

Différentes lignes sont affichées dans Python par un dataframe:

Dans Python, nous pourrions également utiliser Matplotlib pour créer différentes lignes dans le même graphique par des données obtenues par un DataFrame. Nous y accomplirons en utilisant le matplotlib.pypllot.Plot () Méthode pour définir plusieurs valeurs de DataFrame comme arguments de l'axe x et de l'axe y. En divisant le dataframe, nous spécifierons également des éléments.

Importer des pandas en tant que PD
Importer Matplotlib.pypllot comme plt
Importer Numpy comme NP
df = pd.DataFrame ([[8, 6, 4], [11, 15, 6], [20, 13, 17],
[27, 22, 19], [33, 35, 16], [40, 25, 28],
[50, 36, 30]])
df.renommer (colonnes = 0: 'a', 1: 'b', 2: 'c', inplace = true)
Imprimer (NP.forme (df), type (df), df, sep = '\ n')
PLT.tracé (df ['a'], df ['b'], color = 'b', label = 'première ligne')
PLT.tracé (df ['a'], df ['c'], color = 'g', label = 'deuxième ligne')
PLT.légende()
PLT.montrer()

Nous acquérons les packages requis dans ce cas. Pour une représentation visuelle, nous utilisons Pypllot de Matplotlib, Numpy pour la collecte et le traitement des données, et Pandas pour indiquer l'ensemble de données. Nous allons maintenant obtenir les données de ce scénario. Nous développons donc une dataframe pour spécifier la valeur numérique qui doit être représentée.

Nous initialisons un tableau 2D, et il est fourni à la bibliothèque des Pandas ici. Nous appelons le DF.La fonction Rename () et les étiquettes des composants sont modifiées en «x», «y» et «z». En plus de cela, nous définissons les fonctions pour afficher les lignes sur le tracé. Par conséquent, nous organisons les données et ajoutons les attributs du graphique que nous voulons être dans le tracé. L'attribut «couleur» et «étiquette» est fourni au PLT.Fonction de tracé (). En fin de compte, nous représentons la figure.

Conclusion:

Dans cet article, nous avons observé comment utiliser Matplotlib pour afficher de nombreuses lignes sur le même graphique ou dimensions. Nous avons expliqué comment afficher les lignes dans les mêmes axes ayant plusieurs échelles, comment afficher les lignes avec des étiquettes et afficher les lignes dans une figure avec un dataframe.