autotion/training.python.beginner
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update language basics

Browse Source 
Updated TIOBE graph to 2025 and removed 2021.
Updated language basics slides.
Split long tables into two pages.
This commit is contained in:
Steve Kossouho
2025-07-06 20:12:53 +02:00
parent c8682d4801
commit ebe0844882
4 changed files with 116 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
documentation/01-discover.md
View File

@ -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.0 (Python 3000) sorti en décembre 2008 : réorganisation
- Python 3.11 sorti en novembre 2022 : performance
- Python 3.14 est la prochaine version
----
@ -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épandue (Linux) : _3.9_
- Version la plus récente stable : _3.13_ (2024)
- 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.

159
documentation/02-language-basics.md
View File

@ -11,8 +11,8 @@ author: Steve Kossouho
Le langage Python peut être découpé en deux grands types d'instructions :
- Les déclarations
- Les expressions
- Les [déclarations]{.naming}
- 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 or b`{.python} : Vaut `True`{.python} si `a` **ou** `b` vaut `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`{.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}
et `%=`{.python}
| Opérateur | Description | Exemple | Équivalent à |
|-----------|-----------------------------------------|------------------|------------------------|
| `=` | 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 |
|------------------------------------------------------------------|---------------------------------------------------|
| `()` | Parenthèses |
| `**` | Exposant |
| `+x`, `-x`, `~x` | Plus unaire, Moins unaire, NOT binaire |
| `*`, `/`, `//`, `%` | Multiplication, Division, Division entière, Modulo |
| `+`, `-` | Addition, Soustraction |
| `<<`, `>>` | Opérateurs de décalage binaire |
| `&` | AND binaire |
| `^` | XOR binaire |
| `\|` | OR binaire |
| `==`, `!=`, `>`, `>=`, `<`, `<=`, `is`, `is not`, `in`, `not in` | Comparaisons, Identité, Opérateurs d'appartenance |
| `not` | NOT logique |
| `and` | AND logique |
| `or` | OR logique |
| `:=` | Expression d'assignation |
| Opérateurs | Signification |
|------------------------------------------------------------------|----------------------------------------|
| `()` | Parenthèses |
| `**` | Exposant |
| `+x`, `-x`, `~x` | Plus unaire, Moins unaire, NOT binaire |
| `*`, `/`, `//`, `%` | Multiplication, Divisions, Modulo |
| `+`, `-` | Addition, Soustraction |
| `<<`, `>>` | Opérateurs de décalage binaire |
| `&` | AND binaire |
| `^` | XOR binaire |
| <code>&#124;</code> | OR binaire |
1 sur 2
----
| 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 à
l'indentation, Python sait où le code en question commence et où il s'arrête.
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 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
premiers nombres, de 0 à 9, on utilise le mot-clé `for`{.python} avec la fonction `range`{.python} :
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},
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
entiers. Elle fonctionne avec un, deux ou trois arguments selon l'objectif.
La fonction `range()`{.python} fournie par Python permet de générer des [suites arithmétiques]{.naming} de nombres
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)
one_to_eight = range(1, 9) # start, stop
every_other_one = range(0, 10, 2) # start, stop, step
no_number_generated = range(10, 0, 2) # start, stop, step
# Un argument : fin. départ = 0, pas = 1
zero_to_nine = range(10) # 0, 1, 2, ..., 8, 9
# Deux arguments : début, fin. pas = 1
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
l'expression à droite du signe `=` est une séquence à `n` éléments (avec `n > 1`),
vous pouvez assigner la séquence à `n` variables :
En Python, le "dépaquetage" ([unpacking]{.naming}) est une forme d'assignation de variables où, lorsque
l'expression à droite du signe `=` est un objet de type séquence à `n` éléments (avec `n > 1`),
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

BIN
documentation/assets/images/x-intro-tiobe-2021.jpg
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 86 KiB

BIN
documentation/assets/images/x-intro-tiobe-2025.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 170 KiB