Update language basics

Updated TIOBE graph to 2025 and removed 2021.
Updated language basics slides.
Split long tables into two pages.

documentation/01-discover.md

@@ -22,18 +22,18 @@ Python, c'est surtout :
 
 ----
 
-### Popularité 2021
-
-![Popularité des langages de programmation 2021](assets/images/x-intro-tiobe-2021.jpg)
-
-----
-
 ### Popularité 2022
 
 ![Popularité des langages de programmation 2022](assets/images/x-intro-tiobe-2022.png)
  
 ----
 
+### Popularité 2025
+
+![Popularité des langages de programmation 2025](assets/images/x-intro-tiobe-2025.png)
+ 
+----
+
 ## Historique de Python
 
 - Développement débuté en décembre 1989 par **Guido Van Rossum**
@@ -41,9 +41,7 @@ Python, c'est surtout :
 - Maintenu par la **Python Software Foundation** (mars 2001)
 - Licence permissive (PSFL) similaire à la BSD
 - Utilisé en éducation, IA, traitement de données, automatisme etc.
-- Python 2.0 sorti en octobre 2000 : gestion Unicode
+- Python 3.14 est la prochaine version
-- Python 3.0 (Python 3000) sorti en décembre 2008 : réorganisation
-- Python 3.11 sorti en novembre 2022 : performance
 
 ----
 
@@ -73,8 +71,8 @@ Le langage Python repose sur le socle technique suivant :
 
 - Première version (Python 3000) datée du 3 décembre 2008
 - Version prise en charge la plus ancienne : _3.7_ (2018)
-- Version la plus récente stable : _3.11_ (2022)
+- Version la plus récente stable : _3.13_ (2024)
-- Version la plus répandue (Linux) : _3.9_
+- Version la plus répandue (Linux) : _3.10_
 
 
 ----
@@ -85,7 +83,7 @@ Les machines Linux proposent toujours un terminal, même si vous y travaillez vi
 L'environnement de développement intégré graphique **PyCharm** en inclut également un.
 
 Sous Windows, l'invite de commande ou **PowerShell** sont également des terminaux. On conseillera
-largement PowerShell face à `cmd.exe`. Pour cette raison, passez à Windows 10 au minimum.
+largement PowerShell face à `cmd.exe`. Pour cette raison, passez à Windows 10 (2015) au minimum.
 
 ----
 
@@ -102,7 +100,6 @@ Il existe de nombreux éditeurs de code et environnements intégrés de dévelop
 1. PyCharm (Community ou Professional)
 2. Visual Studio Code
 3. Spyder
-4. ~~Atom~~
 
 Les environnements de développement vous facilitent l'écriture et l'exécution de code en Python,
 même si vous pourriez également tout faire avec un terminal et un éditeur de texte.

documentation/02-language-basics.md

@@ -11,8 +11,8 @@ author: Steve Kossouho
 
 Le langage Python peut être découpé en deux grands types d'instructions :
 
-- Les déclarations
+- Les [déclarations]{.naming}
-- Les expressions
+- Les [expressions]{.naming}
 
 Les déclarations sont en général des instructions pour créer des variables ou des structures de données.
 
@@ -30,7 +30,7 @@ print("Hello world!")
 
 ## Commentaires
 
-En Python, un commentaire est un élément textuel dans votre code qui sera ignoré à l'exécution.
+En Python, un commentaire est un élément textuel dans votre code qui sera complètement ignoré à l'exécution.
 Il ne pourra pas causer d'erreur de syntaxe, mais encore faut-il l'utiliser correctement :
 
 ```python {.numberLines}
@@ -42,7 +42,7 @@ print("Bonjour")  # Commentaire à la fin d'une ligne de code
 
 ## Variables
 
-Une variable est une boîte en mémoire à laquelle on donne un nom, et dans cette boîte, on place une valeur.
+Une variable est une référence à une donnée à laquelle on donne un nom. Une variable est toujours associée à une valeur.
 Cette valeur peut être un peu n'importe quoi en Python, mais notamment :
 
 - Un nombre (entier ou flottant)
@@ -57,7 +57,7 @@ Cette valeur peut être un peu n'importe quoi en Python, mais notamment :
 a = 15  # Python comprend qu'il s'agit d'un entier
 c = 3.14159265358979323  # Python comprend qu'il s'agit d'un flottant
 b = "Bonjour"  # Python reconnaît du texte
-d = input("Entrez du texte")
+d = input("Entrez du texte")  # Une fonction retourne une valeur
 del c  # Détruit la variable, qui devient invalide
 ```
 
