# Notion de liste : maths Première

Chapitre 5 du programme de mathématiques de Première (thème : Algorithmique et programmation). Ressource gratuite OptiTAB.

- Cours : https://www.optitab.net/ressources-gratuites/maths/premiere/notion-de-liste/
- Fiche de révision : https://www.optitab.net/ressources-gratuites/maths/premiere/notion-de-liste/fiche/
- Exercices corrigés : https://www.optitab.net/ressources-gratuites/maths/premiere/notion-de-liste/exercices/

## Cours

**Objectifs : Générer une liste en extension, par ajouts successifs avec `append` et en compréhension ; lire et modifier ses éléments grâce à leurs indices ; parcourir une liste par ses éléments ou par ses indices ; utiliser des listes en mathématiques : termes d’une suite, valeurs d’une fonction, résultats d’une simulation, coefficients directeurs de sécantes.**

**Prerequis : Programme de Seconde : variables et affectation, fonctions (`def`, `return`), instruction conditionnelle `if`, boucles `for` (avec `range`) et `while`. La notion de liste est la seule notion d’algorithmique nouvelle en Première.**

## I. Qu’est-ce qu’une liste ?

**Définition : Liste**
Une **liste** est une suite finie et **ordonnée** de valeurs. En Python, on l’écrit entre crochets, les éléments étant séparés par des virgules : `[12, 15, 9, 14, 10]`. La **liste vide** s’écrit `[]`.

**Propriété : Longueur d’une liste**
`len(L)` renvoie le **nombre d’éléments** de la liste `L`. La liste vide a pour longueur $0$.

```python
notes = [12, 15, 9, 14, 10]
vide = []
print(notes)
print(len(notes), len(vide))
```

```console
[12, 15, 9, 14, 10]
5 0
```

**Remarque : Pourquoi des listes ?**
Une variable ne garde qu’une valeur : à chaque affectation, l’ancienne valeur est perdue. Une liste garde **toutes** les valeurs calculées, dans l’ordre : les termes d’une suite, les valeurs d’une fonction, les résultats d’une simulation… On peut ensuite les relire, les compter, en faire la moyenne ou les représenter.

## II. Éléments et indices

### 1. Lire un élément

**Définition : Indice**
Chaque élément d’une liste est repéré par sa position, appelée **indice**. Le premier élément a l’indice $0$ : une liste de $n$ éléments a pour indices $0$, $1$, …, $n-1$. L’élément d’indice `i` de la liste `L` s’écrit `L[i]`.

![La liste notes = 12, 15, 9, 14, 10 en cinq cases, avec les indices 0 à 4 au-dessus et les indices négatifs -5 à -1 en dessous](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n164_co152_1_liste_indices.png)

**Propriété : Indices négatifs**
Python compte aussi à partir de la fin : `L[-1]` est le **dernier** élément, `L[-2]` l’avant-dernier, etc. Pour une liste de $n$ éléments, `L[-1]` désigne le même élément que `L[n - 1]`.

```python
notes = [12, 15, 9, 14, 10]
print(notes[0], notes[2])
print(notes[-1], notes[-2])
print(notes[len(notes) - 1])
```

```console
12 9
10 14
10
```

**Attention : Indice hors de la liste**
Avec $5$ éléments, les indices vont de $0$ à $4$ (ou de $-5$ à $-1$). L’instruction `print(notes[5])` arrête le programme sur l’erreur `IndexError: list index out of range` (indice hors de la liste). Le dernier élément s’obtient par `notes[-1]` ou `notes[len(notes) - 1]`, jamais par `notes[len(notes)]`.

### 2. Modifier un élément

**Propriété : Affectation d’un élément**
`L[i] = v` remplace l’élément d’indice `i` par la valeur `v`. La longueur de la liste ne change pas.

```python
notes = [12, 15, 9, 14, 10]
notes[2] = 11
notes[-1] = notes[-1] + 2
print(notes)
```

```console
[12, 15, 11, 14, 12]
```

### 3. Indices et rangs d’une suite

**Méthode : Faire correspondre indice et rang**
Si la liste `u` contient les termes $u_0$, $u_1$, $u_2$, … d’une suite, dans cet ordre, alors l’élément `u[n]` est le terme $u_n$ : **l’indice est le rang**.

Si la suite commence au rang $1$, la liste contient $u_1$, $u_2$, … : il y a un décalage, `u[0]` est $u_1$ et, plus généralement, `u[n - 1]` est $u_n$.

## III. Générer une liste

### 1. En extension

Quand on connaît toutes les valeurs, on les écrit entre crochets : `premiers = [2, 3, 5, 7, 11]`. On peut aussi transformer un `range` en liste : `list(range(5))` vaut `[0, 1, 2, 3, 4]`.

