Aller au contenu principal

Sous-sections de Premières structures de données : listes et tuples

Physique, Chimie et Informatique > 1ère Spécialité NSI > Premières structures de données : listes et tuples

Les tuples

Objectif

Regrouper plusieurs valeurs dans un seul objet, le tuple, pour qu’une fonction puisse renvoyer plusieurs résultats à la fois.

Une fonction peut-elle renvoyer deux valeurs ?

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.

Q22.

Recopier la fonction suivante dans la partie principale de l’éditeur Thonny :

def min_max(a: float, b: float):
    """Retourne le plus petit puis le plus grand des nombres a et b."""
    if a < b:
        return a, b
    return b, a
  1. Appeler min_max(9, 4) dans la console. Qu’affiche-t-elle ?
  2. Saisir ensuite 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.

À retenir

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.

Vérifier ses acquis 2 questions

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.

Créer un tuple et lire ses éléments

C’est la virgule qui fait le tuple

Q23.

Pour chacune des expressions suivantes, prévoir le type de la valeur obtenue, puis vérifier avec la fonction type dans la console :

>>> type((3, 7, 12))
>>> type(3, 7, 12)
>>> type((5))
>>> type((5,))
>>> type(())

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 :

ville = ("Paris", 48.86, 2.35)

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é.

Repérer un élément par son indice

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.

Q24.

Saisir t = (3, 7, 12) dans la console. Prévoir le résultat de chacune des instructions suivantes, puis vérifier :

>>> t[0]
>>> t[2]
>>> len(t)
>>> t[3]
>>> t[len(t) - 1]

Quel est l’indice du dernier élément d’un tuple qui contient n éléments ?

Indices négatifs

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].

Q25.

Avec ville = ("Paris", 48.86, 2.35), écrire une instruction qui affiche, à l’aide d’une f-string et des indices :

Paris : latitude 48.86, longitude 2.35
À retenir

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 ().

Vérifier ses acquis 3 questions

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.

Un tuple ne peut pas être modifié

Q26.

Toujours avec t = (3, 7, 12), essayer de remplacer le premier élément par 4 :

>>> t[0] = 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.

Q27.

Prévoir, puis vérifier, le contenu de t et de u après chacune des instructions suivantes :

>>> t = (3, 7, 12)
>>> u = t + (20,)
>>> u
>>> t
>>> t = (4, t[1], t[2])
>>> t

L’opérateur + a-t-il modifié t ? La dernière affectation a-t-elle modifié le tuple (3, 7, 12) ?

Q28.

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.

À retenir

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.

Vérifier ses acquis 3 questions

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.

Parcourir un tuple

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.

Q29.

Recopier les deux fonctions suivantes dans l’éditeur :

def somme(valeurs: tuple[float, ...]) -> float:
    """Retourne la somme des éléments du tuple valeurs."""
    total = 0
    for v in valeurs:
        total += v
    return total

def somme_2(valeurs: tuple[float, ...]) -> float:
    """Retourne la somme des éléments du tuple valeurs."""
    total = 0
    for i in range(len(valeurs)):
        total += valeurs[i]
    return total
  1. Tester somme((3, 7, 12)) et somme_2((3, 7, 12)).
  2. Dans chaque fonction, quelles valeurs prend successivement la variable de boucle (v ou i) ?
  3. L’annotation 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.

Q30.

Écrire la fonction indice_max dont la spécification est :

def indice_max(valeurs: tuple[float, ...]) -> int:
    """Retourne l'indice du plus grand élément de valeurs.
    valeurs ne doit pas être vide.

    >>> indice_max((12, 5, 18, 7))
    2
    """

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.

À retenir

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.
Vérifier ses acquis 2 questions

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.

Déballer un tuple

L’affectation multiple

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.

Q31.

Saisir les instructions suivantes dans la console, en prévoyant le résultat avant chaque validation :

>>> point = (2, 5)
>>> x, y = point
>>> x
>>> y
>>> a, b = (1, 2, 3)

Expliquer le message d’erreur obtenu à la dernière ligne.

Q32.

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.

Retour sur l’échange de deux variables

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.

Q33.

Saisir les instructions suivantes dans la console :

>>> a = 605
>>> b = 506
>>> a, b = b, a
>>> a, b
  1. Les valeurs ont-elles été échangées ?
  2. La séquence 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.
Q34.

Pour l’épreuve écrite. Sans utiliser Python, compléter le tableau d’état de la séquence suivante, puis vérifier dans la console.

a, b = 3, 8
a, b = b, a + b
a, b = b - a, a
Instruction a b
a, b = 3, 8
a, b = b, a + b
a, b = b - a, a
Q35.

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 '.

