|
|
|
:construction_worker: en construction :construction_site:
|
|
|
|
Comment déchiffrer la doc ?
|
|
|
|
* les **arguments**
|
|
|
|
* les **paramètres** et comment les modifier
|
|
|
|
* les **arguments** (arguments de position, nommés, par mot-clé...), appelés **Parameters**
|
|
|
|
* ce que les méthodes **retournent** : très important !
|
|
|
|
* pour matplotlib : comment modifier les objets créés après coup (qui ont été "retournés" par la méthode)
|
|
|
|
|
|
|
|
:chart_with_upwards_trend: Un exemple de **matplotlib** : la célébrissime fonction **plot**.
|
|
|
|
:panda_face: Un exemple (à venir) de **pandas** (module DataFrame)
|
| ... | ... | @@ -12,8 +12,141 @@ La méthode **plot** est la plus commune des méthodes de tracé : plt.plot(vect |
|
|
|
Comment en savoir plus sur la méthode ?
|
|
|
|
|
|
|
|
La doc de la **version 3.5** décrit la méthode comme ceci :
|
|
|
|
###Axes.plot(*args, scalex=True, scaley=True, data=None, **kwargs)
|
|
|
|
|
|
|
|
#### Axes.plot(*args, scalex=True, scaley=True, data=None, **kwargs)
|
|
|
|
Description : "Plot y versus x as lines and/or markers."
|
|
|
|
|
|
|
|
### **classe** à laquelle s'applique la méthode
|
|
|
|
il s'agit de **Axes**
|
|
|
|
En toute rigueur, la syntaxe est don **mon_ax**.plot(), mais on explique par ailleurs dans ces pages que plt.plot() est une méthode de plt qui va chercher l'axe courant (**gca** : get current Axes) soit plt.**gca()**.plot()
|
|
|
|
|
|
|
|
### **arguments** à fournir à la méthode
|
|
|
|
|
|
|
|
La formule *_args_ signifie que vous "déballez" avec * un tuple nommé par convention _args__ ("unpacking de tuple"), ce qui signifie qu'on peut passer une série de un ou plusieurs arguments.
|
|
|
|
Certains arguments sont obligatoires (il faut au minimum une série à tracer...), et d'autres facultatifs, mais l' **ordre** est important sinon l'interpréteur ne saura pas qui fait quoi.
|
|
|
|
|
|
|
|
La ligne "call signatures" détaille un peu plus les arguments :
|
|
|
|
|
|
|
|
``` python
|
|
|
|
# Call signatures:
|
|
|
|
plot([x], y, [fmt], *, data=None, **kwargs)
|
|
|
|
plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)
|
|
|
|
```
|
|
|
|
|
|
|
|
Première ligne :
|
|
|
|
[x] = argument facultatif ; eh oui, x est facultatif ! Ici, il y a une valeur de x "par défaut", qui est range(0, len(y))
|
|
|
|
y = argument obligatoire
|
|
|
|
[fmt] = argument facultatif : description condensée du format de la courbe (voir ci-dessous)
|
|
|
|
* = séparateur d'arguments, ceux suivant l'étoile seront obligatoirement nommés dans les appels (
|
|
|
|
|
|
|
|
Deuxième ligne :
|
|
|
|
On passe plusieurs séries (x,y) à la suite, avec un format **fmt** pour **[x],y** et un autre **fmt2** pour **[x2],y2**
|
|
|
|
|
|
|
|
### *args : tuple d'arguments
|
|
|
|
On remarque dans la liste des arguments un séparateur d'arguments(...,*,...)
|
|
|
|
Avant le séparateur '*' on passe des arguments sans rappeler leur nom, et même on ne *peut pas* les nommer car on a placé cette étoile. (on n'en dira pas plus ici, voir tutographie à la fin)
|
|
|
|
|
|
|
|
*args permet donc de faire passer un nombre non précisé d'arguments, l'interpréteur se débrouillera avec. Par contre, quand ils ne sont pas nommés (et ici c'est d'ailleurs interdit) il faudra respecter l'**ordre** sinon il ne saura pas qui est quoi.
|
|
|
|
|
|
|
|
``` python
|
|
|
|
plot(un_vecteur) # (1 = y seul) : plot **un_vecteur vs x** par défaut = index des réels 0 à len(y)-1)
|
|
|
|
plot(vecteur_1, vecteur_2) # ( 2 = x et y dans cet ordre) : plot **vecteur_2 vs vecteur_1** avec le style par défaut
|
|
|
|
|
|
|
|
plot(x, y, 'bo') # (3 = x,y, fmt ) : plot y vs x avec un format défini : cercles bleus
|
|
|
|
```
|
|
|
|
Dans les exemples ci-dessus, on voit que la syntaxe est 'intuitive' mais pourtant un peu retorse :
|
|
|
|
- si on ne passe qu'un argument, c'est pris comme y, et les x manquants sont par défauts les entiers de 0 à N.
|
|
|
|
- si on passe 2 arguments, ce sont x et y dans cet ordre
|
|
|
|
- le 3e arguments est un descripteur de format fmt = '[marker][line][color]' sous forme condensée (là encore l'**ordre** est important) :
|
|
|
|
- pas besoin de taper le nom de l'argument (marker, linestyle, color)
|
|
|
|
- la valeur à passer est tronquée à un ou deux caractère(s).
|
|
|
|
|
|
|
|
C'est bien pratique... quand on a l'habitude :
|
|
|
|
`'bo' = color='**b**lack', marker='**o**' `
|
|
|
|
`'r+' = color='**r**ed', marker='**+**' `
|
|
|
|
|
|
|
|
|
|
|
|
### arguments nommés, après le séparateur d'arguments(...,*,...)
|
|
|
|
Après le séparateur '*' on passe forcément à des arguments nommés.
|
|
|
|
Il faut donc rappeler le nom de l'argument : "nom_argument = variable_que_je_passe"
|
|
|
|
Comme on précise le nom, la position n'a pas d'importance.
|
|
|
|
|
|
|
|
Les arguments nommés sont optionnels s'ils ont une valeur par défaut.
|
|
|
|
Ainsi, **data=None** signifie que si on ne passe pas explicitement d'argument **data**, ce sera comme si on avait déclaré data=None.
|
|
|
|
|
|
|
|
## :warning: vérifications en cours ! ! diff argument nommé vs kwargs ???
|
|
|
|
### keyword arguments
|
|
|
|
|
|
|
|
La syntaxe **kwargs précise qu'il existe des arguments définis par un dictionnaire. Comme pour les *args, le nombre n'est pas fixe, on peut en mettre un ou plusieurs.
|
|
|
|
Dit autrement, pour les autres réglages (linewidth, markersize...) il existe un **dictionnaire** qui fait une correspondance entre l'argument passé, pris comme clé, et sa valeur.
|
|
|
|
|
|
|
|
Exemple :
|
|
|
|
``` python
|
|
|
|
lineStyles = {'': '_draw_nothing', ' ': '_draw_nothing', '-': '_draw_solid', '--': '_draw_dashed', '-.': '_draw_dash_dot', ':': '_draw_dotted', 'None': '_draw_nothing'}
|
|
|
|
```
|
|
|
|
|
|
|
|
Ces noms sont explicites si on connaît un tant soit peu l'anglais technique de base...
|
|
|
|
|
|
|
|
``` python
|
|
|
|
# Arguments nommés, ajoutés à la suite des arguments situés avant le '*' :
|
|
|
|
plot(x, y, 'go--', **linewidth**=2, **markersize**=12)
|
|
|
|
plot(x, y, **color**='green', **marker**='o', **linestyle**='dashed',
|
|
|
|
linewidth=2, markersize=12)
|
|
|
|
```
|
|
|
|
|
|
|
|
### ce que **retourne** la méthode
|
|
|
|
:bell: c'est très important, et peut être un peu caché dans la doc de la version 3.5.
|
|
|
|
Repérons la ligne suivante :
|
|
|
|
#### Returns
|
|
|
|
#### **list** of **Line2D**
|
|
|
|
#### A list of lines representing the plotted data.
|
|
|
|
|
|
|
|
On a deux informations à noter :
|
|
|
|
- la méthode renvoie une **liste**
|
|
|
|
- c'est une liste d'instances de classe **Line2D**
|
|
|
|
|
|
|
|
En pratique, je peux récupérer les objets tracés en nommant ce que la fonction retourne :
|
|
|
|
|
|
|
|
``` python
|
|
|
|
# je nomme ce qui est retourné
|
|
|
|
un_truc = plot(x, y, **color**='green', **marker**='o', **linestyle**='dashed',
|
|
|
|
linewidth=2, markersize=12)
|
|
|
|
```
|
|
|
|
Vérifiez la nature de **un_truc** : c'est une **liste de un objet de type Line2D**.
|
|
|
|
Si je veux agir sur l'objet Line2D, je vais devoir récupérer l'objet lui-même, avec l'un ou l'autre méthode:
|
|
|
|
|
|
|
|
# je récupère une liste dont je prends ensuite le premier (et, ici, unique) élément
|
|
|
|
un_truc = plot(x, y, **color**='green')
|
|
|
|
ma_ligne = un_truc[0]
|
|
|
|
```
|
|
|
|
# je récupère la liste dans un tuple ; si j'ai un élément la VIRGULE est importante pour préciser que c'est un tuple de 1 unique élément
|
|
|
|
premier_element, = plot(x, y, **color**='green')
|
|
|
|
|
|
|
|
```
|
|
|
|
Nous avons donc nommé l'objet, ici une instance de **Line2D**, ce qui nous permettra de le modifier au besoin.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#### comment modifier l'objet créé
|
|
|
|
Les arguments sont ce que vous **passez** à la méthode.
|
|
|
|
Ce ne sont pas forcément directement les mêmes noms que les **attributs** de la classe, et vous n'avez pas toujours la permission de modifier ces attributs.
|
|
|
|
|
|
|
|
Il faut au préalable connaître la nature de l'objet, et vérifier comment modifier les attributs : à la volée ou le plus souvent avec des **setters**.
|
|
|
|
|
|
|
|
On remarque que les attributs correspondant aux vecteurs x et y s'appellent **xdata** et **ydata** pour un objet Line2D.
|
|
|
|
Pour modifier les valeurs il faut utiliser les setters **set_xdata(nouveau_vecteur_x)** et **set_ydata(nouveau_vecteur_y)**
|
|
|
|
|
|
|
|
_Autres exemples_ : set_data(x,y), set_title("mon titre"), set_color("red")...
|
|
|
|
|
|
|
|
De même, vous pouvez récupérer les valeurs des attributs avec des **getters** : get_data(), get_xdata(), get_color().
|
|
|
|
|
|
|
|
On utilisera ces méthodes dans les graphiques interactifs de l'[atelier widgets](Atelier_G_widgets) et l'[atelier clics](Atelier_clics)
|
|
|
|
|
|
|
|
|
|
|
|
## Lire les infos de la méthode pandas.**resample** : à venir
|
|
|
|
|
|
|
|
|
|
|
|
## Pour en savoir plus sur les *args et **kwargs
|
|
|
|
|
|
|
|
[un tuto}(https://realpython.com/python-kwargs-and-args/) |
|
|
\ No newline at end of file |