### 2. Par ajouts successifs

**Propriété : La méthode `append`**
`L.append(x)` ajoute la valeur `x` **à la fin** de la liste `L` : sa longueur augmente de $1$.

**Méthode : Construire une liste par ajouts successifs**
On part d’une liste de départ (vide, ou réduite au premier terme), puis une boucle ajoute un élément à chaque tour avec `append`. Le dernier élément ajouté est `L[-1]` : on s’en sert pour calculer le suivant.

**Exemple : Termes d’une suite définie par récurrence**
La suite $(u_n)$ est définie par $u_0 = 1$ et, pour tout entier naturel $n$, $u_{n+1} = 2u_n + 1$.

```python
u = [1]
for k in range(5):
    u.append(2 * u[-1] + 1)
print(u)
print(len(u))
```

```console
[1, 3, 7, 15, 31, 63]
6
```

La boucle fait $5$ tours, mais la liste contient $6$ termes : $u_0$, présent au départ, puis $u_1$, …, $u_5$ ajoutés un par un. Le schéma montre les quatre premiers tours.

![La liste u = 1 qui grandit à chaque tour de boucle : 1, 3, 1, 3, 7, 1, 3, 7, 15, 1, 3, 7, 15, 31, le nouvel élément 2 × u-1 + 1 étant ajouté à la fin](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n164_co152_2_liste_append.png)

**Attention : `append` modifie la liste et ne renvoie rien. On écrit `u.append(x)` seul sur sa ligne, jamais `u = u.append(x)` : la variable `u` vaudrait alors `None` et la liste serait perdue.**

### 3. En compréhension

**Définition : Liste en compréhension**
L’écriture `[expression for k in range(n)]` construit en une ligne la liste des valeurs de l’expression pour $k$ allant de $0$ à $n - 1$.

On peut aussi parcourir une autre liste, `[expression for x in L]`, et ne garder que certains éléments avec un filtre, `[x for x in L if condition]`.

```python
print([k**2 for k in range(6)])
print([3*n + 2 for n in range(5)])
L = [12, 15, 9, 14, 10]
print([x for x in L if x >= 12])
```

```console
[0, 1, 4, 9, 16, 25]
[2, 5, 8, 11, 14]
[12, 15, 14]
```

La première liste contient les carrés des entiers de $0$ à $5$ ; la deuxième, les cinq premiers termes de la suite arithmétique $u_n = 3n + 2$ (premier terme $2$, raison $3$) ; la troisième, les notes supérieures ou égales à $12$.

**Méthode : Choisir la bonne écriture**
- Valeurs connues à l’avance : **en extension**.
- Suite donnée par une formule explicite $u_n = f(n)$ : **en compréhension**, `[f(n) for n in range(N)]`.
- Suite donnée par une relation de récurrence (le terme suivant se calcule à partir du précédent) : **par ajouts successifs**, avec `u[-1]`.

## IV. Parcourir une liste

**Propriété : Deux façons de parcourir une liste**
- **Par les éléments** : avec `for x in L:`, la variable `x` prend successivement chaque valeur de `L`. Ce parcours suffit quand seules les valeurs comptent.
- **Par les indices** : avec `for i in range(len(L)):`, la variable `i` prend les valeurs $0$, $1$, …, $n - 1$ et l’élément correspondant est `L[i]`. Ce parcours est nécessaire quand la position compte : donner le rang d’un terme, comparer deux termes voisins, modifier `L[i]`.

```python
u = [1, 3, 7, 15]
for i in range(len(u)):
    print("u", i, "vaut", u[i])
```

```console
u 0 vaut 1
u 1 vaut 3
u 2 vaut 7
u 3 vaut 15
```

### Trois algorithmes de référence

**Méthode : Somme et moyenne**
Un **accumulateur** `s`, initialisé à $0$, reçoit chaque élément.

```python
notes = [12, 15, 9, 14, 10]
s = 0
for x in notes:
    s = s + x
print(s, s / len(notes))
```

```console
60 12.0
```

La moyenne vaut $\dfrac{60}{5} = 12$. Python écrit le résultat d’une division `/` avec un point décimal : `12.0`. Les fonctions `sum(L)`, `max(L)` et `min(L)` donnent directement la somme, le plus grand et le plus petit élément.

**Méthode : Compter, calculer une fréquence**
Un **compteur** `c`, initialisé à $0$, augmente de $1$ pour chaque élément qui vérifie la condition.

```python
notes = [12, 15, 9, 14, 10]
c = 0
for x in notes:
    if x >= 12:
        c = c + 1
print(c, c / len(notes))
```

```console
3 0.6
```

