Aller au contenu

Chapitre 2.1 - Les Listes⚓︎

image

Les listes font partie de ce qu'on appelle les données composites (nous verrons plus tard les tuples et les dictionnaires). Elles permettent de regrouper de manière structurée un ensemble de valeurs (et non plus une valeur unique). On les appelle listes en Python, ou bien tableaux de manière plus générale.

1. Déclaration d'une liste⚓︎

Exemple fondateur n°1 ❤

Une variable de type liste sera délimitée par des crochets, et ses éléments séparés par des virgules :

Python
>>> maliste = ["riri", "fifi", "loulou"]

On peut observer le type de la variable ainsi créée :

Python
>>> type(maliste)
<class 'list'>

Remarques :

  • Même si cela n'a ici un grand intérêt, les éléments d'une liste peuvent donc être de types différents : ici, tous les éléments de ma liste sont des chaînes de caractères (str), mais la liste ["riri", 5, "fifi", "loulou"] est aussi une liste valide.

  • Une liste vide se déclarera avec [].

    Python
    >>> copies_corrigees = []
    Nous verrons plus tard qu'il est fréquent dans les exercices de partir d'une liste vide et d'ajouter progressivement des éléments.

2. Accès aux éléments d'une liste⚓︎

Exemple fondateur n°2 ❤

On accède à un élément d'une liste en mettant entre crochets l'indice de l'élément (qui commence à zéro).

Python
>>> famille = ["Bart", "Lisa", "Maggie"] # (1)
>>> famille[0]
'Bart'
>>> famille[1]
'Lisa'
>>> famille[2]
'Maggie'
>>> famille[3]
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
IndexError: list index out of range

  1. Nous prendrons souvent l'exemple de la famille Simpsons.

Remarques :

  • Un indice qui dépasse la valeur  longueur de la liste -1 provoquera donc une erreur list index out of range. C'est une erreur très fréquente lorsqu'on manipule des listes. image

  • Il est par contre possible d'utiliser des indices négatifs. On utilise par exemple très souvent l'indice -1 pour accéder au dernier élément de la liste, sans avoir à connaître la longueur de celle-ci :

Python
>>> famille[-1]
'Maggie'

3. Longueur d'une liste⚓︎

Exemple fondateur n°3 ❤

La longueur d'une liste sera donnée par la fonction len(), qui renvoie donc un nombre entier positif ou nul.

Python
>>> len(famille)
3

Remarques :

  • La liste vide a pour longueur 0 :
    Python
    >>> len([])
0
  • Le dernier élément d'une liste maliste (non vide) sera donc toujours l'élément d'indice len(maliste)-1.
    Python
    >>> famille[len(famille) - 1]
'Maggie'
  • Comme indiqué précédemment, ce dernier élément est aussi accessible par l'indice -1.

4. Parcours des éléments d'une liste ⭐ ⭐ ⭐⚓︎

Il existe deux méthodes pour parcourir séquentiellement tous les éléments d'une liste. Ces deux méthodes sont à maîtriser impérativement.

4.1 Parcours «par éléments»⚓︎

C'est la méthode la plus naturelle, celle déjà vue lors de la présentation de la boucle for. Nous allons simplement itérer sur les éléments de la liste.

Exemple fondateur n°4 ❤

Le code :

Python
1
2
3
4
famille = ["Bart", "Lisa", "Maggie"]

for membre in famille:
    print(membre)
renverra :
Python
Bart
Lisa
Maggie

Remarque :

  • Penser à donner un nom signifiant à la variable qui parcourt la liste. Il aurait par exemple été très maladroit d'écrire
    Python
    for k in famille:
    print(k)
    En effet le nom de variable k est habituellement utilisé pour les nombres (les indices, les compteurs...).
Exercice 1

Après un référendum, la liste urne contient uniquement des 'oui' ou des 'non'. Déterminer le vainqueur de ce référendum.

Python
urne = ['oui', 'non', 'non', 'oui', 'oui', 'oui', 'non', 'oui', 'oui', 'oui', 'non', 'oui', 'non', 'non', 'oui', 'non', 'non', 'oui', 'oui', 'oui', 'oui', 'non', 'non', 'oui', 'non', 'oui', 'non', 'non', 'non', 'oui', 'oui', 'oui', 'oui', 'non', 'oui', 'non', 'non', 'oui', 'non', 'non', 'oui', 'non', 'non', 'non', 'non', 'non', 'non', 'non', 'oui', 'non', 'non', 'oui', 'oui', 'non', 'oui', 'oui', 'oui', 'oui', 'oui', 'oui', 'non', 'non', 'oui', 'oui', 'oui', 'oui', 'non', 'non', 'non', 'oui', 'oui', 'oui', 'non', 'non', 'non', 'non', 'oui', 'non', 'non', 'non', 'non', 'non', 'non', 'non', 'non', 'oui', 'non', 'oui', 'non', 'non', 'oui', 'oui', 'non', 'non', 'non', 'oui', 'oui', 'non', 'oui', 'oui', 'non', 'non', 'oui', 'oui', 'oui', 'non', 'oui', 'non', 'oui', 'oui', 'oui', 'oui', 'oui', 'non', 'non', 'non', 'non', 'oui', 'oui', 'oui', 'non', 'oui', 'non', 'oui', 'oui', 'oui', 'oui', 'oui', 'non', 'non', 'oui', 'non', 'non', 'non', 'non', 'non', 'non', 'oui', 'non', 'non', 'oui', 'non', 'non', 'oui', 'non', 'non', 'oui', 'oui', 'oui', 'oui', 'oui', 'oui', 'non', 'oui']
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
urne = ['oui', 'non', 'non', 'oui', 'oui', 'oui', 'non', 'oui', 'oui', 'oui', 'non', 'oui', 'non', 'non', 'oui', 'non', 'non', 'oui', 'oui', 'oui', 'oui', 'non', 'non', 'oui', 'non', 'oui', 'non', 'non', 'non', 'oui', 'oui', 'oui', 'oui', 'non', 'oui', 'non', 'non', 'oui', 'non', 'non', 'oui', 'non', 'non', 'non', 'non', 'non', 'non', 'non', 'oui', 'non', 'non', 'oui', 'oui', 'non', 'oui', 'oui', 'oui', 'oui', 'oui', 'oui', 'non', 'non', 'oui', 'oui', 'oui', 'oui', 'non', 'non', 'non', 'oui', 'oui', 'oui', 'non', 'non', 'non', 'non', 'oui', 'non', 'non', 'non', 'non', 'non', 'non', 'non', 'non', 'oui', 'non', 'oui', 'non', 'non', 'oui', 'oui', 'non', 'non', 'non', 'oui', 'oui', 'non', 'oui', 'oui', 'non', 'non', 'oui', 'oui', 'oui', 'non', 'oui', 'non', 'oui', 'oui', 'oui', 'oui', 'oui', 'non', 'non', 'non', 'non', 'oui', 'oui', 'oui', 'non', 'oui', 'non', 'oui', 'oui', 'oui', 'oui', 'oui', 'non', 'non', 'oui', 'non', 'non', 'non', 'non', 'non', 'non', 'oui', 'non', 'non', 'oui', 'non', 'non', 'oui', 'non', 'non', 'oui', 'oui', 'oui', 'oui', 'oui', 'oui', 'non', 'oui']

nb_oui = 0
nb_non = 0
for vote in urne:
    if vote == 'oui':
        nb_oui += 1
    else:
        nb_non += 1
print('pourcentage de oui', 100*nb_oui/len(urne), '%')
print('pourcentage de non', 100*nb_non/len(urne), '%')
print('-'*10)
if nb_oui > nb_non:
    print('le oui est vainqueur')
elif nb_oui < nb_non:
    print('le non est vainqueur')
else:
    print('le oui et le non sont à égalité')

4.2 Parcours «par indice»⚓︎