À retenir

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.

Vérifier ses acquis 3 questions

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.

Écrire une fonction qui renvoie un tuple

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, ...].

Consigne

É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.

Q36.

Division euclidienne. Écrire la fonction division_euclidienne dont la spécification est :

def division_euclidienne(a: int, b: int) -> tuple[int, int]:
    """Retourne le quotient et le reste de la division euclidienne
    de a par b (b non nul).

    >>> division_euclidienne(17, 5)
    (3, 2)
    >>> division_euclidienne(20, 4)
    (5, 0)
    """

Comparer avec le résultat de la fonction divmod(17, 5), fournie par Python.

Q37.

Convertir une durée. Une course de fond a duré 3725 s. On veut exprimer cette durée en heures, minutes et secondes.

  1. Sans ordinateur, effectuer la conversion à la main, en détaillant le calcul.
  2. Écrire la fonction convertir_duree dont la spécification est :
def convertir_duree(duree: int) -> tuple[int, int, int]:
    """Convertit une durée donnée en secondes en un tuple
    (heures, minutes, secondes).

    >>> convertir_duree(3725)
    (1, 2, 5)
    >>> convertir_duree(59)
    (0, 0, 59)
    """
Q38.

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 :

def milieu(a: tuple[float, float], b: tuple[float, float]) -> tuple[float, float]:
    """Retourne les coordonnées du milieu du segment [AB].

    >>> milieu((0, 0), (4, 2))
    (2.0, 1.0)
    >>> milieu((-1, 3), (1, 3))
    (0.0, 3.0)
    """

Indication. Commencer par déballer chacun des deux tuples.

Q39.

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 A(xA,yA,zA)A(x_A, y_A, z_A) et B(xB,yB,zB)B(x_B, y_B, z_B) est :

AB=(xB−xA)2+(yB−yA)2+(zB−zA)2A B = \sqrt{(x_B - x_A)^2 + (y_B - y_A)^2 + (z_B - z_A)^2}
  1. Écrire la fonction distance dont la spécification est :
def distance(a: tuple[float, ...], b: tuple[float, ...]) -> float:
    """Retourne la distance entre les points a et b, qui doivent
    avoir le même nombre de coordonnées.

    >>> distance((0, 0), (3, 4))
    5.0
    >>> distance((1, 2, 3), (1, 2, 3))
    0.0
    >>> distance((0, 0, 0), (1, 2, 2))
    3.0
    """
  1. Que devrait faire la fonction si on l’appelle avec distance((0, 0), (1, 1, 1)) ? Ajouter au début du corps de la fonction l’instruction :
assert len(a) == len(b), "les deux points doivent avoir la même dimension"

puis tester à nouveau cet appel.

À retenir

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.

Q40.

Plus petit et plus grand élément. Écrire la fonction min_max_tuple dont la spécification est :

def min_max_tuple(valeurs: tuple[float, ...]) -> tuple[float, float]:
    """Retourne le plus petit et le plus grand élément de valeurs,
    qui ne doit pas être vide.

    >>> min_max_tuple((12, 5, 18, 7))
    (5, 18)
    >>> min_max_tuple((4,))
    (4, 4)
    """

Les fonctions min et max de Python ne doivent pas être utilisées. Vérifier la précondition par une assertion.

Vérifier ses acquis 3 questions

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.

Exercices de synthèse

Q41.

Équation du second degré. On cherche les solutions réelles de l’équation ax2+bx+c=0a x^2 + b x + c = 0, avec a≠0a \neq 0. On note Δ=b2−4ac\Delta = b^2 - 4 a c le discriminant.

  • Si Δ>0\Delta > 0, il y a deux solutions : x1=(−b−Δ)/(2a)x_1 = (-b - \sqrt{\Delta}) / (2 a) et x2=(−b+Δ)/(2a)x_2 = (-b + \sqrt{\Delta}) / (2 a).
  • Si Δ=0\Delta = 0, il y a une seule solution : x0=−b/(2a)x_0 = -b / (2 a).
  • Si Δ<0\Delta < 0, il n’y a pas de solution réelle.

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 :

def racines(a: float, b: float, c: float) -> tuple[float, ...]:
    """Retourne le tuple des solutions réelles de a x² + b x + c = 0,
    avec a non nul.

    >>> racines(1, -3, 2)
    (1.0, 2.0)
    >>> racines(1, 2, 1)
    (-1.0,)
    >>> racines(1, 0, 1)
    ()
    """
Q42.

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 :