$3$ notes sur $5$ sont supérieures ou égales à $12$ : la fréquence est $\dfrac{3}{5} = 0{,}6$.

**Méthode : Plus grand élément et son indice**
On retient l’indice `imax` du plus grand élément rencontré ; on le remplace dès qu’on trouve un élément plus grand.

```python
notes = [12, 15, 9, 14, 10]
imax = 0
for i in range(len(notes)):
    if notes[i] > notes[imax]:
        imax = i
print(imax, notes[imax])
```

```console
1 15
```

La meilleure note, $15$, est la deuxième : son indice est $1$.

## V. Les listes en mathématiques

### 1. Termes d’une suite et nuage de points

**Exemple : Conjecturer le comportement d’une suite**
La suite $(u_n)$ est définie par $u_0 = 1$ et $u_{n+1} = 0{,}5\,u_n + 2$.

```python
u = [1]
for k in range(4):
    u.append(0.5 * u[-1] + 2)
print(u)
print(sum(u))
```

```console
[1, 2.5, 3.25, 3.625, 3.8125]
14.1875
```

On lit $u_1 = 2{,}5$, $u_2 = 3{,}25$, $u_3 = 3{,}625$, $u_4 = 3{,}8125$ et $u_0 + u_1 + \dots + u_4 = 14{,}1875$. Avec `range(8)`, on obtient $u_0$, …, $u_8$, que l’on représente par le nuage des points de coordonnées $(n \,;\, u_n)$.