Chaque élément étant accessible par son indice (de 0 à len(liste) - 1 ), il suffit de faire parcourir à une variable i l'ensemble des entiers de 0 à len(liste) - 1, par l'instruction range(len(liste)) :

Exemple fondateur n°5 ❤

Le code :

Python
1
2
3
4
famille = ["Bart", "Lisa", "Maggie"]

for i in range(len(famille)):
    print(famille[i])
renverra :
Python
Bart
Lisa
Maggie

⚠ Bonne habitude à prendre : nommer sa variable d'indice i, j, k ou indice mais pas autre chose !

image

4.3 Avantages et inconvénients de chaque méthode⚓︎

4.3.1 Parcours par élément⚓︎

Python
    for membre in famille:
        print(membre)

Les avantages 👍

  • la simplicité : un code plus facile à écrire, avec un nom de variable explicite.
  • la sécurité : pas de risque d'index out of range !

Les inconvénients 👎

  • méthode rudimentaire : lorsqu'on est «positionné» sur un élément, il n'est pas possible d'accéder au précédent ou au suivant. (et c'est parfois utile).
  • on ne peut pas modifier l'élément sur lequel on est positionné :
Python
>>> lst = [1, 2, 3]
>>> for nb in lst:
        nb = nb * 2 # (1)

>>> lst 
[1, 2, 3] # (2)
  1. On veut multiplier par 2 chaque élément de la liste
  2. La liste lst n'a pas changé...

4.3.2 Parcours par indice⚓︎

Python
    for i in range(len(famille)):
        print(famille[i])

Les avantages 👍

  • le contrôle : en parcourant par indice, on peut s'arrêter où on veut, on peut accéder au suivant/précédent...
  • pour les tableaux à deux dimensions, on retrouve la désignation classique d'un élément par numéro de ligne / numéro de colonne.

Les inconvénients 👎

  • la complexité : il faut connaître le nombre d'éléments de la liste (ou le récupérer par la fonction len() )
  • le risque d'erreur : encore et toujours le index out of range...
Exercice 2

On donne la liste :

Python
lst = [3, 1, 4, 1, 5, 9]
En utilisant un parcours par indice :

  1. Afficher un à un les éléments de cette liste.
  2. Afficher un à un les éléments de cette liste dans l'ordre inverse (en commençant par 9)
  1. Python
    1
2
    for i in range(len(lst)):
    print(lst[i])

2.

Python
1
2
3
4
lst = [3, 1, 4, 1, 5, 9]

for i in range(len(lst)-1, -1, -1):
    print(lst[i])
}

Exercice 3

Trouvez le nombre qui est exactement à la même place dans la liste list1 et dans la liste list2, sachant que les deux listes ont la même taille.

  1. En utilisant une boucle for (une seule !).
  2. En utilisant une boucle while. Quel est l'avantage de la boucle while ?
Python
list1 = [8468, 4560, 3941, 3328, 7, 9910, 9208, 8400, 6502, 1076, 5921, 6720, 948, 9561, 7391, 7745, 9007, 9707, 4370, 9636, 5265, 2638, 8919, 7814, 5142, 1060, 6971, 4065, 4629, 4490, 2480, 9180, 5623, 6600, 1764, 9846, 7605, 8271, 4681, 2818, 832, 5280, 3170, 8965, 4332, 3198, 9454, 2025, 2373, 4067]
list2 = [9093, 2559, 9664, 8075, 4525, 5847, 67, 8932, 5049, 5241, 5886, 1393, 9413, 8872, 2560, 4636, 9004, 7586, 1461, 350, 2627, 2187, 7778, 8933, 351, 7097, 356, 4110, 1393, 4864, 1088, 3904, 5623, 8040, 7273, 1114, 4394, 4108, 7123, 8001, 5715, 7215, 7460, 5829, 9513, 1256, 4052, 1585, 1608, 3941]
Python
1
2
3
4
5
6
list1 = [8468, 4560, 3941, 3328, 7, 9910, 9208, 8400, 6502, 1076, 5921, 6720, 948, 9561, 7391, 7745, 9007, 9707, 4370, 9636, 5265, 2638, 8919, 7814, 5142, 1060, 6971, 4065, 4629, 4490, 2480, 9180, 5623, 6600, 1764, 9846, 7605, 8271, 4681, 2818, 832, 5280, 3170, 8965, 4332, 3198, 9454, 2025, 2373, 4067]
list2 = [9093, 2559, 9664, 8075, 4525, 5847, 67, 8932, 5049, 5241, 5886, 1393, 9413, 8872, 2560, 4636, 9004, 7586, 1461, 350, 2627, 2187, 7778, 8933, 351, 7097, 356, 4110, 1393, 4864, 1088, 3904, 5623, 8040, 7273, 1114, 4394, 4108, 7123, 8001, 5715, 7215, 7460, 5829, 9513, 1256, 4052, 1585, 1608, 3941]

for i in range(len(list1)):
    if list1[i] == list2[i]:
        print(list1[i])

Python
1
2
3
4
5
6
7
list1 = [8468, 4560, 3941, 3328, 7, 9910, 9208, 8400, 6502, 1076, 5921, 6720, 948, 9561, 7391, 7745, 9007, 9707, 4370, 9636, 5265, 2638, 8919, 7814, 5142, 1060, 6971, 4065, 4629, 4490, 2480, 9180, 5623, 6600, 1764, 9846, 7605, 8271, 4681, 2818, 832, 5280, 3170, 8965, 4332, 3198, 9454, 2025, 2373, 4067]
list2 = [9093, 2559, 9664, 8075, 4525, 5847, 67, 8932, 5049, 5241, 5886, 1393, 9413, 8872, 2560, 4636, 9004, 7586, 1461, 350, 2627, 2187, 7778, 8933, 351, 7097, 356, 4110, 1393, 4864, 1088, 3904, 5623, 8040, 7273, 1114, 4394, 4108, 7123, 8001, 5715, 7215, 7460, 5829, 9513, 1256, 4052, 1585, 1608, 3941]

i = 0
while list1[i] != list2[i]:
    i += 1
print(list1[i])
Avantage : on s'arrête dès qu'on a trouvé !

Inconvénient : on part du principe que ce nombre existe vraiment. Si on ne le trouve pas, on aura une erreur...

Exercice 4

Dans la liste

Python
lst = [2428970, 1518306, 4971405, 1690994, 7918102, 4030834, 8830131, 7514856, 7903128, 6307569, 6624056, 5260490, 6447835, 4598783, 9108626, 5045240, 4128269, 4460134, 2497873, 5076659, 8104003, 7604887, 7451976, 4136924, 5691945, 8726293, 7855592, 3562473, 8849129, 6488474, 5303587, 2606124, 5484044, 4559758, 7592232, 2211406, 9974334, 7988936, 7582946, 7668748, 1799997, 3837917, 3196209, 7064342, 2543765, 1182013, 7253381, 1153735, 1037391, 4375946, 4445821, 5965587, 6001887, 4162629, 5235783, 8716582, 4901175, 5445422, 1120005, 8332321, 7075046, 2194175, 5557300, 2887907, 5103214, 2520744, 5104399, 2065665, 3035703, 7890213, 1758301, 3407982, 1355453, 4896338, 7979392, 9671602, 9690721, 7423779, 7423780, 3080825, 6785783, 3836837, 7310931, 1857470, 3492507, 2823231, 1492310, 1911148, 9620515, 5564910, 7009452, 7464745, 9608747, 7267383, 6939140, 6556578, 3592267, 8135497, 4881660, 5346884, 6859150]
se cachent deux nombres consécutifs (comme les nombres 4 et 5 dans la liste [6, 2, 4, 5, 3] ). Pouvez-vous les trouver ?