def est_avant(d1: tuple[int, int, int], d2: tuple[int, int, int]) -> bool:
    """Retourne True si la date d1 est strictement antérieure
    à la date d2, False sinon.

    >>> est_avant((14, 7, 1789), (11, 11, 1918))
    True
    >>> est_avant((25, 12, 2025), (1, 1, 2025))
    False
    >>> est_avant((3, 5, 2026), (3, 5, 2026))
    False
    >>> est_avant((3, 5, 2026), (4, 5, 2026))
    True
    """

Indication. Comparer d’abord les années. Si elles sont égales, comparer les mois, et ainsi de suite.

Bilan

À l’issue de cette activité, je sais…
  • créer un tuple, y compris un tuple d’un seul élément (5,) et le tuple vide () ;
  • lire un élément d’un tuple grâce à son indice, en sachant que les indices vont de 0 à len(t) - 1 ;
  • expliquer pourquoi t[0] = 4 provoque une erreur, et construire un nouveau tuple à la place ;
  • tester la présence d’une valeur dans un tuple avec in ;
  • parcourir un tuple par ses éléments ou par ses indices, et choisir l’écriture adaptée ;
  • déballer un tuple par une affectation multiple, et expliquer pourquoi a, b = b, a échange deux valeurs ;
  • écrire une fonction qui renvoie un tuple de valeurs, avec une signature du type -> tuple[int, int] ;
  • vérifier une précondition à l’aide d’une assertion.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premières structures de données : listes et tuples

Les listes

Objectif

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.

Quand un tuple ne suffit plus

Un professeur range les notes d’un devoir dans un tuple :

notes = (12, 15, 9, 14)

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.

Q1.

Saisir les instructions suivantes dans la console :

>>> notes = [12, 15, 9, 14]
>>> type(notes)
>>> notes[2] = 11
>>> notes

La modification a-t-elle été acceptée ?

À retenir

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.

Remarque

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.

Vérifier ses acquis 2 questions

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.

Lire et modifier les éléments d’une liste

Bonne nouvelle : tout ce qu’on a appris sur les indices des tuples reste vrai pour les listes.

Q2.

Saisir notes = [12, 15, 11, 14] dans la console. Prévoir le résultat de chacune des instructions suivantes, puis vérifier :

>>> notes[0]
>>> len(notes)
>>> notes[len(notes) - 1]
>>> notes[4]
>>> 15 in notes
>>> []
>>> len([])

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.

Q3.

Le professeur décide d’ajouter un point à chaque note. Un élève propose :

notes = [12, 15, 11, 14]
for n in notes:
    n += 1

Un autre élève propose :

notes = [12, 15, 11, 14]
for i in range(len(notes)):
    notes[i] += 1
  1. Exécuter les deux propositions et afficher notes après chacune d’elles. Laquelle fonctionne ?
  2. Expliquer pourquoi l’autre ne modifie pas la liste.
À retenir

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.

Vérifier ses acquis 3 questions

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.

Construire une liste

Une liste de taille fixée à l’avance

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.

Q4.

Recopier et compléter la fonction suivante, qui doit construire la liste des carrés des entiers de 0 à n - 1 :

def carres(n: int) -> list[int]:
    """Retourne la liste des carrés des entiers de 0 à n - 1.

    >>> carres(5)
    [0, 1, 4, 9, 16]
    """
    resultat = [0] * n
    for i in range(n):
        ...
    return resultat

Une liste en compréhension

En mathématiques, on décrit parfois un ensemble par une règle plutôt qu’en écrivant tous ses éléments : k2∣k∈0,1,2,3,4{k^2 | k \in {0, 1, 2, 3, 4}} se lit « l’ensemble des k2k^2 pour kk appartenant à {0,1,2,3,4}\{0, 1, 2, 3, 4\} ». Python permet d’écrire une liste de la même façon :

[k * k for k in range(5)]

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.

Q5.

Prévoir la liste obtenue pour chacune des expressions suivantes, puis vérifier dans la console :

>>> [2 * k + 1 for k in range(5)]
>>> [n / 2 for n in [12, 15, 11, 14]]
>>> [len(mot) for mot in ["tuple", "liste", "indice"]]
>>> [k for k in range(1, 21) if k % 3 == 0]

À quoi sert la partie if k % 3 == 0 dans la dernière expression ?

Q6.

Écrire une liste en compréhension qui donne :

  1. les 10 premiers multiples de 7 : [7, 14, 21, ..., 70] ;
  2. les notes de la liste notes = [12, 15, 8, 14, 6, 17] qui sont inférieures à 10 ;
  3. la liste [True, False, True, False, True, False] qui indique, pour chaque entier de 0 à 5, s’il est pair.
À retenir