![Nuage des points (n ; u_n) pour n de 0 à 8, avec u_0 = 1 et u_(n+1) = 0,5 u_n + 2 : les points montent et se rapprochent de la droite d'équation y = 4](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n164_co152_3_suite_nuage.png)

Les points montent et semblent se rapprocher de la droite d’équation $y = 4$ : on **conjecture** que la suite est croissante et que ses termes se rapprochent de $4$. Une liste de termes permet de conjecturer ; elle ne démontre rien.

### 2. Liste de valeurs d’une fonction

**Méthode : Tableau de valeurs avec deux listes**
Pour tabuler une fonction $f$ sur $[a \,;\, b]$ avec un pas $p$, on construit la liste `X` des abscisses $a$, $a + p$, $a + 2p$, …, puis la liste `Y` des images, en compréhension. L’élément `Y[i]` est l’image de `X[i]`.

**Exemple : Fonction $f(x) = x^2 - 2x$ sur $[-2 \,;\, 4]$, pas $1$**
```python
def f(x):
    return x**2 - 2*x

X = list(range(-2, 5))
Y = [f(x) for x in X]
print(X)
print(Y)
print(min(Y))
```

```console
[-2, -1, 0, 1, 2, 3, 4]
[8, 3, 0, -1, 0, 3, 8]
-1
```

Les deux listes forment le tableau de valeurs de $f$ : sous chaque abscisse `X[i]`, on lit son image `Y[i]`. Par exemple, `Y[0]` est $f(-2) = 8$ et `Y[3]` est $f(1) = -1$.

La plus petite valeur de la liste, $-1$, est obtenue pour $x = 1$. Pour un pas de $0{,}5$, on écrirait `X = [-2 + 0.5*k for k in range(13)]`.

### 3. Simulation : liste de résultats, fréquences, moyenne

**Exemple : 1 000 lancers d’un dé équilibré**
On range les $1\,000$ résultats dans la liste `R`, puis on compte les effectifs de chaque face dans la liste `E` : la face `x` correspond à l’indice `x - 1`.

```python
from random import randint, seed
seed(1)
R = []
for k in range(1000):
    R.append(randint(1, 6))
E = [0, 0, 0, 0, 0, 0]
for x in R:
    E[x - 1] = E[x - 1] + 1
print(E)
print(E[5] / len(R))
print(sum(R) / len(R))
```

```console
[160, 166, 165, 163, 183, 163]
0.163
3.532
```

`randint(1, 6)` renvoie un entier au hasard entre $1$ et $6$. L’instruction `seed(1)` fixe la suite des tirages : le programme donne alors toujours le même affichage, celui ci-dessus (sans elle, les résultats changent à chaque exécution).

- `E[5]` est l’effectif de la face $6$ : sa fréquence est $0{,}163$, proche de $\dfrac{1}{6} \approx 0{,}167$.
- La moyenne des résultats est $3{,}532$, proche de $3{,}5$, moyenne des faces $\dfrac{1 + 2 + \dots + 6}{6}$.

![Diagramme en barres des fréquences des faces 1 à 6 sur 1 000 lancers simulés, comparées à la droite horizontale d'ordonnée 1/6](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n164_co152_4_simulation_histo.png)

**Remarque : Les fréquences observées fluctuent autour de $\dfrac{1}{6}$. Plus le nombre de lancers est grand, plus elles ont tendance à s’en rapprocher.**

### 4. Coefficients directeurs des sécantes

Soit $f(x) = x^2$, $A$ le point de la courbe d’abscisse $1$ et $M$ le point de la courbe d’abscisse $1 + h$ ($h \neq 0$). Le coefficient directeur de la sécante $(AM)$ est le taux de variation
$$\frac{f(1 + h) - f(1)}{h}.$$

![Parabole y = x², point A d'abscisse 1 et point M d'abscisse 1 + h, la sécante (AM) avec l'écart horizontal h et l'écart vertical f(1 + h) - f(1), et la tangente en A en pointillés](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n164_co152_5_secante.png)

```python
def f(x):
    return x**2

def taux(h):
    return (f(1 + h) - f(1)) / h

H = [1, 0.5, 0.25, 0.125, 0.0625]
P = [taux(h) for h in H]
print(P)
```

```console
[3.0, 2.5, 2.25, 2.125, 2.0625]
```

Quand $h$ se rapproche de $0$, les coefficients directeurs se rapprochent de $2$ : la sécante $(AM)$ se rapproche de la tangente en $A$. Le calcul le confirme : pour $h \neq 0$,
$$
\begin{aligned}
\frac{f(1 + h) - f(1)}{h} &= \frac{1 + 2h + h^2 - 1}{h} \\
&= \frac{h(2 + h)}{h} \\
&= 2 + h
\end{aligned}
$$
qui tend vers $2$ quand $h$ tend vers $0$ : le nombre dérivé de $f$ en $1$ est $f'(1) = 2$.

## VI. Erreurs fréquentes

**Attention : Les erreurs classiques**
1. Oublier que le premier indice est $0$ : le premier élément est `L[0]`, le dernier `L[len(L) - 1]` ou `L[-1]`, et `L[len(L)]` provoque une erreur `IndexError`.
2. Écrire `u = u.append(x)` : `append` ne renvoie rien, la liste est perdue.
3. Se tromper sur le nombre de termes : partir de `[u0]` puis faire `range(n)` tours donne $n + 1$ termes, de $u_0$ à $u_n$.
4. Confondre l’indice `i` et la valeur `L[i]` dans un parcours par indices.
5. Oublier de diviser par le nombre d’éléments pour une moyenne ou une fréquence.

**À retenir : - Une liste s’écrit entre crochets ; `len(L)` donne son nombre d’éléments.**
- Indices de $0$ à `len(L) - 1` ; `L[-1]` est le dernier élément ; `L[i] = v` remplace un élément.
- Trois façons de générer une liste : en extension, par ajouts successifs (`append` dans une boucle), en compréhension (`[… for k in range(n)]`, avec un filtre `if` éventuel).
- Deux parcours : par les éléments (`for x in L:`) ou par les indices (`for i in range(len(L)):`).
- En mathématiques : termes d’une suite, tableau de valeurs, résultats d’une simulation, coefficients directeurs de sécantes.
- Fiche de synthèse dans l’onglet Fiches !

## Fiche de révision

**Objectifs : L’essentiel sur les listes en Python : générer, lire, modifier, parcourir, et s’en servir en mathématiques. Programme de Première.**

## I. Éléments et indices

**Définition : Une **liste** est une suite ordonnée de valeurs, écrite entre crochets : `notes = [12, 15, 9, 14, 10]`. `len(notes)` vaut $5$. Les indices vont de $0$ à `len(notes) - 1` ; `notes[-1]` est le dernier élément.**

![La liste notes = 12, 15, 9, 14, 10 en cinq cases, avec les indices 0 à 4 au-dessus et les indices négatifs -5 à -1 en dessous](https://optitab-media.s3.eu-north-1.amazonaws.com/synthesis_images/v1_n164_fi62_1_liste_indices.png)

| Écriture | Valeur ou effet |
|---|---|
| `notes[0]` | `12` (premier élément) |
| `notes[-1]` | `10` (dernier élément) |
| `notes[2] = 11` | remplace `9` par `11` |
| `notes[5]` | erreur `IndexError` |

Pour une suite rangée à partir de $u_0$ : `u[n]` est le terme $u_n$.

## II. Générer une liste

- **En extension** : `[2, 3, 5, 7]`
- **Par ajouts successifs** : `L.append(x)` dans une boucle
- **En compréhension** : `[k**2 for k in range(6)]`
- **Avec un filtre** : `[x for x in L if x > 0]`

```python
u = [1]
for k in range(5):
    u.append(2 * u[-1] + 1)
print(u)
```

```console
[1, 3, 7, 15, 31, 63]
```

![La liste u = 1 qui grandit à chaque tour de boucle : 1, 3, 1, 3, 7, 1, 3, 7, 15, 1, 3, 7, 15, 31, le nouvel élément 2 × u-1 + 1 étant ajouté à la fin](https://optitab-media.s3.eu-north-1.amazonaws.com/synthesis_images/v1_n164_fi62_2_liste_append.png)

**Méthode : Choisir**
Formule explicite $u_n = f(n)$ → compréhension ; relation de récurrence → ajouts successifs avec `u[-1]`.

## III. Parcourir une liste

**Méthode : Deux parcours**
- Par les éléments, quand seules les valeurs comptent : `for x in L:`
- Par les indices, quand la position compte : `for i in range(len(L)):` puis `L[i]`

- Somme et moyenne : accumulateur `s = 0`, puis `s = s + x` ; moyenne `s / len(L)`.
- Fréquence : compteur `c = 0`, puis `c = c + 1` si la condition est vraie ; fréquence `c / len(L)`.
- Directement : `sum(L)`, `max(L)` et `min(L)` donnent la somme, le plus grand et le plus petit élément.

## IV. Les listes en mathématiques

| Usage | Écriture type |
|---|---|
| Termes d’une suite | `u.append(…u[-1]…)` |
| Valeurs d’une fonction | `Y = [f(x) for x in X]` |
| Simulation | `R.append(randint(1, 6))` |
| Sécantes | `[taux(h) for h in H]` |

Une liste de valeurs permet de **conjecturer** (nuage de points, fréquences, coefficients directeurs qui se rapprochent d’un nombre dérivé) ; elle ne démontre pas.

## V. Les pièges à éviter

**Attention : Les 4 erreurs classiques**
1. Croire que le premier élément est `L[1]` : c’est `L[0]`.
2. Utiliser l’indice `len(L)`, qui n’existe pas.
3. Écrire `L = L.append(x)` : `append` modifie la liste et ne renvoie rien.
4. Oublier qu’avec `u = [u0]` et `range(n)` tours, on obtient $n + 1$ termes.

## Exercices corrigés

### Exercice 1 : Indices et éléments d'une liste

Les températures relevées à midi (en °C) pendant une semaine, du lundi au dimanche, sont rangées dans la liste `T`.

```python
T = [14, 17, 12, 19, 16, 11, 15]
```

1. Combien la liste `T` contient-elle d’éléments ? Quels sont ses indices ?
2. Sans ordinateur, donner la valeur de :
   - a) `T[0]` ;
   - b) `T[3]` ;
   - c) `T[-1]` ;
   - d) `T[len(T) - 2]`.
