I. Variables et affectation
Un programme manipule des valeurs qu'il faut bien ranger quelque part. Une variable est une case de la mémoire, désignée par un nom, dans laquelle le programme dépose une valeur pour la réutiliser plus tard.
Affecter une valeur à une variable, c'est ranger cette valeur dans la case correspondante. En langage naturel, l'affectation se note avec une flèche, par exemple . En Python, elle s'écrit avec le signe égal :
a = 5
b = a + 3
Après ces deux lignes, la variable a contient et la variable b contient .
Le signe = d'un programme n'est pas le signe d'égalité des mathématiques. La ligne n = n + 1 n'a aucun sens comme équation, mais elle est parfaitement claire comme instruction : elle remplace le contenu de n par ce contenu augmenté de .
Chaque valeur possède un type, qui décide des opérations autorisées.
| type | nom Python | exemples |
|---|---|---|
| entier | int | 0, -7, 2026 |
| nombre à virgule | float | 3.14, -0.5 |
| booléen | bool | True, False |
| chaîne de caractères | str | "bonjour", "12" |
La virgule décimale s'écrit avec un point en Python : le nombre se note 3.5.
Le calcul "12" + "3" renvoie la chaîne "123", alors que 12 + 3 renvoie l'entier 15. Le type change complètement le résultat, d'où l'importance de savoir ce que contient chaque variable.
II. Les instructions conditionnelles
Une instruction conditionnelle exécute un bloc d'instructions seulement lorsqu'une condition est vraie, et éventuellement un autre bloc sinon.
if note >= 10:
mention = "admis"
else:
mention = "ajourné"
La condition est une proposition qui vaut True ou False. Les instructions du bloc sont décalées vers la droite : cette indentation fait partie du langage, elle indique ce qui appartient au bloc.
Les comparaisons s'écrivent <, >, <=, >=, == pour l'égalité et != pour la différence. Le double signe égal distingue la comparaison de l'affectation.
Le programme suivant calcule la distance de x à zéro, c'est-à-dire la valeur absolue de x, en distinguant les deux cas.
if x >= 0:
d = x
else:
d = -x
III. Les boucles
Répéter une instruction dix fois à la main est fastidieux, et impossible si le nombre de répétitions dépend du calcul. Les boucles servent exactement à cela, et il en existe deux sortes.
Une boucle bornée répète un bloc un nombre de fois connu à l'avance.
somme = 0
for i in range(1, 11):
somme = somme + i
L'instruction range(1, 11) fait prendre à la variable i les valeurs entières de à . La borne de droite est exclue.
Une boucle non bornée répète un bloc tant qu'une condition reste vraie. Le nombre de tours n'est pas connu au départ.
n = 1
while 2 ** n < 1000:
n = n + 1
À la fin de l'exécution, la variable n contient le plus petit exposant tel que .
Dans une boucle non bornée, quelque chose doit faire évoluer la condition à chaque tour. Sans cela le programme tourne indéfiniment. Ici, c'est la ligne n = n + 1 qui garantit l'arrêt.
La question à se poser est simple : sait-on compter les répétitions avant de lancer le programme ? Si oui, la boucle bornée convient. Si le nombre de tours dépend d'un résultat obtenu en cours de route, par exemple « jusqu'à dépasser », la boucle non bornée s'impose.
IV. Les fonctions
Une fonction est un morceau de programme nommé, qui reçoit des arguments et renvoie un résultat. La définir une fois permet de l'utiliser autant de fois que nécessaire.
def aire_rectangle(longueur, largeur):
return longueur * largeur
L'appel aire_rectangle(5, 3) renvoie alors .
L'instruction return met fin à la fonction et transmet la valeur calculée. Sans elle, la fonction ne renvoie rien, et le résultat du calcul est perdu.
La fonction suivante applique une remise de à un prix donné.
def prix_remise(prix):
return prix * 0.8
L'appel prix_remise(50) renvoie . Une remise de revient bien à multiplier par .
V. Simuler le hasard
Un programme peut tirer des nombres au hasard, ce qui permet de simuler une expérience aléatoire des milliers de fois et d'observer les fréquences obtenues.
Le module random fournit les fonctions de tirage au hasard.
from random import randint, random
randint(1, 6) # un entier au hasard entre 1 et 6, bornes comprises
random() # un nombre à virgule au hasard dans [0 ; 1[
La fonction suivante compte le nombre de six obtenus en n lancers d'un dé équilibré.
from random import randint
def nombre_de_six(n):
compteur = 0
for i in range(n):
if randint(1, 6) == 6:
compteur = compteur + 1
return compteur
En divisant le résultat par n, on obtient la fréquence des six. Pour grand, cette fréquence est proche de , ce qui illustre la loi des grands nombres.
Deux exécutions du même programme aléatoire ne donnent pas le même résultat. C'est normal, et c'est même tout l'intérêt : la fluctuation observée d'une simulation à l'autre est un objet d'étude à part entière.
Passer à la pratique
9 exercices corrigés sur ce chapitre.