💻Python : listes et dictionnaires

Une liste range plusieurs valeurs dans un ordre précis, entre crochets et séparées par des virgules :

notes = [12, 9, 15, 8, 17]

Chaque élément a un indice : on commence à compter à 0. notes[0] vaut 12, notes[1] vaut 9, etc. La fonction len(notes) donne le nombre d'éléments (ici 5), donc le dernier indice valide est len(notes) - 1 (ici 4).

Les indices négatifs comptent depuis la fin : notes[-1] est le dernier (17) et notes[-2] l'avant-dernier (8).

Pour repérer un élément :

1. Compte les positions à partir de 0, de gauche à droite.
2. L[i] désigne l'élément de position i.
3. Le dernier élément est L[len(L) - 1], ou plus simplement L[-1].
4. Un indice trop grand (≥ len(L)) provoque une erreur IndexError.

Le piège classique : une liste de 5 éléments a ses indices de 0 à 4, pas de 1 à 5. L[len(L)] est toujours une erreur.

Une tranche extrait une sous-liste avec la syntaxe L[debut:fin]. On prend les éléments de l'indice debut (inclus) jusqu'à fin (exclu) :

L = [10, 20, 30, 40, 50]
print(L[1:4])   # [20, 30, 40]
print(L[:3])    # [10, 20, 30]  (du début à l'indice 3 exclu)
print(L[2:])    # [30, 40, 50]  (de l'indice 2 jusqu'à la fin)

Si on omet debut, la tranche part de 0 ; si on omet fin, elle va jusqu'à la fin. Une tranche ne modifie pas la liste de départ : elle en construit une nouvelle.

⭐ Pour les curieux — pourquoi ça marche ? Quand $a$ et $b$ sont deux indices valides avec $a \le b$, pourquoi la tranche L[a:b] contient-elle exactement $b - a$ éléments ? Parce qu'elle prend les indices $a, a+1, \dots, b-1$ (la fin est exclue) : ce sont les entiers de $a$ à $b-1$, et il y en a $(b-1) - a + 1 = b - a$. C'est le même décompte que les barreaux d'une échelle : du barreau $a$ au barreau $b$, il y a $b - a$ intervalles, donc $b - a$ pas. Vérifie avec L[1:4] : les indices retenus sont $1, 2, 3$, soit $4 - 1 = 3$ éléments — et c'est précisément la « fin exclue » qui rend la soustraction aussi propre : si la fin était incluse, il faudrait écrire l'embêtant $b - a + 1$.

Pour compter les éléments d'une tranche L[a:b] : il y en a b - a (quand a et b sont dans la liste). L[1:4] contient 4 - 1 = 3 éléments.

« fin exclue » : L[1:4] ne contient pas L[4].

On parcourt une liste avec une boucle for. Deux styles :

notes = [12, 9, 15]
# 1) parcourir les valeurs
for note in notes:
    print(note)
# 2) parcourir les indices
for i in range(len(notes)):
    print(notes[i])

Pour agrandir une liste, on utilise .append(valeur) qui ajoute la valeur à la fin. On peut aussi remplacer un élément par affectation : notes[0] = 20.

Schéma très fréquent : partir d'une liste vide [] et la remplir au fil d'une boucle :

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

range(n) produit les entiers 0, 1, …, n-1 : il y en a n, et le dernier est n - 1. Donc range(len(L)) donne exactement les indices valides de L.

Une liste en compréhension construit une liste en une seule ligne, directement à partir d'une autre :

carres = [i * i for i in range(5)]      # [0, 1, 4, 9, 16]
doubles = [2 * x for x in [3, 5, 8]]    # [6, 10, 16]

On peut filtrer avec un if à la fin : on ne garde que les éléments qui vérifient la condition :

pairs = [n for n in range(10) if n % 2 == 0]   # [0, 2, 4, 6, 8]

Pour lire [expression for x in source if condition] :

1. for x in source : on prend chaque élément de la source ;
2. if condition (facultatif) : on ne garde que ceux qui passent le test ;
3. expression : on calcule la valeur à mettre dans la nouvelle liste.

Une compréhension remplace souvent une liste vide + un for + un append. Les deux écritures donnent le même résultat : choisis celle que tu lis le mieux.

Un dictionnaire associe à chaque clé une valeur. On l'écrit entre accolades, sous la forme clé: valeur :

ages = {"Léa": 16, "Tom": 15, "Zoé": 17}
print(ages["Tom"])    # 15  (on accède par la clé, pas par un indice)
ages["Sam"] = 14       # ajoute une nouvelle paire clé/valeur

Contrairement à une liste, on n'accède pas par un indice 0, 1, 2… mais par la clé. len(d) donne le nombre de paires.

Pour parcourir un dictionnaire d :

• for cle in d: parcourt les clés ;
• d.values() donne les valeurs (utile avec sum, max, …) ;
• for cle in d: puis d[cle] permet d'avoir clé et valeur.

Tester "Léa" in ages répond True si la clé existe.

d[cle] plante (KeyError) si la clé n'existe pas. Pour compter des occurrences, pense à initialiser : if x in d: d[x] += 1 sinon d[x] = 1.