Matplotlib Twinx

Matplotlib est une expansion analytique numérique pour le package Numpy en Python. La classe Axes définit l'ensemble des points et comprend la majorité des composants graphiques: axe, marque, annotation, polyligne, etc. Les objets axes impliquent un processus qui prend en charge les appels de fonction. Pour développer un double axes qui partage l'axe X, utilisez simplement les axes.Méthode Twinx () dans la section des axes du package Matplotlib. Jetons un coup d'œil à la fonction twinx () en détail.

Utilisation des axes.Méthode twinx ():

Dans cette étape, nous voyons comment utiliser la fonction Twinx (). Cette méthode crée des doubles axes qui partagent l'axe x.

Importer Matplotlib.pypllot comme plt
Importer Numpy comme NP
def gfg1 (temp):
retour (6. / dix.) * (temp - 40)
DEF GFG2 (AX1):
y1, y2 = ax1.get_ylim ()
ax_twin .set_ylim (gfg1 (y1), gfg1 (y2))
ax_twin .chiffre.toile.dessiner()
Fig, ax1 = plt.sous-intrigues ()
ax_twin = ax1.Twinx ()
ax1.rappels.connecter ("ylim_changed", gfg2)
ax1.Terrain (NP.lispace (-60, 100, 200))
ax1.set_xlim (50, 150)
ax1.set_ylabel ('axe y-")
ax_twin .set_ylabel ('axe y-")
figue.suptitle ('Figure \ n \ n', fontweight = "bold")
PLT.montrer()

La première étape avant d'écrire le programme est d'introduire Matplotlib.pypllot comme plt et numpy que np. Nous définissons l'objet et appelons la fonction qui renvoie la valeur de température. Nous définissons également GFG2, et il contient un objet.

Nous appelons la fonction get_ylim () pour spécifier la limite de l'axe y. Nous fournissons des arguments «gfg1» et «gfg2» à la fonction set_ylim (). Nous déclarons un nouvel objet ax_twin.chiffre.toile.dessiner.

Maintenant plt.La fonction subpots () est appliquée pour créer le graphique. Une nouvelle fonction ax_twin (). Il est utilisé pour fabriquer des axes identiques qui partagent l'axe X. Nous avons spécifié l'espace de ligne du graphique en utilisant la fonction NP.lispace () de la bibliothèque Numpy.

De plus, nous fixons les limites de l'axe des x en appelant la méthode set_xlim (). Nous devons définir les étiquettes des deux côtés de l'axe y en appliquant la méthode set_label (). Nous utilisons la figue.fonction suptitle () pour définir le titre du graphique. Le paramètre de poids de police est fourni pour cette fonction.

La fonction plt.show () est appelé dans la résiliation du code pour représenter le graphique.

Insérez l'axe Y supplémentaire dans Matplotlib:

Nous pourrions utiliser la méthode Twinx () pour générer un deuxième axe Y.

Importer Matplotlib.pypllot comme plt
Fig, bx = plt.sous-intrigues ()
bx.Plot ([2, 4, 6, 8, 10], [1, 3, 9, 11, 1], color = 'vert')
bx1 = bx.Twinx ()
bx1.Terrain ([22, 32, 42, 52, 5], [10, 12, 14, 16, 18], color = 'orange')
figue.serré_layout ()
PLT.montrer()

Nous importons la bibliothèque requise Matplotlib.pypllot comme plt. Nous prenons deux variables, 'Fig' et 'BX.'Nous utilisons PLT.Fonctions subpots () où aucune ligne et colonnes ne sont définies sur 1. En plus de cela, nous appelons le bx.Plot () Fonction pour tracer la première ligne du graphique. Cette fonction contient deux tableaux ayant des ensembles de données de l'axe x et de l'axe y.

Nous avons également passé la couleur de la ligne comme argument à cette fonction. Ensuite, nous appliquons le bx.Méthode Twinx () pour générer un jumeau d'axes ayant un axe X mutuel. Pour tracer une autre ligne sur le graphique, nous utilisons le BX1.Fonction de tracé (). Ici, nous déclarons deux tableaux. Ces tableaux sont constitués de points de données de l'axe X et de l'axe Y pour la deuxième ligne.

Nous avons défini la couleur de la deuxième ligne du graphique en fournissant des paramètres de couleur au tracé de la fonction (). Nous tracez la deuxième ligne sur BX1. Maintenant la fonction Fig.Tirm_layout () est défini afin que nous devions régler l'espacement entre les lignes. Nous utilisons le PLT.show () Fonction pour afficher le graphique.

Matplotlib Twin Y-Axes:

Dans cette sous-tête, nous explorerons à l'aide de Matplotlib en Python pour créer une figure avec des axes Y jumeaux. Nous allons créer un tracé unique contenant différentes échelles de variables car nous avons besoin d'une analyse simple. La méthode Twinx () dans Matplotlib est utilisée pour fabriquer des axes doubles. Regardons une instance dans laquelle se forment les deux axes Y

Importer Matplotlib.pypllot comme plt
Importer Numpy comme NP
x = np.Arange (5, 20, 1.5)
d1 = np.péché (x)
d2 = np.cos (x)
Fig, cx1 = plt.sous-intrigues ()
CX1.set_xlabel ('x')
CX1.set_ylabel ('y1', color = 'noir')
CX1.tracé (x, d1, color = 'noir')
CX1.tick_params (axe = 'y', labelcolor = 'noir')
dx2 = cx1.Twinx ()
dx2.set_ylabel ('y2', color = 'magenta')
dx2.Plot (x, d2, color = 'magenta')
dx2.tick_params (axe = 'y', labelcolor = 'magenta')
PLT.montrer()

Nous intégrons les bibliothèques matplotlib.pyplot as PLT et Numpy que NP au début du code. Nous avons utilisé la fonction arrange () pour spécifier les points de données. Nous créons deux variables pour stocker les ensembles de données. Pour créer le graphique, nous utilisons le PLT.Fonction sous-tracés (). Ici, nous avons également spécifié le titre de l'axe x et de l'axe y en appelant set_xLabel () et set_ylabel ().

Nous pouvons définir la couleur de l'étiquette de l'axe y en passant le paramètre «couleur». Nous appliquons le CX1.Set () Fonction pour passer les ensembles de données de l'axe Y. De même, nous pouvons ajuster la couleur de ces points de données. La fonction Tick_params () est utilisée pour tracer la ligne. Il comprend la couleur de la ligne. De plus, nous dessinons les ensembles de données parmi les x axes X et le deuxième axe Y à l'aide de la fonction Plot ().

Maintenant, la fonction Twinx () est appliquée pour générer un double axe y. Maintenant, nous définissons l'étiquette et la couleur de l'axe y de la deuxième ligne. Nous appelons donc le dx2.Set_ylabel () Fonction. La couleur des points de données de la deuxième ligne de l'axe y est définie par le DX2.Plot () Méthode. Nous utilisons le PLT.show () fonction dans le dernier pour montrer l'intrigue.

Matplotlib double axes Y avec les mêmes données:

Ici, nous allons discuter de la façon d'appliquer la fonction Plot () avec la fonction Twinx () pour fabriquer des axes Y jumeaux et les visualiser avec des données identiques: Importer Matplotlib.pypllot comme plt.

Importer Numpy comme NP
a = np.Arange (300)
b = np.péché (a)
Fig, cx1 = plt.sous-intrigues ()
CX1.Terrain (A, B)
CX1.set_xlabel ('x')
CX1.set_ylabel ('y1')
dx2 = cx1.Twinx ()
dx2.set_ylabel ('y2')
PLT.montrer()

Après avoir inclus les bibliothèques, nous devons définir les ensembles de données à l'aide de méthodes Numpy () et sin (). Nous définissons un objet, puis utilisons la fonction sous-tracés () pour dessiner un graphique. En plus de cela, les étiquettes de l'axe X et un axe Y sont spécifiées en utilisant la fonction set_label ().

Nous créons deux axes, nous appelons donc la méthode Twinx (). En dehors de cela, nous définissons l'étiquette d'un autre axe Y, et à la fin du programme, nous affichons le graphique en utilisant le PLT.Méthode Show ().

Conclusion:

Dans ce tutoriel, nous avons discuté de la méthode Matplotlib Twinx () avec leurs exemples. Cette fonction crée un double axe y qui partage un axe X similaire. Nous utilisons cette fonction en utilisant différentes approches.