Aller au contenu

TP - Boucles☘

Rappels importants☘

Rédiger un programme (ou un script), c'est saisir plusieurs instructions dans l'éditeur pour les exécuter toutes d'un coup :

  • Le programme Python peut être sauvegardé sous forme de fichier texte avec l'extension .py.
  • Pour exécuter le programme il suffit de le sauvegarder puis d'appuyer sur la touche [F5].
Rappels - Sauvegarder ses programmes

Vous allez devoir écrire de très nombreux programmes cette année. Pour s'y retrouver, vous devez organiser vos fichiers en leur donnant un nom explicite et en les « rangeant » correctement. Pour cela :

  1. Dans le répertoire [NSI], créez le dossier [F01-Bases de programmation].
  2. Dans ce dossier, enregistrez vos fichiers avec le nom donné à l'exercice (TPF01.31.py, TPF01.32.py, ...).

TPF01.31 : Boucler☘

En mathématiques, on appelle « factorielle n » le produit des entiers de 1 à n.
En d'autres termes, la factorielle 5 est 1 × 2 × 3 × 4 × 5 = 120.

  1. Dans un nouveau script (que vous prendrez soin de sauvegarder au bon endroit, avec le bon nom), copiez/collez et complétez le corps de la fonction facto() en respectant ses spécifications. 

    1
2
3
4
5
    def facto(n):
    """
    n – int, entier strictement positif
    Sortie : int – la factorielle de n
    """

  2. Vérifiez et corrigez si besoin votre travail avec l'aide des tests suivants : 

    >>> facto(5)
120

>>> facto(12)
479001600

Hasard et programmation☘

Le module random contient des fonctions qui permettent de générer des nombres pseudo-aléatoires. Parmi ces fonctions, on trouve :

  • randint(a, b) génère un entier compris entre a (inclus) et b (inclus).
  • random() génère un flottant compris entre 0 (inclus) et 1 (exclus).

On peut importer toutes les fonctions incluses dans le module random en début de programme grâce à l'instruction :

1
from random import *

TPF01.32 : Les petits chevaux☘

Dans le jeu des « petits chevaux », on ne peut pas sortir le cheval de son camp tant qu'on n'a pas obtenu « 6 » en lançant un dé équilibré à 6 faces.

  1. Ouvrez et sauvegardez un nouveau script.

  2. Complétez le corps de la fonction attente() qui n'a pas de paramètre. 

    1
2
3
4
5
6
7
    from random import randint

def attente():
    """
    Sortie : int – le nombre de lancers nécessaires pour
             obtenir un « 6 » avec un dé à 6 faces.
    """

    Une piste

    Voici une version « à trous » pour vous aider : 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
    from random import randint

def attente():
    """
    Sortie : int – le nombre de lancers nécessaires pour
             obtenir un « 6 » avec un dé à 6 faces.
    """
    nb = ...
    lancer = ...
    while ...:
        nb = ...
        lancer = ...
    return nb

  3. Voici un exemple d'exécution où il a fallu 4 lancers de dé avant d'obtenir un « 6 » : 

    >>> attente()
4

TPF01.33 : Somme aléatoire☘

  1. Ouvrez et sauvegardez un nouveau script.

  2. Complétez le corps de la fonction somme_hasard(n) qui doit générer successivement des entiers aléatoires entre 0 et n et renvoie la somme totale des entiers générés. La boucle s'arrête lorsque l'entier généré est 0.

    1
2
3
4
5
6
7
8
    from random import randint

def somme_hasard(n):
    """
    n – int, entier strictement positif
    Sortie : int – somme des entiers aléatoires générés entre 0 et n.
             On renvoie la somme dès que 0 est généré.
    """
    Une piste

    Voici une version « à trous » pour vous aider : 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
    from random import randint

def somme_hasard(n):
    """
    n – int, entier strictement positif
    Sortie : int – somme des entiers aléatoires générés entre 0 et n.
             On renvoie la somme dès que 0 est généré.
    """
    somme = ...
    genere = ...
    while ... :
        ...
        ...
    return ...

  3. Voici un exemple d'exécution : 

    >>> somme_hasard(10)
97

Problème : que s'est-il passé ? Y a-t-il eu neuf nombres 10 générés, un nombre 7 puis un 0 ? On ne sait pas. Une manière le savoir est d'afficher dans la consoles les étapes intermédiaires de calcul.

  1. En ajoutant l'instruction print() aux endroits judicieux de votre programme, essayez d'obtenir une exécution qui ressemble à la suivante : 
    >>> somme_hasard(10)
Nombre généré : 9, somme : 9
Nombre généré : 1, somme : 10
Nombre généré : 8, somme : 18
Nombre généré : 4, somme : 22
Nombre généré : 8, somme : 30
Nombre généré : 2, somme : 32
Nombre généré : 7, somme : 39
Nombre généré : 2, somme : 41
Nombre généré : 5, somme : 46
Nombre généré : 2, somme : 48
Nombre généré : 10, somme : 58
Nombre généré : 1, somme : 59
59

Remarque très importante

Ce print() dans le programme permet de vérifier son travail. Cependant, dans le cas d'un travail rendu à l'enseignant et noté, il faudra « nettoyer son code » de tous ces affichages qui ne correspondent pas aux spécifications (au cahier des charges) du programme.