Python_quelques-bases.md

@@ -229,6 +229,31 @@ ma_fonction()   #   = appel à la fonction (elle s’exécute)
 truc= ma_fonction # truc est une fonction, en fait truc se comporte maintenant comme ma_fonction
 truc= ma_fonction()  # j'exécute ma_fonction et truc est ce que renvoie ma_fonction
 ```
+
+:warning: le chaînage de fonctions :chains: 
+
+Dans certains cas, par exemple avec **pandas** on peut chainer les fonctions, et on "voit" ainsi apparaître plusieurs paires de parenthèses successives : `monthly_resampled_data = df_pluie_journaliere.station4.resample('M').mean()`. 
+
+Pour comprendre, partons d'instructions successives écrites avec des **fonctions**.
+
+```python
+resultat_1 = fonction_retourne_type_a(*mes_arguments)   #   une 1ère fonction prend mes_arguments en argument et retourne un objet resultat_1 de type "a"
+resultat_2 = fonction_retourne_type_b(resultat_1 ) # une 2e  fonction prend resultat_1  en argument et retourne un objet resultat_2 de type "b"
+resultat_3 = fonction_retourne_type_c(resultat_2 ) # une 3e  fonction prend resultat_2  en argument et retourne un objet resultat_3 de type "c"
+```
+Maintenant, voyons ce que ça donnerait avec des **méthodes** qui s'appliqueraient respectivement aux types de mes_arguments, a et b : on remarque que cette fois les méthodes ne prennent pas d'arguments (elles pourraient... mais les fonctions qu'elles remplacent ne prenaient pas d'arguments supplémentaires) :
+
+```python
+resultat_1 = mes_arguments.methode_retourne_type_a()   #   une 1ère méthode appliquée au conteneur mes_arguments retourne un objet resultat_1 de type "a"
+resultat_2 = resultat_1.methode_retourne_type_b( ) # une 2e  methode appliquée à resultat_1  retourne un objet resultat_2 de type "b"
+resultat_3 = resultat_2.methode_retourne_type_c( ) # une 3e  methode appliquée à resultat_2  retourne un objet resultat_3 de type "c"
+```
+
+Ces trois instructions peuvent être écrites en une ligne, avec l'avantage de ne pas créer de variables intermédiaires (resultat_1, resultat_2 )
+```python
+resultat_3 = mes_arguments.methode_retourne_type_a().methode_retourne_type_b().methode_retourne_type_c() 
+```
+
 b) une fonction *retourne toujours quelque chose*, si rien n’est précisé par défaut return = None
 je peux récupérer tout ce qu’elle retourne dans une variable, ici appelée resultat, qui est éventuellement un *tuple* contenant plusieurs objets ;
 ```python
@@ -237,7 +262,7 @@ resultat = ma_fonction()   #  éventuellement resultat = None ou un *tuple*
 
 ```python
 def ma_fonction(x):
-   #  définition d'une fonction prenant en argument x ; je ne précise pas son type
+   #  définition d'une fonction prenant en argument x ; le type de x n'est pas précisé ici
    print(x)
    return x, 2*x, x**2    # la fonction renvoie un tuple de 3 éléments
 
@@ -375,8 +400,6 @@ If False, return a copy. Otherwise, do operation inplace and return None.
 Returns 
 DataFrame  (DataFrame without the removed index or column labels) : sauf si inplace=True.
 
-
-
 e) *une fonction peut être passée en argument d’une autre fonction*
 ```python
 fonction_avec_options(var1, var2, ma_fonction)