On peut construire une liste :

  • de taille fixée, avec [valeur] * n, puis la remplir par indice ;
  • en compréhension, avec [expression for element in iterable]. On peut ajouter un filtre : [expression for element in iterable if condition].
Vérifier ses acquis 3 questions

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 liste, plusieurs noms

Une surprise

Q7.

Saisir les instructions suivantes dans la console, en prévoyant le résultat de la dernière ligne avant de la valider :

>>> n = [12, 18, 9]
>>> m = n
>>> m[0] = 0
>>> n

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 →\rightarrow
arrow.larrow.l 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.

Q8.

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 :

>>> n = [12, 18, 9]
>>> c = [x for x in n]
>>> c[0] = 0
>>> n
>>> c

Une fonction peut modifier la liste qu’on lui donne

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.

Q9.

Recopier les deux fonctions suivantes dans l’éditeur :

def reinitialiser_1(notes: list[float]) -> None:
    notes = [0] * len(notes)

def reinitialiser_2(notes: list[float]) -> None:
    for i in range(len(notes)):
        notes[i] = 0

Prévoir, puis vérifier, le contenu de releve après chaque appel :

>>> releve = [12, 15, 9, 14]
>>> reinitialiser_1(releve)
>>> releve
>>> reinitialiser_2(releve)
>>> releve

Expliquer la différence de comportement entre les deux fonctions.

Effet de bord

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.

À retenir

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.

Vérifier ses acquis 3 questions

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.

Des listes de listes

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 = [[1, 2, 3],
     [4, 5, 6]]

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.

Q10.

Avec la liste m ci-dessus, prévoir puis vérifier :

>>> m[0]
>>> m[1][2]
>>> len(m)
>>> len(m[0])
>>> m[0][1] = 0
>>> m

Que représentent len(m) et len(m[0]) pour la matrice ?

Q11.

Écrire la fonction somme_matrice dont la spécification est :

def somme_matrice(m: list[list[int]]) -> int:
    """Retourne la somme de tous les éléments de la matrice m.

    >>> somme_matrice([[1, 2, 3], [4, 5, 6]])
    21
    """

Indication. Utiliser deux boucles imbriquées : l’une parcourt les indices des lignes, l’autre ceux des colonnes.

Q12.

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 :

def table_multiplication(n: int) -> list[list[int]]:
    """Retourne la table de multiplication des entiers de 1 à n,
    sous forme d'une matrice de n lignes et n colonnes.

    >>> table_multiplication(4)
    [[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]
    """

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 ?

Un piège classique

Pour fabriquer une grille de 3 lignes et 3 colonnes remplie de zéros, l’écriture [[0] * 3] * 3 semble naturelle. Pourtant :

>>> g = [[0] * 3] * 3
>>> g[0][0] = 5
>>> g
[[5, 0, 0], [5, 0, 0], [5, 0, 0]]

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 :

>>> g = [[0] * 3 for i in range(3)]
À retenir

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.

Vérifier ses acquis 3 questions

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.

Exercices de synthèse

Consigne

É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.

Q13.

Moyenne. Écrire la fonction moyenne dont la spécification est :

def moyenne(notes: list[float]) -> float:
    """Retourne la moyenne des éléments de notes, qui ne doit pas être vide.

    >>> moyenne([12, 15, 9, 14])
    12.5
    """

Vérifier la précondition à l’aide d’une assertion (voir Doc. 3,1).

Q14.

Recherche d’une valeur. Écrire la fonction indice dont la spécification est :

def indice(valeurs: list[int], cherchee: int) -> int:
    """Retourne l'indice de la première occurrence de cherchee dans
    valeurs, ou -1 si cherchee n'est pas dans valeurs.

    >>> indice([4, 8, 15, 16, 23, 42], 16)
    3
    >>> indice([4, 8, 15, 16, 23, 42], 7)
    -1
    >>> indice([5, 3, 5], 5)
    0
    """

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 ?

Q15.

Statistiques d’un devoir. On veut écrire la fonction statistiques dont la spécification est :

def statistiques(notes: list[float]) -> tuple[float, int, int, int]:
    """Retourne un tuple (m, bas, milieu, haut) où m est la moyenne
    des notes, bas le nombre de notes strictement inférieures à m - 3,
    milieu le nombre de notes comprises entre m - 3 et m + 3 (bornes
    incluses), haut le nombre de notes strictement supérieures à m + 3.

    >>> statistiques([12, 15, 8, 14, 6, 17])
    (12.0, 2, 3, 1)
    >>> statistiques([10, 7, 13])
    (10.0, 0, 3, 0)
    """
  1. Vérifier à la main le premier exemple de la documentation.
  2. Écrire la fonction, en utilisant la fonction moyenne de la question précédente.
  3. Un élève propose de compter les notes de chaque groupe avec une fonction qui compte les valeurs comprises dans un intervalle [a;b][a ; b], bornes incluses, appelée trois fois : sur [0;m−3][0 ; m - 3], sur [m−3;m+3][m - 3 ; m + 3] et sur [m+3;20][m + 3 ; 20]. Le deuxième exemple de la documentation montre pourquoi cette idée donne un résultat faux. Expliquer.