Python
1
2
3
4
5
lst = [2428970, 1518306, 4971405, 1690994, 7918102, 4030834, 8830131, 7514856, 7903128, 6307569, 6624056, 5260490, 6447835, 4598783, 9108626, 5045240, 4128269, 4460134, 2497873, 5076659, 8104003, 7604887, 7451976, 4136924, 5691945, 8726293, 7855592, 3562473, 8849129, 6488474, 5303587, 2606124, 5484044, 4559758, 7592232, 2211406, 9974334, 7988936, 7582946, 7668748, 1799997, 3837917, 3196209, 7064342, 2543765, 1182013, 7253381, 1153735, 1037391, 4375946, 4445821, 5965587, 6001887, 4162629, 5235783, 8716582, 4901175, 5445422, 1120005, 8332321, 7075046, 2194175, 5557300, 2887907, 5103214, 2520744, 5104399, 2065665, 3035703, 7890213, 1758301, 3407982, 1355453, 4896338, 7979392, 9671602, 9690721, 7423779, 7423780, 3080825, 6785783, 3836837, 7310931, 1857470, 3492507, 2823231, 1492310, 1911148, 9620515, 5564910, 7009452, 7464745, 9608747, 7267383, 6939140, 6556578, 3592267, 8135497, 4881660, 5346884, 6859150]

for i in range(len(lst)-1): # Il faut s'arrêter à l'avant-dernier élément de la liste
    if lst[i] + 1 == lst[i+1]:
        print(lst[i], lst[i+1])

5. Modification d'une liste⚓︎

En Python, les objets de type List sont modifiables (on emploie le mot mutables). Et c'est souvent une bonne chose, car des listes peuvent évoluer après leur création. Lorsqu'on souhaitera figer le contenu d'une liste (pour des raisons de sécurité du code essentiellement), on utilisera alors le type Tuple, qui sera vu ultérieurement.

5.1 Modification d'un élément existant⚓︎

Il suffit d'écraser la valeur actuelle avec une nouvelle valeur

Exemple fondateur n°6 ❤

Python
>>> famille = ["Bart", "Lisa", "Maggie"]
>>> famille[0] = "Bartholomew" # oui, c'est son vrai nom
>>> famille
['Bartholomew', 'Lisa', 'Maggie']

5.2 Ajout d'un élement à la fin d'une liste : la méthode append() ⭐⚓︎

Exemple fondateur n°7 ❤

Python
>>> famille = ["Bart", "Lisa", "Maggie"]
>>> famille.append("Milhouse")
>>> famille
['Bart', 'Lisa', 'Maggie', 'Milhouse']

Remarques :

  • La méthode append() rajoute donc un élément à la fin de la liste.
  • Dans beaucoup d'exercices, on part d'une liste vide [] que l'on remplit peu à peu avec des append().
  • (HP) Il est possible d'insérer un élément à la position i avec la méthode insert :
    Python
    >>> famille = ["Bart", "Lisa", "Maggie"]
>>> famille.insert(1, "Nelson") # on insère à la position 1
>>> famille
['Bart', 'Nelson', 'Lisa', 'Maggie']
Exercice 5

Construire une liste contenant tous les nombres inférieurs à 100 qui sont divisibles par 7.

Python
1
2
3
4
lst = []
for n in range(1, 101):
    if n % 7 == 0:
        lst.append(n)
Exercice 6

On considère la liste temp = [4, -5, 8, 10, -1, -2, 7, 13].
Construire la liste temp_pos qui ne contient que les éléments positifs de temp.

Python
1
2
3
4
5
6
temp = [4, -5, 8, 10, -1, -2, 7, 13]

temp_pos = []
for t in temp:
    if t > 0:
        temp_pos.append(t)

5.3 Suppression d'un élément d'une liste ...⚓︎

5.3.1 ... par la méthode remove()⚓︎

Exemple fondateur n°7 ❤

Python
>>> famille = ['Bart', 'Nelson', 'Lisa', 'Maggie']
>>> famille.remove("Nelson")
>>> famille
['Bart', 'Lisa', 'Maggie']

Remarques :

  • Attention, remove n'enlève que la première occurrence de l'élément désigné. S'il y en a d'autres après, elles resteront dans la liste :
    Python
    >>> lst = [3, 1, 4, 5, 1, 9, 4]
>>> lst.remove(4)
>>> lst
[3, 1, 5, 1, 9, 4]
  • Si l'élément à supprimer n'est pas trouvé, un message d'erreur est renvoyé :
    Python
    >>> lst = [3, 1, 4, 5, 1, 9]
>>> lst.remove(2)
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
ValueError: list.remove(x): x not in list

5.3.2 ... par l'instruction del⚓︎

L'instruction del (qui n'est pas une fonction) permet de supprimer un élément en donnant son indice.

Python
>>> maliste = [8, 4, 2, 5, 7]
>>> del maliste[3]
>>> maliste
[8, 4, 2, 7]
Exercice 7

Exercice de la BNS.

6. Construction d'une liste d'éléments identiques⚓︎

Il est souvent pratique d'initialiser une liste de taille donnée, souvent en la remplissant de 0.

Imaginons par exemple que nous souhaitions une liste de taille 26 remplie de 0. Il est possible de faire comme ceci :

Python
1
2
3
lst = []
for _ in range(26):
    lst.append(0)

mais on préfèrera ce code :

Exemple fondateur n°8 ❤

Python
>>> lst = [0]*26

qui produira la liste [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Exercice 8

Que fait le code ci-dessous ?

Python
texte = "cet texte est prodigieusement ennuyeux"

def rang(lettre):
    return ord(lettre) - 97

compt = [0]*26
for lettre in texte :
    if lettre != " " :
        compt[rang(lettre)] += 1

À l'issue de ce code la variable compt contient [0, 0, 1, 1, 9, 0, 1, 0, 2, 0, 0, 0, 1, 3, 1, 1, 0, 1, 2, 5, 3, 0, 0, 2, 1, 0], qui correspond au nombre d'occurences de chaque lettre : 0 fois la lettre 'a', 0 fois la lettre 'b', 1 fois la lettre 'c', etc.

Ce genre de comptage se fera de manière beaucoup plus efficace et élégante avec la structure de dictionnaire.

7. Construction d'une liste en compréhension ⭐ ⭐ ⭐⚓︎

C'est une grande caractéristique du langage Python (même si ce n'est pas une exclusivité) : la méthode de liste en compréhension propose une manière élégante, rapide et naturelle pour créer des listes.

7.1 «en compréhension», pourquoi ?⚓︎

Cette expression vient des mathématiques. On dit qu'on définit un sous-ensemble par compréhension lorsqu'on part d'un ensemble plus grand dont on ne garde que les éléments vérifiant une certaine propriété.

On pourrait par exemple définir les élèves de Première NSI de cette manière :

«élèves du lycée inscrits en classe de Première ayant choisi la spécialité NSI»

On part d'un ensemble large (les élèves du lycée) qu'on va ensuite réduire par des caractérisations spécifiques : être un élève de Première, puis avoir choisi la spécialité NSI.

7.2 Premier exemple⚓︎

Exemple fondateur n°9 ❤

Imaginons que nous possédons une liste data de températures, dont nous ne voulons garder que celles strictement supérieures à 20.

Python
>>> data = [17, 22, 15, 28, 16, 13, 21, 23]
>>> good = [t for t in data if t > 20]
>>> good
[22, 28, 21, 23]

Explications :

image

7.2.1 le filtre éventuel⚓︎

C'est lui qui donne tout son sens à cette méthode : il permet de ne garder que certaines valeurs. Il est pourtant éventuel : que se passe-t-il s'il n'y a pas de filtre ?

Python
>>> data = [17, 22, 15, 28, 16, 13, 21, 23]
>>> good = [t for t in data]
>>> good
[17, 22, 15, 28, 16, 13, 21, 23]
On se retrouve évidemment avec une nouvelle liste qui contient exactement les éléments de la liste de départ, ce qui n'est pas très intéressant. Pourtant les listes en compréhension sans filtre sont très fréquentes, nous le verrons plus loin.

Exercice 9

