Correction de l'ordre des mots, pour de bon cette fois ci

cours/source/03-variables-et-types/01-variables.rst

@@ -7,12 +7,13 @@ Instructions
 Pour l'instant, dans tous les exemples de code, chaque ligne qu'on a écrit
 contenait une *instruction*.
 
-Un instruction ne renvoie pas de valeur, mais a un
-effet sur le programme.
+Un instruction a un effet sur le programe dans lequel elle est présented
 
 Par exemple, l'expression ``print("bonjour")`` affiche "bonjour" dans
 le terminal. On dit que l'expression est *exécutée*.
 
+En règle générale, les expressions sont éxécutées une par une, de haut en bas.
+
 Expressions
 -----------
 
@@ -48,15 +49,14 @@ Variables et valeurs
 
 On peut associer des *variables* à des *valeurs* en les plaçant
 de part et d'autre du signe ``=`` : on appelle cette opération
-une *assignation*::
-
+une *affectation*::
 
     a = 2
 
-Notez qu'une assignation *n'est pas* une expression, c'est une
-*instruction*.
+Ici on assigne l'entier 2 à la variable ``a``.
 
-On dit aussi que ``a`` est une *référence* vers la valeur ``2``.
+Notez qu'une affectation *n'est pas* une expression, c'est une
+*instruction*.
 
 Si plus tard dans le code, on utilise le nom de la variable,
 tout se passera comme si nom de la variable avait été
@@ -71,8 +71,8 @@ remplacé par sa valeur::
 Variables et expressions
 -------------------------
 
-En fait, on peut assigner une variable à n'importe quelle
-*expression*, et pas simplement des littéraux::
+En fait, on peut assigner n'importe qu'elle *expression* à une variable,
+et pas simplement des littéraux::
 
     a = 1 + 2
     print(a)
@@ -109,8 +109,8 @@ Autres exemples::
 Changer la valeur d'une variable
 ---------------------------------
 
-On peut aussi *changer* la valeur d'une variable en l'assignant
-à une nouvelle valeur::
+On peut aussi *changer* la valeur d'une variable en affectant
+une nouvelle valeur à celle-ci::
 
 
     a = 2
@@ -119,10 +119,10 @@ On peut aussi *changer* la valeur d'une variable en l'assignant
     print(a)
     # affiche: 2, puis 3
 
-Combiner opération et assignation
+Combiner opération et affectation
 ----------------------------------
 
-La notation ``+=`` permet de combiner addition et assignation :
+La notation ``+=`` permet de combiner addition et affectation :
 les deux exemples ci-dessous sont équivalents::
 
    x = 3

cours/source/03-variables-et-types/04-booléens.rst

@@ -41,7 +41,7 @@ Par exemple::
 
 .. warning::
 
-    Ne pas confondre: ``==`` pour la comparaison et ``=`` pour l'assignation
+    Ne pas confondre: ``==`` pour la comparaison et ``=`` pour l'affectation
 
 Autres opérations booléennes
 -----------------------------

cours/source/05-fonctions-01/01-functions.rst

@@ -54,9 +54,10 @@ Appel: en passant une variable ou une valeur dans les parenthèses::
 
     dire_bonjour("Germaine")
 
-L'éxécution de l'appel à une foctionne exactement  comme si on assignait
-les arguments de la fonction avant d'éxécuter le code
-dans le corps::
+Pour évaluer une expression qui contient l'appel a une fonction, on:
+
+* assigne le contenu des parenthèses aux arguments de la fonction
+* puis on éxécute les instructions dans le corps de la fonction
 
     # Ceci:
     dire_bonjour("Dimitri")

cours/source/05-fonctions-01/06-return.rst

@@ -10,7 +10,7 @@ Récupérer la valeur de retour::
 
    a = 3
    b = 4
-   c = additionner(a, b)   # encore une assignation
+   c = additionner(a, b)   # encore une affectation
    print(c)
    # Affche: 7
 

cours/source/06-listes/index.rst

@@ -81,8 +81,8 @@ Avec les mots-clés ``for`` et `` in``::
 
    prénoms = ["Alice", "Bob", "Charlie"]
    for prénom in prénoms:
-   	# La variable 'prénom" est assignée à chaque
-   	# élément de la liste
+   	   # Chaque élément de la liste est assigné tour à tour
+       # à la variable 'prénom"
        print("Bonjour", prénom)
 
 .. code-block:: text

cours/source/08-dictionnaires/index.rst

@@ -90,9 +90,10 @@ Avec ``for ... in ...``, comme pour les listes::
 
     scores = {"john": 10, "bob": 42}
     for nom in scores:
-    	# `nom` est assigné à "john" puis "bob"
+    	# on assigne la valeur "john" à la variable `nom`, puis "bob"
     	score_associé_au_nom = scores[nom]