Q16.

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 :

def loto() -> list[int]:
    """Retourne une liste de 6 entiers différents, tirés au hasard
    entre 1 et 49 (bornes incluses).
    """

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 ?

Pour aller plus loin

Q17.

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 :

def transposee(m: list[list[int]]) -> list[list[int]]:
    """Retourne la transposée de la matrice m.

    >>> transposee([[1, 2, 3], [4, 5, 6]])
    [[1, 4], [2, 5], [3, 6]]
    """

Bilan

À l’issue de cette activité, je sais…
  • expliquer la différence entre une liste, mutable, et un tuple, non mutable ;
  • lire et modifier un élément d’une liste grâce à son indice ;
  • parcourir une liste par ses éléments pour la lire, et par ses indices pour la modifier ;
  • construire une liste de taille fixée avec [valeur] * n ;
  • construire une liste en compréhension, avec ou sans filtre if ;
  • expliquer pourquoi, après m = n, une modification de m est visible dans n, et faire une vraie copie d’une liste ;
  • prévoir si une fonction modifie la liste qu’elle reçoit en argument ;
  • représenter une matrice par une liste de listes et utiliser la notation m[i][j] ;
  • écrire un algorithme de recherche d’une valeur, de calcul d’une moyenne, sur une liste.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premières structures de données : listes et tuples

Une liste est un objet auquel on peut passer des messages

Objectif

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.

Q14.

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 :

>>> courses = []
>>> courses[0] = "pain"

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 ».

Envoyer un message à une liste

Objets, messages et méthodes

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 :

courses.append("pain")

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.

Q15.

Saisir les instructions suivantes dans la console, en prévoyant le résultat de chaque ligne avant de la valider :

>>> courses = []
>>> courses.append("pain")
>>> courses
>>> len(courses)
>>> courses.append("lait")
>>> courses.append("œufs")
>>> courses
>>> courses[2]

À quel indice se trouve l’élément qu’on vient d’ajouter avec append ? Exprimer cet indice à l’aide de len(courses).

À retenir

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 [].

Construire une liste en partant 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.

def multiples(n: int, k: int) -> list[int]:
    """Retourne la liste des multiples de k compris entre 1 et n.

    >>> multiples(20, 3)
    [3, 6, 9, 12, 15, 18]
    """
    resultat = []                # 1. on part de la liste vide
    for i in range(1, n + 1):    # 2. on examine chaque entier de 1 à n
        if i % k == 0:           # 3. s'il convient...
            resultat.append(i)   #    ... on l'ajoute au bout de la liste
    return resultat              # 4. on retourne la liste construite

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.

Q16.

En suivant la même méthode, écrire la fonction diviseurs dont la spécification est :

def diviseurs(n: int) -> list[int]:
    """Retourne la liste des diviseurs de l'entier n, avec n >= 1,
    rangés dans l'ordre croissant.

    >>> diviseurs(12)
    [1, 2, 3, 4, 6, 12]
    >>> diviseurs(7)
    [1, 7]
    """

Pourquoi la méthode [0] * taille du Doc. 3,2 serait-elle mal adaptée ici ?

Q17.

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 :

def loto() -> list[int]:
    """Retourne une liste de 6 entiers différents, tirés au hasard
    entre 1 et 49 (bornes incluses).
    """

Quelle variable de l’ancienne version devient inutile ? Par quoi est-elle remplacée ?

Coups de pouce
  1. On ne sait pas combien de tirages il faudra, puisqu’un numéro déjà sorti est rejeté. La boucle reste donc une boucle while.
  2. La boucle doit s’arrêter quand la liste contient 6 numéros. Quelle expression donne le nombre de numéros déjà rangés ?
Vérifier ses acquis 3 questions

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.

Retirer un élément : le message pop

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.

Q18.

Saisir les instructions suivantes dans la console, en prévoyant le résultat de chaque ligne avant de la valider :

>>> pile = [3, 7, 12, 5]
>>> pile.pop()
>>> pile
>>> x = pile.pop(0)
>>> x
>>> pile
>>> pile.pop()
>>> pile.pop()
>>> pile.pop()
  1. Quel élément pop() retire-t-il lorsqu’on ne lui donne pas d’argument ? Et pop(0) ?
  2. Contrairement à append, la ligne pile.pop() affiche quelque chose. Que représente ce qui est affiché ?
  3. Pourquoi la dernière ligne provoque-t-elle une erreur ?
