Vue d'ensemble
Les listes et les chaînes de caractères stockent des séquences de valeurs, accessibles par leur indice. Savoir les créer, les indexer, les parcourir et connaître leur différence clé — une liste est modifiable, une chaîne ne l'est pas — est indispensable pour presque tout algorithme de prépa.
for, découper (slicing), et distinguer liste (mutable) de chaîne (immutable).
Prérequis
- Variables, types et expressions
- Boucle
foretrange
Les indices te font perdre des points bêtes ? Indexation à partir de 0, dernier élément, bornes du slicing : nos mentors alumni X · Centrale · Mines t'entraînent jusqu'à ce que ces manipulations deviennent automatiques.
Trouver un mentor →1. Créer et indexer
Les éléments d'une séquence sont numérotés à partir de 0. t[0] est
le premier, t[len(t) - 1] le dernier ; t[-1] désigne aussi le dernier.
t = [10, 20, 30, 40]
t[0] # 10 (premier)
t[-1] # 40 (dernier)
len(t) # 4 (nombre d'éléments)
s = "prepa"
s[0] # 'p'
len(s) # 5t[0]Indexation à partir de 0. Le premier élément a l'indice 0, pas 1. Piège classique de début de prépa.t[-1]Compter par la fin. t[-1] est le dernier, t[-2] l'avant-dernier. Pratique pour éviter len(t) - 1.len(t)Longueur. Nombre d'éléments. Les indices valides vont de 0 à len(t) - 1.t = [10, 20, 30, 40], t[4]
déclenche une erreur (IndexError) : le dernier indice valide est 3.
2. Parcourir une séquence
Deux manières de parcourir : par les éléments, ou par les indices.
t = [10, 20, 30]
# par les éléments (le plus simple)
for x in t:
print(x) # 10, puis 20, puis 30
# par les indices (utile si on a besoin de la position)
for i in range(len(t)):
print(i, t[i]) # 0 10, puis 1 20, puis 2 30for x in t:Parcours par valeur. x prend successivement chaque élément de t. À privilégier quand la position n'importe pas.for i in range(len(t)):Parcours par indice. i va de 0 à len(t) - 1 ; on accède à l'élément par t[i]. Utile pour modifier la liste ou comparer des voisins.3. Modifier : liste vs chaîne
Différence fondamentale : une liste est modifiable (mutable), une chaîne ne l'est pas (immutable).
t = [10, 20, 30]
t[0] = 99 # OK : t devient [99, 20, 30]
t.append(40) # ajoute 40 à la fin : [99, 20, 30, 40]
s = "abc"
# s[0] = "z" # -> erreur : une chaîne est immutable
s[1:3] # 'bc' (découpage : de l'indice 1 à 2)
t2 = [10, 20, 30, 40][1:3] # [20, 30]t[0] = 99Liste mutable. On peut réaffecter une case en place. append ajoute un élément à la fin.s[0] = "z"Chaîne immutable. Interdit : on ne peut pas modifier une chaîne en place. Il faut en construire une nouvelle.s[1:3]Slicing. [a:b] renvoie du caractère d'indice a jusqu'à b - 1 (borne de fin exclue), comme range. Ici "abc"[1:3] = "bc".[1:3] prend les indices 1 et 2,
pas 3. Même logique d'exclusion que range.
4. Exercices d'application
À faire de tête avant d'ouvrir le corrigé.
Soit t = [5, 8, 13, 21, 34]. Que valent t[2], t[-1] et len(t) ?
Voir la correction détaillée
t[2] : l'élément d'indice 2 (le 3ᵉ) = 13.t[-1] : le dernier = 34.len(t) : nombre d'éléments = 5 (indices valides de 0 à 4).Que vaut s à la fin ?
t = [4, 7, 2, 5]
s = 0
for x in t:
s = s + xVoir la correction détaillée
s (initialisé à 0).Récap final — Ce qu'il faut absolument retenir
Tu dois pouvoir répondre « oui » sans hésiter à chaque point.
- Sais-tu que l'indexation commence à 0 et que le dernier indice est
len(t) - 1? - Sais-tu utiliser les indices négatifs (
t[-1]= dernier) ? - Sais-tu parcourir par valeur (
for x in t) et par indice (for i in range(len(t))) ? - Sais-tu qu'une liste est modifiable (mutable) et une chaîne non (immutable) ?
- Sais-tu que la borne de fin d'un slicing
[a:b]est exclue ? - Sais-tu appliquer le motif de l'accumulateur (somme, comptage) à une liste ?