-        # score_associé_au_nom est assigné à '10' puis '42'
+        # on assigne la valeur 10 puis la valeur 42 à la variable
+        # score_associé_au_nom
     	print(nom, score_associé_au_nom)
 
 .. code-block::

cours/source/10-classes-01/index.rst

@@ -114,7 +114,7 @@ On peut *créer* des attributs dans *n'importe quel instance*, en utilisant l'*a
    print(mon_instance.x)
    # affiche: 42
 
-Ici l'attribut ``mon_attribut`` de l'instance ``mon_instance`` à la valeur de l'entier ``42``.
+Ici on assigne la valeur ``42`` à l'attribut ``x`` de l'instance ``mon_instance``
 
 Méthodes - définition
 ----------------------

cours/source/11-modules-01/index.rst

@@ -17,7 +17,7 @@ Importer un module
 Ou: accéder à du code provenant d'un *autre* fichier source.
 
 Créons un fichier `bonjour.py` contenant seulement une assignation
-d'une variable `a` à l'entier 42 ::
+de l'entier 42 à la variable `a`::
 
     # Dans bonjour.py
     a = 42
@@ -38,7 +38,7 @@ on peut accéder à cette variable en *important* le module::
   Le nom du module est écrit directement, ce n'est *pas* une
   chaîne de caractères.
 
-On voit que l'assignation de la variable `a` dans `bonjour.py` est devenue
+On voit que la variable `a` dans `bonjour.py` est devenue
 un *attribut* du module `bonjour` lorsque `bonjour` a été importé
 
 
@@ -66,7 +66,7 @@ Il est important de noter que:
 * mais il n'est *pas* ré-éxécuté si le module a déjà été importé auparavant.
 
 On peut le voir en mettant du code dans `bonjour.py`,
-en plus des simples définitions de fonctions et assignations
+en plus des simples définitions de fonctions et de créations
 de variables::
 
     # Dans bonjour.py

cours/source/17-décorateurs/01-introduction.rst

@@ -6,14 +6,11 @@ Introduction
 
 Reprenons ce qu'on a vu jusqu'ici.
 
-D'une part, on peut créer des variables en les assignant à une valeur::
+D'une part, on peut créer des variables en assignant des valeurs à celles-ci::
 
     # Création d'une variable `x` avec la valeur 4
     x = 4
 
-
-On dit aussi que ``x`` *référence* la valeur ``4``
-
 D'autre part, on peut définir et appeler des fonctions::
 
     # Définition de la fonction:
@@ -29,7 +26,9 @@ D'autre part, on peut définir et appeler des fonctions::
 Fonctions en tant que variables
 -------------------------------
 
-Il se trouve qu'en Python, on peut assigner des variables à ... des fonctions
+Il se trouve qu'en Python, on peut assigner des fonctions à des
+variables. C'est différent d'assigner le résultat de l'appel à une
+fonction à une variable, et ça permet de retarder l'appel:
 
 .. code-block:: python
 
@@ -41,10 +40,11 @@ Il se trouve qu'en Python, on peut assigner des variables à ... des fonctions
   def dire_bonjour_en_anglais(nom):
       print("Hello " + nom)
 
-  # Création d'une variable qui référence la fonction française:
+  # Assigne une fonction à la variable - aucune fonction
+  # n'est appelée à ce stade.
   ma_fonction_qui_dit_bonjour = dire_bonjour_en_français
 
-  # Appel de la fonction:
+  # Appel de la fonction (retardé)
   ma_fonction_qui_dit_bonjour("Max")
 
   # Affiche: Bonjour Max
@@ -53,11 +53,11 @@ Il se trouve qu'en Python, on peut assigner des variables à ... des fonctions
 De façon cruciale, notez que l'on n'a *pas* mis de parenthèses à droite
 lorsqu'on a créé la variable `ma_fonction_qui_dit_bonjour`.
 
-On peut donc dire que lorsqu'on définit une fonction avec `def()` et un corps
+On peut donc dire que lorsqu'on définit une fonction avec ``def ma_fonction()`` et un corps:
 il y a en réalité deux étapes:
 
 1. Python stocke le corps de la fonction quelque part
-2. Il crée une variable qui référence ce corps
+2. Il assigne le corps de celle-ci à une variable dont le nom est ``ma_fonction``.
 
 En Python, il est assez fréquent d'utiliser de code tel que celui-ci, souvent avec un dictionnaire::
 
@@ -79,10 +79,9 @@ En Python, il est assez fréquent d'utiliser de code tel que celui-ci, souvent a
 Fonctions en tant qu'argement d'autres fonctions
 ------------------------------------------------
 
-On a vu en début de chapitre qu'on peut créé des variables qui référencent
-des fonctions.
+On a vu en début de chapitre qu'on peut assigner des fonctions à des variables.
 
-Du coup, rien n'empêche de les passer en *argument* d'autres fonctions.
+Du coup, rien n'empêche de passer des fonctions en *argument* d'autres fonctions.
 
 Par exemple::