@@ -110,6 +110,7 @@ a = 15
 chaine = "bonjour"
 nombre = 15
 print(a)  # `a` existe et peut être utilisée comme expression
+
 beau_temps = True  # Valeur spécifique *vrai*
 sale_temps = False  # Valeur spécifique *faux*
 non_defini = None  # valeur spéciale considérée comme "pas de valeur".
@@ -119,7 +120,7 @@ non_defini = None  # valeur spéciale considérée comme "pas de valeur".
 
 ## Types de données
 
-En programmation, les types de données ont des noms, et en Python ce sont les suivants :
+En programmation, les types de données ont des noms, et en Python ceux de base sont les suivants :
 
 - `int`{.python} : (integer) nombres entiers
 - `float`{.python} : (floating point numbers) nombres à virgule flottante
@@ -169,8 +170,8 @@ Exemples d'opérateurs : `+`{.python}, `>`{.python}, `**`{.python}, `%`{.python
 
 ### Opérateurs booléens en langage naturel
 
-- `a and b`{.python} : Vaut `True`{.python} si `a` **et** `b` valent `True`{.python}, sinon `False`.
+- `a and b`{.python} : Vaut `True`{.python} si `a` **et** `b` valent `True`{.python}, sinon `False`{.python}.
-- `a or b`{.python} : Vaut `True`{.python} si `a` **ou** `b` vaut `True`{.python}, sinon `False`.
+- `a or b`{.python} : Vaut `True`{.python} si `a` **ou** `b` vaut `True`{.python}, sinon `False`{.python}.
 - `a in b`{.python} : `True`{.python} si `a` fait partie de la collection ou séquence `b`.
 - `a not in b`{.python} : `True`{.python} si `a` ne fait pas partie de la collection ou séquence `b`
   .
@@ -186,7 +187,7 @@ Exemples d'opérateurs : `+`{.python}, `>`{.python}, `**`{.python}, `%`{.python
 Si `a`{.python} et `b`{.python} ne sont pas des booléens, la règle plus générale pour l'évaluation 
 des expressions utilisant des opérateurs booléens est la suivante :
 
-- `a and b`{.python} : Vaut `a` si `a` est équivalent à la valeur fausse, sinon vaut b.
+- `a and b`{.python} : Vaut `a` si `a` est équivalent à la valeur fausse, sinon vaut `b`.
 - `a or b`{.python} : Vaut `a` si `a` est équivalent à la valeur vraie, sinon vaut `b`.
 
 ----
@@ -218,6 +219,10 @@ print(kilometers, "kilomètres et", remaining_meters, "mètres")
 
 print(2 ** 3)  # affiche `8`
 print(2 <= 3)  # affiche `True`
+
+# Pour les pros de l'algèbre binaire
+print(0b1010 & 0b0011)  # affiche 2 (0b0010)
+print(0b1010 | 0b0011)  # affiche 11 (0b1011)
 ```
 
 Petit exemple de code avec conversion d'ordres de grandeur proportionnels (ex. mètres),
@@ -225,40 +230,77 @@ et usage d'autres opérateurs pour des opérations plus classiques.
 
 ----
 
+### Opérateurs d'assignation supplémentaires
+
 `a += b`{.python} est équivalent à → `a = a + b`{.python}
 
 Des opérateurs similaires sont disponibles pour les autres opérations arithmétiques :
 
-`-=`{.python}, `*=`{.python}, `/=`{.python}, `**=`{.python}, `//=`{.python}
+| Opérateur | Description                             | Exemple          | Équivalent à          |
-  et `%=`{.python}
+|-----------|-----------------------------------------|------------------|------------------------|
+| `=`       | Assignation simple                      | `x = 5`          | -                      |
+| `+=`      | Addition puis assignation               | `x += 3`         | `x = x + 3`            |
+| `-=`      | Soustraction puis assignation           | `x -= 2`         | `x = x - 2`            |
+| `*=`      | Multiplication puis assignation         | `x *= 4`         | `x = x * 4`            |
+| `/=`      | Division puis assignation               | `x /= 2`         | `x = x / 2`            |
+| `//=`     | Division entière puis assignation       | `x //= 2`        | `x = x // 2`           |
+| `%=`      | Modulo puis assignation                 | `x %= 3`         | `x = x % 3`            |
+| `**=`     | Exponentiation puis assignation         | `x **= 2`        | `x = x ** 2`           |
+1 sur 2
 