On considère la variable phrase = 'Bonjour les vacances sont finies' et la variable voyelles = 'aeiouy'.

Construire en compréhension la liste liste_voyelles qui contient toutes les voyelles présentes dans la variable phrase.

Python
>>> phrase = 'Bonjour les vacances sont finies'
>>> voyelles = 'aeiouy'
>>> liste_voyelles = [lettre for lettre in phrase if lettre in voyelles]
>>> liste_voyelles
['o', 'o', 'u', 'e', 'a', 'a', 'e', 'o', 'i', 'i', 'e']

7.2.2 l'ensemble de départ⚓︎

C'est à partir de lui que va se construire notre liste. Pour l'instant, cet ensemble de départ a toujours été de type list.

Cet ensemble peut être aussi donné à partir de l'instruction range(). Souvenons-nous de l'exercice 4 : «Construire une liste contenant tous les nombres inférieurs à 100 qui sont divisibles par 7.».

Une solution possible était :

Python
1
2
3
4
lst = []
for n in range(1, 101):
    if n % 7 == 0:
        lst.append(n)

Ce code peut maintenant s'écrire très simplement en une seule instruction :

Exemple fondateur n°10 ❤

Python
>>> lst = [n for n in range(1,101) if n % 7 == 0]
>>> lst
[7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]

7.2.3 la valeur à garder⚓︎

Pour l'instant, nous avons procédé à des filtres sur des ensembles existants, sans modifier la valeur filtrée (la valeur à garder).
Les listes en compréhension deviennent encore plus intéressantes lorsqu'on comprend qu'il est possible de modifier la valeur filtrée :

Exemple fondateur n°11 ❤

Python
>>> lst_carres = [t**2 for t in range(1,10)]
>>> lst_carres
[1, 4, 9, 16, 25, 36, 49, 64, 81]
Exercice 10
  1. On considère la fonction mathématique \(f(x) = 2 \times x+3\). Coder la fonction f.
  2. Créer (en compréhension) une liste contenant l'image des entiers de 1 à 10 par la fonction \(f\).
Python
1
2
3
4
def f(x):
    return 2*x + 3

lst = [f(x) for x in range(1, 11)]
Exercice 11

On considère la liste lst = [51, 52, 66, 91, 92, 82, 65, 53, 86, 42, 79, 95]. Seuls les nombres entre 60 et 90 ont une signification : ce sont des codes ASCII (récupérables par la fonction chr ).
Créer (en compréhension) une liste sol qui contient les lettres correspondants aux nombres ayant une signification.

Python
>>> lst = [51, 52, 66, 91, 92, 82, 65, 53, 86, 42, 79, 95]
>>> decode = [chr(k) for k in lst if k > 60  and k < 90]
>>> decode
['B', 'R', 'A', 'V', 'O']

7.2.4 Des exercices⚓︎