3. Quel est l’indice de la température du jeudi ? Quel est l’indice de la plus basse température de la semaine ?
4. Le relevé du mercredi était faux : il fallait lire $13$. Écrire l’instruction qui corrige la liste, puis donner la liste obtenue.
5. Que se passe-t-il si l’on exécute `print(T[7])` ?

#### Correction détaillée

## Question 1 : Nombre d’éléments et indices

**Méthode : Une liste de $n$ éléments a pour indices $0$, $1$, …, $n - 1$ : on commence à compter à $0$.**

**Etape : Nombre d’éléments**
La liste contient une température par jour de la semaine : `len(T)` vaut $7$.

**Etape : Indices**
Les indices vont de $0$ (lundi) à $6$ (dimanche). En comptant depuis la fin, ils vont de $-7$ à $-1$.

![La liste T = 14, 17, 12, 19, 16, 11, 15 en sept cases, avec les indices 0 à 6 en vert au-dessus et les indices négatifs -7 à -1 en dessous](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n164_ex1063_1_ex1063_indices.png)

**Resultat : `T` contient $7$ éléments, d’indices $0$, $1$, $2$, $3$, $4$, $5$, $6$.**

## Question 2 : Lire des éléments

**Méthode : `T[i]` est l’élément d’indice `i` ; `T[-1]` est le dernier élément.**

**Etape : Indices positifs**
- `T[0]` est le premier élément : $14$.
- `T[3]` est le **quatrième** élément (indices $0$, $1$, $2$, $3$) : $19$.

**Etape : Indices négatifs et calculés**
- `T[-1]` est le dernier élément : $15$.
- `len(T) - 2` vaut $7 - 2 = 5$, donc `T[len(T) - 2]` est `T[5]`, c’est-à-dire $11$ (l’avant-dernier élément).
**On : vérifie à la machine :**

```python
T = [14, 17, 12, 19, 16, 11, 15]
print(T[0], T[3], T[-1])
print(T[len(T) - 2])
```

```console
14 19 15
11
```

