Python : boucles et fonctions — Exercices

1. La boucle for

Combien de fois le message "Salut" est-il affiché par ce programme ?
```
for i in range(7):
    print("Salut")
```
Quelles sont les valeurs successives prises par i dans for i in range(4): ?
Écris un programme qui affiche les nombres de $1$ à $10$ (inclus), un par ligne, à l’aide d’une boucle for et de range.

Voir le corrigé

$7$ fois, car range(7) produit $7$ valeurs.
i prend successivement les valeurs $0, 1, 2, 3$ (quatre valeurs, de $0$ à $3$ ).
```
for i in range(1, 11):
    print(i)
```
(range(1, 11) produit les valeurs de $1$ $1$ à $10$ $10$ , le nombre $11$ $11$ n’étant jamais atteint.)

On donne le programme suivant :

compteur = 0
while compteur < 5:
    print(compteur)
    compteur = compteur + 1

Voir le corrigé

Il affiche $0, 1, 2, 3, 4$ (cinq valeurs).
Après avoir affiché $4$ , compteur devient $5$ : la condition compteur < 5 devient fausse ( $5$ n’est pas strictement inférieur à $5$ ), donc la boucle s’arrête.
Sans cette ligne, compteur resterait toujours égal à $0$ : la condition compteur < 5 resterait toujours vraie, et la boucle tournerait indéfiniment (boucle infinie), affichant 0 sans jamais s’arrêter.

Écris une fonction dire_au_revoir (sans paramètre) qui affiche "Au revoir !".
Appelle cette fonction trois fois dans ton programme.
Quelle est la différence entre définir une fonction et l’appeler ?

Voir le corrigé

def dire_au_revoir():
    print("Au revoir !")

dire_au_revoir()
dire_au_revoir()
dire_au_revoir()

Définir une fonction (avec def) décrit ce qu’elle fait, sans encore l’exécuter. L’appeler (en écrivant son nom suivi de parenthèses) exécute réellement les instructions qu’elle contient.

Écris une fonction double(nombre) qui reçoit un paramètre nombre et renvoie le double de ce nombre (utilise return).
Utilise cette fonction pour calculer et afficher le double de $17$ .
Quelle est la différence entre print(...) à l’intérieur d’une fonction et return ... ?

Voir le corrigé

def double(nombre):
    return nombre * 2

```
resultat = double(17)
print(resultat)
```
(Affiche 34.)
print(...) affiche une valeur à l’écran, mais le programme qui a appelé la fonction ne peut pas la récupérer pour un calcul ultérieur. return ... renvoie la valeur au programme appelant, qui peut alors la stocker dans une variable ou la réutiliser, sans qu’elle soit forcément affichée.

Écris une fonction produit_jusqua(n) qui calcule et renvoie le produit des entiers de $1$ à $n$ (par exemple, produit_jusqua(4) doit renvoyer $1 \times 2 \times 3 \times 4 = 24$ ), à l’aide d’une boucle for.
Teste ta fonction en affichant produit_jusqua(5). Vérifie le résultat par un calcul à la main.
Pourquoi faut-il initialiser la variable qui accumule le produit à $1$ , et non à $0$ , contrairement à une somme ?

Voir le corrigé

def produit_jusqua(n):
    total = 1
    for i in range(1, n + 1):
        total = total * i
    return total

```
print(produit_jusqua(5))
```
Affiche 120, car $1 \times 2 \times 3 \times 4 \times 5 = 120$ $1 \times 2 \times 3 \times 4 \times 5 = 120$ , ce que l’on peut vérifier : $1 \times 2 = 2$ $1 \times 2 = 2$ , $2 \times 3 = 6$ $2 \times 3 = 6$ , $6 \times 4 = 24$ $6 \times 4 = 24$ , $24 \times 5 = 120$ $24 \times 5 = 120$ .
Si total valait $0$ au départ, alors total * i vaudrait toujours $0$ à chaque tour de boucle (multiplier par $0$ donne toujours $0$ ), et le résultat final serait $0$ au lieu du produit attendu. En partant de $1$ (l’élément neutre de la multiplication), les multiplications successives donnent bien le produit recherché.