Exercice 12
Python
tableau = [i for i in range(5, 15)]
  • tableau = [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
  • tableau = [i, i, i, i, i, i, i, i, i, i]
  • tableau = [0, 0, 0, 0, 0, 0, 0, 0, 0]
  • tableau = [5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
  • ❌ La valeur 15 est exclue.
  • ❌ i prend les valeurs de l'intervalle.
  • ❌ La valeur n'est pas contante.
  • ✅ i prend tour à tour les valeurs de 5 jusqu'à 14.
Exercice 13

Ecrire en compréhension la liste [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5] qui contient 20 fois l'entier 5.

Puzzle

Exercice 14

Compléter le script ci-dessous :

###(Dés-)Active le code après la ligne # Tests (insensible à la casse)
(Ctrl+I)
Entrer ou sortir du mode "deux colonnes"
(Alt+: ; Ctrl pour inverser les colonnes)
Entrer ou sortir du mode "plein écran"
(Esc)
Tronquer ou non le feedback dans les terminaux (sortie standard & stacktrace / relancer le code pour appliquer)
Si activé, le texte copié dans le terminal est joint sur une seule ligne avant d'être copié dans le presse-papier
Évaluations restantes : 5/5

.128013(og)wrh3a [;v,clS/ekm=4èpRniqb1:y-2]ut_xdPf7s0050P0t0M0j0C0q0T0k0p0q0j0T0T0w010M0C0z010406050T0L0v0v0j0g0H040r0c0q0L0/0c0B0k020j0v0z0m0k0A0t0|0g0D0L0t0T050s0_0{0}0 0@0z04051u1n1x0s1u0@0P0C0n0%0)0+0-0)0B0d0L0j0d0t0I0z0H0M0h160k0h0C0d0h0q1Z0h0M0=050Y0E0q0t1G0*0,011Y1!1$1!0M1,1.1*0M0g1v1U0%120T0z0j0B0-0J011:1I010R0!0t0B1a0t1*25272c1=2f1.2i0v2k040a0k0Q0g0c0z0c0T0C15170W230g0g0t0p2F1n2m0B1v0s1U2R1 21201+0P2o1J0C0B2h2C1*1D1F0(1;2#2%0B0c2+1*0z2K1v2P2R2{0^26172-2d2;0g0|0q1*0j1X2K0R0-030N0N0p2=0t1$2:0c0I0x0S0I0F0=0F1n0j2|2 0?2~2n311=333537390t3b013d3f3h3j2(3m3o2a040J3t3v272R2^0t2R2+2U0P212Z3A0-3g0W2*1E1v3X2`3w2O3=3+3Y3y170C0P0-3e2P3O3p3E3|3~3K0W3M2;413q0k2s0t453^483l3n422R3u3`2!010B0=0p2h0M1m1o3w0k4n3)010c0=0w3?3V4y2P4o0;040l4F2Q4z1H1=0v0C3r0U0U4N044H2 4o0u0=0R0c0g4X4Z3z4Q0-4q040u4+4P2.4B0f0=2$4?4I4A0B0E0=0g271P4X4@2d4K0b564~4.014S4U5b4!4A4K0e0K4X0@4w3V4n44013 2 413Q05385s3e4g2$3N4j2a4c2j4f3L5D495F1*0s4m5c4^4:4t0C0t0g4v2{4,305d4C044E5p2Q5!4J0=4M5*3;4-5S0=4=5:5,4A4$044(4*5_573B5@4}5i5$4`044|605R325104531L0t5h5=580=5a5:610-5f043s6n6b1=4K0o646j4R4T6r6s2}6u0-5k5m5:5o2}0s3^3W2_1n3!1n0M3$6S2X2S0j1-3_0s3!1t5;5#4^2K0v0N0R0j0u0t0N0h0i0=1f1h1j1l0k0G561A3x1u0Q0*0k2H6+0}6{0k260g0/0p0L1$0y2K7a0c0L0g0%0X0k0t0O5W0p0C4s1y3x6#0X0Z0#04.
Solution
Python
# un tableau cents en compréhension qui contient 10 entiers 100.
cents = [100 for k in range(10)]

# un tableau entiers en compréhension qui contient les 10 entiers entre 1 et 10 compris.
entiers = [k for k in range(1, 11)]

On peut aussi utiliser des chaînes de caractères :

Testez

Exécuter le script ci-dessous :

###(Dés-)Active le code après la ligne # Tests (insensible à la casse)
(Ctrl+I)
Entrer ou sortir du mode "deux colonnes"
(Alt+: ; Ctrl pour inverser les colonnes)
Entrer ou sortir du mode "plein écran"
(Esc)
Tronquer ou non le feedback dans les terminaux (sortie standard & stacktrace / relancer le code pour appliquer)
Si activé, le texte copié dans le terminal est joint sur une seule ligne avant d'être copié dans le presse-papier

Exercice 15

Ecrire en compréhension : ['NSI-1', 'NSI-2', 'NSI-3', 'NSI-4', 'NSI-5', 'NSI-6', 'NSI-7', 'NSI-8', 'NSI-9', 'NSI-10']

###(Dés-)Active le code après la ligne # Tests (insensible à la casse)
(Ctrl+I)
Entrer ou sortir du mode "deux colonnes"
(Alt+: ; Ctrl pour inverser les colonnes)
Entrer ou sortir du mode "plein écran"
(Esc)
Tronquer ou non le feedback dans les terminaux (sortie standard & stacktrace / relancer le code pour appliquer)
Si activé, le texte copié dans le terminal est joint sur une seule ligne avant d'être copié dans le presse-papier

Solution
Python
mon_tab = ["NSI-"+ str(i) for i in range(1, 11)]
print(mon_tab)
Exercice 16

Compléter ci dessous le script : Ecrire en compréhension lst3 qui donne la liste de la somme des éléments de [2, 3, 1, 5] et de [4, 1, 7, 0]. On doit obtenir : [6, 4, 8, 5]

###(Dés-)Active le code après la ligne # Tests (insensible à la casse)
(Ctrl+I)
Entrer ou sortir du mode "deux colonnes"
(Alt+: ; Ctrl pour inverser les colonnes)
Entrer ou sortir du mode "plein écran"
(Esc)
Tronquer ou non le feedback dans les terminaux (sortie standard & stacktrace / relancer le code pour appliquer)
Si activé, le texte copié dans le terminal est joint sur une seule ligne avant d'être copié dans le presse-papier

Solution
Python
lst1 = [2, 3, 1, 5]
lst2 = [4, 1, 7, 0]
lst3 = [lst1[p] + lst2[p] for p in range(len(lst1))]
print(lst3)
Exercice 17

Répondre sur papier.

Donner les listes lst1, lst2, lst4, lst6 et lst7

Python
lst1 = [3 for i in range(4)]
lst2 = [4-i for i in range(3)]
lst3 = [1, 2, 3]
lst4 = [lst3[i]**2 for i in range(len(lst3))]
lst5 = ["a","b","c"]
lst6 = [lst5[i]*2 for i in range(len(lst5))]
lst7 = [elem*2 for elem in lst5]
Solution
Python
lst1 = [3, 3, 3, 3]
lst2 = [4, 3, 2]
lst4 = [1, 4, 9]
lst6 = ['aa', 'bb', 'cc']
lst7 = ['aa', 'bb', 'cc']

7.2.5 Utilisation plus élaborée des tableaux en compréhension⚓︎

Grâce à la construction par compréhension, il est possible d'appliquer un traitement (opération, fonction...) à chaque élément d'un tableau.

Testez

Exécuter le script ci-dessous :

###(Dés-)Active le code après la ligne # Tests (insensible à la casse)
(Ctrl+I)
Entrer ou sortir du mode "deux colonnes"
(Alt+: ; Ctrl pour inverser les colonnes)
Entrer ou sortir du mode "plein écran"
(Esc)
Tronquer ou non le feedback dans les terminaux (sortie standard & stacktrace / relancer le code pour appliquer)
Si activé, le texte copié dans le terminal est joint sur une seule ligne avant d'être copié dans le presse-papier

Exercice 18
Python
double = [i*2 for i in range(10)]
  • double = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  • double = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
  • double = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
  • double = [4, 8, 12, 16]
  • ❌ Un traitement est appliqué aux valeurs prises par i.
  • ❌ Le mauvais traitement est appliqué.
  • ✅ le tableau est composé du double de chaque valeur de l'intervalle [0,9]
  • ❌ Le tableau double doit contenir autant d'éléments que le tableau d'origine.
Exercice 19

Compléter pour obtenir la liste dizaines = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

Puzzle

7.2.6 Appliquer un filtre⚓︎

La construction par compréhension permet d'appliquer un filtre à une structure de données de départ, afin de ne garder que certains éléments. On utilise pour cela une condition précédée du mot-clé if.

On peut ainsi créer un tableau qui ne conserve que les nombres pairs d'un tableau initial.

Python
>>> tableau = [0, 1, 6, 5, 4, 11, 12, 23, 26]
>>> pairs = [p for p in tableau if p%2 == 0]
>>> pairs
[0, 6, 4, 12, 26]
Exercice 20
Python
tableau = [i for i in range(5, 15)]
nouveau_tableau = [j for j in tableau if j < 10]
  • nouveau_tableau = [5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
  • nouveau_tableau = [5, 6, 7, 8, 9]
  • nouveau_tableau = [9, 8, 7, 6, 5]
  • nouveau_tableau = [10, 11, 12, 13, 14]
  • ❌ La condition entraine la sélection de certaines valeurs.
  • ✅ on sélectionne tous les éléments du tableau inférieurs à 10.
  • ❌ Les éléments conservent l'ordre dans lequel il se trouvent dans le tableau initial.
  • ❌ La condition indique les éléments qui sont conservés.
Exercice 21

Créer en compréhension la liste des carrés des nombres de la liste nombresqui sont négatifs.

Puzzle

Exercice 22

Compléter le script ci-dessous :

###(Dés-)Active le code après la ligne # Tests (insensible à la casse)
(Ctrl+I)
Entrer ou sortir du mode "deux colonnes"
(Alt+: ; Ctrl pour inverser les colonnes)
Entrer ou sortir du mode "plein écran"
(Esc)
Tronquer ou non le feedback dans les terminaux (sortie standard & stacktrace / relancer le code pour appliquer)
Si activé, le texte copié dans le terminal est joint sur une seule ligne avant d'être copié dans le presse-papier

Solution
Python
# un tableau positifs en compréhension qui contient 
# les nombres réels positifs du tableau nombres
nombres = [1, 0, -2, 9, -5, 4, -7, 5, -8]
positifs = [k for k in nombres if k > 0]

# un tableau voyelle_phrase en compréhension qui ne contient que les voyelles 
# contenues dans la chaine de caractère phrase
phrase = "je ne suis pas sans voix !"
VOYELLES = "aeiouy"
voyelle_phrase = [caractere for caractere in phrase if caractere in VOYELLES]

8. Un phénomène inquiétant : la copie de liste⚓︎

une copie un peu trop parfaite

Observez le code ci-dessous, réalisé sans trucage.

Python
>>> listA = [1, 2, 3]
>>> listB = listA
>>> listA.append(7)
>>> listB
[1, 2, 3, 7]
>>> listB.append(8)
>>> listA
[1, 2, 3, 7, 8]

Tout se passe comme si les listes listA etlistB étaient devenus des clones «synchronisés» depuis l'affectation listB = listA.

Analyse grâce à PythonTutor

L'illustration de PythonTutor nous donne la clé de l'énigme : image

listA etlistB sont en fait un seul et même objet.

Comment en avoir le cœur net ? En observant leur adresse-mémoire, disponible grâce à la fonction id :

Python
>>> id(listA)
140485841327616
>>> id(listB)
140485841327616

Ceci met en évidence que la métaphore du tiroir dont on se sert pour expliquer ce qu'est une variable est malheureusement inexacte. Une variable est une référence vers une adresse-mémoire. Si deux variables font référence à la même adresse-mémoire, alors elles sont totalement identiques: toute modification de l'une entraîne une modification de l'autre.

Pour en savoir plus sur les variables, vous pouvez revenir sur la partie optionnelle du cours sur les variables.

Mais alors, comment copier le contenu d'une liste vers une autre sans créer un clone ?⚓︎

Exemple fondateur n°12 ❤

Python
>>> listA = [3, 4, 5]
>>> listB = list(listA)
D'autres possibilités existent, comme listA.copy(), ou encore listA[::]...

Exercice 23

Effectuer les tests nécessaires pour prouver que l'exemple précédent a bien produit deux objets différents.

Python
>>> listA = [3, 4, 5]
>>> listB = list(listA)
>>> listA.append(9)
>>> listB
[3, 4, 5]
>>> id(listA)
140157471522368
>>> id(listB)
140157465797184

9. Tableaux à plusieurs dimensions : listes de listes⚓︎

Nous avons vu qu'une liste pouvait contenir des éléments de tous types : des entiers, des chaines des caractères... et pourquoi pas une liste qui contient des listes ?

9.1 Syntaxe⚓︎

Exemple fondateur n°12 ❤

La liste tab ci-dessous est composée de 3 listes qui elles-mêmes contiennent trois nombres :

Python
tab =  [[3, 5, 2],
        [7, 1, 4], 
        [8, 6, 9]]

  • tab[0][0] = 3
  • tab[0][1] = 5
  • tab[2][1] = 6
  • tab[1] = [7, 1, 4]

image

La liste a est composée de 3 éléments qui sont eux-même des listes de 3 éléments.

Exercice 24

On considère le jeu du Morpion (ou Tic-Tac-Toe) dont la surface de jeu vierge est representée par le tableau :
tab = [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]

Les premiers coups joués sont ceux-ci :

  • tab[1][1] = 'X'
  • tab[2][1] = 'O'
  • tab[2][2] = 'X'
  • tab[0][0] = 'O'

Quel coup doit maintenant jouer le joueur 'X' pour s'assurer la victoire ?

Python
tab[0][2] = 'X'
# ou
tab[1][2] = 'X'

9.2 Parcours d'une liste de listes⚓︎

Exemple fondateur n°13 ❤

  • Parcours par éléments :

    Python
    1
2
3
    for ligne in tab:
    for elt in ligne:
        print(elt)

  • Parcours par indice :

    Python
    1
2
3
    for i in range(3):
    for j in range(3):
        print(tab[i][j])

Exercice 25

On considère la liste m ('m' comme matrice) suivante :

m = [[1, 9, 4], [4, 1, 8], [7, 10, 1]]

Quelle est la somme de tous les nombres de la matrice m ?

Python
1
2
3
4
5
6
7
8
m = [[1, 9, 4], [4, 1, 8], [7, 10, 1]]

somme = 0
for ligne in m:
    for elt in ligne:
        somme += elt

print(somme)

ou bien

Python
1
2
3
4
5
6
7
8
m = [[1, 9, 4], [4, 1, 8], [7, 10, 1]]

somme = 0
for i in range(3):
    for j in range(3):
        somme += m[i][j]

print(somme)

9.3 Les listes de listes avec compréhensions imbriquées⚓︎

Pour construire un tableau de tableaux de même longueurs, on peut utiliser des compréhensions imbriquées.

Dans les exemples qui suivent nous appelerons matrice notre tableau de tableaux.

Python
>>> matrice = [[k for k in range(4)] for j in range(3)]
>>> matrice
[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]

Pour bien visualiser le tableau matrice que nous venons de créer, nous pouvons l'écrire de la façon suivante :

Python
    matrice = [ [0, 1, 2, 3],
                [0, 1, 2, 3],
                [0, 1, 2, 3] ]
👉 Chaque élément de matrice correspond donc à une "ligne".

On peut considérer que matrice a quatre "colonnes". Par exemple la première colonne (de rang 0) est [0, 0, 0], et la dernière est [3, 3, 3].

💡 Il est possible d'extraire une ligne de matrice.

Python
>>> ligne_0 = matrice[0]
>>> ligne_0
[0, 1, 2, 3]

💡 Il est possible d'extraire une colonne de matrice.

Python
>>> colonne_2 = [ligne[2] for ligne in matrice]
>>> colonne_2
[2, 2, 2]
QCM
Python
matrice = [[j for i in range(4)] for j in range(4)]
  • matrice = [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]]
  • matrice = [[0, 0, 0, 0], [1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]]
  • matrice = [[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
  • matrice = [0, 1, 2, 3]
  • ❌ La valeur j est constante pour chaque ligne.
  • ✅ La valeur j prend la valeur 0 pour la première ligne, puis 1, etc.
  • ❌ La valeur j est constante pour chaque ligne.
  • ❌ Les constructions imbriquées engendrent un tableau de tableaux.
Puzzle

Créer en compréhension la matrice [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Puzzle

À vous de jouer 1

Compléter le script ci-dessous :

###(Dés-)Active le code après la ligne # Tests (insensible à la casse)
(Ctrl+I)
Entrer ou sortir du mode "deux colonnes"
(Alt+: ; Ctrl pour inverser les colonnes)
Entrer ou sortir du mode "plein écran"
(Esc)
Tronquer ou non le feedback dans les terminaux (sortie standard & stacktrace / relancer le code pour appliquer)
Si activé, le texte copié dans le terminal est joint sur une seule ligne avant d'être copié dans le presse-papier

Solution
Python
# un tableau matrice_carre_10 en compréhension, matrice 10x10
# dont chaque ligne contient les entiers de 1 à 10.
matrice_carre_10 = [[k for k in range(1, 11)] for j in range(10)]

# un tableau ligne_5 en compréhension qui contient la colonne 5 (située à l'indice 4)
# de la matrice matrice_carre_10
colonne_5 = [ligne[4] for ligne in matrice_carre_10]

# un tableau diagonale en compréhension qui contient les éléments situés 
# à la 1ère colonne de la 1ère ligne,
# à la 2ème colonne de la 2ème ligne ... de la matrice carrée matrice_carre_10
diagonale = [matrice_carre_10[i][i] for i in range(len(matrice_carre_10))]
À vous de jouer 2

Compléter la fonction donne_colonne qui prend en paramètres une matrice matrice, un entier colonne et renvoie la liste des éléments de la colonne colonne.

Nous avons déjà réalisé cet exercice dans le chapitre : listes de listes. Vous devez ici absolument utiliser une liste en compréhension.

Par exemple :

Python Console Session
>>> m = [[1, 3, 4],
    [5, 6, 8],
    [2, 1, 3],
    [7, 8, 15]]
>>> donne_colonne(m, 0)
[1, 5, 2, 7]
>>> donne_colonne(m, 2)
[4, 8, 3, 15]
>>>

###(Dés-)Active le code après la ligne # Tests (insensible à la casse)
(Ctrl+I)
Entrer ou sortir du mode "deux colonnes"
(Alt+: ; Ctrl pour inverser les colonnes)
Entrer ou sortir du mode "plein écran"
(Esc)
Tronquer ou non le feedback dans les terminaux (sortie standard & stacktrace / relancer le code pour appliquer)
Si activé, le texte copié dans le terminal est joint sur une seule ligne avant d'être copié dans le presse-papier
Évaluations restantes : 5/5

.128013(og)5wrh36a [;v,clS/ekm=4Epqnib1:y-2é]ut_dPf7s050Q0v0O0l0E0s0U0m0r0s0l0U0U0y010O0E0B010406050U0N0x0x0l0h0I040t0c0s0N0/0c0D050u0_0{0}0 0@0B04051f181i0u1f0@0Q0E0p0%0)0+0-0)0D0d0N0l0d0v0J0B0I0O0i160m0i0E0d0i0s1K0i0O0=050Y0F0s0v1r0*0,011J1L1N1L0O1T1V1R0O0h1g1F0%120U0B0l0D0-0K011X1t010S0!0v0D0l0x0v1R1?1^1}1Z201V23250=0a0m0R0h0c0B0c0U0E150D0m0W1;0h0h0v0r2q18280D1g0u1F2D1-1/1.1S0Q2a1u0E0D222n1R1o1q0(1Y2N2P0D0c2T1R0B2w1g2B2D2*0^1@2r2V1~2Z0h0|0s1R0l1I2w0S0-030P0P0r2!0v1N2Y0c0J0T0z0J0G0=0G180l2+2.0?2-292:1Z2=2@2_2{0v2}012 3133352Q383a1{040K3f3h1^3j2B2M013o0l2^1g2`0i2|2~30320W3y2Z3A0J0j0=0j3F2A3i0@3J3m0-3M3O053Q3S3u3U3x2O3z390J0z0=0z3(193*3k2/1s3n0c2?3N3q3R3s3T3w3W3`3Y3|0f0=0f412*3+2.3K3/4b3?3v3V344h373|0k0=0k4n433,463.483p3P3r3t4v3_363Z0T0=0T4E3H1j2(182T2G0Q1/2L3-014w2S1p1g2%0v2)3i3)4W4w4;290E0Q0-302B3Z3c4L4{4}4f4x4Q3|3c0m2e0v544w3X4z3a513(4G2W010w0=0W0S4?2C0m444r0S5o162P3w0s5y0v5r4_455l0;040b5E5u4)0D0=0|1-0E0r5D424W5k1~5I0q5E5t5X3n0=0D5A5C5L5%0-5I0e5#5M4H010c0=0J020d0O0o5=5.3L0F0=1N0U0O604q4)5I0H5E0@5V2C5u53014~2.3Z3C3;0m6i3^4g573B1|5b5d4P3{6u2D3g5?5l0g0=0m6H5t6f5F3K0U0Q0=020C0N0c5~6Q6S6U6R6T5 6K6e2,3J6q0P4 3|3#524|6j555f3Z3#5a245c6:5e4y6?1R0u6C616N6G6I0A0D1-0L1W0H0m5Q0h5S7a0m0N2P0m650O1W2t7l0v0U0q7h2r220/0v0h5a5+0D7j1V5a0`0L2k2s1W0)1;5B7B5U4o5-4q6)6+3a3~6.6x6s6z3}6v6_7X567Z7V5j695@73046I0m110h7w0m7b327M7j7b7i7J0E667n160O7k7q0m0L0s0L25770$0U83850$888a7v0$7o2`7`5C7E0x7G0c7z8o7N6d7Q4`6/6k1^3Z4k7W6{6y4i3a4k6^257%6=4j6 717,5l7.7:6V6Z8W6X6W6!7P6K6h8A6*6l4A3q6)6|6t0J4B8L6`6r7(8I8;8Q7/6I6D2;0=8v2P683l5@5_040y945G5Y0=0n8y9b5(047d7f9f3K5I9e8%615O041%939p8S9c040M9o6%9w9h5*927O4=615I0M9a3K5n040S489L5N641K9u2*5$9C0-0c6F042O9R5@0D63040h1^1A9l6a0=5K9v955l9*64229:5@5I9?9B9^909i0l5R5T9}5H0=0e0e9K6#9l7S8+3a4S8F8^8Oai7#8M8G7Y8`aj3F7:8 1Z9N2w0O0N0h176K9Xa29h9F8x8%0u4^4X4:4Z4-180O4$aR2J2E0l1UaO0u4!6e0W0Y0!0U04.
À vous de jouer 3

Compléter le script ci-dessous :

👉 Vous pouvez tester les ### en haut à droite de la fenêtre.

###(Dés-)Active le code après la ligne # Tests (insensible à la casse)
(Ctrl+I)
Entrer ou sortir du mode "deux colonnes"
(Alt+: ; Ctrl pour inverser les colonnes)
Entrer ou sortir du mode "plein écran"
(Esc)
Tronquer ou non le feedback dans les terminaux (sortie standard & stacktrace / relancer le code pour appliquer)
Si activé, le texte copié dans le terminal est joint sur une seule ligne avant d'être copié dans le presse-papier
Évaluations restantes : 4/4

.128013.128161.128073àog)rh6av,ck4Ep9Rqb1]_tP7(5w3 [;OA8lS/em=ni:y-2éêuxd.fs0050$0P0z0k0T0M0)0G0n0M0k0)0)0R010z0T0r010406050)0!0Q0Q0k0h0V040N0e0M0!0~0e0S0G020k0Q0r0I0G0t0P180h0u0!0P0)050O1517191b130r04051G1z1J0O1G130$0T0l0?0^0`0|0^0S0f0!0k0f0P0W0r0V0z0i1i0G0i0T0f0i0M1/0i0z11050.0v0M0P1S0_0{011.1:1=1:0z1{1}1_0z0h1H1*0?1e0)0r0k0S0|0X011 1U010(0:0P0S1m0P1_2h2j2o212r1}2u0Q2w040a0G0A0h0e0r0e0)0T1h1j0,2f0h0h0P0n2R1z2y0S1H0O1*2%2b2d2c1`0$2A1V0T0S2t2O1_1P1R0@202;2?0S0e2`1_0r2W1H2#2%37142i1j2|2p300h180M1_0k1-2W0(0|030y0y0n310P1=2 0e0W0B0D0W0w110G0w1z0k383b123a2z3d213f3h3j3l0P3n013p3r3t3v2@3y3A2m040G0X3G3I2j3K2#2:013P0k3i1H3k0i3m3o3q3s0,3Z303#0W0F3D0F3+2!3J133/3N0|3=3@053_3{3V3}3Y2=3!3z0W0p3D0p471A493L3c1T3O0e3g3?3R3`3T3|3X3 4m414o0D3D0D4t374a3b3:4e4D4i3W3~3u4J3x4o0j3D0j4P4v4b4y4d4A3Q3^3S3U4X4l3w420B3D0B4*3-4R3M4-3;4/4C4;4E4?4k4I4_4o0L3D0L4~2$504x2}534B4f4h4F4j4H4Z5b3A0s3D0s5g3.4S4c5l4:4g4=4G4Y404#3A0w0*115L5y5i4T545n5F5q5H4!420w3C045Z5P4w5R5m4V5p4@5a4n5K3%0w3*0O3H484 5(5B4U564W595s5/3B445#465@3,5h5{525}5E575G4^620w4q5#4s675_694,5k6c5o585r5I5Y4M5#4O6m4u3-1K351z2`2*0$2d2/5B4Y2_1Q1H340P363J6n1H4Y6S2z0T0$0|3q2#5Y3R6Z6#6u5X4o3C0G2E0P6+5W5t3B1_6m6p2p0o110,0(6U0G6a6q0(111#0z0y1P1!0y5?396|2110040C6U743e110;0z7l7g0|7i0g727m210e110W020f0z0I7w7s3;0v7o0T0)7q6B2$737H7i0U6U137O6X1j6*016$3b423%5E7Z606v4o2m6:2v6?6g4K3$6`5^7H0E3D0G7}7r5A520)0$11021v0e7E850!870I898b7U7 6Y6!7!0y6%4o647)8i7+6-3A447/2F7;5.7?437^7X3:827|7}0q0S2b0Y1~0U0G7p0G8L0!2?8M7L0z1~2T1=7M1x0G2T0Q0Z2F0=0M1i1Y0P0!0h1y7W7V7f4S7*8k7$4o6j8o8w618y4q8u6=8j6@628|6{805k8D3(7}0G1d0h0~8K8!0T7c0X8O0G8Q1~8X8U8!1i0z8M8Z0Y0M0Y2F8H0=0)9u9w0=9y9A2t0z0=8W3k0X1s8V9k0f1i3?1~8f7W5(8^8l3A6x8}947=5J0W4M928~7,9$8A7x0|9b9d0G0C0$02030F0s0I2t1-0k1g7}0$2L2Q1~0d0Ga20v0_0Gab0fa40n0i0P7v8;8g7Y8p8_2j424%4;8^958y4%9.9)8x9+av477H9^9d7C887D8caM0G0Q0G0R0G0HaT0w0m0G0FaX0p0x0m9X8?8h6+9#3y6)aray9+4{aB8q6^4{2%7_992paI9_a 9d0H0D0G0m0jb40La$a(6T3/9!8`3A5dawa/9*425da?6,6^bgaGa|21a~b0a 0H0XaXaWaY0x0G0xba6Cbcara,5vbh9/8r0W5vbma:42bJbq519a839c7}aKaNaL7E0G787a9S7d0C0Qan4Qap0Gbdat6.5MbKaC8 9+5L2n6;bL6^b}a`8B5Bbt0H0paX0jaX0XbDao9YbGa+be3B5!9(a@6h6/b b`9:cj8A8=bb8@bHci5=a.c06h7.cpcm8yczc39?01bt8d8886cN8a7EbE2$9Zcxb?5K8n3kaxbj6.8tcEbn6h8n67cubFcwchcW3B8|cZbiaD5Y91c(bQ6.973H9_cJ0S112=1P0n0P0y180#7Gbr0|7z040RdcbU3e7J042Db:5B7i7kcfdd3;7o7Mdo527udi5j2pdf0WdA3:0Q0T5NcS8Bb=0S6wcAcqbM0w9-c|c#5K9%67d17H6~042W0z8.0SdFdp110Hdx6qdv7Na)dB7hd-d/7n040Td`d^040xd.dsdj3Od40Sd6d8dad~de7Aebdud|ee7icd377Qdtd#0(4Ad+6bd4eq5k0e7{d|d*7Wele44ddl0h2j1#eh11drd?4Tdldne3d@7teIeed3dmdweO3:7u0gej4v9Y0O6W6D6R6F6O1z0z6Ie-2-2(0k1|e*0O6G1Fc4522W0Q0y0(0k0od80i641r1t1v8Z7Te$1N1I040b0G0J1j0r8-9va40`0T9o0~8X0P0h9w0Gf12Q0Gf9fv0,0h0S0Tft0G9I9B9v0$009p8S8Yac7M8!00d50Td70G3BaX0M000k0l2jfKftfEfGfLfUfW0W9m0-0n0%1K3K1G0c0G0K1g2W0G0h0Y2N0S0)1~2Nfoe@9nf^1O1Q3:1W1Y1!1$1(1*1,231;1?1^e|5k2C2t2v110A1)1+ey396Q7X686V3tdLcVdN0B0j6_b_cF4#gKco7:dQ5bgP2n6e5Vc#gUcId!6 3Tet3e7604b(7b0f7deH7jeSd;g:b.3JeAeP01dDbZg(3OeM8Tg eQ04fbb/eWdM3ygK7(c@cB4Khbb~gRgNhaf:gV5 c)hfhlg!dtewd1eWc5bWcM8ccOhzcQ7FceeKh9gJ8zgMhogO8zbPgYhMgW5-b{hkc+a{eBcKbW9_8G8I9i8N8P8R9r8V9q8T8Z8#8%8Z8*1X1w8.0)f@hEcva*8j8lgKc?b;c^hShHc{hihKhk91hQhji59=aHhY9d9f9h9ng-7d9nfNh*9t8H9GfH9zfJ9D9F1}9Hiu9K9M9q9O9Q9j1!9U1}73h{c.h}7#b?gK9%hdgS4niQhh8viThp9-ibi8hHdXhVg{bt9{9}9 a11j0ia49v8!a89sabadafahajalg^5`h8gHhkaFiSicgKaAdUc_hHaAi#c}j8iedtcLaMbZbZaPaRaTaVaXaZ0Ga#a%iLcTcgh~8`gKa_cli$jBiW93j7a-5UhR7,jFhrhWbtbub1b3b5b7b9jwgGc:gIgKbpj6jE0Wbljai4j#hm5,jIbp98jPigjR9_bwbyjrbBe!j1hFj3hHbSj%jfbNjGhehLbOjehObSj=i*j@1kjkkib$g,b*0Xb,j069j2jZhkc2jDk5b}hNjbgP5MjKjIkuke8Ckgc7c9cbj~kqk0kshH5ZdPkDgQiXkSj.6tkwckc,b:hGgPhci2k8ktcDi7kw7.kbkz3B7(kFhw8E1khAhyhydKcUkOgPcYk)iYhL0wc%k-hOl6kW6fk;lac3c-jxc/jziPc=kRj(6ik7l4ktiahnkwc bXg`3:d#d%d)h3017ie2eK5|g?hvdyd_lJd:eglM2peilFh|g{dDeedHdJlP7yedlZ4desl$lD11kL3(cJenepezd2l(ekcJeve6lC0SeDeF0Pg:eJlTeL7o2tm0g=eUd=m2d,040geZk~e%gFe)2%e`6F0-0/0;04.
Solution
Python
def get_diag_2(lst) -> list :
"""
Entrée : lst : une liste de listes de mêmes longueurs
Sortie : diag_2 : une liste dont les éléments sont les éléments de 
la 2eme diagonale (de en bas à gauche à en haut  droite)
>>> m = [ [1, 3, 4],
        [5 ,6 ,8],
        [2, 1, 3] ]
>>> get_diag_2(m)
[4, 6, 2]

"""

