Corrections suite aux relectures de Georges

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

@@ -1,17 +1,17 @@
-Expressions et variables
-=========================
+Expressions, instructions, et variables
+=======================================
 
 Instructions
 ------------
 
-Pour l'instant, dans tous les examples de code, chaque ligne qu'on a écrit
+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.
 
-Par exemple, l'expression ``print("bonjour")`` afiche "bonjour" dasn
-le terminal. On dit que l'expression est *éxécutée*.
+Par exemple, l'expression ``print("bonjour")`` affiche "bonjour" dans
+le terminal. On dit que l'expression est *exécutée*.
 
 Expressions
 -----------
@@ -21,16 +21,16 @@ Les instructions peuvent contenir des *expressions*.
 Un expression est toujours *évaluée* pour retourner une
 *valeur*
 
-Par example, ``1 + 2`` es une expression qui renvoie la valeur ``3``
+Par exemple, ``1 + 2`` es une expression qui renvoie la valeur ``3``
 une fois évaluée.
 
 Elle est constituée de 3 éléments:
 
-* Le *litéral* 1
+* Le *littéral* 1
 * L'*opérateur* ``+``
-* Le *litéral* 2
+* Le *littéral* 2
 
-Pour évaluer une expression, Python remplace les litéraux
+Pour évaluer une expression, Python remplace les littéraux
 par leur valeur, puis calcule la valeur finale en
 utilisant les opérateurs.
 
@@ -39,7 +39,7 @@ Notez que les expressions peuvent être imbriquées ::
     1 + (2 * 3)
 
 À droite du plus, on a une expression ``2 + 3``. Quand Python
-évaluera l'expression, il verra d'abord le litéral ``1`` et le ``+``,
+évaluera l'expression, il verra d'abord le littéral ``1`` et le ``+``,
 puis il évaluera l'expression à droite (``2*3 = 6``), et finalement
 l'expression en entier (``1 + 6 = 7``).
 
@@ -62,6 +62,8 @@ Si plus tard dans le code, on utilise le nom de la variable,
 tout se passera comme si nom de la variable avait été
 remplacé par sa valeur::
 
+
+
    a = 2
    print(a)
    # affiche: 2
@@ -85,14 +87,25 @@ Les expressions peuvent également contenir des variables.
 Quand Python évalue une expression qui contient des noms de variables,
 il remplace celles-ci par leur valeur::
 
+    a = 1
+    print(a + 2)   # ici a a été remplacé par 1
+    # affiche: 3
+
+Notez que la valeur de variable `a` n'a pas changé::
+
+    a = 1
+    print(a + 2)
+    # affiche: 3
+    print(a)
+    # affiche: 1
+
+Autres exemples::
+
     x = 1
     y = 2
-    z = x + y
-    print(z)
+    print(x+y)  # ici x a été remplacé par 1 et y par 2
     # affiche: 3
 
-Ici on a créé ``z`` en *évaluant* l'expression ``x+y``.
-
 Changer la valeur d'une variable
 ---------------------------------
 
@@ -109,17 +122,16 @@ On peut aussi *changer* la valeur d'une variable en l'assignant
 Combiner opération et assignation
 ----------------------------------
 
-La notation ``+=`` permet de combiner addition et assignation::
+La notation ``+=`` permet de combiner addition et assignation :
+les deux exemples ci-dessous sont équivalents::
 
    x = 3
    x = x + 1
-   print(x)
-   # affiche :: 4
+
+::
 
    x = 3
    x += 1
-   print(x)
-   # affiche :: 4
 
 
 Cela fonctionne aussi pour ``-=``, ``/=`` etc.
@@ -133,7 +145,11 @@ mais il est préférable d'avoir des noms longs et descriptifs
 Aussi, la convention est de:
 
 * Les écrire en minuscules
-* De séparer les mots par des tirest bas (*underscore*)::
+* De séparer les mots par des tirets bas (*underscore*)::
 
    score = 42
-   age_moyen = 22
+   âge_moyen = 22
+
+Notez que certains noms ne peuvent être utilisés comme nom
+de variables. On les appelle des *mots-clés*. La liste
+est disponible ici: https://docs.python.org/fr/3/reference/lexical_analysis.html#keywords

