8. TP - Matplotlib



8.1. Introduction

Dans ce TP, on s'intéresse à la librairie matplotlib qui permet de réaliser des graphiques et dont la documentation peut être trouvée à cette adresse matplotlib.org.

8.2. Tracé d'une fonction (plot)

On désire tracer une fonction réelle. On utilise pour cela la fonction plot.

On peut également utiliser la fonction savefig afin de sauvegarder un graphique.

8.2.1. Sans numpy

Voici une première version sans numpy pour l'évaluation de la fonction. On utilise la fonction sinus et il est donc nécessaire de faire appel au module math :

  1. # import libraries / packages
  2. import matplotlib.pyplot as plt
  3. import math
  4.  
  5. # function to plot
  6. def f(x):
  7.     return x*x-3*x+6*math.sin(x)
  8.  
  9. # values for x, we use numpy
  10. # we generate 100 values from 0 to 100
  11. x_values = range(0, 10)
  12. print(x_values)
  13. y_values = [f(x) for x in x_values]
  14. print(y_values)
  15.  
  16.  
  17. plt.plot(x_values, y_values, color='orange')
  18. plt.grid(color='grey', linestyle='-', linewidth=1)
  19. plt.ylabel('f(x)')
  20. plt.savefig('img/plot_function_without_numpy.png')
  21. plt.show()
  22.  
  23.  

On calcule les valeurs pour x (x_values) puis celles de y(y_values) et enfin on dessine la courbe en utilisant ces valeurs.

8.2.2. Avec numpy

Voici une seconde version avec numpy pour l'évaluation de la fonction ce qui permet de simplifier la génération des valeurs à la fois pour x et pour y. On notera l'utilisation de np.sin(x) au lieu de math.sin(x) dans le calcul de la fonction $f$ :

  1. # import libraries / packages
  2. import matplotlib.pyplot as plt
  3. import math
  4. import numpy as np
  5.  
  6. # function to plot
  7. def f(x):
  8.     return x * x - 3 * x + 6 * np.sin(x)
  9.  
  10. # values for x, we use numpy
  11. # we generate 100 values from 0 to 100
  12. x_values = np.linspace(0, 10, 100)
  13. print(x_values)
  14.  
  15. # we generate values for y by applying f()
  16. # on the numpy array v_calues
  17. y_values = f(x_values)
  18. print(y_values)
  19.  
  20.  
  21. plt.plot(x_values, y_values, color='green')
  22. plt.grid()
  23. plt.ylabel('f(x)')
  24. plt.show()
  25.  
  26.  

On remarquera que l'on utilise la fonction linspace de numpy afin de générer des valeurs dans l'intervalle [0,10].

Exercice 8.1

Afficher le graphique de la fonction :

$$ f1(x) = (√|x| - 3) × x $$

Exercice 8.2

Afficher sur le même graphique les fonctions :

