Exercices — Python : les listes

1. L[0] est le premier élément (les indices commencent à 0) : 4. L[3] est l’élément d’indice 3, le quatrième : 9. len(L) est le nombre d’éléments : 4.

2. Étape par étape :

• L.append(5) ajoute 5 à la fin : [4, 7, 2, 9, 5] ;
• L[1] = 8 remplace l’élément d’indice 1 (le 7) par 8 : [4, 8, 2, 9, 5] ;
• del L[2] supprime l’élément d’indice 2 (le 2) : [4, 8, 9, 5] — les éléments suivants se décalent d’un cran vers la gauche.

3. Il affiche [4, 8, 9, 5].

Réflexe à retenir : pour prévoir un programme qui modifie une liste, écris la liste après chaque ligne, comme un tableau d’étapes — et souviens-toi que del L[2] supprime l’élément d’indice 2, pas la valeur 2.

1. On part de la liste vide et on ajoute $7 \times n$ pour $n$ allant de 1 à 10 :

M = []
for n in range(1, 11):
    M.append(7 * n)
print(M)   # affiche [7, 14, 21, 28, 35, 42, 49, 56, 63, 70]

(Attention à range(1, 11) : la borne de droite est exclue, il faut aller jusqu’à 11 pour atteindre $7 \times 10 = 70$.)

2. On place $u_0 = 3$ dans la liste, puis chaque nouveau terme se calcule à partir du précédent, termes[n] :

termes = [3]
for n in range(5):
    termes.append(2 * termes[n] - 1)
print(termes)   # affiche [3, 5, 9, 17, 33, 65]

Vérification à la main : $2 \times 3 - 1 = 5$, $2 \times 5 - 1 = 9$, $2 \times 9 - 1 = 17$, $2 \times 17 - 1 = 33$, $2 \times 33 - 1 = 65$ ✓. La boucle ne tourne que 5 fois (range(5)) car $u_0$ est déjà dans la liste : 1 terme de départ + 5 ajouts = 6 termes.

Réflexe à retenir : le duo liste vide (ou premier terme) + append dans une boucle est LA recette de construction — et pour une suite, le nouveau terme se fabrique avec termes[n], le dernier terme déjà rangé.

1. [n**2 for n in range(1, 11)], qui vaut [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]. (Avec range(10), on aurait commencé au carré de 0.)

2. Un impair s’écrit $2n + 1$ : [2 * n + 1 for n in range(10)], qui vaut [1, 3, 5, 7, 9, 11, 13, 15, 17, 19].

3. La condition n % 4 == 0 garde les entiers dont le reste de la division par 4 est nul, c’est-à-dire les multiples de 4. Dans range(1, 31) (de 1 à 30) :

[4, 8, 12, 16, 20, 24, 28]

C’est la traduction Python de l’ensemble $\{\,n \in \{1,\,\ldots,\,30\} \ \text{tels que} \ n \text{ est multiple de } 4\,\}$ — le if joue exactement le rôle du « tels que » des mathématiques.

4. On combine transformation et condition : [n**2 for n in range(10) if n % 2 == 0], qui vaut [0, 4, 16, 36, 64] (les carrés de 0, 2, 4, 6, 8).

Réflexe à retenir : une compréhension se lit comme un ensemble mathématique — « la liste des [expression] pour n dans [domaine] tels que [condition] ». Traduis la phrase, la syntaxe suit.

1. Un accumulateur, initialisé à 0, et un parcours par éléments :

notes = [12, 15, 9, 18, 6]
somme = 0
for x in notes:
    somme = somme + x
print(somme)              # affiche 60
print(somme / len(notes)) # affiche 12.0 (la moyenne)

2. On garde en mémoire le plus grand élément vu jusqu’ici, initialisé au premier :

maxi = notes[0]
for x in notes:
    if x > maxi:
        maxi = x
print(maxi)   # affiche 18

3. Même squelette, avec un compteur qui ne grandit que si la condition est vraie :

compteur = 0
for x in notes:
    if x > 10:
        compteur = compteur + 1
print(compteur)   # affiche 3 (les notes 12, 15 et 18)

4. Dès que la position compte : afficher le rang de chaque note, comparer un élément à son voisin L[i + 1], ou modifier la liste pendant le parcours (L[i] = ...). Quand seules les valeurs comptent — somme, maximum, comptage — le parcours par éléments est plus simple et plus lisible.

Réflexe à retenir : les trois programmes ont le même squelette — initialisation avant la boucle, mise à jour dans la boucle, résultat après — seule la mise à jour change (additionner, comparer, compter). Maitrise ce squelette et tu sais tout parcourir.

1. On range $u_0$, puis on ajoute $n - 1$ termes calculés chacun à partir du précédent :

def premiers_termes(n):
    termes = [5]
    for i in range(n - 1):
        termes.append(2 * termes[i] - 3)
    return termes

print(premiers_termes(6))   # affiche [5, 7, 11, 19, 35, 67]

Vérification : $2 \times 5 - 3 = 7$, $2 \times 7 - 3 = 11$, $2 \times 11 - 3 = 19$, $2 \times 19 - 3 = 35$, $2 \times 35 - 3 = 67$ ✓.

2. On définit $f$, puis une compréhension sur range(7) (pour aller de 0 à 6) :

def f(x):
    return x**2 - 4*x + 3

images = [f(x) for x in range(7)]
print(images)   # affiche [3, 0, -1, 0, 3, 8, 15]

3. Un compteur et un parcours par éléments :

compteur = 0
for y in images:
    if y < 0:
        compteur = compteur + 1
print(compteur)   # affiche 1

Une seule image est strictement négative : $f(2) = -1$ (les valeurs $f(1) = 0$ et $f(3) = 0$ ne comptent pas, l’inégalité est stricte).

4. La boucle while ajoute des termes tant que le dernier terme rangé, termes[n], ne dépasse pas 1000. Les termes valent successivement 5, 7, 11, 19, 35, 67, 131, 259, 515, 1027 : le premier terme strictement supérieur à 1000 est $u_9 = 1027$. La boucle s’arrête quand termes[n] vaut 1027, c’est-à-dire pour $n = 9$ : le programme affiche 9. On en déduit que le plus petit entier $n$ tel que $u_n > 1000$ est $n = 9$ — c’est le programme type des « questions de seuil » du chapitre suites.

Réflexe à retenir : liste + boucle, c’est le couteau suisse des suites — for quand tu connais le nombre de termes à construire, while quand tu cherches le premier terme qui dépasse un seuil.