À retenir

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.

Q19.

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.

historique = []
historique.append("écrire Bonjour")
historique.append("mettre en gras")
historique.append("écrire Monde")
derniere = historique.pop()
print("Annulé :", derniere)
historique.append("souligner")
derniere = historique.pop()
print("Annulé :", derniere)
derniere = historique.pop()
print("Annulé :", derniere)
print(historique)
Q20.

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 :

def inverser(t: list[int]) -> list[int]:
    """Retourne une nouvelle liste formée des éléments de t
    pris dans l'ordre inverse.

    >>> inverser([12, 15, 9, 14])
    [14, 9, 15, 12]
    """
    resultat = []
    while len(t) > 0:
        resultat.append(t.pop())
    return resultat
  1. Recopier la fonction, puis saisir dans la console :
    >>> releve = [12, 15, 9, 14]
    >>> r = inverser(releve)
    >>> r
    >>> releve
    La fonction retourne-t-elle le bon résultat ? Quel autre effet a-t-elle ?
  2. Expliquer cet effet à l’aide du Doc. 3,2.
  3. Corriger la fonction pour que la liste reçue en argument ne soit pas modifiée, en conservant l’idée de l’élève.
Coups de pouce
  1. Au moment de l’appel inverser(releve), combien de listes existent en mémoire ? Combien de noms les référencent ?
  2. Le message pop modifie la liste qui le reçoit. Sur quelle liste faudrait-il l’envoyer pour que releve ne soit pas touchée ?
Vérifier ses acquis 3 questions

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.

Un message qui modifie la liste ne renvoie rien

Q21.

Une élève veut ajouter le lait à sa liste de courses. Elle écrit :

>>> courses = ["pain"]
>>> courses = courses.append("lait")
>>> print(courses)
None

Sa liste a disparu. Elle essaie alors de ranger des notes dans l’ordre croissant avec le message sort (trier) :

>>> notes = [12, 15, 9, 14]
>>> print(notes.sort())
None
>>> notes
[9, 12, 14, 15]
  1. Que renvoie le message append ? Et le message sort ?
  2. Expliquer, étape par étape, ce qui s’est passé lors de l’instruction courses = courses.append("lait").
  3. Comment fallait-il écrire cette instruction ?

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.

Q22.

Prévoir, puis vérifier, le contenu de n et de m à la fin de chacune des deux séquences :

>>> n = [1, 2, 3]
>>> m = n
>>> m.append(4)
>>> n
>>> m
>>> n = [1, 2, 3]
>>> m = n
>>> m = m + [4]
>>> n
>>> m

Expliquer la différence.

À retenir

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.

Vérifier ses acquis 3 questions

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.

D’autres messages

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
Q23.

À 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.

>>> t = [5, 8, 2, 8]
>>> t.insert(1, 10)
>>> t
>>> t.remove(8)
>>> t
>>> t.index(2)
>>> t.count(8)
>>> t.remove(7)
>>> t.reverse()
>>> t
Remarque

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.

À retenir

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.

Vérifier ses acquis 3 questions

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.

Exercices de synthèse

Consigne

É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.

Q24.

Sans doublons. Écrire la fonction sans_doublons dont la spécification est :

def sans_doublons(t: list[int]) -> list[int]:
    """Retourne une nouvelle liste contenant les éléments de t,
    chacun une seule fois, dans l'ordre de leur première apparition.

    >>> sans_doublons([3, 1, 3, 2, 1])
    [3, 1, 2]
    >>> sans_doublons([])
    []
    """

Pourquoi ne peut-on pas obtenir ce résultat simplement avec une liste en compréhension filtrée par if x not in t ?

Q25.

Pairs et impairs. Écrire la fonction separer dont la spécification est :

def separer(valeurs: list[int]) -> tuple[list[int], list[int]]:
    """Retourne un tuple (pairs, impairs) : pairs est la liste des
    éléments pairs de valeurs, impairs celle des éléments impairs,
    dans l'ordre où ils apparaissent dans valeurs.

    >>> separer([4, 7, 10, 3, 8])
    ([4, 10, 8], [7, 3])
    """

Tester ensuite, dans la console, l’affectation multiple p, i = separer([4, 7, 10, 3, 8]) (Doc. 3,1).

Pour aller plus loin

Q26.

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.

