Update language basics
Updated TIOBE graph to 2025 and removed 2021. Updated language basics slides. Split long tables into two pages.
This commit is contained in:
@ -22,18 +22,18 @@ Python, c'est surtout :
|
||||
|
||||
----
|
||||
|
||||
### Popularité 2021
|
||||
|
||||
|
||||
|
||||
----
|
||||
|
||||
### Popularité 2022
|
||||
|
||||
|
||||
|
||||
----
|
||||
|
||||
### Popularité 2025
|
||||
|
||||
|
||||
|
||||
----
|
||||
|
||||
## 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.
|
||||
|
||||
@ -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 |
|
||||
| `*`, `/`, `//`, `%` | Multiplication, Divisions, 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 |
|
||||
| <code>|</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
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 86 KiB |
BIN
documentation/assets/images/x-intro-tiobe-2025.png
Normal file
BIN
documentation/assets/images/x-intro-tiobe-2025.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 170 KiB |
Reference in New Issue
Block a user