Listes et chaînes de caractères

2. Modifier une liste

Une liste est modifiable (on dit mutable) : on peut changer une case, ajouter, insérer ou supprimer des éléments sans recréer la liste.

t = [10, 20, 30]

t[0] = 99         # réaffecte la case d'indice 0 -> [99, 20, 30]
t.append(40)      # ajoute 40 à la fin          -> [99, 20, 30, 40]
t.insert(1, 15)   # insère 15 à l'indice 1      -> [99, 15, 20, 30, 40]
del t[2]          # supprime l'élément d'indice 2 -> [99, 15, 30, 40]

carres = []
for n in range(1, 5):
    carres.append(n * n)
# carres vaut [1, 4, 9, 16]

3. La chaîne de caractères

Une chaîne de caractères (type str) est une séquence de caractères, écrite entre guillemets. Elle s'indexe et se mesure exactement comme une liste.

s = "prepa"
s[0]        # 'p'  -> premier caractère
s[-1]       # 'a'  -> dernier caractère
len(s)      # 5    -> nombre de caractères

# parcours caractère par caractère
for c in s:
    print(c)     # 'p', 'r', 'e', 'p', 'a'

4. Parcourir une séquence

Parcourir, c'est passer sur chaque élément l'un après l'autre. Deux façons de faire, valables aussi bien pour une liste que pour une chaîne : par les éléments, ou par les indices.

t = [10, 20, 30]

# (a) par les éléments : le plus simple et le plus lisible
for x in t:
    print(x)          # 10, puis 20, puis 30

# (b) par les indices : quand on a besoin de la position
for i in range(len(t)):
    print(i, t[i])    # 0 10, puis 1 20, puis 2 30

mot = "abracadabra"
n = 0
for c in mot:
    if c == "a":
        n = n + 1
# n vaut 5

5. Le slicing (tranches)

Le slicing extrait une sous-séquence d'un coup, sans boucle. Il marche pareil sur une liste et sur une chaîne, et c'est un outil à connaître par cœur.

t = [10, 20, 30, 40, 50]
t[1:3]      # [20, 30]        -> indices 1 et 2 (3 exclu)
t[:2]       # [10, 20]        -> depuis le début
t[3:]       # [40, 50]        -> jusqu'à la fin
t[:]        # [10,20,30,40,50] -> copie de toute la liste
t[::2]      # [10, 30, 50]    -> un élément sur deux (pas = 2)

s = "informatique"
s[0:4]      # 'info'
s[-4:]      # 'ique'

6. Mutable vs immuable, la différence qui piège

C'est LE point à ne pas rater. Une liste se modifie en place ; une chaîne ne se modifie jamais. Sur une chaîne, toute « modification » produit en réalité une nouvelle chaîne.

# Liste : mutable -> on change la case
t = [10, 20, 30]
t[0] = 99
print(t)          # [99, 20, 30]  (t a changé)

# Chaîne : immuable -> on reconstruit
s = "abc"
# s[0] = "X"      # interdit : TypeError
s = "X" + s[1:]   # on fabrique une nouvelle chaîne
print(s)          # 'Xbc'

a = [1, 2, 3]
b = a          # b est un ALIAS de a (même liste)
b.append(4)
print(a)       # [1, 2, 3, 4]  -> a a changé aussi !

c = a[:]       # vraie copie (tranche complète)
c.append(9)
print(a)       # [1, 2, 3, 4]  -> a est intacte

7. Exercices d'application

À faire de tête avant d'ouvrir le corrigé.

t = [10, 20, 30, 40, 50, 60]
t[1:4]
t[:2]
t[3:]
t[::2]

t = [3, 1, 4, 1]
for i in range(len(t)):
    if t[i] > 2:
        print(i, t[i])

8. Erreurs classiques (les pièges qui coûtent des points)

Quatre pièges reviennent sans arrêt dans les copies. Repère-les avant qu'ils ne te coûtent cher.

8. Pour aller plus loin

Tu maîtrises les bases : indexer, parcourir, découper, et distinguer mutable et immuable. Les deux fiches sœurs approfondissent chacun des deux objets, et les chapitres d'algorithmique réinvestissent tout ce que tu viens de voir.

• Manipuler les listes (slug manipuler-les-listes) — méthodes utiles (append, sort, in), listes en compréhension, listes de listes.
• Chaînes de caractères (slug chaines-de-caracteres) — méthodes (split, upper, find), formatage et parcours de texte.
• Patrons d'algorithmes — accumulateur (somme, compte), recherche d'un maximum, recherche d'un élément, qui s'appuient tous sur le parcours d'une séquence.