indice_max = len(lst) - 1
return [lst[i][indice_max-i] for i in range(len(lst))]

10 Exercices⚓︎

1. Exercices variés⚓︎

Exercices variés

😀 La correction est arrivée ...

2. "π à Monte-Carlo"⚓︎

Sujet - π à Monte-Carlo

La méthode de Monte-Carlo est un ensemble de méthodes algorithmiques visant à déterminer la valeur approchée d'une constante en utilisant des procédés aléatoires.

On peut utiliser cette méthode afin de déterminer une valeur approchée de \(\pi\). L'idée est la suivante :

  • on considère un carré de \(2\) unités de côtés. Son aire vaut donc \(4\) ;
  • on considère un disque de rayon \(1\) centré au centre du carré. Son aire vaut donc \(\pi \times 1^2=\pi\) ;
  • on génère un grand nombre de points aléatoires répartis de façon uniforme dans le carré.

Il reste alors à compter le nombre de points à l'intérieur du disque. On peut montrer que leur fréquence tend vers \(\frac{\pi}{4}\) quand le nombre de points aléatoires devient très grand.

Une valeur approchée de \(\pi\) est donc :

\[\pi \approx 4 \times \frac{\text{nombre de points dans le disque}}{\text{nombre de points dans le carré}}\]

On observe ci-dessous le carré de départ ainsi que de nombreux points. On a représenté de couleur différente ceux qui sont dans le cercle et ceux qui n'y sont pas.

