Python_-quelques-bases.md

@@ -144,7 +144,63 @@ Le numéro  50  s'écrit : cinquante
 La fonction est un objet comme les autres (ou presque) !
 Les fonctions et méthodes (fonctions définies dans une classe) peuvent être appelées pour exécuter des instructions et retourner un ou plusieurs objets. Techniquement, ce sont donc des « callables »  (http://sametmax.com/quest-ce-quun-callable-en-python/ ).
 
-#### A.3.1. Rappel des bases pour éviter des erreurs courantes :
+#### A.3.1. Rappels, fonction et **paramètres** de la fonction
+
+Une fonction (ou une méthode) est définie par le mot-clé **def**, un nom de fonction suivi d'une liste de noms de variables entre parenthèses, puis un bloc de code introduit par les "**:**", qui commence de préférence par une docstring.
+
+``` python
+def ma_fonction(param1, param2, param3):
+    """ doctring pour décrire ce que fait ma_fonction """
+
+``` 
+
+Cas particulier des **méthodes**, avec le mot-clé **self**pour renvoyer à l'instance courante (attention, tout autre mot fait l'affaire, dont si vous l'oubliez le premier nom fourni fera office de "self" !).
+On remarque que dans le cas de le fonction **__init__** qui initialise l'instance, les **attributs** n'ont pas forcément le même nom que les paramètres, et peuvent d'ailleurs être en nombre différent !
+
+``` python
+class MonObjet:
+    def __init__ (param1, param2, param3):
+        self.param1 = param1
+        self.somme = param2 + param3
+    def ma_methode(self, a, b):ab: 
+         """J'ajoute a et b à self.somme.
+         :param a : un truc à ajouter
+         :type a : entier
+         :param b : un autre truc à ajouter
+         :type a : flottant ou entier
+         :return: somme a + b
+         :rtype: flottant
+        """
+        aplusb = a + b
+        self.somme += aplusb 
+        return aplusb 
+ 
+```
+
+On peut remplacer **self** par **this**, comme en java ; ce n'est pas du tout recommandé, mais on insiste sur l'importance de ne pas l'oublier !
+``` python
+    def ma_methode(this, a, b):
+        """ petite description de ma fonction : elle calcule a + b, et l'ajoute à l'attribut somme ; elle retourne aussi a+b  """
+        aplusb = a + b
+        this.somme += aplusb 
+        return aplusb 
+``` 
+
+machin = MonObjet(4,5,6)
+
+bidule = machin.ma_methode(1,2)
+
+Un point de vocabulaire : **paramètres** et **arguments**
+En Python vous trouverez ces deux termes. Pour la documentation des fonctions (les "docstrings"), qui est une bonne pratique [recommandée dans les PEPs](https://peps.python.org/pep-0257/), selon le format suivi va vous demander de les définir comme `:param nom_variable: ` ([Sphinx](https://sphinx-rtd-tutorial.readthedocs.io/en/latest/docstrings.html) ) 
+En théorie, les **paramètres** sont ce qui est **déclaré** dans la fonction, entre les parenthèses, et les **arguments** sont ce qui est passé lors de l'**appel** de la fonction.
+Donc, ici a et b seraient les paramètres de `ma_methode` et 1,2 seraient les arguments passés lors de l'appel.
+La méthode `ma_methode` renvoie ici un nombre calculé par la fonction, qui est également décrit dans la docstring.
+
+La manière de définir et d'ordonner les paramètres est décrite dans le point **f** ci-dessous
+
+
+
+#### A.3.2. Rappel des bases pour éviter des erreurs courantes :
 Gardez en tête que la fonction est un objet ! Cela aide à bien comprendre les points importants suivants, qui seront détaillés ensuite.
 
 a) Attention à mettre les parenthèses quand on appelle la fonction et seulement là !