focus_scatter.md

@@ -2,22 +2,31 @@
 
 ## focus sur la méthode **SCATTER**
 
-Objectif : connaître la méthode **scatter** et en particulier :
+**Objectif** : connaître la méthode **scatter** et en particulier :100:
 
-1) faire varier les symboles : les différentes manières d'utiliser les codes couleur (une couleur, liste de couleurs fixées par l'utilisateur, code couleur selon une colormap...) idem avec les tailles : taille fixe, taille selon liste ou taille selon une colonne
-2) pistes pour créer une légende détaillée (faisant figurer le code couleur et/ou la taille des symboles)
-3) les méthodes pour updater une courbe de type scatter (set_data, set_facecolors...)
+- Introduction : Présentation et comparaison avec la méthode plot
+- manipuler les arguments **c**olors et **s**izes et leurs légendes
+  * taille : par défaut taille unique,  **ou bien** définies par un vecteur de tailles, éventuellement issu de la transformation d'un vecteur de valeur pour donner une échelle pertinente
+  * couleur : couleur des symboles unique **ou bien** définies par un vecteur de couleurs  **ou encore** liées à un vecteur de valeurs par une colormap. 
+- Ajouter une légende :
+  * pour la taille : attention à bien spécifier la valeur de départ et non pas la valeur transformée
+  * pour les couleurs : on peut utiliser la même méthode que pour la taille, ou bien préférer une "colorbar" discrète ou continue. On proposera aussi une méthode pour "construire" une légende à la main.
+- updater une courbe de type scatter (set_data, set_facecolors...)
 
