Q4 (21-SPO1U59-INFO-TS1-Q4)

Écrire un programme en Python qui :

Crée une liste $L1$ et la remplit de façon aléatoire avec 8 entiers appartenant à $[10, 100]$.
Affiche la liste $L1$.
Demande à l’utilisateur de saisir un entier $N$ compris entre $2$ et $9$. Le programme bouclera sur cette saisie tant que cette condition n’est pas validée ($2\leq N \leq 9$).
Crée une liste $L2$ et la remplir avec les valeurs de $L1$ qui sont multiples de $N$.
Affiche la taille $T$ de $L2$ ainsi que le contenu de $L2$.

Commençons par traiter le premier point :

Crée une liste $L1$ et la remplit de façon aléatoire avec 8 entiers appartenant à $[10, 100]$.

Notez que l’énoncé stipule que les nombres entiers doivent être obtenus « de façon aléatoire ».

Nous avons ici besoin du module random de la librairie standard Python ! Plus précisément, nous utiliserons la méthode random.randint() rendue disponible par l’importation de ce module.

Plus généralement, ce module contient plein de fonctions qui vont nous permettre de jouer avec le hasard.

Par module, je vous demande d’imaginer un autre programme, qui contient des fonctions toutes prêtes, ici des fonctions en lien avec la génération aléatoire de nombres. Afin de pouvoir en tirer avantage, nous devons importer le module random dans notre programme Python. Cela mettra le code des fonctions de ce module à notre disposition au sein de notre code, de façon sous-jacente, et nous pourrons ainsi faire appel à n’importe quelle fonction du module random et ce sans restriction… Notre code commencera donc par

import random

En Python, nous pouvons utiliser la méthode randint() pour générer un nombre entier aléatoire.

Prenons un exemple, et décrivons ce qui se passe d’un point de vue strictement formel. L’exécution de la commande

randint(5,15)

retourne un entier, choisi au hasard parmi les éléments de

$$ \left\{5,6,7,8,9,10,11,12,13,14,15\right\}$$

Plus généralement, la commande

randint(a,b)

où $a$ et $b$ sont des entiers de votre choix, va retourner un entier choisi aléatoirement parmis les entiers $x$ satisfaisant

$$ a\leq x \leq b.$$

Nous avons tous les outils nécessaires à la réussite de notre première mission : Définissons une liste $L1$ remplie de façon aléatoire avec des entiers appartenant à $[10,100]$ :

L1 = [random.randint(10,100) for i in range(8)]

Pour construire la liste, nous avons procédé en disant à l’ordinateur :

« Tu dois effectuer 8 tirages successifs d’un entier choisi aléatoirement parmi les entiers compris entre $10$ et $100$ ».

Notez que range(8) initialise une séquence de nombres entiers : $0,1,2,3,4,5,6,7,8$, qui permet à l’ordinateur de savoir combien de fois répéter l’opération $\textbf{random.randint}(10,100)$.

Par exemple, si nous voulons demander à l’ordinateur de générer une liste qui ne contient 5 fois la chaîne de caractères stabilo, nous pouvons procéder de la façon suivante :

LISTE_STABILO = [str("stabilo") for i in range(5)]

Liste avec cinq chaînes de caractères (strings) **stabilo**

Si nous voulons par exemple une liste avec $12$ chaînes de caractères stabilo, il nous suffit de remplacer le $\text{range}(5)$ par $\text{range}(12)$ dans la définition de la liste.

LISTE_STABILO = [str("stabilo") for i in range(5)]

Liste avec douze chaînes de caractères **stabilo**. Pour mémoire, on définit une chaîne de caractères avec **str(« mot »)**, par exemple, **str(« stabilo »)**.

Entrons le code :

Le second point nous demande d’entrer une commande qui permet d’afficher la liste $L1$.

Les options ne manquent pas :

Nous pouvons soit utiliser simplement la commande

L1

ou encore

print(L1)

ou bien

display(L1)

Ces trois commandes afficheront la liste $L1$, comme illustré ci-dessous :

Le troisième point requiert que nous demandions à l’utilisateur de saisir un entier $N$ compris entre $2$ et $9$.
Notez que l’énoncé indique que le code doit être pensé de façon à ce que le programme boucle sur cette saisie tant que la condition $$2 \leq N \leq 9$$ n’est pas validée.

Nous allons utiliser une boucle while qui contiendra le morceau de code qui permet à l’utilisateur de saisir $N$, et bouclera à l’infini, demandant à l’utilisateur de saisir une valeur de $N$, tant que la condition sur $N$ spécifiée par l’énoncé n’est pas satisfaite.