**Attention : `T[3]` n’est pas le troisième élément mais le quatrième : on compte à partir de $0$.**

**Resultat : a) $14$ ; b) $19$ ; c) $15$ ; d) $11$.**

## Question 3 : Retrouver un indice

**Etape : Jeudi**
Lundi a l’indice $0$, mardi $1$, mercredi $2$, donc jeudi a l’indice $3$.

**Etape : Plus basse température**
La plus petite valeur de la liste est $11$ ; elle est en sixième position, à l’indice $5$ (samedi).

**Resultat : Le jeudi a l’indice $3$ ; la plus basse température, $11$ °C, a l’indice $5$.**

## Question 4 : Modifier un élément

**Méthode : `T[i] = v` remplace l’élément d’indice `i` par `v`, sans changer la longueur.**

**Etape : Instruction**
Le mercredi est le troisième jour : son indice est $2$. On écrit `T[2] = 13`.

```python
T = [14, 17, 12, 19, 16, 11, 15]
T[2] = 13
print(T)
```

```console
[14, 17, 13, 19, 16, 11, 15]
```

**Resultat : `T[2] = 13` ; la liste devient `[14, 17, 13, 19, 16, 11, 15]`.**

## Question 5 : Indice hors de la liste

**Etape : Analyse**
Les indices de `T` vont de $0$ à $6$ : l’indice $7$ n’existe pas. Python arrête le programme sur l’erreur `IndexError: list index out of range` (indice hors de la liste).

**Resultat : `print(T[7])` provoque une erreur `IndexError`. Le dimanche, dernier jour, s’obtient par `T[6]` ou `T[-1]`.**

#### Réponses

1. $7$ éléments, d’indices $0$ à $6$.
2. a) $14$ ; b) $19$ ; c) $15$ ; d) `T[5]`, soit $11$.
3. Jeudi : indice $3$ ; plus basse température ($11$ °C) : indice $5$.
4. `T[2] = 13`, d’où `[14, 17, 13, 19, 16, 11, 15]`.
5. Erreur `IndexError` : l’indice $7$ n’existe pas.

### Exercice 2 : Liste des termes d'une suite

La suite $(u_n)$ est définie par $u_0 = 5$ et, pour tout entier naturel $n$, $u_{n+1} = 2u_n - 3$.

1. Calculer $u_1$, $u_2$ et $u_3$.
2. Compléter la fonction `termes` pour qu’elle renvoie la liste $[u_0, u_1, \dots, u_n]$, construite par ajouts successifs. Que renvoie `termes(5)` ?

```python
def termes(n):
    u = [5]
    for k in range(n):
        ...
    return u
```

3. On admet que, pour tout entier naturel $n$, $u_n = 2^{n+1} + 3$. Écrire **en compréhension** la liste des termes $u_0$ à $u_5$ à l’aide de cette formule, et vérifier qu’on retrouve la liste de la question 2.
4. Calculer la somme $u_0 + u_1 + \dots + u_5$ à l’aide de la liste.
5. Placer les points de coordonnées $(n \,;\, u_n)$ pour $n$ allant de $0$ à $5$ dans le repère ci-dessous. Que peut-on conjecturer sur le sens de variation de la suite ?

![Repère vide, n de 0 à 5 en abscisse et u_n de 0 à 70 en ordonnée, pour placer les points de la suite](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n164_ex1066_1_ex1066_repere.png)

#### Correction détaillée

## Question 1 : Premiers termes

**Méthode : On applique la relation de récurrence avec $n = 0$, puis $n = 1$, puis $n = 2$.**

**Etape : Calculs**
$$
\begin{aligned}
u_1 &= 2u_0 - 3 = 2 \times 5 - 3 = 7 \\
u_2 &= 2u_1 - 3 = 2 \times 7 - 3 = 11 \\
u_3 &= 2u_2 - 3 = 2 \times 11 - 3 = 19
\end{aligned}
$$

**Resultat : $u_1 = 7$, $u_2 = 11$, $u_3 = 19$.**

## Question 2 : Fonction `termes`

**Méthode : Le dernier terme calculé est `u[-1]` : le suivant vaut `2 * u[-1] - 3`, que l’on ajoute avec `append`.**

```python
def termes(n):
    u = [5]
    for k in range(n):
        u.append(2 * u[-1] - 3)
    return u

print(termes(5))
```

```console
[5, 7, 11, 19, 35, 67]
```

**Etape : Nombre de termes**
La liste part de $u_0$ et la boucle fait $n$ tours : `termes(n)` contient $n + 1$ termes, de $u_0$ à $u_n$. Pour $n = 5$ : $u_4 = 2 \times 19 - 3 = 35$ et $u_5 = 2 \times 35 - 3 = 67$.