$$\{\table f1(x) = x; f2(x) = x × \log(x); f3(x) = x × x; $$

Exercice 8.3

Créez dans le fichier lemniscate.py, le graphique paramètrique suivant pour $t ∈ [0,2π ]$ qui correspond au Lemniscate de Bernoulli (Courbe en forme de huit) :

$$\{\table x(t) = (4 × cos(t)) / (1 +sin^2(t)); y(t) = (8 × cos(t) × sin(t)) / (1 +sin^2(t)); $$

Vous devriez obtenir l'image suivante :

graphique paramétrique lemniscate Bernoulli

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3.  
  4. t = np.linspace(0, 2 * np.pi, 250)
  5. # x =
  6. # y =
  7.  
  8. # Tracer le graphique
  9. plt.figure(figsize=(10, 8))
  10. plt.plot(x, y, label='x(t),y(t)', color='blue')
  11.  
  12. plt.ylim(-10, 10)
  13.  
  14. #....
  15.  
  16. # Afficher le graphique
  17. plt.grid(True, linestyle='--', alpha=0.6)
  18. plt.show()
  19.  

8.3. Données en barres (bar, barh)

Il est parfois nécessaire de modéliser les données sous forme graphique et les graphes qui utilisent des barres permettent de rendre compte d'une donnée numérique associée à une catégorie.

A titre d'exemple, considérons que nous avons interrogé 75 personnes et que nous leur avons demandé quel langage de programmation elles utilisent le plus souvent. Voici les résultats de ce sondage :

8.3.1. Barres verticales (bar)

On peut représenter ces données sous forme de barres verticales ce qui permet tout de suite de voir quel langage est le plus utilisé et quel langage est le moins utilisé, est-ce qu'un langage se démarque des autres, etc. Sur quatre données cela est inutile mais sur des dizaines de données cela est beaucoup plus pratique.

Voici le code correspondant à ce graphique :

  1. import matplotlib.pyplot as plt
  2. from matplotlib import cm
  3. import math
  4. import numpy as np
  5.  
  6. # langages de programmation
  7. y_labels = [ 'C++', 'Ruby', 'Python', 'Php' ]
  8.  
  9. # x_values indique sur l'axe des x où on doit situer
  10. # la barre verticale
  11. x_values = [ 1, 2, 3, 4 ]
  12.  
  13. # y_values représentent les données associées à chaque langage
  14. y_values = [ 20, 10, 30, 15 ]
  15.  
  16. plt.bar(x=x_values, height=y_values, width=0.9,
  17.     color='#7788aa', tick_label = y_labels)
  18. plt.savefig('img/plot_bar_chart.png')
  19. plt.show()
  20.  
  21.  

8.3.2. Barres horizontales (barh)

On peut procéder de la même manière mais avec des barres horizontales.

  1. import matplotlib.pyplot as plt
  2. from matplotlib import cm
  3. import math
  4. import numpy as np
  5.  
  6. # langages de programmation
  7. x_labels = [ 'C++', 'Ruby', 'Python', 'Php' ]
  8.  
  9. x_values = [ 1, 2, 3, 4 ]
  10. y_values = [ 20, 10, 30, 15 ]
  11.  
  12. plt.barh(y=x_values, width=y_values, height=0.9,
  13.     color=['#be7733', '#138ABc', '#89bf76', '#4A987f'],
  14.     tick_label = x_labels, hatch="/",
  15.     edgecolor='#888888')
  16. plt.savefig('img/plot_barh_chart.png')
  17. plt.show()
  18.  
  19.  

8.4. Camembert (pie)

Le camembert ou (pie chart en anglais) permet également, tout comme les graphes de barres, de donner une idée de la répartition des données mais sous forme de pourcentage.

  1. import matplotlib.pyplot as plt
  2. from matplotlib import cm
  3. import math
  4. import numpy as np
  5.  
  6. x_labels = [ 'C++', 'Ruby', 'Python', 'Php' ]
  7. x_values = [ 20, 10, 30, 15 ]
  8. x_explode = (0, 0, 0.1, 0)
  9.  
  10. plt.pie(x_values, labels=x_labels, autopct='%1.1f%%', explode=x_explode)
  11. plt.title("Utilisation des langages de programmation")
  12. plt.savefig('img/plot_pie_chart.png')
  13. plt.show()
  14.  
  15.  

Exercice 8.4
Afficher un graphique sous forme de camembert pour un ensemble de valeurs générées aléatoirement avec une dizaine de valeurs. Faire en sorte que la valeur la plus grande soit détachée du graphique.

8.5. Graphe de points (scatter)

8.5.1. Exemple classique

Dans certains cas, on dispose de données éparses et on désire les afficher afin de savoir si elle sont corrélées.

Voici un premier exemple généré de manière aléatoire en utilisant numpy :

  1. import matplotlib.pyplot as plt
  2. import math
  3. import numpy as np
  4.  
  5. x_values = np.random.uniform(-1.0, 1.0, 50)
  6. y_values = np.random.uniform(-1.0, 1.0, 50)
  7.  
  8. plt.scatter(x_values, y_values)
  9. plt.savefig('img/plot_scatter_random.png')
  10. plt.show()
  11.  
  12.  

Le deuxième exemple utilise une fonction linéaire pour associer les données :

  1. import matplotlib.pyplot as plt
  2. import math
  3. import numpy as np
  4.  
  5. def f(x):
  6.     return 2*x+5
  7.    
  8. x_values = np.random.uniform(-1.0, 1.0, 50)
  9. y_values = f(x_values) + np.random.uniform(-0.2, 0.3, 50)
  10.  
  11. plt.scatter(x_values, y_values)
  12. plt.savefig('img/plot_scatter_correlated.png')
  13. plt.show()
  14.  
  15.  

Exercice 8.5
Afficher un graphique sous forme "scatter plot" pour des valeurs de $x$ dans l'intervalle $[0,10]$ et qui correspondent à une fonction $f(x) = 2x+5$ pour laquelle on aura introduit de petites variations par rapport à la fonction.

Par exemple pour $x=1$, on devrait avoir $f(1) = 7$, mais on s'arrangera pour avoir $6.8$ ou $7.2$. Pensez à générer un vecteur de valeurs aléatoires qui sera ajouté au calcul de $f(x)$.

8.5.2. Exemple des étudiants de l'université de Malibu

On dispose d'un fichier mu.csv qui contient pour différents étudiants qui sont inscrits en première année à l'université de Malibu en Californie, trois champs : provenance (état), moyenne en mathématiques, moyenne en informatique 

arizona,14,13
california,18,17
nevada,8,19
other,6,3
arizona,14,12
arizona,12,13
...

Quatre états sont représentés : Californie, Arizona, Nevada et Other pour les étudiants en provenances d'autres états.

On désire réaliser un graphique représentatif comme celui-ci:

Notes

Exercice 8.6

Créez un fichier malibu.py afin de réaliser ce graphique.

  • on récupérera le fichier et on extraira les données suivants trois colonnes : etats, notes_math, notes_info
  • on affichera la moyenne de notes_math et notes_info
  • il faudra remplacer les noms des états par des chiffres, par exemple si on prend l'ordre alphabétique :
    • arizona : 0
    • california : 1
    • nevada : 2
    • other : 3

Voici quelques éléments de code :

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3. import matplotlib.colors as col
  4. from matplotlib.colors import ListedColormap
  5.  
  6. # création d'une colormap afin de distinguer chaque groupe
  7. # d'étudiant en fonction de l'état de provenance
  8. colors = ['orangered', 'dodgerblue', 'chartreuse', 'peru' ]
  9. jmr_cmap = ListedColormap(colors)
  10.  
  11. # ...
  12. # indices_etats = [ 0, 1, 0, 2, ... ] à créer en remplaçant
  13. # chaque nom d'état par un indice identifiant de manière
  14. # unique l'état
  15.  
  16. plt.figure(figsize=(10, 8))
  17. ax = plt.axes()
  18. ax.set_facecolor("cornsilk")
  19.  
  20. plt.xlabel("notes math")
  21. plt.ylabel("notes info")
  22. plt.xlim(0,22)
  23. plt.ylim(0,22)
  24. # affichage des diagonales
  25. x=np.arange(1,20)
  26. y1=x
  27. y2=20-x
  28. plt.plot(x, y1, "silver", linestyle='--', alpha=0.6)
  29. plt.plot(x, y2, "silver", linestyle='--', alpha=0.6)
  30. # affichage des données
  31. plt.scatter(notes_math, notes_info, c=indices_etats, cmap=jmr_cmap, s=50)
  32.  
  33. plt.show()