Encore des réécritures, suppression d'un chapitre redondant

cours/source/01-introduction/index.rst

@@ -1,5 +1,5 @@
-Chapitre 1 - Introduction
-=========================
+Introduction
+============
 
 
 .. toctree::

cours/source/02-premiers-pas/index.rst

@@ -1,5 +1,5 @@
-Chapitre 2 - Premiers pas
-=========================
+Premiers pas
+============
 
 .. toctree::
    :maxdepth: 1

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

@@ -1,25 +1,30 @@
-Variables
-=========
+Expressions et variables
+=========================
+
+Instructions
+------------
+
+Pour l'instant, dans tous les examples 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*.
 
 Expressions
 -----------
 
-Un peu de vocabulaire avant de continuer.
-
-Quand on écrit ``1 + 2`` en Python, on a ce qu'on
-appelle une *expression* -
+Les instructions peuvent contenir des *expressions*.
 
 Un expression est toujours *évaluée* pour retourner une
-*valeur* (ici 3)
+*valeur*
 
-Quand on écrit ``print(1 + 2)`` on a une *instruction*.
+Par example, ``1 + 2`` es une expression qui renvoie la valeur ``3``
+une fois évaluée.
 
-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:
+Elle est constituée de 3 éléments:
 
 * Le *litéral* 1
 * L'*opérateur* ``+``
@@ -29,6 +34,15 @@ Pour évaluer une expression, Python remplace les litéraux
 par leur valeur, puis calcule la valeur finale en
 utilisant les opérateurs.
 
+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 ``+``,
+puis il évaluera l'expression à droite (``2*3 = 6``), et finalement
+l'expression en entier (``1 + 6 = 7``).
+
 Variables et valeurs
 --------------------
 
@@ -113,7 +127,7 @@ Cela fonctionne aussi pour ``-=``, ``/=`` etc.
 Nom des variables
 -----------------
 
-Ci-dessus j'ai utilisé des noms de variables à une lettre, comme en maths,
+Ci-dessus j'ai utilisé des noms de variables à une lettre,
 mais il est préférable d'avoir des noms longs et descriptifs
 
 Aussi, la convention est de:

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

@@ -42,3 +42,29 @@ Par exemple::
 .. warning::
 
     Ne pas confondre: ``==`` pour la comparaison et ``=`` pour l'assignation
+
+Autres opérations booléennes
+-----------------------------
+
++-------+-----------+
+|``not``| négation  |
++-------+-----------+
+|``and``| et        |
++-------+-----------+
+|``or`` | ou        |
++-------+-----------+
+
+Exemples::
+
+    a = not True
+    print(a)
+    # affiche `False`
+
+    il_pleut = True
+    j_ai_un_parapluie = False
+    print(il_pleut and j_ai_un_parapluie)
+    # afiche: False
+
+    je_suis_mouillé = il_pleut and not j_ai_un_parapluie
+    prin(je_suis_mouillé)
+    # afiche: True

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

@@ -1,5 +1,5 @@
-Chapitre 3 - Variables et types
-================================
+Variables et types
+==================
 
 .. toctree::
    :maxdepth: 1

cours/source/04-booléens/index.rst