def guichet(evenements: list[str]) -> tuple[list[str], list[str]]:
    """Retourne un tuple (servis, en_attente) : servis est la liste
    des clients servis, dans l'ordre où ils l'ont été, en_attente
    celle des clients qui attendent encore à la fin.
    On suppose que la file n'est jamais vide quand "*" survient.

    >>> guichet(["Ana", "Bilal", "*", "Chloé", "Dylan", "*"])
    (['Ana', 'Bilal'], ['Chloé', 'Dylan'])
    """
  1. Écrire la fonction guichet.
  2. Un élève a écrit 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 ?
Coups de pouce
  1. La file est une liste qui part vide. Que faut-il lui envoyer quand un client arrive ?
  2. Le client servi est celui qui est arrivé le premier. À quel indice de la file se trouve-t-il ?
  3. Le client servi doit à la fois quitter la file et rejoindre la liste servis. Un seul message renvoie l’élément qu’il retire.

Bilan

À l’issue de cette activité, je sais…
  • expliquer la différence entre appeler une fonction, comme len(t), et envoyer un message à une liste, comme t.append(x) ;
  • construire une liste en partant de la liste vide et en ajoutant ses éléments avec append dans une boucle ;
  • retirer le dernier élément d’une liste, ou celui d’indice i, avec pop, et utiliser l’élément renvoyé ;
  • éviter d’envoyer pop à une liste vide ;
  • dire, pour un message donné, s’il modifie la liste et ce qu’il renvoie, et ne jamais écrire t = t.append(x) ;
  • prévoir l’effet d’un message envoyé à une liste qui a plusieurs alias, notamment lorsqu’elle est passée en argument à une fonction ;
  • utiliser une liste comme une pile (append et pop()) ou comme une file (append et pop(0)).
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premières structures de données : listes et tuples

Simuler un gaz avec Pyxel

Objectif

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.

Q24.

Sur un billard, une bille frappe la bande de droite. Le schéma montre sa vitesse juste avant le choc.

Bille juste avant le choc Bille juste avant le choc

Dessiner la flèche de sa vitesse juste après le choc. Lequel des deux mouvements, horizontal ou vertical, est modifié par le choc ?

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 décrite par un tuple

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.

import pyxel

# Constantes
LARGEUR = 160    # largeur de la fenêtre, en pixels
HAUTEUR = 120    # hauteur de la fenêtre, en pixels
RAYON = 3        # rayon d'une particule, en pixels

# Type d'une particule : (x, y, vx, vy, couleur)
Particule = tuple[int, int, int, int, int]

def dessiner_particule(p: Particule) -> None:
    """Dessine la particule p = (x, y, vx, vy, couleur)."""
    x, y, couleur = p[0], p[1], p[4]
    pyxel.circ(x, y, RAYON, couleur)

def update(gaz: list[Particule]) -> None:
    """Fait avancer le gaz d'une image."""
    pass

def draw(gaz: list[Particule]) -> None:
    """Dessine les particules du gaz."""
    pyxel.cls(0)
    dessiner_particule(gaz[0])

# Programme principal
pyxel.init(LARGEUR, HAUTEUR, title="Gaz parfait")
particules = [(36, 60, 2, -1, 8)]     # le gaz : une seule particule pour l'instant
pyxel.run(lambda: update(particules), lambda: draw(particules))

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.

Règle de ce programme

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.

Q25.

Lancer le programme. Avec particules = [(36, 60, 2, -1, 8)] :

  1. que vaut particules[0][2] ? Quelle grandeur représente-t-il ?
  2. que faut-il écrire pour obtenir la couleur de la particule ?
  3. la particule va-t-elle monter ou descendre quand elle bougera ? Justifier à l’aide du repère de Pyxel (Doc. 2,5).
Q26.

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.

Vérifier ses acquis 3 questions

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.

Faire avancer la particule

Pyxel affiche 30 images par seconde et appelle update(particules) avant chaque image. À chaque appel, on ajoute vx à x et vy à y.

Q27.

Sans exécuter le programme. La particule part de x=36x = 36 avec vx = 2. Elle touche le bord droit quand son centre atteint x=159−3=156x = 159 - 3 = 156. Au bout de combien de temps ?

Un élève propose :

def deplacer(p: Particule) -> None:
    p[0] = p[0] + p[2]
    p[1] = p[1] + p[3]
Q28.

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 :

x, y, vx, vy, couleur = p      # x reçoit p[0], y reçoit p[1], etc.

Il faut autant de noms à gauche que d’éléments dans le tuple.

Q29.

Écrire la fonction deplacer :

def deplacer(p: Particule) -> Particule:
    """Retourne la particule p après une image de déplacement."""

Tester dans la console : deplacer((36, 60, 2, -1, 8)) doit retourner (38, 59, 2, -1, 8).

