Algorithmique et listes en première

Une seule notion est nouvelle cette année : la liste. Tout le reste - variable, affectation, condition, boucle - se consolide.

Les acquis à consolider

Variable et affectation

Affecter, c'est ranger une valeur dans une variable. En langage naturel on écrit \(\longleftarrow\), en Python on écrit \(=\).

Langage naturel :

n ← 7
n ← n + 1

Python :

n = 7
n = n + 1

\(n = n + 1\) n'est pas une équation - elle n'aurait aucune solution. C'est une action : prendre la valeur actuelle, ajouter 1, ranger le résultat au même endroit.

Condition et boucles

Structure	Quand l'employer
\(\text{if}\) … \(\text{else}\)	un traitement différent selon un test
\(\text{for}\)	le nombre de tours est connu à l'avance
\(\text{while}\)	on répète jusqu'à ce qu'une condition change

choisir sa structure avant d'écrire une ligne

Le choix entre \(\text{for}\) et \(\text{while}\) se décide sur une seule question : sait-on d'avance combien de tours ? Chercher un seuil, c'est un \(\text{while}\) ; parcourir dix termes, c'est un \(\text{for}\).

La liste

Une liste

Une liste est une suite ordonnée de valeurs, rangée dans une seule variable. Chaque valeur a un indice, qui commence à zéro.

L = [3, 8, 5, 12]

Indice	\(0\)	\(1\)	\(2\)	\(3\)
Valeur	\(3\)	\(8\)	\(5\)	\(12\)

une liste de quatre éléments, d'indices 0 à 3

Le dernier indice d'une liste de \(n\) éléments est \(n - 1\), jamais \(n\). C'est l'erreur la plus fréquente, et elle arrête le programme.

Les trois façons de construire une liste

En extension : on écrit les éléments
```
L = [1, 4, 9, 16, 25]
```
Par ajouts successifs : on part du vide et on remplit
```
L = []
for k in range(1, 6):
    L.append(k * k)
```
La méthode append ajoute un élément à la fin de la liste.
En compréhension : on décrit ce qu'elle contient
```
L = [k * k for k in range(1, 6)]
```
Cette écriture se lit comme une définition d'ensemble : « les \(k^2\) pour \(k\) allant de 1 à 5 ».

Les trois donnent exactement la même liste. La compréhension peut aussi porter une condition:

P = [k for k in range(20) if k % 2 == 0]

On y lit « les \(k\) de 0 à 19 tels que \(k\) soit pair » - c'est la notation ensembliste, écrite en Python.

Manipuler une liste

Écriture	Effet, sur \(L = [3, 8, 5, 12]\)
\(L[0]\)	le premier élément : \(3\)
\(L[-1]\)	le dernier élément : \(12\)
\(\text{len}(L)\)	le nombre d'éléments : \(4\)
\(L.\text{append}(7)\)	ajoute \(7\) à la fin
\(L[1] = 20\)	remplace \(8\) par \(20\)
\(\text{sum}(L)\)	la somme des éléments : \(28\)

les opérations qui suffisent au programme de première

Parcourir une liste

Deux parcours coexistent, et le choix n'est pas indifférent.

Par élément :

for x in L:
    print(x)

Par indice :

for i in range(len(L)):
    print(L[i])

Le parcours par élément est plus lisible, et suffit dès qu'on ne veut que lire. Le parcours par indice devient nécessaire pour modifier la liste, ou pour comparer un élément à son voisin.

Découper en fonctions

Plutôt qu'un long programme, on écrit de petites fonctions, chacune faisant une seule chose. C'est ce qu'on appelle la programmation modulaire.

def moyenne(L):
    return sum(L) / len(L)

notes = [12, 15, 8, 17]
print(moyenne(notes))

Le mot return renvoie un résultat à qui a appelé la fonction ; print se contente de l'afficher. Confondre les deux rend une fonction inutilisable dans un calcul.

Trois usages en mathématiques

Les termes d'une suite
```
u = 2
termes = [u]
for n in range(10):
    u = 3 * u + 1
    termes.append(u)
```
La liste conserve tous les termes, là où une simple variable ne garderait que le dernier.
Un tableau de valeurs
```
X = [k / 2 for k in range(-6, 7)]
Y = [x * x - 3 for x in X]
```
Deux listes parallèles : les abscisses, puis les images.
Une série statistique
```
def etendue(L):
    return max(L) - min(L)
```
Les indicateurs de seconde se programment en une ligne, une fois les données rangées dans une liste.

La liste est ce qui permet de garder plutôt que de recalculer : c'est en cela qu'elle éclaire les suites, les tableaux de valeurs et les séries statistiques - trois objets qui sont, au fond, des listes de nombres.