-(_dans la pratique, on n'utilisera que très rarement autre chose que les opérations de base, mais le principe est là_)
+----
+
+| Opérateur | Description                             | Exemple          | Équivalent à          |
+|-----------|-----------------------------------------|------------------|------------------------|
+| `&=`      | ET binaire puis assignation             | `x &= 1`         | `x = x & 1`            |
+| `|=`      | OU binaire puis assignation             | `x |= 2`         | `x = x | 2`            |
+| `^=`      | OU exclusif (XOR) binaire puis assignation | `x ^= 3`       | `x = x ^ 3`            |
+| `<<=`     | Décalage binaire à gauche puis assignation | `x <<= 1`     | `x = x << 1`           |
+| `>>=`     | Décalage binaire à droite puis assignation | `x >>= 1`     | `x = x >> 1`           |
+2 sur 2
+
+(_dans la pratique, on n'utilisera que très rarement autre chose que les opérations de base)
 
 ----
 
 ### Priorité des opérateurs en Python
 
-| Opérateurs                                                       | Signification                                     |
+| Opérateurs                                                       | Signification                          |
-|------------------------------------------------------------------|---------------------------------------------------|
+|------------------------------------------------------------------|----------------------------------------|
-| `()`                                                             | Parenthèses                                       |
+| `()`                                                             | Parenthèses                            |
-| `**`                                                             | Exposant                                          |
+| `**`                                                             | Exposant                               |
-| `+x`, `-x`, `~x`                                                 | Plus unaire, Moins unaire, NOT binaire            |
+| `+x`, `-x`, `~x`                                                 | Plus unaire, Moins unaire, NOT binaire |
-| `*`, `/`, `//`, `%`                                              | Multiplication, Division, Division entière, Modulo |
+| `*`, `/`, `//`, `%`                                              | Multiplication, Divisions, Modulo      |
-| `+`, `-`                                                         | Addition, Soustraction                            |
+| `+`, `-`                                                         | Addition, Soustraction                 |
-| `<<`, `>>`                                                       | Opérateurs de décalage binaire                    |
+| `<<`, `>>`                                                       | Opérateurs de décalage binaire         |
-| `&`                                                              | AND binaire                                       |
+| `&`                                                              | AND binaire                            |
-| `^`                                                              | XOR binaire                                       |
+| `^`                                                              | XOR binaire                            |
-| `\|`                                                             | OR binaire                                        |
+| <code>&#124;</code>                                              | OR binaire                             |
-| `==`, `!=`, `>`, `>=`, `<`, `<=`, `is`, `is not`, `in`, `not in` | Comparaisons, Identité, Opérateurs d'appartenance |
+1 sur 2
-| `not`                                                            | NOT logique                                       |
+
-| `and`                                                            | AND logique                                       |
+----
-| `or`                                                             | OR logique                                        |
+
-| `:=`                                                             | Expression d'assignation                          |
+| Opérateurs                                                       | Signification                          |
+|------------------------------------------------------------------|----------------------------------------|
+| `==`, `!=`, `>`, `>=`, `<`, `<=`, `is`, `is not`, `in`, `not in` | Comparaisons, appartenance             |
+| `not`                                                            | NOT logique                            |
+| `and`                                                            | AND logique                            |
+| `or`                                                             | OR logique                             |
+| `:=`                                                             | Expression d'assignation               |
+2 sur 2
 
 ----
 
 # Structures de contrôle
 
+Les structures de contrôle permettent de contrôler l'exécution du code, pour en augmenter l'interactivité.
+Nous parlerons dans cette partie de plusieurs sujets :
+
+- Conditions
+- Boucles : `for`
+- Boucles : `while`
+- Interrompre des boucles
+
 ----
 
 ## Conditions
@@ -268,7 +310,7 @@ certaines conditions sont vérifiées. En Python comme ailleurs, on utilise le m
 pour faire ce choix.
 
 Le mot-clé `if`{.python} est suivi d'une expression booléenne (`True`{.python} ou `False`{.python}
-ou équivalent) qui permet de savoir si on exécute du code ou pas.
+ou équivalent) qui permet de déterminer si l'on va exécuter du code ou pas.
 
 ```python {.numberLines}
 a = 15
@@ -280,8 +322,8 @@ print("Exécuté quoi qu'il arrive")
 
 . . .
 
-Ce qui est exécuté pour cette condition est indenté de 4 espaces (on parle de bloc). Grâce à
+Ce qui est exécuté pour cette condition est indenté de 4 espaces (on parle de [bloc]{.naming}). Grâce à
-l'indentation, Python sait où le code en question commence et où il s'arrête.
+l'indentation, Python sait où le code concerné commence et où il s'arrête.
 
 ----
 
@@ -343,8 +385,9 @@ else:  # Aucun des cas de figure du dessus
 ## Faire des boucles : `for … in liste`
 
 En programmation, une boucle consiste à répéter un bloc de code. En Python, le bloc est répété à
-chaque fois qu'on parcourt un élément dans une liste. Par exemple, si on veut afficher les 10
+chaque fois qu'on récupère une valeur dans une liste. Par exemple, si on veut afficher les 10
-premiers nombres, de 0 à 9, on utilise le mot-clé `for`{.python} avec la fonction `range`{.python} :
+premiers nombres, de 0 à 9, on utilise le mot-clé `for`{.python} avec la fonction `range`{.python},
+qui elle, génère des suites arithmétiques d'entiers :
 
 ```python {.numberLines}
 nombres = range(10)  # une liste de 10 entiers de 0 à 9 inclus