Q30.

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.

Q31.

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.

Vérifier ses acquis 4 questions

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.

Rebondir contre les murs

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 :

def deplacer(p: Particule) -> Particule:
    """Retourne la particule p après une image : sa vitesse change
    si elle touche un mur, puis elle avance."""
    x, y, vx, vy, couleur = p
    if x + RAYON >= LARGEUR - 1:      # le bord droit du disque touche le mur
        vx = -vx
    return (x + vx, y + vy, vx, vy, couleur)
Q32.

Compléter deplacer pour les murs de gauche, du haut et du bas, puis tester.

Coups de pouce
  1. Pour les murs du haut et du bas, quelle composante de la vitesse change de signe ?
  2. Le mur du haut est la ligne y=0y = 0. Quel point du disque l’atteint en premier ?
Q33.

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
Q34.

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.

À retenir

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.

Vérifier ses acquis 3 questions

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.

Un gaz : une liste de particules

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) :

NB_PARTICULES = 30          # nombre de particules du gaz
VITESSE_MAX = 2             # valeur maximale d'une composante de la vitesse
COULEURS = (8, 11, 12)      # couleurs possibles
Q35.

Écrire la fonction nouvelle_particule, puis la tester plusieurs fois dans la console :

def nouvelle_particule() -> Particule:
    """Retourne une particule entièrement visible, tirée au hasard.
    Chaque composante de la vitesse est comprise entre -VITESSE_MAX
    et VITESSE_MAX. La couleur est l'un des éléments de COULEURS."""
Coups de pouce
  1. Un disque est entièrement visible si son centre est à au moins RAYON pixels de chaque bord (Doc. 2,5).
  2. Pour la couleur, tirer au hasard l’indice d’un élément de COULEURS.
Q36.

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 ?

Q37.

Modifier draw pour dessiner toutes les particules de gaz.

Pour faire bouger toutes les particules, un élève écrit :

def update(gaz: list[Particule]) -> None:
    for p in gaz:
        p = deplacer(p)
Q38.

Sans exécuter le programme, prévoir ce qu’on observe. Expliquer, puis corriger.

À retenir

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] = ....

Vérifier ses acquis 3 questions

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.

Pour aller plus loin : des collisions entre particules

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.

Q39.

Ajouter from math import sqrt au début du programme, puis écrire :

def distance(p1: Particule, p2: Particule) -> float:
    """Retourne la distance entre les centres de p1 et p2."""

def se_touchent(p1: Particule, p2: Particule) -> bool:
    """Retourne True si p1 et p2 se touchent, False sinon."""

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.

Q40.

Écrire la fonction choc :

def choc(p1: Particule, p2: Particule) -> tuple[Particule, Particule]:
    """Retourne les particules p1 et p2 après leur collision :
    elles ont échangé leurs vitesses."""

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).

def gerer_chocs(gaz: list[Particule]) -> None:
    """Fait échanger leurs vitesses aux particules de gaz qui se touchent."""
    for i in range(len(gaz)):
        for j in range(i + 1, len(gaz)):
            p1 = gaz[i]
            p2 = gaz[j]
            if se_touchent(p1, p2):
                gaz[i], gaz[j] = choc(p1, p2)
Q41.
  1. Avec 3 particules, écrire tous les couples (i, j) testés.
  2. Pourquoi la boucle intérieure commence-t-elle à i + 1 et non à 0 ?
Q42.

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.

Coups de pouce
  1. Que fait gerer_chocs à l’image qui suit un échange de vitesses ?
  2. Sur le mur, on n’a fait rebondir que les particules qui s’en approchaient. Comment savoir si deux particules se rapprochent ? On peut utiliser deplacer et distance.

Il reste un défaut : des particules rapides se traversent parfois.

Q43.

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.

Q44.

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.

Vérifier ses acquis 3 questions

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.

Défis

Q45.

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.

Q46.

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 ?

Bilan

À l’issue de cette activité, je sais…
  • représenter un objet par un tuple et lire un élément par son indice ;
  • expliquer pourquoi on ne peut pas modifier un élément d’un tuple, et écrire une fonction qui retourne un nouveau tuple ;
  • déballer un tuple pour nommer ses éléments ;
  • construire une liste de tuples en compréhension ;
  • choisir entre un parcours par éléments, pour lire une liste, et un parcours par indices, pour la modifier ;
  • passer une liste en paramètre à une fonction, et expliquer pourquoi la fonction peut modifier ses éléments mais pas la remplacer ;
  • parcourir toutes les paires d’éléments d’une liste avec deux boucles imbriquées ;
  • faire tourner un programme à la main pour trouver l’origine d’un comportement inattendu.