cours/source/04-flot-de-controle/01-flot-de-contrôle.rst

@@ -14,7 +14,7 @@ contrôle, et c'est  l'essence de la programmation!
 if
 ++
 
-On peut utiliser le mot ``if`` pour autoriser ou empécher
+On peut utiliser le mot-clé ``if`` pour autoriser ou empécher
 l'éxcution des instructions suivantes::
 
    a = 3
@@ -71,7 +71,7 @@ Ce code n'affiche pas "a et b sont égaux", mais affiche bien "on continue".
 if / else
 ---------
 
-On peut utiliser le mot ``else`` après un condition en ``if``
+On peut utiliser le mot-clé ``else`` après un condition en ``if``
 pour éxécutér un bloc si la condition est fausse::
 
    a = 3
@@ -104,7 +104,7 @@ conditions::
 while
 -----
 
-On peut utiliser ``while`` pour répéter un bloc tant qu'une condition
+On peut utiliser le mot-clé ``while`` pour répéter un bloc tant qu'une condition
 est vraie::
 
     i = 0
@@ -132,10 +132,10 @@ Dans ce cas, il faut appuyer sur ``CTRL-C`` pour interrompre
 le programme.
 
 
-Combiner while et if
---------------------
+Combiner while, if, et break
+-----------------------------
 
-On peut "sortir" de la boucle ``while`` avec ``break``::
+On peut "sortir" de la boucle ``while`` avec le mot-clé ``break``::
 
     i = 0
     while True:
@@ -151,3 +151,4 @@ On peut "sortir" de la boucle ``while`` avec ``break``::
    3
    4
 
+

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

@@ -10,7 +10,7 @@ Définition::
         print("Bonjour")
 
 
-* avec `def`
+* avec le mot-clé `def`
 * avec un `:` à la fin et un *bloc indenté* (appelé *le corps de la fonction*).
 
 Appel::
@@ -24,7 +24,7 @@ Example complet::
     def dire_bonjour():
         print("Bonjour")
 
-    bonjour()
+    dire_bonjour()
     # Affiche: bonjour'
 
 

cours/source/06-listes/index.rst

@@ -1,17 +1,15 @@
 Listes
 ======
 
-// TODO: split in pages
-
 Définition
 ----------
 
-Une liste est une *suite ordonée* d'éléments.
+Une liste est une *suite ordonnée* d'éléments.
 
 Créer une liste
 ---------------
 
-Avec des crochets: ``[``, ``]``, et les élements séparés par des virgules::
+Avec des crochets: ``[``, ``]``, et les éléments séparés par des virgules::
 
     liste_vide = []
     trois_entiers = [1, 2, 3]
@@ -76,10 +74,10 @@ Avec ``in``::
     print("Charlie" in prénoms)
     # affiche: False
 
-Itérer sur les élements d'une liste
+Itérer sur les éléments d'une liste
 ------------------------------------
 
-Avec ``for ... in``::
+Avec les mots-clés ``for`` et `` in``::
 
    prénoms = ["Alice", "Bob", "Charlie"]
    for prénom in prénoms:
@@ -93,6 +91,25 @@ Avec ``for ... in``::
    Bonjour Bob
    Bonjour Charlie
 
+
+Continue
+--------
+
+On peut interrompre l'exécution du bloc courant avec le mot-clé
+``continue``::
+
+   prénoms = ["Alice", "Bob", "Charlie"]
+   for prénom in prénoms:
+       if prénom == "Bob":
+           continue
+       print("Bonjour", prénom)
+
+.. code-block:: text
+
+   Bonjour Alice
+   Bonjour Charlie
+
+
 Indéxer une liste
 ------------------
 
@@ -150,7 +167,7 @@ On peut tester si un caractère est présent::
     # affiche: False
 
 
-Mais on neut peut pas modifier une string::
+Mais on ne peut pas modifier une string::
 
    prénom = "Charlotte"
    l = prénom[0]

cours/source/07-none-et-pass/01-none.rst

@@ -4,9 +4,9 @@ None
 Définition
 -----------
 
-``None`` est une "valeur magique" natif en python. il est toujours présent, et il est unique.
+``None`` est un mot-clé qui sert à représenter l'absence.
 