-Objectif secondaire : point sur les _colormaps_ et sur les _colorbars_ [voir ce tuto de la doc pour customiser une colormap](https://matplotlib.org/stable/tutorials/colors/colorbar_only.html)
+**Objectif secondaire** : point sur les _colormaps_ et sur les _colorbars_ [voir ce tuto de la doc pour customiser une colormap](https://matplotlib.org/stable/tutorials/colors/colorbar_only.html)
 
 :warning: les différences entre colorbar par défaut et customisée, continue et discrète, par liste, entre colorbar et légende de couleurs ne sont pas forcément simples quand on découvre : si mon topo n'est pas assez clair, signalez-le :telephone:, je reformulerai avec plus de détails
 
 :new: du nouveau sur les **colorbars** dans la version 3.5 de matplotlib : l'utilisateur peut "zoomer" sur la colorbar (outils 'loupe' pour zoomer et 'flèches" pour décaler, en bas à gauche, les mêmes que pour "zoom" et "pan" sur la courbe).
 
+**Ce qui n'est pas traité spécifiquement ici** : la version **seaborn** de **scatter**, qui peut être plus "jolie" et plus facile à mettre en oeuvre si vos données sont stockées dans une **dataframe pandas**. :panda_face: :
+
 **Cette partie utilise la manière "simple mais pas recommandée" de définir des graphiques, avec plt.plot et plt.scatter puis "plt" pour appeler toutes les méthodes. Vous pouvez vous exercer à remplacer les instructions par une syntaxe plus pythonesque : nommer figure et Axes, puis appliquer les méthodes sur les bons objets.**
 
 ## :books: refs
-[**La Doc ! ; article scatter**](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.scatter.html)
+
+[**La Doc ! article scatter**](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.scatter.html)
+
 [**et la doc ! article sur les légendes**](https://matplotlib.org/stable/gallery/lines_bars_and_markers/scatter_with_legend.html)
 
 ## Introduction : Présentation et comparaison avec la méthode plot
@@ -36,6 +45,10 @@ Le tableau ci-dessous est proposé pour mettre en évidence quelques différence
 | update des coordonnées des points | facile : set_data, set_xdata, set_ydata | facile : set_offset |
 | update des couleurs des points | facile : set_color | facile : set_edgecolors, set_facecolors |
 
+## 1. Manipuler les arguments **c**olors et **s**izes
+
+Notez le "s" du pluriel car, contrairement à plot, on peut définir un vecteur d'autant de couleurs (ou de tailles) qu'il y a d'arguments.
+
 ### Exemple le plus simple : scatter avec une seule couleur et une seule taille
 
 Vous pouvez tester le petit code ci-dessous : la méthode plot trace des lignes grises, la méthode scatter place des points bleus. N'hésitez pas à modifier les arguments pour comprendre. On trace ici le numéro du mois en fonction de la date, cela n'a pas grand intérêt mais permet de bien comprendre comment fonctionnent les arguments de couleur et de taille.
@@ -57,17 +70,76 @@ plt.plot(dates, liste_mois)  # on n'a pas précisé de marker : il n'y en a pas
 plt.scatter(dates, liste_mois, c='blue', s=20) # marker par défaut = cercle
 plt.show()
 ```
-| introduction : couleur et taille unique | partie 1 : on fait varier tailles et couleurs (la ligne est tracée en plus, avec plot)|
-|-----------------------------------------|-----------------------------------------------|
+| introduction : couleur et taille unique | partie 1 : on fait varier tailles et couleurs (la ligne est tracée en plus, avec plot) |
+|-----------------------------------------|----------------------------------------------------------------------------------------|
 | ![scatter_1](uploads/283a2242bf835e48b439c84056d2a5f4/scatter_1.png) | ![test_scatter_2](uploads/17c13b803970c2e3873f1e7d81cb47f2/test_scatter_2.png) |
 | markers bleus, taille 20 | taille dépend de l'année, numéro du mois selon code couleur (cmap) |
 
-## 1. Faire varier les couleurs et les tailles
+### Faire varier les tailles
+
+On définit d'abord la règle pour **la taille**. On souhaite visualiser l'année (c'est juste pour l'exercice...). Grâce à l'argument **year** on peut facilement récupérer le numéro d'année d'un vecteur de dates.
+
+:warning: par des raisons de lisibilité, on va souvent être amenés à écrire une transformation entre la valeur à coder par une taille et la taille en pixels. Ici, des pixels proportionnels à une date en YYYY seraient évidemment stupides ; une date en YY aurait au contraire une taille trop petite. Ici on a choisi de prendre la date en YY plus 10, fois 4 pour mieux marquer les différences. On définit ce vecteur des tailles directement dans les arguments de la fonction (vous reconnaîtrez une _comprehension list_).
+
+Pour que la légende ne masque pas les points - même si ici ils n'ont aucun intérêt...- on va couper la figure en deux vignettes "Axes"; on efface les axes (Axis) de la vignette du bas et on pose la légende à des coordonnées situées en dehors du premier "ax", et plus exactement dans celui du dessous... **bbox_to_anchor** s'exprime en coordonnées de l'ax **ax**, de 0 à 1 ; si on impose y=-0.5 il sera en dessous, d'une demi-hauteur...
+
+```python
+    fig, (ax, ax2) = plt.subplots(nrows=2)
+    ax2.axis('off')
+    fig.suptitle("Variation de la taille seulement")
+
+    points = ax.scatter(dates, liste_mois, c="forestgreen", s=[4 * (date.year - 1990) for date in dates],
+                        edgecolor='none', label='des dates')
+    legend_size = ax.legend(*points.legend_elements(prop="sizes"), bbox_to_anchor =(0.5,-0.5),
+                    loc="upper center", title="Tailles", ncol=4)
+```
+
+**Comment faire apparaître une légende ?** 
+
+On peut imaginer que **plt.legend()** fera le boulot. Vous pouvez essayer, si possible en affectant un nom à l'argument **label** du scatter. Hélas, vous verrez un symbole unique, donc avec l'une des couleurs et l'une des tailles possibles. 
+
+On va appliquer ici la recette donnée dans la doc : on fait passer à la méthode **legend** les legend_elements du scatter, que l'on a pris la précaution de nommer. On précise que l'on veut la légende des **tailles** avec \`prop="sizes"\`
+
+ :warning: attention à ne pas mélanger les arguments de **legend** et les arguments de **legend_elements**
+| avec options par défaut | en précisant la couleur et une fonction de transformation |
+|-------------------------|-----------------------------------------------------------|
+|  | ![scatter_legende_taille_mieux](uploads/014003d61d4c92e5e2e03ce043a7639d/scatter_legende_taille_mieux.png) |
+
+
+On peut être déçu par :
+
+* la couleur noire, qui n'est pas la couleur de nos points (ici ils sont tous verts) : c'est la modalité par défaut
+* l'échelle des tailles, qui ne correspond pas à nos données de départ (les dates) mais aux tailles. 
+
+On va donc modifier le code pour que la couleur soit celle de l'objet scatter, et pour que le code des valeurs soit correct il faut passer la réciproque de la fonction de transformation...
+
+L'argument **num** permet de fixer le nombre d'entrées de la légende. L'argument **func** permet de définir la fonction réciproque de la transformation, soit en passant un nom de fonction définie au préalable, soit en créant une fonction adhoc "jetable", soit en python une fonction **lambda**
+
+\`\`\`python
+
+```
+fig, (ax, ax2) = plt.subplots(nrows=2)
+fig.suptitle("Variation de la taille seulement")
+ax2.axis('off')
 
-On va créer un code couleur de plusieurs façons ; on va en détailler 2.
-On en profite pour faire varier également la taille ; on définit le vecteur des tailles par une opération sur l'année (vous reconnaîtrez une _comprehension list_). Grâce à l'argument **year** on peut facilement récupérer le numéro d'année d'un vecteur de dates.
+points = ax.scatter(dates, liste_mois, c="forestgreen", s=[4 * (date.year - 1990) for date in dates],
+                    edgecolor='none', label='des dates')
 
-a) au plus simple, on désigne juste un vecteur dont les valeurs vont être traduites en couleurs selon une colormap choisie dans une liste ; ici on a opté pour "viridis". 
+legend_size = ax.legend(*points.legend_elements(prop="sizes", c=points.get_facecolors(), func=lambda s:(s/4)+1990, num=6), bbox_to_anchor =(0.5,-0.5),
+                loc="upper center", title="Tailles", ncol=4)
+
+plt.show()
+```
+
+\`\`\`
+
+### Faire varier les couleurs
+
+Ensuite, on va créer un code couleur. Il existe plusieurs façons de faire ; on va en détailler 2.
+
+Les manières de créer une légende sont également plusieurs.
+
+a) au plus simple, on désigne juste un vecteur dont les valeurs vont être traduites en couleurs automatiquement selon une colormap (cf doc ; liste des cmaps disponibles dans mpl); ici on a opté pour "viridis".
 
 \*\* Code de l'exemple 1.a \*\*
 
@@ -79,13 +151,13 @@ plt.show()
 ```
 
 **Comment faire apparaître une légende ?**
-En regardant la figure, on devine qu'il y a un code couleur, mais le graphique ne donne aucune indication sur une éventuelle correspondance valeur/couleur.
-On peut imaginer que **plt.legend()** fera le boulot. Vous pouvez essayer, si possible en affectant un nom à l'argument **label** du scatter. Hélas, vous verrez un symbole unique, donc avec l'une des couleurs et l'une des tailles possibles. 
-Pour montrer l'échelle de couleur d'une **colormap**, il suffit d'appeler la **colorbar** correspondante, que l'on peut 'personnaliser' (customize pour les recherches anglophones). 
-On va donner ici la procédure, très simple, et avancer vers des colorbars plus personnalisées, ici pour tenir compte de la nature discrète des valeurs.
-On donnera ensuite d'autres méthodes pour tracer des **légendes plus classiques personnalisées**, en s'inspirant des tutos de la doc.
+
+Là encore, si on utilise **plt.legend()** on verra un symbole unique, donc avec l'une des couleurs et l'une des tailles possibles. 
+
+Pour montrer l'échelle de couleur d'une **colormap**, la vôtre ou celle qui est définie par défaut, il suffit d'appeler la **colorbar** correspondante, que l'on peut 'personnaliser' (customize pour les recherches anglophones). On va donner ici la procédure, très simple, et avancer vers des colorbars plus personnalisées, ici pour tenir compte de la nature discrète des valeurs. On donnera ensuite d'autres méthodes pour tracer des **légendes plus classiques personnalisées**, en s'inspirant des tutos de la doc.
 
 ### ajouter une colorbar continue
+
 Il suffit d'associer une colorbar à notre courbe portant un code couleur ("mappable") en une instruction. On peut ajouter des arguments, comme par exemple un titre.
 
 ```python
@@ -95,8 +167,8 @@ plt.colorbar(cax)  # c'est cet objet qui est passé en argument à la méthode c
 ```
 
 ### ajouter une colorbar discrétisée à partir de la colorbar continue
-Ici, on a certes utilisé une colorbar continue, mais on a des valeurs discrètes, et on préfèrerait marquer la correspondance valeur discrète/couleur. On va donc **discrétiser la colormap** en définissant des limites de classe que l'on va transformer en objet **norm**, que l'on passera comme argument dans la méthode scatter (détail ci-dessous).
-En première intention, on pensera sans doute à définir des limites commençant aux valeurs entières : \[1,2,3,...,12\] ; soit en Python **range(1,13)**. Cependant, pour avoir une légende avec des classes centrées sur les valeurs entières, on propose de décaler les limites des classes d'un demi, en écrivant par exemple np.arange(0.5, 13, 1). On a changé, cette fois on utilise la colormap **rainbow**, vous pouvez en tester d'autres.
+
+Ici, on a certes utilisé une colorbar continue, mais on a des valeurs discrètes, et on préfèrerait marquer la correspondance valeur discrète/couleur. On va donc **discrétiser la colormap** en définissant des limites de classe que l'on va transformer en objet **norm**, que l'on passera comme argument dans la méthode scatter (détail ci-dessous). En première intention, on pensera sans doute à définir des limites commençant aux valeurs entières : \[1,2,3,...,12\] ; soit en Python **range(1,13)**. Cependant, pour avoir une légende avec des classes centrées sur les valeurs entières, on propose de décaler les limites des classes d'un demi, en écrivant par exemple np.arange(0.5, 13, 1). On a changé, cette fois on utilise la colormap **rainbow**, vous pouvez en tester d'autres.
 
 En fait, ici c'est **BoundaryNorm** qui paraît faire tout le travail :
 
@@ -123,8 +195,6 @@ points = plt.scatter(dates, liste_mois, c=liste_mois, cmap=cmap, norm=norm, s=[4
 legend1 = ax.legend(*points.legend_elements(), loc="lower left", title="Classes")
 ax.add_artist(legend1)
 ```
-
-
 | Légende par colorbar | Légende construite à partir des classes de valeurs |
 |----------------------|----------------------------------------------------|
 | ![test_scatter_3](uploads/26181233c98a12ef4a8b0b955d238c17/test_scatter_3.png) | ![test_scatter_3](uploads/11864d5dd885fb013949169a0792af67/test_scatter_3.bis.png) |
@@ -154,16 +224,15 @@ for mois in range(1,13):
 plt.title("test 4")
 plt.show() 
 ```
-| ListedColorMap : colormap discrète définie par une liste | argument c = liste de couleurs|
-|----------------------------------------------------------|--------|
+| ListedColorMap : colormap discrète définie par une liste | argument c = liste de couleurs |
+|----------------------------------------------------------|--------------------------------|
 | ![test_scatter_4](uploads/cf3e97051da614bed3e2e4b93f88062d/test_scatter_4.png) | ![test_scatter_5](uploads/6406ab387e48e826a1703dbb10bf3e7f/test_scatter_5.png) |
-| on a en plus customisé la colorbar pour comprendre | légende construite à la main|
+| on a en plus customisé la colorbar pour comprendre | légende construite à la main |
 
 ### définir la liste de couleurs item par item, légende customisée (cf Atelier C)
 
 Variante : au lieu d'utiliser une colorbar, on peut aussi écrire une fonction pour affecter les couleurs élément par élément, s'il y a par exemple des conditions à vérifier. Ici on boucle sur les dates, et on ajoute à la liste des couleurs la valeur du dictionnaire DICO_COULEURS_MOIS qui correspond à la clé **date_month**
 
-
 Comme on ne passe pas par de "colormap" avec cette méthode, il faut trouver une autre manière d'obtenir une légende des couleurs. La légende "standard" ne donne qu'un exemplaire du symbole, donc n'est pas très utile. La méthode indiquée dans la doc ne semble marcher que quand on passe à l'argument **c** un vecteur de valeurs, et que scatter se débrouille pour utiliser une cmap par défaut
 
 ```python
@@ -194,13 +263,17 @@ handles = [Line2D([0], [0], marker='o', color="b", label=DICO_NOM_MOIS[mois],
                           markerfacecolor=DICO_COULEURS_MOIS[mois], markersize=15) for mois in range(1, 13)]
 ax_legende_coul_a_la_main.legend(handles=handles, ncol=6, fontsize=8, title_fontsize=10,
                    labelspacing=1.5)
+plt.show()
 ```
 
-##  updater une courbe de type scatter (set_data, set_facecolors...)
-
 ### autres méthodes
 
 La [doc nous indique un moyen plus simple d'obtenir une légende quand il y a un nombre raisonnable de valeurs différentes](https://matplotlib.org/stable/gallery/lines_bars_and_markers/scatter_with_legend.html)
 
-
 Il existe d'autres moyens d'afficher un symbole par classe sous forme d'une légende classique. La [doc fournit un tuto intéressant, mais qui ne donne pas forcément toutes les clés si on a beaucoup de catégories ou un lien indirect entre la valeur et la taille...](https://matplotlib.org/stable/gallery/lines_bars_and_markers/scatter_with_legend.html)
+
+## Légende de taille
+
+## updater une courbe de type scatter (set_data, set_facecolors...)
+
+à venir...![scatter_legende_taille](uploads/0af506a8cd25614d387e8443a7530d62/scatter_legende_taille.png)
\ No newline at end of file