@@ -360,14 +403,21 @@ valeur assignée lors de la boucle.
 
 ### La fonction `range()`{.python}
 
-La fonction `range()`{.python} fournie par Python permet de générer des suites arithmétiques de nombres
+La fonction `range()`{.python} fournie par Python permet de générer des [suites arithmétiques]{.naming} de nombres
-entiers. Elle fonctionne avec un, deux ou trois arguments selon l'objectif.
+entiers. Une suite arithmétique possède une valeur de [départ]{.naming}, de [fin]{.naming}, et un [pas]{.naming} à ajouter à chaque étape.
+
+La fonction range fonctionne avec un, deux, ou trois arguments. La valeur de fin n'est **jamais** générée :
 
 ```python {.numberLines}
-zero_to_nine = range(10)  # stop (non inclus)
+# Un argument : fin. départ = 0, pas = 1
-one_to_eight = range(1, 9)  # start, stop
+zero_to_nine = range(10)  # 0, 1, 2, ..., 8, 9
-every_other_one = range(0, 10, 2)  # start, stop, step
+# Deux arguments : début, fin. pas = 1
-no_number_generated = range(10, 0, 2)  # start, stop, step
+one_to_eight = range(1, 9)  # 1, 2, ..., 7, 8
+impossible_1 = range(9, 1)  # ∅ ensemble vide
+# Trois arguments : début, fin, pas.
+every_other_one = range(0, 10, 2)  # 0, 2, 4, 6, 8
+impossible_2 = range(10, 0, 2)  # ∅ ensemble vide
+every_other_reverse = range(10, 0, -2)  # 10, 8, 6, 4, 2
 ```
 
 ----
@@ -375,7 +425,7 @@ no_number_generated = range(10, 0, 2)  # start, stop, step
 ## Faire des boucles : `while condition`
 
 Python propose un autre type de boucle `while`{.python} dont le bloc est exécuté tant qu'une