-Un peu comme ``True`` et ``False`` qui sont deux valeurs qui servent à représenter tous les booléens.
+Un peu comme ``True`` et ``False`` qui sonts des mot-clés qui réprésentent des booléens.
 
 Retourner None
 ----------------

cours/source/07-none-et-pass/02-pass.rst

@@ -1,12 +1,14 @@
 pass
 ====
 
-En Python, à cause de l'organisation en blocs indentés, on ne
-peut pas vraiment avoir de blocs vides. Mais parfois, on
-a besoin d'un bloc qui ne fasse rien.
 
-Dans ce cas, on peut utiliser le mot-clé `pass`, par exemple
-après un if::
+À cause de l'organisation du flot de contrôle en blocs indentés, on ne
+peut pas vraiment avoir de blocs vides. Mais parfois, on a besoin d'un bloc
+qui ne fasse rien - c'est là que le mot-clé `pass` rentre en jeu.
+
+`pass` représente une instruction qui ne fait rien.
+
+Un exemple::
 
     une_condition = False
     if une_condition:
@@ -19,3 +21,5 @@ définir une fonction qui ne fait rien::
 
     def ne_fait_rien():
         pass
+
+

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

@@ -68,7 +68,7 @@ Les classes sont utilisées pour construire des *instances*.
 Créons des instances
 ---------------------
 
-On peut faire un plan de construction vide avec le mot clé pass::
+On peut faire un plan de construction vide avec le mot-clé pass::
 
    class MaClasse:
        pass
@@ -111,9 +111,11 @@ On peut *créer* des attributs dans *n'importe quel instance*, en utilisant l'*a
    mon_instance.x = 42
 
    # Accés à l'attribut `x` dans `mon_instance`
-   print(mon_instance.mon_attribut)
+   print(mon_instance.x)
    # affiche: 42
 
+Ici l'attribut ``mon_attribut`` de l'instance ``mon_instance`` à la valeur de l'entier ``42``.
+
 Méthodes - définition
 ----------------------
 
@@ -126,6 +128,9 @@ moins un argument appelé `self`, et être à l'intérieur du bloc de la classe:
         def ma_méthode(self):
             return 42
 
+Notez que les méthodes *sont aussi des attributs*. Leur valeur est une *fonction* qui prend
+en argument l'instance courante.
+
 Méthodes - appel
 ----------------
 

cours/source/12-classes-02/02-composition.rst

@@ -102,12 +102,15 @@ qui va:
         def console(self):
             self.chat.caresse()
 
+
+Si on combine ces deux classes dans le même morceau de code et qu'on
+exécute les instructions suivantes::
+
     boule_de_poils = Chat("Boule de Poils")
     alice = Enfant("Alice", boule_de_poils)
-    # Alice est triste, on la console
     alice.console()
-    # affiche: Boule de Poils fait "prrrrr"
-    # Alice est consolée :)
+
+On afffichera ```Boule de Poils fait "prrr"`` et alice sera consolée.
 
 On dit parfois qu'on a *délégué* l'implémentation de la méthode ``console()`` de la classe Enfant
 à la méthode ``caresse()`` de la classe Chat.

cours/source/16-classes-03/index.rst

@@ -4,7 +4,8 @@ Héritage
 Rappel - composition
 ---------------------
 
-Dans le chapitre 13 on a parlé de *composition* qui décrit une relation entre deux classes.
+Dans un chapitre précédent on a parlé de *composition* qui décrit une classe à l'intérieur
+d'une autre classe.
 
 Pour rappel::
 

cours/source/17-décorateurs/02-décorateurs.rst

@@ -11,7 +11,9 @@ de la fonction décorée::
 
     def mon_décorateur(fonction):
         def fonction_retournée():
-            # fais quelque chose avec fonction
+            # fait quelque chose l'argument `fonction`, par exemple
+            # l'appeler avec un argument:
+            fonction(42)
         return fonction_retournée
 
     @mon_décorateur

cours/source/18-exceptions/02-exceptions-natives.rst

@@ -55,7 +55,7 @@ ValueError
 ``ValueError`` est levée (entre autres) quand on tente une maunvaise conversions::
 
    entrée_utilisateur = "pas un nombre"
-   valeu = int(entrée_utilisateur)
+   valeur = int(entrée_utilisateur)
 
 
 KeyboardInterrupt