**Resultat : `termes(5)` renvoie `[5, 7, 11, 19, 35, 67]`.**

## Question 3 : Avec la formule explicite

**Méthode : Avec une formule explicite, la compréhension suffit : on écrit la formule dans une fonction `w`, puis `[w(n) for n in range(6)]`.**

```python
def termes(n):
    u = [5]
    for k in range(n):
        u.append(2 * u[-1] - 3)
    return u

def w(n):
    return 2**(n + 1) + 3

v = [w(n) for n in range(6)]
print(v)
print(v == termes(5))
```

```console
[5, 7, 11, 19, 35, 67]
True
```

**Etape : Lecture**
`v == termes(5)` vaut `True` : les deux listes ont les mêmes éléments, dans le même ordre. Par exemple $u_5 = 2^6 + 3 = 64 + 3 = 67$.

**Attention : En Python, la puissance s’écrit `**` : `2**(n + 1)`. Le symbole `^` ne calcule pas une puissance.**

**Resultat : La liste en compréhension des $2^{n+1} + 3$, pour $n$ de $0$ à $5$, est `[5, 7, 11, 19, 35, 67]` : c’est la même liste.**

## Question 4 : Somme des termes

**Etape : Calcul**
`sum(termes(5))` additionne les éléments de la liste :
$$
\begin{aligned}
S &= 5 + 7 + 11 + 19 + 35 + 67 \\
&= 144
\end{aligned}
$$

**Resultat : $u_0 + u_1 + \dots + u_5 = 144$.**

## Question 5 : Nuage de points

**Etape : Points à placer**
La liste donne les ordonnées : $(0 \,;\, 5)$, $(1 \,;\, 7)$, $(2 \,;\, 11)$, $(3 \,;\, 19)$, $(4 \,;\, 35)$, $(5 \,;\, 67)$.

![Nuage des points (n ; u_n) pour n de 0 à 5 : (0 ; 5), (1 ; 7), (2 ; 11), (3 ; 19), (4 ; 35), (5 ; 67), qui montent de plus en plus vite](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n164_ex1066_2_ex1066_nuage.png)

**Etape : Conjecture**
Les points montent de plus en plus vite : chaque terme semble plus grand que le précédent.

**Resultat : On conjecture que la suite $(u_n)$ est croissante.**

#### Réponses

1. $u_1 = 7$, $u_2 = 11$, $u_3 = 19$.
2. Instruction manquante : `u.append(2 * u[-1] - 3)` ; `termes(5)` renvoie `[5, 7, 11, 19, 35, 67]`.
3. `[w(n) for n in range(6)]`, où `w(n)` renvoie `2**(n + 1) + 3`, donne la même liste.
4. $144$.
5. Les points montent : on conjecture que $(u_n)$ est croissante.

### Exercice 3 : Simuler des lancers de deux dés avec une liste

On lance deux dés équilibrés à six faces et on note la somme $S$ des deux résultats. Le programme suivant simule $1\,000$ lancers ; l’instruction `seed(2)` fixe les tirages, pour que chacun obtienne les mêmes résultats.

```python
from random import randint, seed

seed(2)
S = []
for k in range(1000):
    a = randint(1, 6)
    b = randint(1, 6)
    S.append(a + b)
```

1. Que contient la liste `S` ? Quelle est sa longueur ? Quelles valeurs peuvent y apparaître ?
2. Compléter le programme pour qu’il calcule la fréquence de la somme $7$ dans `S`. L’exécution donne $0{,}172$.
3. À l’aide d’un tableau à double entrée, calculer la probabilité $P(S = 7)$ et la comparer à la fréquence observée.
4. Compléter le programme pour qu’il calcule la moyenne des sommes obtenues. L’exécution donne $7{,}008$. Comparer avec $3{,}5 + 3{,}5$.
5. On complète le programme pour ranger dans une liste `E` les effectifs des sommes $2$, $3$, …, $12$.

```python
# suite du programme
E = [0 for k in range(11)]
for s in S:
    E[s - 2] = E[s - 2] + 1
```

- a) Pourquoi `E` a-t-elle $11$ éléments ? Pourquoi utilise-t-on l’indice `s - 2` ?
- b) Quel élément de `E` contient l’effectif de la somme $7$ ?

#### Correction détaillée

## Question 1 : Contenu de la liste

**Méthode : À chaque tour, `append` ajoute un élément : la liste reçoit autant d’éléments que de tours de boucle.**

**Etape : Contenu et longueur**
À chaque tour, on tire deux entiers entre $1$ et $6$ et on ajoute leur somme à la fin de `S`. La boucle fait $1\,000$ tours : `len(S)` vaut $1\,000$.