Méthode de Monte-Carlo

On se donne donc :

  • une liste de nb_points aléatoires, tous dans le carré décrit ci-dessus. Cette liste est nommée points et chaque point est représenté par ses coordonnées. Par exemple [(-0.5313, 0.0936), (0.9638, 0.3577), ...].

  • une fonction distance_origine prenant en argument les coordonnées x et y d'un point et renvoyant sa distance à l'origine du repère (et donc au centre du cercle)

On demande d'extraire la liste des points situés dans le cercle à l'aide d'une liste en compréhension.

La fonction random

Le module random de Python propose une fonction random qui génère des nombres aléatoires uniformément répartis entre 0 et 1.

👉 On a donc 2 * random() qui est compris entre 0 et 2

👉 On en déduit que 2 * random() - 1 est compris entre -1 et 1.

À vous de jouer

###(Dés-)Active le code après la ligne # Tests (insensible à la casse)
(Ctrl+I)
Entrer ou sortir du mode "deux colonnes"
(Alt+: ; Ctrl pour inverser les colonnes)
Entrer ou sortir du mode "plein écran"
(Esc)
Tronquer ou non le feedback dans les terminaux (sortie standard & stacktrace / relancer le code pour appliquer)
Si activé, le texte copié dans le terminal est joint sur une seule ligne avant d'être copié dans le presse-papier

Solution

Pour ne pas surcharger le site, nous avons choisi ici nb_points = 1000. Chez vous, sur votre prpre éditeur Python, vous pouvez tester avec nb_points = 100_000, pour obtenir une meilleure précision.

Python
from math import sqrt
from random import random

def distance_origine(x, y):
    return sqrt(x*x + y*y)

nb_points = 1000
points = [(2 * random() - 1, 2 * random() - 1) for _ in range(nb_points)]
dans_cercle = [p for p in points if distance_origine(p[0], p[1]) <= 1]

# Affiche une valeur approchée de pi
approximation = 4 * len(dans_cercle) / nb_points
print("Pi est environ égal à : ", approximation)