Encore une passe de relecture

Ajout aussi d'une explication sur les concepts
d'"instruction" et d"expression".

cours/source/01-introduction/01-introduction.rst

@@ -6,13 +6,12 @@ Apprendre la programmation en partant de rien, en utilisant Python et la ligne d
 Pourquoi Python?
 ----------------
 
-* Excellent langage pour débuter
+* Excellent langage pour débuter - il a d'ailleurs été créé avec cet objectif en tête
 * Mon langage préféré
-* Vraiment cross-platform (sauf pour le mobile)
+* Facile à installer quelque soit le système d'exploitation (Linux, macOS, Windows)
 
 Pourquoi la ligne de commande?
 ------------------------------
 
-Interface universelle
-
-La plus simple à utiliser (en Python en tout cas)
+C'est un interface universelle. Pour faire des programmes en lignes de commande,
+on n'a juste besoin de manipuler du *texte*, et c'est le plus simple au début.

cours/source/02-premiers-pas/01-bases-ligne-de-commandes.rst

@@ -13,11 +13,30 @@ Pourquoi la ligne de commande?
 Les bases
 ----------
 
-On tape un commande, on appuie sur entrée, l'ordinateur interprète ce qui a été tapé et affiche un message:
+Les lignes de commandes sont à taper dans un *terminal*.
 
-* `cd chemin/vers/fichier`
-* `ls` (ou `dir` sous Windows)
-* `pwd`
+* Sur linux, vous en avez probablement un insallé par défaut.
+* Sur macOS, il se trouve dans `Applications/Utilitaires`
+* Sum Windows, il se lance en tapant ``cmd.exe``
 
-* Le premier mot est une *commande*, les autres mots sont des *arguments*
+Dans tous les cas, cela ressemble à ceci:
 
+.. image:: /img/terminal.png
+
+Notez le petit bout de texte avant le curseur : on appelle ça
+une *invite* de commande (``prompt`` en anglais).
+
+Pour lancer une commande, on tape son nom, suivi parfois d'un certain
+nombre de mots séparés par des espaces, puis on appuie sur entrée.
+
+Par exemple, on peut utiliser ``ls`` (ou ``dir``) sous Windows pour lister
+le contenu du répertoire courant:
+
+.. image:: /img/terminal-ls.png
+
+Et on peut utiliser ``cd`` suivi du nom d'un répertoire pour changer de répertoire
+courrant:
+
+.. image:: /img/terminal-cd.png
+
+Notez que l'invite de commande a changé.

cours/source/02-premiers-pas/03-code-source.rst

@@ -59,8 +59,6 @@ Revenons sur ce qu'il s'est passé : nous avions le mot `print` avec des parenth
 et quelque chose à l'intérieur des parenthèses, et ceci a provoqué l'affichage
 du contenu des parenthèses dans le terminal.
 
-C'est *la* principale façon d'intéragir avec du code Python : on peut demander
-à l'interpréteur d'afficher n'importe quel valeur.
 
 Commentaires
 ------------

cours/source/02-premiers-pas/04-maths-simples.rst

@@ -75,17 +75,3 @@ et on peut utiliser des parenthèses pour grouper les opérations::
     print((1 + 2) * 3)
     # affiche: 9
 
-Combiner opération et assignation
-----------------------------------
-
-La notation ``+=`` permet de combiner addition et assignation::
-
-   x = 3
-   x = x + 1
-   print(x)
-   # affiche :: 4
-
-   x = 3
-   x += 1
-   print(x)
-   # affiche :: 4

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

@@ -1,22 +1,86 @@
 Variables
 =========
 
+Expressions
+-----------
+
+Un peu de vocabulaire avant de continuer.
+
+Quand on écrit ``1 + 2`` en Python, on a ce qu'on
+appelle une *expression* -
+
+Un expression est toujours *évaluée* pour retourner une
+*valeur* (ici 3)
+
+Quand on écrit ``print(1 + 2)`` on a une *instruction*.
+
+Un instruction ne renvoie pas de valeur, mais a un
+effet sur le programme, ici l'affichage de la valeur
+de l'expression évaluée dans le terminal.
+
+Enfin, l'expression ``1 + 2`` est constituée de trois
+éléments:
+
+* Le *litéral* 1
+* L'*opérateur* ``+``
+* Le *litéral* 2
+
+Pour évaluer une expression, Python remplace les litéraux
+par leur valeur, puis calcule la valeur finale en
+utilisant les opérateurs.
+
+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*.
+de part et d'autre du signe ``=`` : on appelle cette opération
+une *assignation*::
 