**Etape : Valeurs possibles**
La plus petite somme est $1 + 1 = 2$, la plus grande $6 + 6 = 12$ : toutes les sommes entières de $2$ à $12$ sont possibles, soit $11$ valeurs.

**Resultat : `S` contient les $1\,000$ sommes simulées ; ses éléments sont des entiers de $2$ à $12$.**

## Question 2 : Fréquence de la somme 7

**Méthode : Compteur : `c` augmente de $1$ chaque fois qu’un élément de `S` vaut $7$ ; la fréquence est `c / len(S)`.**

```python
from random import randint, seed

seed(2)
S = []
for k in range(1000):
    a = randint(1, 6)
    b = randint(1, 6)
    S.append(a + b)
c = 0
for s in S:
    if s == 7:
        c = c + 1
print(c, c / len(S))
```

```console
172 0.172
```

**Resultat : La somme $7$ apparaît $172$ fois : sa fréquence est $0{,}172$.**

## Question 3 : Probabilité de la somme 7

**Méthode : Les $6 \times 6 = 36$ couples (dé 1 ; dé 2) sont équiprobables : on compte ceux dont la somme vaut $7$.**

**Etape : Issues favorables**
$(1 \,;\, 6)$, $(2 \,;\, 5)$, $(3 \,;\, 4)$, $(4 \,;\, 3)$, $(5 \,;\, 2)$, $(6 \,;\, 1)$ : $6$ couples.

**Etape : Probabilité**
$$P(S = 7) = \frac{6}{36} = \frac{1}{6} \approx 0{,}167$$

**Resultat : $P(S = 7) = \dfrac{1}{6} \approx 0{,}167$ : la fréquence observée $0{,}172$ en est proche (écart d’environ $0{,}005$).**

## Question 4 : Moyenne des sommes

**Méthode : La moyenne d’une liste de nombres est `sum(S) / len(S)`.**

```python
from random import randint, seed

seed(2)
S = []
for k in range(1000):
    a = randint(1, 6)
    b = randint(1, 6)
    S.append(a + b)
print(sum(S) / len(S))
```

```console
7.008
```

**Etape : Comparaison**
Un dé donne en moyenne $\dfrac{1 + 2 + \dots + 6}{6} = 3{,}5$ ; on s’attend donc à une somme moyenne proche de $3{,}5 + 3{,}5 = 7$.

**Resultat : La moyenne observée, $7{,}008$, est très proche de $7$.**

## Question 5 : Liste des effectifs

**Etape : a) Taille de `E` et indice `s - 2`**
Il y a $11$ sommes possibles, de $2$ à $12$ : `E` a un élément par somme. La somme $2$ doit correspondre à l’indice $0$, la somme $3$ à l’indice $1$… : la somme `s` correspond à l’indice `s - 2`, qui va de $0$ à $10$.

**Etape : b) Effectif de la somme 7**
La somme $7$ correspond à l’indice $7 - 2 = 5$ : son effectif est `E[5]`.

```python
from random import randint, seed

seed(2)
S = []
for k in range(1000):
    a = randint(1, 6)
    b = randint(1, 6)
    S.append(a + b)
E = [0 for k in range(11)]
for s in S:
    E[s - 2] = E[s - 2] + 1
print(E[5], len(E), sum(E))
```

```console
172 11 1000
```

Le diagramme compare les fréquences observées $\dfrac{E[s-2]}{1\,000}$ (barres, la somme $7$ en vert) aux probabilités théoriques (traits orange).

![Diagramme en barres des fréquences observées des sommes 2 à 12 de deux dés sur 1 000 lancers, la barre de la somme 7 en vert, avec les probabilités théoriques en traits orange](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n164_ex4947_1_exn2_histo.png)

**Attention : `E[7]` n’est pas l’effectif de la somme $7$ mais celui de la somme $9$ : l’indice est décalé de $2$.**

**Resultat : - a) Une case par somme possible ($11$ sommes) ; la somme $s$ est rangée à l’indice $s - 2$.**
- b) L’effectif de la somme $7$ est `E[5]`, qui vaut $172$.

#### Réponses

1. Les $1\,000$ sommes simulées ; longueur $1\,000$ ; valeurs de $2$ à $12$.
2. Compteur `c` des éléments égaux à $7$, puis `c / len(S)` : $0{,}172$.
3. $P(S = 7) = \dfrac{6}{36} = \dfrac{1}{6} \approx 0{,}167$, proche de $0{,}172$.
4. `sum(S) / len(S)` donne $7{,}008$, proche de $7$.
5. a) $11$ sommes possibles, la somme $s$ à l’indice $s - 2$ ; b) `E[5]`, qui vaut $172$.