@@ -1,72 +0,0 @@
-Chapitre 4 - Booléens et conditions
-===================================
-
-En Python, les variables ``True`` et ``False`` sont toujours définies
-et servent à représenter une valeur vraie ou fausse.
-
-(Notez qu'elles commencent par une majuscule)
-
-Assignation
------------
-
-On peut assigner des variables à True ou False::
-
-
-    la_terre_est_plate = False
-    python_c_est_genial = True
-
-
-Comparaisons
-------------
-
-Certaines opérations renvoient des booléens:
-
-+------+-----------------------------+
-|``=`` | égal                        |
-+------+-----------------------------+
-|``!=``| différent                   |
-+------+-----------------------------+
-|``>`` | strictement supérieur       |
-+------+-----------------------------+
-|``>=``| supérieur ou égal           |
-+------+-----------------------------+
-|``<`` | strictement inférieur       |
-+------+-----------------------------+
-|``<=``| inférieur                   |
-+------+-----------------------------+
-
-Par example::
-
-   a = 2
-   b = 3
-   print(a > b)
-   # affiche: False
-
-   print(2 + 2 == 4)
-   # affiche: True
-
-.. warning::
-
-    Ne pas confondre: ``==`` pour la comparaison et ``=`` pour l'assignation
-
-
-Enfin, on peut écrire des encadrements::
-
-    a = 3
-    print(2 <= a < 4)
-    # affiche: True
-
-
-not
----
-
-Enfin, on peut utiliser ``not`` pour inverser une condition::
-
-    a = 3
-    if not a == 4:
-        print("a est différent de 4")
-    # affiche: a est différent de 4
-
-    la_terre_est_plate = False
-    print(not la_terre_est_plate)
-    # affiche: True

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

@@ -5,7 +5,9 @@ Pour l'instant, toutes les instructions que nous avons
 écrites ont été exécutée une par une et dans l'ordre
 d'apparition dans le code source.
 
-Modifier l'ordre d'exécution de ces lignes s'appelle modifier le flot de
+De plus, chaque ligne était constituée d'une unique expression.
+
+Modifier l'ordre d'exécution de ces instructions s'appelle modifier le flot de
 contrôle, et c'est  l'essence de la programmation!
 
 
@@ -13,15 +15,13 @@ if
 ++
 
 On peut utiliser le mot ``if`` pour autoriser ou empécher
-l'éxcution du code en-dessous::
+l'éxcution des instructions suivantes::
 
    a = 3
    b = 4
    if a == b:
        print("a et b sont égaux")
-   print("on continue")
-   # affiche juste
-   # on continue
+   # n'affiche rien
 
 La 4ème ligne n'est pas éxécutée parce la condition
 est fausse.
@@ -31,10 +31,11 @@ Notes:
 * il y a le caractère ``:`` (deux points) à la fin de la ligne
 * le code en-dessous du ``if`` commence par 4 espaces: on appelle
   cela une *indentation*
-* si la condition n'est pas vraie, rien ne se passe
 
-Notez qu'on peut mettre uniquement une variable ou une valeur
-après le if. Ceci ne fonctionne pas::
+Notez qu'on a utilisé une **expression** après le if.
+On ne peut pas utiliser d'instruction après un ``if`` en Python.
+
+Autrement dit, ce code ne fonctionne pas::
 
     if a = 3:
     	print("a égale 3")
@@ -48,10 +49,25 @@ On parle aussi de "bloc" si plusieurs lignes sont identées::
        # début du bloc
        print("a et b sont égaux")
        c = 2 * a
-       # fin du block
+       # fin du bloc
+
+Notez qu'on reprend l'ordre habituel d'éxécution des instructions s'il
+y a un bloc identé dans l'autre sens après le ``if``::
+
+   a = 3
+   b = 4
+   if a == b:
+       # début du bloc
+       print("a et b sont égaux")
+       c = 2 * a
+       # fin du bloc
+   # on est après le bloc if
    print("on continue")
 
 
+Ce code n'affiche pas "a et b sont égaux", mais affiche bien "on continue".
+
+
 if / else
 ---------
 
@@ -115,8 +131,6 @@ On parle de *boucle infinie* si la condition ne devient jamais fausse::
 Dans ce cas, il faut appuyer sur ``CTRL-C`` pour interrompre
 le programme.
 
-Notez ici qu'on a mis directement la valeur ``True``, et non une comparaison.
-
 
 Combiner while et if
 --------------------
@@ -136,3 +150,4 @@ On peut "sortir" de la boucle ``while`` avec ``break``::
    2
    3
    4
+

cours/source/04-flot-de-controle/02-falsy-truthy.rst

@@ -0,0 +1,66 @@
+Falsy et truthy
+================
+
+Expressions après un if
+-----------------------
+
+Jusqu'ici les expressions qu'on a utilisées donnait un booléens une fois évaluées, mais
+un expression apès un ``if`` peut être d'un autre type.
+
+Par exemple, un entier::
+
+    x = 0
+    if x:
+        print("x n'est pas nul")
+    else:
+        print("x est nul")
+
+    # affiche: x est nul
+
+On dit que ``0`` est ``Falsy``, parce qu'après un ``if``, il se comporte comme une expression
+qui vaudrait False.
+
+Réciproquement, tous les entiers sauf 0 sont ``Truthy``, parce qu'ils se comportent comme
+une expression qui vaudrait True::
+
+    y = 6
+    if y:
+        print("y n'est pas nul")
+    else:
+        print("y est nul")
+
+    # affiche: y n'est pas nul
+
+
+On retrouve ce principe avec les chaînes de caractères::
+
+    message = ""
+    if message:
+        print("le message n'est pas vide")
+    else:
+        print("le message est vide")
+    # affiche: le message est vide
+
+
+Le chaînes vides sont falsy, les autres sont truthy.
+
+
+Expressions quelconques
+-----------------------
+
+En fait, on peut utiliser tous les opérateurs booléens avec des expressions
+quelconques::
+
+    message = "bonjour"
+    if not message:
+        print("le message n'est pas vide")
+    # affiche : le message n'est pas vide
+
+
+    score = 42
+    if message and score:
+        print("le message et le score sont truthy")
+    # affiche : le message et le score sont truthy
+
+
+

cours/source/04-flot-de-controle/index.rst

@@ -0,0 +1,9 @@
+Flot de contrôle
+================
+
+.. toctree::
+   :maxdepth: 1
+
+   ./01-flot-de-contrôle.rst
+   ./02-falsy-truthy.rst
+   ./03-exercice.rst

cours/source/05-flot-de-controle/index.rst

@@ -1,8 +0,0 @@
-Chapitre 5 - Flot de contrôle
-=============================
-
-.. toctree::
-   :maxdepth: 1
-
-   01-flot-de-contrôle
-   02-exercice

cours/source/06-fonctions-01/index.rst → cours/source/05-fonctions-01/index.rst

@@ -1,5 +1,5 @@
-Chapitre 6 - Introduction aux fonctions
-=======================================
+Introduction aux fonctions
+==========================
 
 .. toctree::
    :maxdepth: 1

cours/source/07-listes/index.rst → cours/source/06-listes/index.rst

@@ -1,5 +1,5 @@
-Chapitre 7 - Listes
-===================
+Listes
+======
 
 // TODO: split in pages
 

cours/source/08-none-et-pass/index.rst → cours/source/07-none-et-pass/index.rst

@@ -1,5 +1,5 @@
-Chapitre 8 - None et pass
-=========================
+None et pass
+============
 
 .. toctree::
    :maxdepth: 1

cours/source/09-dictionnaires/index.rst → cours/source/08-dictionnaires/index.rst

@@ -1,5 +1,5 @@
-Chapitre 9 - Dictionnaires
-==========================
+Dictionnaires
+==============
 
 Définition
 ----------

cours/source/10-tuples/index.rst → cours/source/09-tuples/index.rst

@@ -1,5 +1,6 @@
-Chapitre 10 - Tuples
-=====================
+Tuples
+======
+
 Définition
 ------------
 

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

@@ -1,5 +1,5 @@
-Chapitre 11 - Introduction aux classes
-======================================
+Introduction aux classes
+========================
 
 Ce qu’on a vu jusqu’ici:
 

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

@@ -1,5 +1,5 @@
-Chapitre 12 - Introduction aux modules
-======================================
+Introduction aux modules
+========================
 
 Un fichier = un module
 ------------------------

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

@@ -0,0 +1,8 @@
+Couplage et composition
+=======================
+
+.. toctree::
+   :maxdepth: 1
+
+   01-couplage
+   02-composition

cours/source/14-bibliothèques-01/index.rst → cours/source/13-bibliothèques-01/index.rst

@@ -1,5 +1,5 @@
-Chapitre 14 - Bibliothèques
-===========================
+Bibliothèques
+=============
 
 .. toctree::
    :maxdepth: 1

cours/source/13-classes-02/index.rst

@@ -1,8 +0,0 @@
-Chapitre 13 - Couplage et composition
-=====================================
-
-.. toctree::
-   :maxdepth: 1
-
-   01-couplage
-   02-composition

cours/source/15-fichiers-et-données-binaires/index.rst → cours/source/14-fichiers-et-données-binaires/index.rst

@@ -1,5 +1,5 @@
-Chapitre 15 - Données binaires et fichiers
-==========================================
+Données binaires et fichiers
+============================
 
 On vous a peut-être déjà dit que l'informatique consiste à
 manipuler des suites de 0 et et de 1s, mais qu'en est-t-il

cours/source/16-interpréteur-interactif/index.rst → cours/source/15-interpréteur-interactif/index.rst

@@ -1,5 +1,5 @@
-Chapitre 16 - L'interpréteur interactif
-=======================================
+L'interpréteur interactif
+=========================
 
 Démarrage
 ----------

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

@@ -1,5 +1,5 @@
-Chapitre 17 - Héritage
-======================
+Héritage
+========
 
 Rappel - composition
 ---------------------

cours/source/18-functions-02/index.rst → cours/source/17-décorateurs/index.rst

@@ -1,5 +1,5 @@
-Chapitre 18 - Décorateurs
-=========================
+Décorateurs
+===========
 
 .. toctree::
    :maxdepth: 1

cours/source/19-exceptions/index.rst → cours/source/18-exceptions/index.rst

@@ -1,5 +1,5 @@
-Chapitre 19 - Exceptions
-========================
+Exceptions
+==========
 
 On a souvent montré des exemples de code qui provoquaient des erreurs au
 cours des chapitres précédents. Il est temps maintenant de se pencher

cours/source/index.rst

@@ -17,21 +17,21 @@ remarques.
    :maxdepth: 1
    :caption: Table des matières:
 
-   01-introduction/index
-   02-premiers-pas/index
-   03-variables-et-types/index
-   05-flot-de-controle/index
-   06-fonctions-01/index
-   07-listes/index
-   08-none-et-pass/index
-   09-dictionnaires/index
-   10-tuples/index
-   11-classes-01/index
-   12-modules-01/index
-   13-classes-02/index
-   14-bibliothèques-01/index
-   15-fichiers-et-données-binaires/index
-   16-interpréteur-interactif/index
-   17-classes-03/index
-   18-functions-02/index
-   19-exceptions/index
+   01-introduction/index.rst
+   02-premiers-pas/index.rst
+   03-variables-et-types/index.rst
+   04-flot-de-controle/index.rst
+   05-fonctions-01/index.rst
+   06-listes/index.rst
+   07-none-et-pass/index.rst
+   08-dictionnaires/index.rst
+   09-tuples/index.rst
+   10-classes-01/index.rst
+   11-modules-01/index.rst
+   12-classes-02/index.rst
+   13-bibliothèques-01/index.rst
+   14-fichiers-et-données-binaires/index.rst
+   15-interpréteur-interactif/index.rst
+   16-classes-03/index.rst
+   17-décorateurs/index.rst
+   18-exceptions/index.rst