Premières structures de données : listes et tuples
Documents
-
Doc. 3,1 : Les tuples
-
Doc. 3,2 : Les listes
-
Doc. 3,3 : Une liste est un objet auquel on peut passer des messages
-
Doc. 3,4 : Simuler un gaz avec Pyxel
Doc. 3,1 : Les tuples
Doc. 3,2 : Les listes
Doc. 3,3 : Une liste est un objet auquel on peut passer des messages
Doc. 3,4 : Simuler un gaz avec Pyxel
Regrouper plusieurs valeurs dans un seul objet, le tuple, pour qu’une fonction puisse renvoyer plusieurs résultats à la fois.
Dans le Doc. 2,4, la fonction plus_grand_plus_petit retournait une chaîne de caractères comme "max : 18.0, min : 7.5". Pour un humain, c’est très lisible. Mais imaginons qu’on veuille ensuite calculer l’écart entre le maximum et le minimum. Il faudrait fouiller dans le texte pour retrouver les chiffres, puis les convertir en nombres. On a fabriqué une phrase alors qu’on voulait deux nombres.
Le vrai problème est le suivant : une instruction return met fin à la fonction. On ne peut donc pas écrire deux return à la suite en espérant récupérer deux résultats. Faisons une expérience.
Recopier la fonction suivante dans la partie principale de l’éditeur Thonny :
min_max(9, 4) dans la console. Qu’affiche-t-elle ?resultat = min_max(9, 4), puis type(resultat). Combien d’objets la fonction a-t-elle retournés ?On n’a donc pas contourné la règle : une fonction renvoie toujours une seule valeur. On a simplement rangé les deux nombres dans une même boîte, et c’est la boîte qu’on renvoie.
Un tuple (le programme dit aussi p-uplet) est une suite ordonnée de valeurs. On l’écrit en séparant les valeurs par des virgules, le plus souvent entre parenthèses : (4, 9).
Le tuple est un type construit : il est fabriqué à partir de valeurs de types de base (int, float, str, bool).
Une fonction ne retourne qu’une seule valeur. Pour retourner plusieurs résultats, elle les regroupe dans un tuple : return a, b.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Avec la fonction min_max du cours, que vaut type(min_max(9, 4)) ?
return a, b regroupe les deux nombres dans un seul objet, un tuple.
Combien d’objets une fonction qui exécute return a, b retourne-t-elle ?
Une fonction retourne toujours un seul objet ; pour transmettre plusieurs résultats, on les regroupe dans un tuple.
Pour chacune des expressions suivantes, prévoir le type de la valeur obtenue, puis vérifier avec la fonction type dans la console :
Le deuxième essai provoque une erreur. Pourquoi, à votre avis ? Comment écrire un tuple qui ne contient qu’un seul élément ?
Les éléments d’un tuple ne sont pas forcément du même type. Une ville peut être décrite par son nom, sa latitude et sa longitude :
Ce tuple n’a de sens que parce qu’on s’est mis d’accord sur l’ordre : d’abord le nom, ensuite la latitude, enfin la longitude. Si on écrivait (48.86, "Paris", 2.35), Python ne protesterait pas, mais un programme qui attend le nom en premier serait trompé.
Chaque élément d’un tuple occupe une position, appelée indice. En Python, les indices commencent à 0. Cela paraît étrange au début. Une façon de s’en souvenir : l’indice indique combien de pas il faut faire depuis le début pour atteindre l’élément. Le premier élément est à zéro pas du début.
| indice | 0 | 1 | 2 |
|---|---|---|---|
élément de t |
3 | 7 | 12 |
On lit l’élément d’indice i du tuple t en écrivant t[i]. La fonction len, déjà rencontrée avec les chaînes de caractères, donne le nombre d’éléments du tuple.
Saisir t = (3, 7, 12) dans la console. Prévoir le résultat de chacune des instructions suivantes, puis vérifier :
Quel est l’indice du dernier élément d’un tuple qui contient n éléments ?
Python accepte aussi des indices négatifs, qui comptent à partir de la fin : t[-1] est le dernier élément, t[-2] l’avant-dernier. Avec t = (3, 7, 12), t[-1] vaut 12, exactement comme t[len(t) - 1].
Avec ville = ("Paris", 48.86, 2.35), écrire une instruction qui affiche, à l’aide d’une f-string et des indices :
Les éléments d’un tuple t sont repérés par leur indice, qui commence à 0. On lit l’élément d’indice i avec t[i].
len(t) donne le nombre d’éléments de t. Les indices valides vont donc de 0 à len(t) - 1. Un indice en dehors de ces limites provoque une erreur IndexError.
Un tuple d’un seul élément s’écrit avec une virgule : (5,). Le tuple vide s’écrit ().
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Que vaut type((5)) ?
Les parenthèses seules ne font qu’entourer l’expression 5. Pour un tuple d’un seul élément, il faut une virgule : (5,).
Avec t = (3, 7, 12), que produit t[3] ?
Le tuple contient 3 éléments, d’indices 0, 1 et 2 : l’indice 3 n’existe pas.
Un tuple t contient n éléments. Quelles expressions donnent son dernier élément ?
Les indices vont de 0 à len(t) - 1. L’indice négatif -1 compte à partir de la fin. t[len(t)] et t[n] sont hors limites.
Toujours avec t = (3, 7, 12), essayer de remplacer le premier élément par 4 :
Que se passe-t-il ?
Un tuple, une fois créé, ne change plus. On dit qu’il est non mutable (ou immuable). Est-ce gênant ? Pas vraiment, car on peut toujours fabriquer un nouveau tuple.
Prévoir, puis vérifier, le contenu de t et de u après chacune des instructions suivantes :
L’opérateur + a-t-il modifié t ? La dernière affectation a-t-elle modifié le tuple (3, 7, 12) ?
Prévoir puis vérifier le résultat de 7 in t et de 8 in t, avec t = (4, 7, 12). De quel type est la valeur obtenue ?
Pourquoi Python propose-t-il un objet qu’on ne peut pas modifier ? Parce que c’est une garantie. Les coordonnées de Paris ne vont pas changer pendant l’exécution du programme. Si on les range dans un tuple et qu’on les confie à une fonction, on est certain de les retrouver intactes, quelle que soit la façon dont cette fonction a été écrite.
Un tuple est non mutable : on ne peut pas modifier ses éléments. L’instruction t[0] = 4 provoque une erreur TypeError.
On peut en revanche construire un nouveau tuple, par exemple par concaténation avec l’opérateur + : (3, 7) + (12,) vaut (3, 7, 12).
valeur in t vaut True si valeur est un élément de t, False sinon.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Avec t = (3, 7, 12), que produit l’instruction t[0] = 4 ?
Un tuple est non mutable : on ne peut pas affecter une nouvelle valeur à l’un de ses éléments.
Après t = (3, 7, 12) puis u = t + (20,), que vaut t ?
La concaténation fabrique un nouveau tuple, rangé dans u. Le tuple t n’est pas modifié.
Avec t = (4, 7, 12), que vaut 8 in t ?
in teste la présence d’une valeur et donne un booléen : 8 n’est pas un élément de t.
Un tuple est un objet itérable, au même titre que ce que produit range (voir Doc. 2,4). On peut donc le parcourir avec une boucle for. Il y a deux façons de le faire.
Recopier les deux fonctions suivantes dans l’éditeur :
somme((3, 7, 12)) et somme_2((3, 7, 12)).v ou i) ?tuple[float, ...] signifie « tuple de nombres flottants, de longueur quelconque ». Pourquoi ne pas avoir écrit tuple[float, float, float] ?La première écriture est plus courte. La seconde n’est utile que lorsqu’on a besoin de connaître la position des éléments, comme dans la question suivante.
Écrire la fonction indice_max dont la spécification est :
Indication. On suppose d’abord que le plus grand élément est celui d’indice 0, puis on compare cet élément à chacun des suivants.
On parcourt un tuple t de deux façons :
for element in t: donne directement les éléments, un par un ;for i in range(len(t)): donne les indices, et on lit l’élément avec t[i]. On utilise cette écriture lorsque la position de l’élément compte.Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Avec t = (3, 7, 12), quelles valeurs la variable v prend-elle dans for v in t: ?
Cette écriture parcourt directement les éléments du tuple.
Pour écrire la fonction indice_max, quel parcours faut-il choisir ?
La fonction doit retourner un indice : il faut connaître la position de chaque élément, donc parcourir les indices.
Quand un tuple contient peu d’éléments, il est souvent plus clair de donner un nom à chacun d’eux. Python permet de le faire en une seule ligne.
Saisir les instructions suivantes dans la console, en prévoyant le résultat avant chaque validation :
Expliquer le message d’erreur obtenu à la dernière ligne.
Reprendre la fonction min_max de la première partie. Écrire dans la console une instruction qui range le résultat de min_max(9, 4) dans deux variables petit et grand, puis calculer l’écart entre ces deux nombres.
Dans le Doc. 2,2, on a vu que la séquence a = b puis b = a n’échange pas les valeurs de deux variables, et qu’il fallait passer par une variable tmp. Avec les tuples, Python propose une écriture bien plus courte.
Saisir les instructions suivantes dans la console :
a = b puis b = a échouait parce que la valeur de a était écrasée avant d’avoir été recopiée. Expliquer, en décrivant ce que fait Python dans l’ordre, pourquoi ce problème ne se pose pas ici.Pour l’épreuve écrite. Sans utiliser Python, compléter le tableau d’état de la séquence suivante, puis vérifier dans la console.
| Instruction | a | b |
|---|---|---|
a, b = 3, 8 |
||
a, b = b, a + b |
||
a, b = b - a, a |
Dans le Doc. 2,4, la fonction fibo utilisait une troisième variable w pour calculer le terme suivant de la suite de Fibonacci. Réécrire cette fonction sans la variable w, à l’aide d’une affectation multiple. Vérifier que fibo(10) retourne '1 1 2 3 5 8 13 21 34 55 '.
L’affectation multiple x, y = point déballe un tuple : chaque variable de gauche reçoit l’élément de même position. Il doit y avoir autant de variables que d’éléments, sinon Python signale une erreur ValueError.
Dans a, b = b, a, Python évalue d’abord tout le membre de droite, qui forme un tuple, puis affecte les variables. C’est pourquoi cette instruction échange les valeurs de a et de b.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Après point = (2, 5) puis x, y = point, que vaut y ?
Chaque variable de gauche reçoit l’élément de même position : x vaut 2 et y vaut 5.
Que produit a, b = (1, 2, 3) ?
Il doit y avoir autant de variables que d’éléments dans le tuple.
Que valent a et b après a, b = 2, 5 puis a, b = b, a + b ?
Le membre de droite est entièrement évalué avec les anciennes valeurs : il forme le tuple (5, 7), puis les deux variables sont affectées.
Pour annoncer qu’une fonction retourne un tuple, on indique dans sa signature le type de chaque élément, dans l’ordre : -> tuple[int, int] signifie « retourne un tuple de deux entiers ». Pour un tuple de longueur quelconque dont tous les éléments ont le même type, on écrit tuple[float, ...].
Écrire chaque fonction dans la partie principale de l’éditeur, avec sa spécification complète (signature et documentation). Tester ensuite chacun des exemples de la documentation dans la console.
Division euclidienne. Écrire la fonction division_euclidienne dont la spécification est :
Comparer avec le résultat de la fonction divmod(17, 5), fournie par Python.
Convertir une durée. Une course de fond a duré 3725 s. On veut exprimer cette durée en heures, minutes et secondes.
convertir_duree dont la spécification est :Milieu d’un segment. Dans un repère, un point est représenté par le tuple (x, y) de ses coordonnées. Écrire la fonction milieu dont la spécification est :
Indication. Commencer par déballer chacun des deux tuples.
Distance entre deux points. Dans le Doc. 2,1, la fonction distance recevait quatre arguments x1, y1, x2, y2. Avec des tuples, deux arguments suffisent. On veut de plus que la fonction marche aussi dans l’espace, avec des points à trois coordonnées. Dans un repère orthonormé de l’espace, la distance entre et est :
distance dont la spécification est :distance((0, 0), (1, 1, 1)) ? Ajouter au début du corps de la fonction l’instruction :puis tester à nouveau cet appel.
L’instruction assert condition, "message" vérifie qu’une condition est vraie. Si elle est fausse, le programme s’arrête avec une erreur AssertionError et affiche le message.
On s’en sert pour vérifier une précondition, c’est-à-dire une condition que les arguments doivent respecter pour que la fonction ait un sens. Mieux vaut un programme qui s’arrête en expliquant pourquoi qu’un programme qui retourne un résultat faux sans prévenir.
Plus petit et plus grand élément. Écrire la fonction min_max_tuple dont la spécification est :
Les fonctions min et max de Python ne doivent pas être utilisées. Vérifier la précondition par une assertion.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Que retourne division_euclidienne(17, 5) ?
: le quotient vaut 3 et le reste 2, dans cet ordre.
Que se passe-t-il à l’exécution de assert len(valeurs) > 0, "valeurs ne doit pas être vide" lorsque valeurs vaut () ?
La condition est fausse : assert arrête le programme en expliquant pourquoi, au lieu de laisser la fonction produire un résultat faux.
Quelle annotation de type, écrite comme dans le cours, convient à une fonction qui retourne une durée sous la forme (heures, minutes, secondes), trois entiers ?
On indique le type de chacun des éléments du tuple retourné.
Équation du second degré. On cherche les solutions réelles de l’équation , avec . On note le discriminant.
Le nombre de solutions change d’une équation à l’autre. Un tuple convient bien : il peut contenir deux, un ou zéro élément. Écrire la fonction racines dont la spécification est :
Comparer deux dates. Une date est représentée par un tuple (jour, mois, annee). Écrire la fonction est_avant dont la spécification est :
Indication. Comparer d’abord les années. Si elles sont égales, comparer les mois, et ainsi de suite.
(5,) et le tuple vide () ;0 à len(t) - 1 ;t[0] = 4 provoque une erreur, et construire un nouveau tuple à la place ;in ;a, b = b, a échange deux valeurs ;-> tuple[int, int] ;Ranger des valeurs de même type dans une liste, modifier et parcourir ses éléments, puis construire des listes, y compris des listes de listes.
Un professeur range les notes d’un devoir dans un tuple :
En relisant les copies, il s’aperçoit que la troisième note est fausse : c’est 11 et non 9. Avec un tuple, l’instruction notes[2] = 11 provoque une erreur, puisqu’un tuple n’est pas mutable (Doc. 3,1). Il faudrait reconstruire un tuple complet, (notes[0], notes[1], 11, notes[3]), pour changer une seule valeur. Avec 35 élèves, ce serait pénible.
Python propose pour cela un autre type construit, la liste, qui s’écrit entre crochets.
Saisir les instructions suivantes dans la console :
La modification a-t-elle été acceptée ?
Une liste est une suite ordonnée de valeurs, écrite entre crochets et séparées par des virgules : [12, 15, 9, 14]. Son type est list.
Une liste est mutable : on peut modifier ses éléments après sa création, alors qu’un tuple ne le permet pas.
Dans cette activité, tous les éléments d’une même liste ont le même type.
Il ne faut pas confondre une liste avec un tableau. Un tableau est un ensemble de valeurs de même type, rangées les unes à la suite des autres dans la mémoire : on dit qu’elles sont contiguës. Une liste Python ne répond pas à cette définition : ses éléments peuvent être de types différents, et ils ne sont pas rangés côte à côte dans la mémoire. Python se sert de tableaux pour fabriquer ses listes, mais une liste n’est pas un tableau.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Après notes = [12, 15, 9, 14] puis notes[2] = 11, que vaut notes ?
Une liste est mutable : on peut remplacer l’élément d’indice 2, qui est le troisième.
Quelles affirmations sont exactes ?
Une liste Python n’est pas un tableau : ses éléments ne sont pas rangés côte à côte en mémoire, et ils peuvent être de types différents.
Bonne nouvelle : tout ce qu’on a appris sur les indices des tuples reste vrai pour les listes.
Saisir notes = [12, 15, 11, 14] dans la console. Prévoir le résultat de chacune des instructions suivantes, puis vérifier :
Ce qui est nouveau, c’est qu’on peut écrire notes[i] à gauche du signe =. L’élément d’indice i est alors remplacé par une nouvelle valeur. Les opérateurs d’affectation du Doc. 2,2 fonctionnent aussi : notes[1] += 2 ajoute 2 à l’élément d’indice 1.
Le professeur décide d’ajouter un point à chaque note. Un élève propose :
Un autre élève propose :
notes après chacune d’elles. Laquelle fonctionne ?t[i] = valeur remplace l’élément d’indice i de la liste t.
Pour modifier les éléments d’une liste dans une boucle, on parcourt les indices : for i in range(len(t)):. La boucle for element in t: permet de lire les éléments, mais pas de les modifier.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Que vaut len([]) ?
La liste vide ne contient aucun élément.
Après notes = [12, 15, 11, 14] puis la boucle for n in notes: n += 1, que vaut notes ?
À chaque tour, n reçoit la valeur d’un élément ; modifier n ne modifie pas la liste.
Quelle boucle ajoute 1 à chaque élément de la liste t ?
Pour modifier les éléments, on parcourt les indices. Dans la troisième proposition, i prend les valeurs des éléments, qui ne sont pas des indices.
L’opérateur * appliqué à une liste et à un entier répète la liste. Ainsi [0] * 6 vaut [0, 0, 0, 0, 0, 0]. On obtient une liste de 6 éléments, qu’on peut ensuite remplir par indice.
Recopier et compléter la fonction suivante, qui doit construire la liste des carrés des entiers de 0 à n - 1 :
En mathématiques, on décrit parfois un ensemble par une règle plutôt qu’en écrivant tous ses éléments : se lit « l’ensemble des pour appartenant à ». Python permet d’écrire une liste de la même façon :
Cette expression se lit presque comme la phrase : « la liste des k * k pour k parcourant range(5) ». On dit que la liste est construite en compréhension. Elle remplace les quatre lignes du corps de la fonction carres.
Prévoir la liste obtenue pour chacune des expressions suivantes, puis vérifier dans la console :
À quoi sert la partie if k % 3 == 0 dans la dernière expression ?
Écrire une liste en compréhension qui donne :
[7, 14, 21, ..., 70] ;notes = [12, 15, 8, 14, 6, 17] qui sont inférieures à 10 ;[True, False, True, False, True, False] qui indique, pour chaque entier de 0 à 5, s’il est pair.On peut construire une liste :
[valeur] * n, puis la remplir par indice ;[expression for element in iterable]. On peut ajouter un filtre : [expression for element in iterable if condition].Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Que vaut [0] * 4 ?
On obtient une liste de 4 éléments, tous égaux à 0, qu’on peut ensuite remplir par indice.
Que vaut [2 * k + 1 for k in range(4)] ?
k prend les valeurs 0, 1, 2 et 3.
Avec notes = [12, 15, 8, 14, 6], que vaut [n for n in notes if n >= 12] ?
Le filtre if ne garde que les éléments pour lesquels la condition est vraie.
Saisir les instructions suivantes dans la console, en prévoyant le résultat de la dernière ligne avant de la valider :
Le résultat est-il celui que vous attendiez ?
Ce résultat surprend presque tout le monde la première fois. Pour le comprendre, il faut revenir à ce que fait vraiment une affectation (Doc. 2,2) : une variable référence une valeur. Elle ne contient pas la liste, elle indique où elle se trouve, un peu comme une étiquette collée dessus.
L’instruction m = n ne fabrique donc pas une deuxième liste. Elle colle une deuxième étiquette, m, sur la même liste :
n
m
Quand on écrit m[0] = 0, on modifie cette liste unique. En la regardant par l’étiquette n, on voit forcément la modification. On dit que m et n sont des alias.
Avec les nombres et les tuples, ce phénomène existe aussi, mais il ne se voit jamais : comme on ne peut pas modifier un nombre ou un tuple, on ne peut pas constater que deux étiquettes désignent le même objet. C’est la mutabilité des listes qui le rend visible.
Pour obtenir une vraie copie, on peut construire une nouvelle liste en compréhension. Prévoir puis vérifier le contenu de n et de c :
Lors d’un appel, le paramètre reçoit la valeur de l’argument, exactement comme dans une affectation. Si l’argument est une liste, le paramètre devient donc un alias de cette liste.
Recopier les deux fonctions suivantes dans l’éditeur :
Prévoir, puis vérifier, le contenu de releve après chaque appel :
Expliquer la différence de comportement entre les deux fonctions.
Une fonction qui modifie une liste reçue en argument agit sur la liste du programme appelant. On parle d’effet de bord. C’est parfois ce qu’on veut, mais il faut alors l’annoncer clairement dans la documentation de la fonction. Si on ne le veut pas, la fonction doit travailler sur une copie, ou construire et retourner une nouvelle liste.
Après m = n, les variables m et n référencent la même liste : ce sont des alias. Toute modification faite par l’une est visible par l’autre.
Pour obtenir une copie indépendante, on construit une nouvelle liste, par exemple [x for x in n].
Une fonction qui reçoit une liste peut la modifier (effet de bord) avec t[i] = .... En revanche, une nouvelle affectation du paramètre (t = ...) ne change pas la liste de l’appelant.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Après n = [12, 18, 9], m = n puis m[0] = 0, que vaut n ?
m et n référencent la même liste : ce sont des alias.
Après n = [12, 18, 9], c = [x for x in n] puis c[0] = 0, que vaut n ?
La compréhension fabrique une nouvelle liste : c est une copie indépendante.
Laquelle de ces fonctions modifie la liste reçue en argument ?
t[0] = 0 modifie la liste partagée avec l’appelant : c’est un effet de bord. La nouvelle affectation t = ... fait seulement référencer une autre liste au paramètre.
Les éléments d’une liste peuvent eux-mêmes être des listes. C’est ainsi qu’on représente des valeurs rangées en lignes et en colonnes, comme les cases d’une grille de jeu. En mathématiques, des nombres rangés de cette façon forment une matrice.
m est une liste de deux éléments : m[0] est la liste [1, 2, 3], qu’on voit comme la première ligne, et m[1] est la liste [4, 5, 6]. Pour atteindre un nombre, on applique deux indices l’un après l’autre : m[1] donne la ligne d’indice 1, puis m[1][2] donne l’élément d’indice 2 de cette ligne.
Avec la liste m ci-dessus, prévoir puis vérifier :
Que représentent len(m) et len(m[0]) pour la matrice ?
Écrire la fonction somme_matrice dont la spécification est :
Indication. Utiliser deux boucles imbriquées : l’une parcourt les indices des lignes, l’autre ceux des colonnes.
Dans le Doc. 2,4, la fonction table_multiplication retournait une chaîne de caractères. On veut maintenant une matrice, pour pouvoir retrouver chaque produit par ses indices. Écrire la fonction table_multiplication dont la spécification est :
Indication. Une ligne de la table est une liste en compréhension. La table entière est une liste de lignes, elle aussi en compréhension.
Avec t = table_multiplication(10), que vaut t[6][7] ? Quel produit cet élément représente-t-il ?
Pour fabriquer une grille de 3 lignes et 3 colonnes remplie de zéros, l’écriture [[0] * 3] * 3 semble naturelle. Pourtant :
Le * 3 extérieur ne fabrique pas trois lignes : il place trois fois la même ligne dans la liste. Les trois lignes sont des alias. La bonne écriture fabrique une nouvelle ligne à chaque tour :
Une liste de listes permet de représenter une matrice, c’est-à-dire des valeurs rangées en lignes et en colonnes. m[i] est la ligne d’indice i, et m[i][j] l’élément de la ligne i et de la colonne j.
len(m) donne le nombre de lignes et len(m[0]) le nombre de colonnes. On parcourt une matrice avec deux boucles imbriquées.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Avec m = [[1, 2, 3], [4, 5, 6]], que vaut m[1][0] ?
m[1] est la ligne [4, 5, 6], et l’élément d’indice 0 de cette ligne vaut 4.
Avec la même matrice m, que valent len(m) et len(m[0]) ?
len(m) est le nombre de lignes, len(m[0]) le nombre de colonnes.
Après g = [[0] * 2] * 2 puis g[0][0] = 5, que vaut g ?
Le * 2 extérieur place deux fois la même ligne dans la liste. Il faut écrire [[0] * 2 for i in range(2)].
Écrire chaque fonction dans la partie principale de l’éditeur, avec sa spécification complète (signature et documentation). Tester ensuite chacun des exemples de la documentation dans la console. Les fonctions sum, min, max et la méthode index de Python ne doivent pas être utilisées.
Moyenne. Écrire la fonction moyenne dont la spécification est :
Vérifier la précondition à l’aide d’une assertion (voir Doc. 3,1).
Recherche d’une valeur. Écrire la fonction indice dont la spécification est :
Dans le pire des cas, combien de comparaisons la fonction effectue-t-elle pour une liste de 1000 éléments ? Et pour une liste deux fois plus longue ?
Statistiques d’un devoir. On veut écrire la fonction statistiques dont la spécification est :
moyenne de la question précédente.Tirage du Loto sans répétition. Dans le Doc. 2,4, la fonction loto_naif pouvait tirer deux fois le même numéro, faute de pouvoir mémoriser les numéros déjà sortis. Une liste résout ce problème. Écrire la fonction loto dont la spécification est :
Indication. Partir de la liste [0] * 6. Tirer un numéro avec random.randint(1, 49). S’il n’est pas déjà dans la liste, le ranger à la première place libre. Le nombre de tirages nécessaires n’est pas connu à l’avance : quelle boucle faut-il utiliser ?
Transposée d’une matrice. La transposée d’une matrice s’obtient en échangeant ses lignes et ses colonnes : la première ligne devient la première colonne, et ainsi de suite. Écrire, en une seule ligne de code, la fonction transposee dont la spécification est :
[valeur] * n ;if ;m = n, une modification de m est visible dans n, et faire une vraie copie d’une liste ;m[i][j] ;Faire grandir et rétrécir une liste en lui envoyant des messages, en particulier append et pop, et savoir si un message modifie la liste ou renvoie une valeur.
On veut noter la liste des courses au fur et à mesure qu’on y pense. Au départ, on n’a pensé à rien : la liste est vide. Prévoir ce qui se passe lorsqu’on saisit les deux instructions suivantes dans la console, puis vérifier :
Dans le Doc. 3,2, on contournait la difficulté en fabriquant d’abord une liste de la bonne taille, par exemple [0] * 6, puis en la remplissant. Cela suppose de connaître la taille à l’avance. Pour une liste de courses, ce n’est pas le cas : on ne sait pas combien de choses on va y écrire. Il faut un moyen de dire à la liste « ajoute cet élément au bout ».
En Python, chaque valeur est un objet : un nombre, une chaîne de caractères, un tuple, une liste. Pour l’instant, retenons qu’un objet regroupe des données et des actions qu’il sait effectuer sur ces données. Les objets seront étudiés en détail en terminale. Ici, on apprend seulement à s’en servir : pour demander à un objet d’effectuer l’une de ses actions, on lui envoie un message. On écrit le nom de l’objet, un point, puis le message suivi de parenthèses :
Cette instruction se lit : « on envoie à la liste courses le message append (ajouter, en anglais), avec l’argument "pain" ». La liste reçoit le message et réagit : elle place "pain" à sa fin. La façon dont un objet réagit à un message s’appelle une méthode. On dit indifféremment « envoyer le message append » ou « appeler la méthode append ».
Ce n’est pas la première fois que vous envoyez un message. Dans le Doc. 2,2, l’écriture "...{}...".format(...) envoyait le message format à une chaîne de caractères.
Comparons avec une fonction. Pour connaître la longueur d’une liste, on écrit len(courses) : on donne la liste à la fonction len, qui l’examine. Avec courses.append("pain"), on s’adresse à la liste elle-même, et c’est elle qui se modifie.
Saisir les instructions suivantes dans la console, en prévoyant le résultat de chaque ligne avant de la valider :
À quel indice se trouve l’élément qu’on vient d’ajouter avec append ? Exprimer cet indice à l’aide de len(courses).
En Python, une liste est un objet. On lui envoie un message avec la notation pointée : liste.message(arguments). La façon dont l’objet réagit au message s’appelle une méthode.
t.append(x) ajoute l’élément x à la fin de la liste t. La liste est modifiée, sa longueur augmente de 1. Cela fonctionne aussi à partir de la liste vide [].
La méthode append permet une façon de construire une liste qu’on utilisera très souvent : partir de la liste vide, puis ajouter les éléments un par un, au fil d’une boucle.
Exemple résolu
On veut la liste des multiples de k compris entre 1 et n.
Suivons l’appel multiples(20, 3). Au départ, resultat vaut []. Pour i égal à 1 et 2, le test est faux : rien ne se passe. Pour i égal à 3, le test est vrai : la liste devient [3]. Elle devient [3, 6] au tour où i vaut 6, et ainsi de suite. On n’a jamais eu besoin de savoir combien de multiples on allait trouver : la liste grandit d’elle-même.
En suivant la même méthode, écrire la fonction diviseurs dont la spécification est :
Pourquoi la méthode [0] * taille du Doc. 3,2 serait-elle mal adaptée ici ?
Retour sur le Loto. Dans le Doc. 3,2, la fonction loto partait de [0] * 6 et utilisait une variable nbre_tirees pour savoir où ranger le prochain numéro. Réécrire cette fonction en partant de la liste vide et en utilisant append :
Quelle variable de l’ancienne version devient inutile ? Par quoi est-elle remplacée ?
while.Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Après t = [], t.append(4) puis t.append(9), que vaut t ?
append ajoute chaque élément à la fin de la liste.
Que représente l’écriture t.append(x) ?
C’est la notation pointée : objet.message(arguments). La liste t elle-même est modifiée.
Pour construire la liste des diviseurs de n en partant de [], quelle instruction faut-il placer dans la boucle, quand d divise n ?
On ajoute d à la fin de la liste. La deuxième proposition remplacerait la liste par None ; la troisième provoquerait une erreur IndexError, car la liste est trop courte.
Le message pop fait l’inverse de append : il retire un élément de la liste. Mais il fait aussi autre chose, que l’on va découvrir.
Saisir les instructions suivantes dans la console, en prévoyant le résultat de chaque ligne avant de la valider :
pop() retire-t-il lorsqu’on ne lui donne pas d’argument ? Et pop(0) ?append, la ligne pile.pop() affiche quelque chose. Que représente ce qui est affiché ?t.pop() retire le dernier élément de la liste t et le renvoie. t.pop(i) retire l’élément d’indice i et le renvoie. Dans les deux cas, la longueur de la liste diminue de 1.
Envoyer pop à une liste vide provoque l’erreur IndexError. Avant un pop, il faut donc s’assurer que la liste n’est pas vide, par exemple avec len(t) > 0.
Les deux messages append et pop() agissent sur la fin de la liste. Utilisés ensemble, ils font de la liste une pile d’assiettes : on pose une assiette sur le dessus, on reprend toujours celle du dessus. C’est exactement ce que fait la commande « Annuler » d’un traitement de texte. Chaque action est ajoutée au bout d’un historique. Annuler, c’est retirer la dernière action effectuée.
Sans exécuter le programme, prévoir les affichages du programme suivant. Écrire le contenu de la liste historique après chaque ligne qui la modifie. Vérifier ensuite.
Un élève veut écrire une fonction qui retourne les éléments d’une liste dans l’ordre inverse. Il a l’idée de vider la liste avec pop(), en ajoutant au fur et à mesure chaque élément retiré dans une nouvelle liste :
inverser(releve), combien de listes existent en mémoire ? Combien de noms les référencent ?pop modifie la liste qui le reçoit. Sur quelle liste faudrait-il l’envoyer pour que releve ne soit pas touchée ?Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Après pile = [3, 7, 12, 5] puis x = pile.pop(), que valent x et pile ?
Sans argument, pop retire le dernier élément et le renvoie.
Après t = [3, 7, 12] puis t.pop(0), que vaut t ?
pop(0) retire l’élément d’indice 0, c’est-à-dire le premier.
Que produit [].pop() ?
On ne peut rien retirer d’une liste vide : il faut le vérifier avant, par exemple avec len(t) > 0.
Une élève veut ajouter le lait à sa liste de courses. Elle écrit :
Sa liste a disparu. Elle essaie alors de ranger des notes dans l’ordre croissant avec le message sort (trier) :
append ? Et le message sort ?courses = courses.append("lait").Cette erreur est l’une des plus fréquentes chez les débutants, et chez les autres. Elle vient d’une confusion entre deux sortes de messages. Certains messages, comme append ou sort, modifient la liste et renvoient None. D’autres, comme pop, modifient la liste et renvoient une valeur utile. Il en existe enfin qui ne modifient rien et se contentent de renvoyer une information sur la liste, comme on va le voir dans la partie 4.
Puisque append modifie la liste elle-même, tous les alias de cette liste voient la modification. L’opérateur +, qui met deux listes bout à bout, se comporte autrement.
Prévoir, puis vérifier, le contenu de n et de m à la fin de chacune des deux séquences :
Expliquer la différence.
Un message qui modifie la liste, comme append ou sort, renvoie None. On l’écrit seul sur sa ligne, sans affectation : t.append(x) et jamais t = t.append(x).
pop modifie la liste et renvoie l’élément retiré, qu’on peut ranger dans une variable : x = t.pop().
Un message envoyé à une liste agit sur la liste elle-même : tous ses alias voient la modification. L’expression t + [x], elle, fabrique une nouvelle liste.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Après courses = ["pain"] puis courses = courses.append("lait"), que vaut courses ?
append modifie la liste puis renvoie None, et c’est cette valeur qui est affectée à courses.
Après n = [1, 2, 3], m = n puis m.append(4), que vaut n ?
m et n sont des alias : le message modifie la liste unique qu’ils référencent.
Après n = [1, 2, 3], m = n puis m = m + [4], que vaut n ?
m + [4] fabrique une nouvelle liste, que l’on affecte à m. La liste référencée par n n’est pas touchée.
Une liste comprend d’autres messages que append et pop. La commande help(list), dans la console, en donne la liste complète, en anglais. En voici quelques-uns, traduits :
| Message | Effet | Renvoie |
|---|---|---|
t.insert(i, x) |
insère x juste avant l’élément d’indice i |
None |
t.remove(x) |
retire la première occurrence de x ; erreur ValueError si x est absent |
None |
t.index(x) |
ne modifie pas la liste ; erreur ValueError si x est absent |
l’indice de la première occurrence de x |
t.count(x) |
ne modifie pas la liste | le nombre d’occurrences de x |
t.reverse() |
renverse l’ordre des éléments | None |
t.sort() |
range les éléments dans l’ordre croissant | None |
t.copy() |
ne modifie pas la liste | une nouvelle liste, copie de t |
À l’aide de ces descriptions, et sans exécuter les instructions, prévoir le résultat de chaque ligne. Indiquer pour chacune si la liste t est modifiée. Vérifier ensuite dans la console.
Dans la question sur la fonction inverser, on aurait pu écrire copie = t.copy() à la place de copie = [x for x in t]. Les deux instructions fabriquent une nouvelle liste contenant les mêmes éléments.
Avant d’utiliser un message, il faut savoir répondre à deux questions : modifie-t-il la liste ? que renvoie-t-il ?
insert, remove, reverse et sort modifient la liste et renvoient None. pop la modifie et renvoie l’élément retiré. index, count et copy ne la modifient pas et renvoient une information ou une nouvelle liste.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Après t = [5, 8, 2, 8] puis t.remove(8), que vaut t ?
remove retire la première occurrence de la valeur.
Quels messages modifient la liste qui les reçoit ?
insert et sort modifient la liste et renvoient None. index et count renvoient une information sans modifier la liste.
Avec t = [5, 10, 2, 8], que vaut t.index(2) ?
index renvoie l’indice de la première occurrence de la valeur : 2 se trouve à l’indice 2.
Écrire chaque fonction dans la partie principale de l’éditeur, avec sa spécification complète (signature et documentation). Tester ensuite chacun des exemples de la documentation dans la console. Aucune de ces fonctions ne doit modifier la liste qu’elle reçoit en argument.
Sans doublons. Écrire la fonction sans_doublons dont la spécification est :
Pourquoi ne peut-on pas obtenir ce résultat simplement avec une liste en compréhension filtrée par if x not in t ?
Pairs et impairs. Écrire la fonction separer dont la spécification est :
Tester ensuite, dans la console, l’affectation multiple p, i = separer([4, 7, 10, 3, 8]) (Doc. 3,1).
Une file d’attente. À un guichet, les clients sont servis dans leur ordre d’arrivée : le premier arrivé est le premier servi. On décrit une matinée par une liste d’événements. Un prénom signale l’arrivée d’un client, qui se place au bout de la file. Le caractère "*" signale que le guichetier sert un client : celui qui attend depuis le plus longtemps.
guichet.pop() au lieu de pop(0). Sans exécuter son programme, prévoir ce que renvoie l’appel de la documentation. Pourquoi les clients ont-ils raison de se plaindre ?servis. Un seul message renvoie l’élément qu’il retire.len(t), et envoyer un message à une liste, comme t.append(x) ;append dans une boucle ;i, avec pop, et utiliser l’élément renvoyé ;pop à une liste vide ;t = t.append(x) ;append et pop()) ou comme une file (append et pop(0)).Construire pas à pas avec Pyxel la simulation d’un gaz : chaque particule est un tuple, le gaz est une liste de tuples passée en paramètre aux fonctions.
Dans un gaz, les particules avancent en ligne droite et rebondissent sur les parois comme la bille sur la bande. Le programme de départ est fourni dans Capytale. Quand une question commence par « Sans exécuter le programme », on écrit sa réponse avant de vérifier.
Une particule est décrite par cinq entiers, rangés dans un tuple, toujours dans le même ordre :
| indice | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| élément | x |
y |
vx |
vy |
couleur |
x et y sont les coordonnées du centre, en pixels. vx et vy sont les nombres de pixels parcourus horizontalement et verticalement à chaque image. Un écran n’a pas de demi-pixel : toutes ces valeurs sont des entiers.
La ligne Particule = tuple[...] donne un nom au type d’une particule, que l’on utilise dans les annotations des fonctions.
pyxel.run attend deux fonctions sans paramètre. lambda: update(particules) est justement une fonction sans paramètre, écrite sur une ligne : à chaque image, elle appelle update en lui passant la liste particules.
Une fonction peut lire les constantes, écrites en majuscules (LARGEUR, RAYON…), car leur valeur ne change jamais. Elle ne lit aucune autre variable du programme principal : la liste des particules lui est toujours passée en paramètre.
Lancer le programme. Avec particules = [(36, 60, 2, -1, 8)] :
particules[0][2] ? Quelle grandeur représente-t-il ?Modifier particules pour obtenir une particule verte (couleur 11), au centre de l’écran, qui se déplacera vers la gauche de 1 pixel par image. Vérifier, puis revenir à la valeur de départ.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Une particule est décrite par le tuple (x, y, vx, vy, couleur). Avec particules = [(36, 60, 2, -1, 8)], que vaut particules[0][1] ?
particules[0] est le tuple de la particule, et son élément d’indice 1 est l’ordonnée y.
Dans Pyxel, une particule a vy = -1. Comment se déplace-t-elle verticalement ?
Dans Pyxel, augmente vers le bas : diminuer fait monter la particule.
D’après la règle du programme, quelles variables une fonction peut-elle lire sans les recevoir en paramètre ?
La valeur des constantes ne change jamais ; la liste des particules, elle, est toujours passée en paramètre.
Pyxel affiche 30 images par seconde et appelle update(particules) avant chaque image. À chaque appel, on ajoute vx à x et vy à y.
Sans exécuter le programme. La particule part de avec vx = 2. Elle touche le bord droit quand son centre atteint . Au bout de combien de temps ?
Un élève propose :
Sans exécuter le programme, prévoir ce qui se passe si on appelle deplacer(particules[0]). Expliquer.
La fonction doit donc fabriquer un nouveau tuple et le retourner. Pour récupérer d’un coup les cinq éléments de p, on le déballe :
Il faut autant de noms à gauche que d’éléments dans le tuple.
Écrire la fonction deplacer :
Tester dans la console : deplacer((36, 60, 2, -1, 8)) doit retourner (38, 59, 2, -1, 8).
Dans update, remplacer pass par gaz[0] = deplacer(gaz[0]). Sans exécuter le programme, prévoir ce qui se passera au bout de 2 secondes, puis vérifier.
Un autre élève écrit dans update : gaz = [deplacer(gaz[0])]. Il n’obtient aucune erreur, mais la particule reste immobile. Expliquer, en s’aidant des fonctions reinitialiser_1 et reinitialiser_2 du Doc. 3,2.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Que produit deplacer(particules[0]) si la fonction contient l’instruction p[0] = p[0] + p[2] ?
On ne peut pas modifier un élément d’un tuple : la fonction doit fabriquer et retourner un nouveau tuple.
Que retourne deplacer((36, 60, 2, -1, 8)) ?
On ajoute vx à x et vy à y : et . La vitesse et la couleur sont inchangées.
Dans update(gaz), laquelle de ces instructions fait réellement avancer la particule de la liste particules ?
gaz[0] = ... modifie un élément de la liste partagée avec le programme principal. gaz = [...] fait seulement référencer une nouvelle liste par la variable locale gaz.
À 30 images par seconde, une particule avance de 2 pixels par image. Combien de temps met-elle à parcourir 120 pixels ?
Sa vitesse vaut px/s, d’où s.
Comme sur le billard, quand la particule touche le mur de droite, vx devient -vx. On complète deplacer : elle change d’abord la vitesse si un mur est touché, puis fait avancer la particule. Première version, qui ne traite que le mur de droite :
Compléter deplacer pour les murs de gauche, du haut et du bas, puis tester.
Sans ordinateur. On part de particules = [(158, 60, 1, 0, 8)]. Compléter le tableau avec les valeurs de x et vx après chaque appel de update. Que fait la particule ? Vérifier à l’écran.
| image | départ | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
x |
158 | ||||
vx |
1 |
Modifier les quatre conditions pour qu’une particule ne rebondisse que si elle se dirige vers le mur qu’elle touche. Refaire le tableau sans ordinateur, puis vérifier.
Un tuple n’est pas mutable : une fonction qui « modifie » une particule fabrique et retourne un nouveau tuple. Le déballage x, y, vx, vy, couleur = p donne un nom à chaque élément.
Lors d’un rebond sur une paroi, la composante de la vitesse perpendiculaire à la paroi change de signe.
Une fonction qui reçoit une liste en paramètre peut modifier ses éléments (gaz[0] = ...). Si elle affecte une nouvelle valeur au paramètre (gaz = ...), la liste d’origine ne change pas.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Une particule touche le mur du haut. Quelle composante de sa vitesse change de signe ?
Lors d’un rebond, la composante de la vitesse perpendiculaire à la paroi change de signe. Le mur du haut est horizontal.
Le disque a un rayon RAYON. Quelle condition indique qu’il touche le mur de gauche, d’abscisse 0 ?
Le point du disque le plus à gauche a pour abscisse x - RAYON : c’est lui qui atteint le mur en premier.
Pourquoi ajoute-t-on la condition vx > 0 au test du mur de droite ?
Sans elle, une particule qui vient de rebondir et touche encore le mur voit sa vitesse inversée une seconde fois : elle reste coincée contre la paroi.
On veut maintenant 30 particules, tirées au hasard. pyxel.rndi(a, b) retourne un entier au hasard entre a et b, bornes comprises. Ajouter ces constantes au début du programme (8, 11 et 12 sont le rouge, le vert et le bleu) :
Écrire la fonction nouvelle_particule, puis la tester plusieurs fois dans la console :
RAYON pixels de chaque bord (Doc. 2,5).COULEURS.Dans le programme principal, remplacer particules = [(36, 60, 2, -1, 8)] par une liste de NB_PARTICULES particules construite en compréhension (Doc. 3,2). Pourquoi cette ligne doit-elle se trouver après la définition de nouvelle_particule ?
Modifier draw pour dessiner toutes les particules de gaz.
Pour faire bouger toutes les particules, un élève écrit :
Sans exécuter le programme, prévoir ce qu’on observe. Expliquer, puis corriger.
Le gaz est une liste de tuples, construite en compréhension. Pour lire ses éléments, on la parcourt par éléments. Pour les remplacer, on la parcourt par indices : gaz[i] = ....
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Quelle instruction construit une liste de NB_PARTICULES particules tirées au hasard ?
La compréhension appelle la fonction à chaque tour. La deuxième écriture répète NB_PARTICULES fois la même particule ; la troisième répète les éléments d’un seul tuple.
Que se passe-t-il avec la boucle for p in gaz: p = deplacer(p) ?
p = ... fait référencer un nouveau tuple par la variable p, mais rien n’est rangé dans la liste. Il faut parcourir les indices : gaz[i] = deplacer(gaz[i]).
Pour dessiner toutes les particules dans draw, quel parcours suffit ?
On ne modifie pas la liste : lire ses éléments un par un suffit.
Dans un gaz réel, les particules se heurtent aussi entre elles. Deux particules se touchent si la distance entre leurs centres est inférieure ou égale à 2 * RAYON.
Ajouter from math import sqrt au début du programme, puis écrire :
Tester : distance((0, 0, 1, 1, 8), (3, 4, 0, 0, 12)) doit retourner 5.0.
Deux particules de même masse qui se heurtent de face échangent leurs vitesses. On adopte ce modèle pour toutes les collisions.
Écrire la fonction choc :
Tester : choc((50, 60, 1, 0, 8), (55, 60, -1, 0, 12)) doit retourner ((50, 60, -1, 0, 8), (55, 60, 1, 0, 12)).
Voici la fonction qui teste toutes les paires de particules de la liste gaz. Sa dernière ligne déballe le tuple retourné par choc, comme a, b = b, a (Doc. 3,1).
(i, j) testés.i + 1 et non à 0 ?Ajouter l’appel gerer_chocs(gaz) à la fin de update. Observer longuement : certaines particules restent collées. Pourquoi ? Corriger, en s’inspirant de la correction des rebonds sur les murs.
gerer_chocs à l’image qui suit un échange de vitesses ?deplacer et distance.Il reste un défaut : des particules rapides se traversent parfois.
Sans ordinateur. Deux particules arrivent de face, en diagonale : (50, 50, 2, 2, 8) et (56, 56, -2, -2, 12). À chaque image, update les déplace, puis appelle gerer_chocs. Compléter le tableau (distances arrondies au dixième), puis expliquer pourquoi les particules se traversent.
| image | départ | 1 | 2 | 3 |
|---|---|---|---|---|
| particule 1 | (50, 50) | |||
| particule 2 | (56, 56) | |||
| distance | 8,5 | |||
se_touchent |
non | |||
se_rapprochent |
oui |
Pour éviter ce chevauchement, il faut anticiper : avant de déplacer les particules, on regarde si elles vont se toucher à l’image suivante.
Modifier la condition de gerer_chocs pour tester si les particules se toucheront après leur déplacement, puis placer l’appel gerer_chocs(gaz) au début de update. Refaire le tableau précédent, puis vérifier à l’écran que les particules ne se traversent presque plus.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Avec 4 particules, combien de couples (i, j) la double boucle for i in range(n): for j in range(i + 1, n): teste-t-elle ?
(0, 1), (0, 2), (0, 3), (1, 2), (1, 3) et (2, 3) : chaque paire n’est testée qu’une fois.
Pourquoi la boucle intérieure commence-t-elle à i + 1 et non à 0 ?
En partant de 0, on testerait (0, 1) puis (1, 0). Il faut aussi éviter de tester une particule avec elle-même.
Que retourne choc((50, 60, 1, 0, 8), (55, 60, -1, 0, 12)) ?
Les particules échangent leurs vitesses ; elles gardent leur position et leur couleur.
Défi A : le mélange de deux gaz. Au départ, les particules rouges sont dans la moitié gauche de la boîte, les bleues dans la moitié droite. Donner à nouvelle_particule les paramètres couleur, x_min et x_max, puis construire la liste. Comparer la vitesse du mélange avec et sans collisions.
Défi B : chauffer le gaz. Chaque appui sur la touche ↑ double les deux composantes de la vitesse de toutes les particules. Que se passe-t-il après plusieurs appuis ?