Un test conditionnel if sera réalisé à chaque exécution de la boucle (en fin de boucle) de façon à vérifier si $2 \leq N \leq 9$ est validée. Lorsque c’est le cas, on utilisera break pour casser la boucle, et sortir de celle-ci.

while True :
    N = int(input("Saisir un entier compris entre 2 et 9 : "))

Notez que si nous nous contentons de cette boucle while, dans cet état, alors celle-ci va tourner à l’infini. Il n’y a pour le moment pas le moindre test conditionnel permettant de vérifier la véracité de la condition désirée sur $N$.

Ajoutons un test, qui cassera la boucle une fois satisfait !

while True :
    N = int(input("Saisir un entier compris entre 2 et 9 : "))
    if (2<=N) and (N<=9) : 
        break

Nous demandons ici à l’ordinateur de tester, en fin de boucle, si les conditions $$2 \leq N \qquad \text{et} \qquad N\leq 9$$ sont satisfaites. Lorsque c’est le cas, la commande break est exécutée, et la boucle est cassée, i.e., elle prend fin, nous sortons de la boucle.

Si ce n’est pas le cas, la boucle continue de tourner, et de demander à l’utilisateur de saisir un nombre $N$ jusqu’à ce que la condition désirée soit éventuellement satisfaite.

Si nous rentrons par exemple $15$, alors le programme nous demande de saisir à nouveau un entier.

Si nous saisissons par exemple la valeur $7$, alors la boucle prendra immédiatement fin !

L’énoncé demande ensuite de définir une liste $L2$ contenant les valeurs de $L1$ qui sont multiples de $N$.

Ici, c’est simple :

Soit $m \in L1$. Alors $m$ est un multiple de $N$ si et seulement s’il existe un entier $k\in ZZ$, $k$ non-nul, tel que

$$ m = kN.$$

Autrement dit, le reste de la division euclidienne de $m$ par $N$ est nul !

En termes de commandes Python, nous pouvons utiliser % pour calculer de tels restes !

Par exemple, la commande

10 % 5

va nous retourner zéro, car $5$ divise $10$, i.e., $10 = 5 \times 2$ est un multiple de $5$ !

Rappel : Soient $a$ et $b$ deux entiers. L’expression $a = bq + r$ avec $0\leq r < b$ est appelée la formule de la division euclidienne, où $q$ est le quotient de $a$ par $b$ et $r$ le reste dans la division euclidienne de $a$ par $b$.
La commande a % b va simplement calculer le reste $r$ de la division euclidenne de $a$ par $b$ !

Donc, $m$ est un multiple de $N$ si et seulement si le reste de la division euclidenne de $m$ par $N$ est nul.

En termes de Python, la condition à tester est :

m % N == 0

Par exemple, la commande

10 % 5 == 0

va retourner True, car le reste de la division euclidenne de $10$ par $5$ est bien nul ($10$ est un multiple de $5$).

La commande

49 % 5 == 0

doit par contre retourner False, car $49$ n’est pas un multiple de $5$.

Définissons la liste $L2$ telle que décrite par l’énoncé : Les éléments de $L2$ contiennent les éléments de $L1$ multiples de $N$ :

L2 = [q for q in L1 if q % N == 0]

Cela nous donne :

On a donc ici, avec $$ L1 = [82, 98, 45, 64, 80, 19, 75, 46]\quad \text{et} \quad N = 7$$

une liste $L2$ ne contenant que l’entier $98$ comme élément.

On a en effet $$ 98 = 14 \times 7$$ i.e., l’entier $98$ est le seul multiple de $N=7$ dans la liste $L1$.

L’énoncé nous demande finalement d’afficher la taille de la liste $L2$, et sous-entend que nous devons assigner la variable $T$ à cette taille.

Lorsque l’on travaille avec des listes, on ne parle pas de « taille », on parle plutôt de length, de longueur de la liste.

La fonction len(LISTE) permet d’obtenir la longueur d’une liste, i.e., le nombre d’éléments que celle-ci contient.

Posons

T = len(L2)

Ici, la liste $L2$ a longueur $1$ : Elle ne contient en effet qu’un seul élément !

Affichons à présent le contenu de $L2$ : Nous pouvons afficher la liste entière, en utilisant soit

L2

print(L2)

ou encore

display(L2)

Q4 (21-SPO1U59-INFO-TS1-Q4)

Connexion

Modal title