-condition est vraie (une expression convertie en booléen). Dès qu'elle devient fausse au début d'une
+condition est vraie (une expression évaluée comme booléen). Dès qu'elle devient fausse au début d'une
 itération, Python quitte la boucle et passe à la suite.
 
 ```python {.numberLines}
@@ -393,14 +443,17 @@ seul le bouton `⏹ Stop` peut l'interrompre.
 
 ## Exemple d'algorithme : Suite de Fibonacci
 
-**Suite de Fibonacci** : Une suite commençant par les nombres 0 et 1. On peut générer itérativement les
+**Suite de Fibonacci** : Une suite commençant par les nombres `0` et `1`. On peut générer itérativement les
 éléments successifs de la suite simplement; chaque nouveau nombre de la suite est la somme des deux qui le précèdent.
 
 Cela donne dans l'ordre :
 
-`0 1 1 2 3 5 8 13 21 34 55 89 144 …`
+| n      | 0  | 1  | 2  | 3  | 4  | 5  | 6  | 7   | 8   | 9   | 10  | 11  | 12   |
+|--------|----|----|----|----|----|----|----|-----|-----|-----|-----|-----|------|
+| F(n)   | 0  | 1  | 1  | 2  | 3  | 5  | 8  | 13  | 21  | 34  | 55  | 89  | 144  |
 
-Pour le résoudre, au choix, on utilise :
+
+Pour le faire, au choix, on utilise :
 
 - Deux variables (avec ou sans _unpacking_), ou trois avec une variable temporaire.
 - Une boucle `while`{.python} (pour définir quand on s'arrête d'afficher un nouvel élément)
@@ -409,9 +462,9 @@ Pour le résoudre, au choix, on utilise :
 
 ### Fibonacci : unpacking
 
-En Python, le "dépaquetage" (**unpacking**) est une forme d'assignation de variables où, lorsque
+En Python, le "dépaquetage" ([unpacking]{.naming}) est une forme d'assignation de variables où, lorsque
-l'expression à droite du signe `=` est une séquence à `n` éléments (avec `n > 1`), 
+l'expression à droite du signe `=` est un objet de type séquence à `n` éléments (avec `n > 1`), 
-vous pouvez assigner la séquence à `n` variables :
+vous pouvez assigner la séquence à exactement `n` variables :
 
 ```python {.numberLines}
 a, b, c = (1, 2, 3)  # a = 1, b = 2 et c = 3
@@ -422,7 +475,7 @@ a = (1, 2, 3)  # aucun problème, a est une séquence de 3 éléments
 . . .
 
 **Rappel** : si vous assignez la séquence à `1` variable, ça fonctionnera à nouveau, et votre 
-variable sera une séquence de `n` éléments.
+variable sera un objet de type séquence de `n` éléments.
 
 ----
 
@@ -505,11 +558,11 @@ Les cas d'indentation extrême doivent pouvoir être simplifiés d'une autre man
 
 ----
 
-## Bonus : Opérateur morse (walrus)
+## Extra : Opérateur morse (walrus)
 
-Sans rentrer dans le détail, on peut, depuis Python 3.8 (fin 2019), simplifier des boucles `while`{.python} avec un opérateur `:=`{.python}.
+On peut, depuis Python 3.8 (fin 2019), simplifier des boucles `while`{.python} avec un opérateur `:=`{.python}.
 C'est un opérateur qui permet d'assigner une valeur à une variable, mais contrairement au mot-clé `=`{.python}, l'opérateur
-forme une expression dont la valeur est l'opérande de droite. On peut ainsi écrire :
+forme une expression dont la valeur est l'**opérande de droite**. On peut ainsi écrire :
 
 ```python {.numberLines}
 while (saisie := input("Saisissez oui :")) != "oui":
@@ -558,10 +611,10 @@ print((a := 1) < 9)  # Affiche True, et a == 1, ce qu'on voulait
 
 ----
 
-### Petit plus : expression ternaire
+### Extra : expression ternaire
 
 En Python, il est possible de décrire une expression qui vaut une valeur `a` si une condition est 
-vraie, et `b` sinon. Sans cet opérateur, on écrit :
+vraie, et `b` sinon. Sans ce type d'expression, on écrit :
 
 ```python {.numberLines}
 if condition:
@@ -572,7 +625,7 @@ else:
 
 . . .
 
-Avec cet opérateur, on écrira plutôt :
+Avec ce type d'expression, on pourra plutôt écrire :
 
 ```python {.numberLines}
 variable = a if condition else b