-Ensuite, on peut utiliser la variable à la place de sa valeur:
-à chaque fois que l'interpréteur essaye d'exécuter du code,
-il commence par remplacer les variables par leurs valeurs::
 
     a = 2
+
+Notez qu'une assignation *n'est pas* une expression, c'est une
+*instruction*.
+
+On dit aussi que ``a`` est une *référence* vers la valeur ``2``.
+
+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
+
+Variables et expressions
+-------------------------
+
+En fait, on peut assigner une variable à n'importe quelle
+*expression*, et pas simplement des littéraux::
+
+    a = 1 + 2
     print(a)
-    # affiche: 2
+    # affiche: 3
+
+
+Variables et expressions contenant d'autres variables
+------------------------------------------------------
+
+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::
+
+    x = 1
+    y = 2
+    z = x + y
+    print(z)
+    # affiche: 3
 
-    b = 3
-    print(a + b)
-    # affiche: 5
+Ici on a créé ``z`` en *évaluant* l'expression ``x+y``.
 
+Changer la valeur d'une variable
+---------------------------------
 
 On peut aussi *changer* la valeur d'une variable en l'assignant
 à une nouvelle valeur::
@@ -24,12 +88,27 @@ On peut aussi *changer* la valeur d'une variable en l'assignant
 
     a = 2
     print(a)
-    # affiche: 2
-
     a = 3
     print(a)
-    # affiche: 3
+    # affiche: 2, puis 3
+
+Combiner opération et assignation
+----------------------------------
+
+La notation ``+=`` permet de combiner addition et assignation::
+
+   x = 3
+   x = x + 1
+   print(x)
+   # affiche :: 4
+
+   x = 3
+   x += 1
+   print(x)
+   # affiche :: 4
+
 
+Cela fonctionne aussi pour ``-=``, ``/=`` etc.
 
 Nom des variables
 -----------------

cours/source/03-variables-et-types/02-chaînes-de-caractères.rst

@@ -47,7 +47,7 @@ Concaténation
 -------------
 
 On peut construire de longues chaînes de caractères en
-en concaténatant de plus petites::
+en concaténatant de plus petites, avec l'opérateur ``+``::
 
    name = "John"
    message = "Bonjour " + name + " !"

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

@@ -7,13 +7,13 @@ d'un côté et un entier de l'autre::
 
    a = 42
    b = 4
-   a + b  # ok
+   c = a + b  # ok
 
    salutation = "bonjour, "
    prénom = "Bob"
    salutation + prénom  # ok
 
-   message = "La réponse est " + a
+   résultat = a + prénom
    # affiche:
    # TypeError: can only concatenate str (not "int") to str
 
@@ -32,14 +32,11 @@ Entier vers string
 ++++++++++++++++++
 
 On peut convertir un entier en string en utilisant le mot ``str`` et des parenthèses
-autour de la variable ou de la valeur::
+autour de l'expression::
 
-    message = "La réponse est: " + str(42)
-    print(message)
-    # affiche: La réponse est 42
-
-    réponse = 42
-    message = "La réponse est: " + str(42)
+    x = 40
+    y = 2
+    message = "La réponse est: " + str(x + y)
     print(message)
     # affiche: La réponse est 42
 

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

@@ -1,25 +1,19 @@
-Booléens et conditions
-======================
+Booléens
+========
 
-En Python, les variables ``True`` et ``False`` sont toujours définies
-et servent à représenter une valeur vraie ou fausse.
+On appelle *booléenne* une valeur qui peut être soit vraie, soit fausse.
 
-(Notez qu'elles commencent par une majuscule)
+En Python, les littéraux ``True`` et ``False`` représentent respectivement les valeurs
+vraies et fausses.
 
-Assignation
------------
-
-On peut assigner des variables à True ou False::
-
-
-    la_terre_est_plate = False
-    python_c_est_genial = True
+(Notez qu'ils commencent par une majuscule)
 
 
 Comparaisons
 ------------
 
-Certaines opérations renvoient des booléens:
+Certaines expressions renvoient des booléens, c'est à dire
+soit la valeur ``True``, soit la valeur ``False``
 
 +------+-----------------------------+
 |``=`` | égal                        |
@@ -35,7 +29,7 @@ Certaines opérations renvoient des booléens:
 |``<=``| inférieur                   |
 +------+-----------------------------+
 
-Par example::
+Par exemple::
 
    a = 2
    b = 3

cours/source/index.rst

@@ -20,7 +20,6 @@ remarques.
    01-introduction/index
    02-premiers-pas/index
    03-variables-et-types/index
-   04-booléens/index
    05-flot-de-controle/index
    06-fonctions-01/index
    07-listes/index