Listes et tuples en Python

Une liste conserve des valeurs dans un ordre choisi. Écris les éléments entre crochets, séparés par des virgules. Chaque élément a une position : des valeurs répétées occupent donc des places distinctes.

Construire une liste et mesurer sa longueur

scores = [88, 92, 75]
print(scores)
print(len(scores))

Sortie :

[88, 92, 75]
3

len() compte les éléments, et non la plus grande valeur ou la dernière position. Les listes peuvent contenir des types différents, comme dans [3, "three", 3.0, True], même si regrouper des données liées facilite généralement leur traitement. [] et list() créent tous deux une liste vide. Sa longueur est 0 et elle peut grandir à mesure que le programme recueille des valeurs.

list() peut aussi recueillir les éléments d’un itérable, un objet qu’une boucle for peut parcourir. list(range(4)) donne [0, 1, 2, 3]. list("cat") donne ['c', 'a', 't'] : la chaîne fournit un caractère à la fois. Le résultat est une nouvelle liste.

Compter les positions à partir de zéro

Un indice désigne une position. Python commence à 0 : les trois notes ont donc les indices 0, 1 et 2.

Les indices négatifs se comptent à rebours depuis la fin. Pour une liste de longueur n, les indices valides vont de -n à n - 1. Le dernier élément est scores[len(scores) - 1], ou plus simplement scores[-1]. -0 vaut toujours 0 ; il ne désigne pas la dernière position.

Reconnaître un indice invalide

scores[3] lève IndexError car il n’existe pas de quatrième élément. scores[len(scores)] commet la même erreur : le nombre d’éléments dépasse d’une unité le dernier indice positif ou nul. Une liste vide n’a aucun indice d’élément valide, pas même -1.

Un indice de liste doit être un entier, et non un flottant. scores[1.0] lève TypeError, même si 1,0 a une valeur entière. / produit un flottant, donc scores[len(scores) / 2] échoue aussi. Avec cette liste de trois éléments, len(scores) // 2 produit l’entier 1, et scores[1] vaut 92.

Vérifier si une valeur est présente

Le test d’appartenance vérifie les valeurs, pas les positions :

colors = ["red", "green"]
print("green" in colors)
print("Green" in colors)
print("blue" not in colors)

Sortie :

True
False
True

in et not in renvoient des valeurs booléennes et fonctionnent aussi sur les listes vides. La comparaison des chaînes est sensible à la casse : "Green" et "green" ne correspondent donc pas. Un test d’appartenance est utile avant une opération qui exige la présence d’une valeur, comme sa suppression ou la recherche de sa position.

Une tranche sélectionne une suite d’éléments et renvoie une nouvelle séquence. Pour une liste, le résultat est une autre liste, même lorsqu’elle ne contient qu’un élément ou aucun.

Inclure le début et exclure la fin

letters = ["a", "b", "c", "d", "e", "f"]
print(letters[1:4])

Sortie :

['b', 'c', 'd']

Les positions sélectionnées sont 1, 2 et 3. La position 4 est la borne de fin, donc 'e' est exclu. Avec un pas de 1 et des bornes qui vérifient 0 <= start <= stop <= len(letters), le nombre d’éléments sélectionnés est stop - start. Ici, il vaut 3. letters[4:2] donne [], car une tranche parcourue vers l’avant ne peut pas atteindre une fin située avant son début.

Omettre une borne

Les bornes négatives se comptent depuis la fin, comme les indices négatifs. letters[:n] et letters[n:] divisent la liste à une même borne. Concaténer ces deux tranches reconstitue son contenu dans l’ordre d’origine.

Contrôler le pas

La forme complète est values[start:stop:step]. Un pas de 2 sélectionne une position, en saute une et sélectionne la suivante. letters[::2] donne ['a', 'c', 'e'], tandis que letters[1::2] donne ['b', 'd', 'f'].

Un pas négatif revient en arrière. letters[::-1] part du dernier élément et produit ['f', 'e', 'd', 'c', 'b', 'a']. Pour une tranche bornée parcourue à rebours, letters[4:1:-1] visite les indices 4, 3 et 2, ce qui donne ['e', 'd', 'c'] ; la fin reste exclue. Un pas de 0 lève ValueError car il ne permet pas de passer à une autre position.

Distinguer une borne d’une position

Les bornes d’une tranche peuvent dépasser l’une ou l’autre extrémité. Python les ramène aux extrémités : letters[4:100] vaut ['e', 'f'] et letters[10:] vaut []. Ces tranches ne lèvent pas IndexError. La lecture de l’élément unique letters[10] le fait.

letters[2] est la chaîne 'c'. letters[2:3] est la liste ['c']. Les deux-points changent la nature du résultat, ce qui compte lorsque le code suivant attend une chaîne ou une liste.

Utiliser le résultat

Après first_three = letters[:3], l’affectation first_three[0] = "z" ne modifie que cette nouvelle liste externe ; letters[0] reste égal à 'a'. Une tranche complète est une copie superficielle : les éléments mutables imbriqués peuvent donc rester partagés.

Les chaînes et les tuples suivent les mêmes règles de bornes et de pas. Le résultat conserve le type de la séquence d’origine : "python"[1:4] donne 'yth', et (10, 20, 30)[1:] donne (20, 30).

Les listes prennent en charge des opérateurs pour construire des séquences et des fonctions pour résumer leurs valeurs. Vérifie si une opération crée une nouvelle liste, produit un nombre ou renvoie du texte : ces résultats ont des usages différents.

Concaténer ou répéter des listes

+ concatène deux listes et crée une nouvelle liste. [1, 2] + [3] donne [1, 2, 3] sans modifier les listes de départ. Les deux opérandes doivent être des listes : [1, 2] + 3 lève TypeError. Place une valeur supplémentaire seule dans une liste à un élément lorsque tu utilises +.

* répète la séquence. [0] * 4 donne [0, 0, 0, 0], et ["ab", "cd"] * 2 donne ['ab', 'cd', 'ab', 'cd']. L’opérateur répète les éléments, pas les caractères de chaque chaîne. Un nombre de répétitions nul ou négatif donne []. counts = [0] * 7 fournit sept compteurs initiaux. Répéter une liste interne la partage entre plusieurs positions, ce qui compte lorsque ces lignes sont modifiées par la suite.

Total, valeurs extrêmes et moyenne

sum() additionne des nombres. Cette fonction ne concatène pas les chaînes ; sum(["a", "b"]) lève TypeError. min() et max() trouvent les plus petits et les plus grands éléments, qui doivent donc pouvoir être comparés entre eux. Les listes composées uniquement de chaînes fonctionnent : max(["pear", "apple"]) donne 'pear' selon l’ordre caractère par caractère. Une liste vide n’a ni minimum ni maximum et lève ValueError pour chacun de ces appels.

La moyenne est le total divisé par le nombre d’éléments :

temps = [18.5, 21.0, 19.5, 23.0]
if temps:
    total = sum(temps)
    mean = total / len(temps)
    print(total, mean)

Sortie :

82.0 20.5

La condition fonctionne parce que les listes vides sont considérées comme fausses et les listes non vides comme vraies. Sans cette condition de garde, calculer la moyenne de [] diviserait par zéro et lèverait ZeroDivisionError. Choisis ce que le programme doit faire lorsqu’il n’existe aucune mesure, par exemple renvoyer None.

Comparer des séquences dans l’ordre

== vérifie que les éléments aux mêmes positions sont égaux. [1, 2, 3] == [1, 2, 3] vaut True ; [1, 2, 3] == [3, 2, 1] vaut False.

Pour < et >, compare les éléments depuis la gauche et arrête-toi à la première paire inégale. [2, 9] < [3, 0] vaut True car 2 est inférieur à 3. Les valeurs 9 et 0 ne décident de rien. Lorsqu’une liste constitue le début d’une autre, la plus courte vient en premier : [2] < [2, 0] vaut True.

Passer du texte aux listes et inversement

colors = "red,green,blue".split(",")
print(colors)
print(", ".join(["red", "green"]))

Sortie :

['red', 'green', 'blue']
red, green

split() découpe une chaîne à son séparateur. join() est appelée sur le séparateur et le place entre les chaînes fournies. Chaque élément doit être une chaîne. Pour assembler des nombres, construis d’abord une liste de leurs résultats obtenus avec str() ; passer directement [1, 2] à join() lève TypeError.

Les listes sont mutables : un programme peut modifier leur contenu après leur création. Une méthode appartient à un objet et s’appelle avec un point, comme dans cart.append("eggs"). Son effet sur la liste et sa valeur de retour sont deux choses distinctes.

Ajouter un ou plusieurs éléments

cart = ["milk"]
cart.append("eggs")
cart.extend(["tea", "jam"])
print(cart)

Sortie :

['milk', 'eggs', 'tea', 'jam']

append(x) ajoute exactement un élément à la fin. Si x est une liste, cette liste entière devient un seul élément imbriqué. En partant de ['milk', 'eggs'], cart.append(["tea", "jam"]) produit ['milk', 'eggs', ['tea', 'jam']], de longueur 3.

extend(iterable) ajoute séparément les éléments fournis par l’itérable. Ajouter les éléments de ["tea", "jam"] porte la longueur du panier à 4. Avec "ab", les caractères 'a' et 'b' sont ajoutés séparément ; ajoute la chaîne comme un seul élément pour conserver 'ab'.

insert(i, x) ajoute un élément avant la position actuelle i. Après nums = [10, 30] et nums.insert(1, 20), la liste vaut [10, 20, 30]. Les éléments suivants sont décalés vers la droite. insert(0, x) ajoute au début ; un indice au-delà de la fin ajoute l’élément à la fin sans erreur d’indice.

Supprimer par position ou par valeur

Avec nums = [10, 20, 30], last = nums.pop() sauvegarde 30 et laisse [10, 20]. nums.pop(0) renvoie ensuite 10 et laisse [20]. Une liste vide ou une position invalide conduit pop() à lever IndexError.

remove() prend une valeur. Avec pets = ["cat", "dog", "cat"], pets.remove("cat") laisse ['dog', 'cat']. Seule la première occurrence disparaît. Si la valeur est absente, remove() lève ValueError. Utilise un test d’appartenance lorsqu’elle risque d’être absente. Pour supprimer toutes les occurrences de 'cat', utilise :

while "cat" in pets:
    pets.remove("cat")

Avec [5, 0, 7], remove(0) supprime la valeur 0 et laisse [5, 7] ; pop(0) retire la valeur à la position 0, ce qui donne [0, 7]. Le sens de l’argument détermine la méthode à choisir.

del peut supprimer une partie : à partir de [5, 6, 7, 8], del nums[1] laisse [5, 7, 8], puis del nums[0:2] laisse [8]. clear() laisse la liste existante vide.

Bien distinguer la valeur de retour

append, extend, insert, remove et clear renvoient None. Écris cart.append("tea") seul sur sa ligne. Écrire cart = cart.append("tea") fait référence à None avec cart ; un appel ultérieur à cart.append("jam") lève AttributeError. Ne sauvegarde le résultat d’une méthode que lorsqu’il fournit une valeur dont le programme a besoin, comme le fait last = cart.pop().

Trouver une valeur, la compter et la remplacer sont des opérations différentes. Utilise un test d’appartenance lorsque tu as besoin d’une réponse par oui ou par non, une méthode de recherche lorsque tu as besoin d’une position et une affectation lorsque tu veux modifier la liste.

Trouver la première position correspondante

days = ["Mon", "Tue", "Wed", "Tue"]
print(days.index("Tue"))
print(days.index("Tue", 2))
print(days.count("Tue"))
print(days.count("Sun"))

Sortie :

1
3
2
0

index(x) renvoie la première position qui contient une valeur égale à x. Son argument de début facultatif indique à Python où commencer la recherche. days.index("Tue", 2) ignore la correspondance à la position 1 et trouve celle de la position 3. Le résultat reste un indice dans toute la liste, et non un décompte depuis le nouveau point de départ.

index() lève ValueError lorsque la valeur est absente. Les listes n’ont pas de méthode find() qui renvoie -1. Si une valeur risque d’être absente, teste d’abord son appartenance :

if "Sun" in days:
    position = days.index("Sun")
    print(position)

Ce code n’affiche rien car 'Sun' est absent. count(x) peut être utilisé sans cette condition de garde : la méthode renvoie 0 lorsqu’il n’y a aucune correspondance. Ces opérations utilisent l’égalité, donc [1, 2.0].count(2) vaut 1. Le texte reste sensible à la casse : 'tue' n’est pas égal à 'Tue'.

Remplacer un élément existant

prices = [4.5, 3.0, 7.25]
prices[1] = 3.5
print(prices)

Sortie :

[4.5, 3.5, 7.25]

L’ancienne deuxième valeur est écrasée et la longueur reste 3. L’indice doit exister : prices[3] = 1.0 lève IndexError. Pour ajouter à la fin, utilise append().

Le remplacement utilise un emplacement existant. L’insertion crée un emplacement supplémentaire avant la position sélectionnée.

Remplacer une partie par affectation de tranche

nums = [1, 2, 3, 4, 5]
nums[1:3] = [20, 30, 40]
print(nums)
nums[0:2] = []
print(nums)

Sortie :

[1, 20, 30, 40, 4, 5]
[30, 40, 4, 5]

La première affectation remplace les deux éléments d’indices 1 et 2 par trois nouveaux éléments, ce qui augmente la longueur de la liste d’une unité. Une tranche contiguë ordinaire peut être remplacée par une séquence plus courte ou plus longue. Affecter [] supprime la partie sélectionnée. Cette opération modifie la liste d’origine ; elle diffère de la lecture d’une tranche dans une nouvelle variable.

Modifier du texte en construisant un nouveau texte

Une chaîne est immuable, donc word = "cat" suivi de word[0] = "b" lève TypeError. Construis une nouvelle chaîne avec word = "b" + word[1:], ou crée une liste de caractères, modifie-la et assemble-la :

letters = list("cat")
letters[0] = "b"
word = "".join(letters)
print(word)

Sortie :

bat

Une boucle peut utiliser les valeurs d’une liste, leurs positions ou les deux. Choisis la forme qui fournit ce dont le corps de la boucle a besoin. Pour modifier la liste, vérifie aussi si l’instruction modifie un élément ou crée simplement une nouvelle liaison pour un nom local.

Utiliser directement les éléments

for name in ["Ana", "Ben"]:
    print("Hi", name)

Sortie :

Hi Ana
Hi Ben

La boucle parcourt chaque élément dans l’ordre. À chaque passage, name fait référence à l’élément courant. Affecter une autre valeur à name ne remplace pas cet élément dans la liste. Dans for r in readings: r = 0, seul le nom r change de liaison.

Utiliser les positions pour remplacer des éléments

readings = [3, -1, 4, -5]
for i in range(len(readings)):
    if readings[i] < 0:
        readings[i] = 0
print(readings)

Sortie :

[3, 0, 4, 0]

range(len(readings)) fournit 0, 1, 2 et 3. À l’indice 1, la condition est vraie, donc l’affectation d’élément remplace -1. À l’indice 3, elle remplace -5. Les mesures positives conservent leurs valeurs. Utiliser range(len(readings) + 1) atteindrait aussi l’indice 4, qui n’existe pas.

Obtenir une position et un élément ensemble

enumerate() fournit des paires. Dépaquette chaque paire dans l’en-tête de la boucle :

for i, name in enumerate(["Ana", "Ben"]):
    print(i, name)

Sortie :

0 Ana
1 Ben

enumerate(names, start=1) fournit des numéros à partir de 1 pour un affichage numéroté. Ces numéros ne sont plus les indices de la liste qui commencent à zéro. Pour parcourir la liste du dernier élément au premier sans la modifier, utilise for item in reversed(names):. Pour obtenir les indices à rebours, utilise range(len(names) - 1, -1, -1) ; une liste de trois éléments donne 2, 1, 0.

Associer deux listes

names = ["Ana", "Ben"]
scores = [90, 85]
for name, score in zip(names, scores):
    print(name, score)

Sortie :

Ana 90
Ben 85

zip() associe les éléments de même position et s’arrête à la fin de l’entrée la plus courte. Si chaque enregistrement compte, vérifie les longueurs avant de l’utiliser ; sinon, un dernier nom sans correspondance sera ignoré.

Contrôler un indice avec while

Une boucle while a besoin d’un indice de départ, d’une vérification de borne et d’un pas :

i = 0
while i < len(readings):
    print(readings[i])
    i += 1

Oublier l’incrémentation empêche cette boucle de se terminer. Utiliser <= atteint len(readings) et provoque IndexError.

Éviter de décaler les éléments pendant une boucle for

Supprimer des éléments change la position de ceux qui suivent. Avec [1, 2, 2, 3], retirer chaque 2 rencontré pendant le parcours de cette même liste laisse [1, 2, 3] : le second 2 est décalé à la position qui vient d’être visitée. Parcours nums[:] si les suppressions doivent toucher l’originale, ou construis une nouvelle liste des éléments à conserver. Ajouter des éléments à la liste en cours de parcours peut aussi produire un comportement inattendu.

De nombreux problèmes sur les listes utilisent quelques schémas de boucle réutilisables. Décide du résultat dont le programme a besoin, initialise-le avant la boucle et mets-le à jour à l’arrivée de chaque élément.

Accumuler un total ou un compte

sales = [120, 75, 205, 50]
total = 0
for sale in sales:
    total += sale
print(total)

Sortie :

450

Le total cumulé prend successivement les valeurs 120, 195, 400 et 450. Placer total = 0 dans la boucle effacerait le travail précédent à chaque passage. sum(sales) calcule directement ce total.

Un compteur ajoute 1 pour chaque élément qui satisfait la condition, et non la valeur de cet élément :

scores = [72, 45, 60, 88, 59]
passed = 0
for score in scores:
    if score >= 60:
        passed += 1
print(passed)

La sortie est 3 : 72, 60 et 88 satisfont la condition. > 60 donnerait 2 car cette condition exclut exactement 60. Fais correspondre la formulation du seuil et la comparaison.

Trouver une valeur extrême

Pour une liste non vide, initialise un maximum courant à partir d’un élément réel :

temps = [-3, -8, -1, -5]
highest = temps[0]
for temp in temps[1:]:
    if temp > highest:
        highest = temp
print(highest)

La sortie est -1. Partir de 0 conserverait à tort 0 car toutes les mesures sont inférieures. Utilise < pour trouver le minimum, ou utilise les fonctions natives min() et max(). Vérifie que la liste n’est pas vide avant d’accéder à son premier élément.

S’arrêter à la première correspondance

values = [4, 0, -2, 5, -7]
position = -1
for i, value in enumerate(values):
    if value < 0:
        position = i
        break
print(position)

La sortie est 2. -1 est un signal choisi pour indiquer l’absence de correspondance ; ne l’utilise pas comme indice si la recherche a échoué, car c’est aussi un indice valide pour le dernier élément. break conserve la position de la première correspondance. Sans cette instruction, les correspondances suivantes écraseraient le résultat.

x in values recherche une valeur précise, et values.index(x) trouve sa première position. Une condition comme « est négatif » nécessite une recherche fondée sur une condition, comme la boucle ci-dessus.

Filtrer ou transformer

Un filtre conserve certains éléments d’origine :

passing = []
for score in scores:
    if score >= 60:
        passing.append(score)
print(passing)

La sortie est [72, 60, 88] ; scores conserve ses cinq éléments. Une transformation calcule un nouvel élément à partir de chaque élément d’origine :

nums = []
for text in ["3", "14", "15"]:
    nums.append(int(text))
print(nums, sum(nums))

La sortie est [3, 14, 15] 32. La conversion a lieu avant l’addition ; additionner les chaînes d’origine échoue.

Renvoyer un résultat réutilisable

def average(values):
    if not values:
        return None
    return sum(values) / len(values)

average([18.5, 21.0, 19.5, 23.0]) renvoie 20.5. Pour une liste vide, la fonction renvoie None sans diviser par zéro, et elle laisse la liste reçue inchangée.

Une liste imbriquée est une liste qui contient d’autres listes. Un tableau utilise généralement une liste interne par ligne. Chaque accès sélectionne un niveau : lire une cellule demande donc deux indices.

Sélectionner la ligne, puis la cellule

grid = [[1, 2, 3], [4, 5, 6]]
print(grid[1])
print(grid[1][2])
print(len(grid), len(grid[0]))

Sortie :

[4, 5, 6]
6
2 3

grid[1] sélectionne la deuxième ligne ; [2] sélectionne ensuite le troisième élément de cette ligne. len(grid) compte les lignes, tandis que len(grid[0]) compte les cellules de la première ligne. Ce tableau rectangulaire comporte six cellules. grid[2][1] échoue dès le premier accès car la ligne 2 n’existe pas. Inverser les positions de ligne et de colonne peut sélectionner la mauvaise cellule ou lever IndexError.

Modifier une cellule ou une ligne entière

grid[0][1] = 20 modifie la deuxième cellule de la première ligne et donne [[1, 20, 3], [4, 5, 6]]. grid[0] = [0, 0, 0] remplace toute la première ligne. Le nombre d’accès indique le niveau qui est remplacé.

Parcourir chaque valeur

grid = [[1, 2, 3], [4, 5, 6]]
total = 0
for row in grid:
    for value in row:
        total += value
print(total)

Sortie :

21

La boucle interne termine la première ligne avant que la boucle externe ne fournisse la deuxième. Elle additionne 1, 2, 3, puis 4, 5, 6. Le total d’une colonne utilise une position fixe dans chaque ligne :

column_total = 0
for row in grid:
    column_total += row[1]
print(column_total)

La sortie est 7, obtenue à partir de 2 et 5. Ce code exige que chaque ligne ait un deuxième élément.

Les lignes ne doivent pas nécessairement avoir la même longueur. [[1], [2, 3]] est une liste imbriquée valide. Les boucles imbriquées directes parcourent toujours chaque valeur car chaque boucle interne suit sa propre ligne. Supposer que toutes les lignes ont len(grid[0]) éléments ferait manquer des valeurs ici. Pour compter les cellules d’un tel tableau, additionne len(row) pour chaque ligne.

Construire des lignes indépendantes

table = []
for r in range(3):
    table.append([0] * 4)
table[0][0] = 1
print(table)

Sortie :

[[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Chaque passage crée une nouvelle liste de quatre éléments. Le raccourci [[0] * 4] * 3 répète une référence à une même ligne ; modifier sa première cellule apparaîtrait dans les trois lignes.

Stocker des enregistrements

Une ligne peut décrire un enregistrement plutôt qu’une ligne de nombres. Avec students = [["Ana", 90], ["Ben", 85]], students[1][0] vaut 'Ben' et students[1][1] vaut 85. Lorsque chaque enregistrement contient deux éléments, for name, score in students: les dépaquette dans des noms utiles. Des listes de tuples peuvent représenter le même type d’enregistrements.

Un tuple stocke des éléments dans l’ordre, comme une liste, mais ses éléments ne peuvent pas être remplacés, ajoutés ou supprimés. C’est l’immuabilité. Les tuples conviennent aux groupes fixes comme les coordonnées, les dates et les enregistrements ; les listes conviennent aux collections qui grandissent ou changent.

Créer et lire un tuple

point = (3, 4)
date = (2024, 7, 15)
print(date[0])
print(date[1:])
print(len(date))

Sortie :

2024
(7, 15)
3

L’accès aux tuples par indice, les indices négatifs, les tranches et l’appartenance suivent les mêmes règles que pour les listes. Une tranche de tuple renvoie un tuple. Tu peux parcourir un tuple avec une boucle ou utiliser +, *, min, max, sum, count et index lorsque ses éléments conviennent à l’opération.

La virgule crée un tuple non vide. t = 3, 4 produit (3, 4) même sans parenthèses. Un tuple à un élément a besoin d’une virgule finale :

list(t) convertit les éléments d’un tuple en une liste modifiable.

Comprendre ce qui ne peut pas changer

point[0] = 5 lève TypeError car un tuple ne permet pas l’affectation d’élément. Les tuples n’ont pas les méthodes append, remove ou sort ; point.append(5) lève AttributeError.

Un nom peut toutefois être lié à un nouveau tuple :

point = (3, 4)
point = (5,) + point[1:]
print(point)

La sortie est (5, 4). L’expression crée un nouveau tuple ; elle ne modifie pas l’ancien.

Un tuple peut contenir un élément mutable

t = ([1, 2], "x")
t[0].append(3)
print(t)

Sortie :

([1, 2, 3], 'x')

La première position contient toujours la même liste. Le contenu de cette liste a changé. t[0] = [9] remplacerait l’objet à cette position et est interdit. L’immuabilité du tuple externe ne fige pas une liste interne.

Adapter la structure à son rôle

Utilise (x, y) pour des coordonnées, (255, 128, 0) pour une couleur RVB ou ("Ana", 90) pour un enregistrement à deux champs. Chaque position a un sens particulier. Utilise une liste pour toutes les notes d’une classe ou les articles d’un panier, dont le nombre et l’ordre peuvent changer. Une liste de tuples, comme [("Ana", 90), ("Ben", 85)], associe une collection modifiable à des enregistrements dont les positions sont fixes.

Un tuple de nombres ou de chaînes peut servir de clé de dictionnaire, comme dans {(0, 0): "origin"}. Les clés doivent être hachables, c’est-à-dire qu’elles respectent les règles de Python permettant un accès stable par clé. Une liste n’est pas hachable, et un tuple qui contient une liste ne l’est pas non plus.

Comparer des tuples

La comparaison commence à gauche et s’arrête à la première paire inégale. (1, 2, 5) < (1, 3, 0) vaut True : les premières valeurs sont égales et 2 est inférieur à 3. Cette même règle ordonne une liste d’enregistrements sous forme de tuples lorsqu’aucune fonction clé n’est fournie.

L’empaquetage rassemble des valeurs dans un tuple. Le dépaquetage affecte dans l’ordre les éléments d’un itérable à des noms. Ensemble, ils permettent au code de donner des noms clairs aux champs d’un enregistrement et de recevoir plusieurs résultats d’une fonction.

Associer les noms aux valeurs

record = "Ana", 34, "Lima"
name, age, city = record
print(name, age, city)

Sortie :

Ana 34 Lima

Le premier élément devient name, le deuxième age et le troisième city. Le dépaquetage fonctionne aussi sur les listes et les chaînes : first, second = [10, 20] et a, b, c = "xyz" affectent leurs éléments dans l’ordre. user, domain = "ana@example.com".split("@") donne 'ana' et 'example.com' car le découpage produit deux parties.

Sans nom étoilé, les nombres doivent correspondre exactement. x, y = (1, 2, 3) lève ValueError car il y a trop de valeurs ; x, y, z = (1, 2) lève ValueError car il n’y en a pas assez. Python ne supprime pas les éléments supplémentaires sans avertissement.

Échanger des valeurs sans risque

a = 1
b = 2
a, b = b, a
print(a, b)

La sortie est 2 1. Python évalue tout le membre de droite avec les anciennes valeurs avant d’effectuer les affectations aux noms de gauche. La tentative en deux instructions a = b puis b = a perd l’ancienne valeur de a et donne la valeur 2 aux deux noms.

Recueillir les éléments restants

Un nom étoilé reçoit une liste des valeurs restantes :

first, *rest = [5, 6, 7, 8]
print(first, rest)
*init, last = [5, 6, 7, 8]
print(init, last)

Sortie :

5 [6, 7, 8]
[5, 6, 7] 8

L’étoile peut aussi se trouver entre des noms non étoilés : first, *middle, last = (5, 6, 7, 8) donne à middle la liste [6, 7]. L’objet recueilli est toujours une liste, même lors du dépaquetage d’un tuple. head, *rest = [5] laisse rest égal à []. Il doit y avoir assez d’éléments pour les noms non étoilés, et un seul nom étoilé est autorisé dans un même dépaquetage.

Dépaqueter pendant une boucle

for name, score in [("Ana", 90), ("Ben", 85)]:
    print(name, score)

Sortie :

Ana 90
Ben 85

L’en-tête dépaquette chaque enregistrement à son arrivée. C’est aussi le fonctionnement de for i, item in enumerate(values): et de for a, b in zip(left, right): : chaque itération fournit une paire.

Renvoyer plusieurs résultats

def min_max(values):
    return min(values), max(values)

low, high = min_max([7, 2, 9])
result = min_max([7, 2, 9])
print(low, high)
print(result)

Sortie :

2 9
(2, 9)

La fonction renvoie un seul tuple. L’appelant peut le dépaqueter ou conserver l’objet entier. Par convention, un trait de soulignement désigne une valeur dont le code n’a pas besoin : _, month, day = (2024, 7, 15) conserve le mois et le jour sous des noms descriptifs. _ reste une variable ordinaire, et non une opération spéciale de rejet.

Une variable est un nom qui fait référence à un objet. Une affectation change l’objet auquel un nom fait référence ; elle ne copie pas automatiquement l’objet. Avec une liste mutable, deux noms peuvent donc donner accès aux mêmes modifications.

Suivre les références

a = [1, 2, 3]
b = a
b.append(4)
print(a)
print(b)

Sortie :

[1, 2, 3, 4]
[1, 2, 3, 4]

Il y a une liste et deux noms pour la désigner. b est un alias de a. L’ajout modifie l’objet partagé : lire la liste par l’un ou l’autre nom montre donc l’élément ajouté. Pour suivre ce code, dessine deux flèches, une depuis chaque nom, vers la même liste.

Distinguer égalité et identité

a = [1, 2]
b = a
c = [1, 2]
print(a == b, a == c)
print(a is b, a is c)

Sortie :

True True
True False

== compare les contenus ; is teste s’il s’agit du même objet. c a un contenu égal, mais désigne une liste distincte. id(x) donne le numéro d’identité d’un objet : id(a) == id(b) donne donc le même résultat que a is b. Les numéros d’identité n’indiquent pas quels éléments une liste contient.

Utilise == pour vérifier si les contenus correspondent. Utilise is pour vérifier le partage ou tester un objet particulier comme None. Un nouveau littéral de liste crée une liste distincte : a is [1, 2] est donc faux pour une liste a existante, même si les contenus correspondent.

La mutation et la nouvelle liaison n’ont pas la même portée

Après la dernière instruction, b pointe vers une nouvelle liste. a continue de faire référence à l’objet d’origine. Créer une nouvelle liaison pour un nom ne redirige pas tous les noms qui faisaient référence à cet objet.

Suivre séparément += et +

Pour les listes, += étend la liste existante :

a = [1]
b = a
a += [2]
print(a, b)

La sortie est [1, 2] [1, 2]. En revanche :

a = [1]
b = a
a = a + [2]
print(a, b)

La sortie est [1, 2] [1]. + crée une nouvelle liste, et l’affectation fait référence à cette liste avec a. b fait toujours référence à la liste d’origine à un élément.

Chercher des alias moins visibles

row = [0, 0] suivi de table = [row, row] stocke deux fois la même ligne. table[0][0] = 5 produit [[5, 0], [5, 0]] car les deux positions donnent accès à la même liste interne.

Les nombres et les chaînes ne peuvent pas changer en place. Après x = 5, y = x, x += 1, y reste égal à 5 ; une nouvelle liaison a été créée pour x. Les positions des éléments d’un tuple restent aussi fixes, mais une liste interne peut changer. Après t = ([1], 2), u = t et t[0].append(3), u affiche ([1, 3], 2) : les deux noms donnent toujours accès au même tuple et à la même liste mutable qu’il contient.

La copie crée un nouvel objet, mais sa profondeur compte. Une nouvelle liste externe peut encore contenir des références aux listes internes d’origine.

Créer une nouvelle liste externe

a = [1, 2, 3]
b = a.copy()
b.append(4)
print(a)
print(b)
print(a is b)

Sortie :

[1, 2, 3]
[1, 2, 3, 4]
False

a[:], list(a) et a.copy() créent tous une copie superficielle d’une liste. Son conteneur externe est nouveau et les références à ses éléments sont copiées. Avec des nombres ou des chaînes immuables, remplacer ou ajouter un élément dans une liste externe laisse l’autre inchangée.

Voir ce qu’une copie superficielle partage

a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)
print(b is a, b[0] is a[0])

Sortie :

[[1, 2, 99], [3, 4]]
False True

Les deux listes externes sont différentes, mais leurs premiers éléments font référence à la même liste interne. append() modifie cet objet interne.

Remplacer un élément de b est différent. Après b[1] = [0], b a une deuxième ligne différente tandis que a[1] reste égal à [3, 4]. L’affectation change une référence dans la liste externe de b ; elle ne modifie pas l’ancienne deuxième ligne.

Copier aussi les listes imbriquées

import copy

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)
b[0].append(99)
print(a)
print(b)

Sortie :

[[1, 2], [3, 4]]
[[1, 2, 99], [3, 4]]

import copy rend le module de copie disponible. copy.deepcopy() copie récursivement la structure de listes imbriquées : les modifications des listes internes copiées ne touchent donc pas l’originale. Utilise cette fonction lorsque les modifications à ces niveaux internes doivent être indépendantes. Une copie superficielle suffit si seuls l’ordre ou les références aux éléments de la liste externe doivent changer.

Éviter les références répétées lors de la construction des lignes

table = [[0] * 3] * 2
table[0][0] = 7
print(table)

La sortie est [[7, 0, 0], [7, 0, 0]]. La multiplication a répété la référence à une seule ligne. Elle n’a pas construit deux lignes.

Construis chaque ligne dans la boucle :

table = []
for r in range(2):
    table.append([0] * 3)
table[0][0] = 7
print(table)

La sortie est [[7, 0, 0], [0, 0, 0]]. [0] * 3 seul convient à des compteurs indépendants : les entiers ne peuvent pas être modifiés, et l’affectation d’élément ne remplace qu’une position.

Choisir une copie pour une raison précise

Conserver l’ordre d’origine avant un tri exige une nouvelle liste externe. Préserver les mesures imbriquées d’origine tout en modifiant les cellules copiées exige aussi des listes internes indépendantes. Un traitement en lecture seule n’a pas besoin de copie, et une modification partagée intentionnelle peut utiliser des alias. Pour examiner un bug dans une structure imbriquée, vérifie à la fois b is a et b[0] is a[0] ; tester uniquement les listes externes ne révèle pas le partage interne.

Un paramètre de fonction est un autre nom pour l’objet fourni par l’appelant. Un argument de type liste n’est pas automatiquement copié. La fonction peut modifier cet objet, créer une nouvelle liaison pour son paramètre local ou renvoyer un nouveau résultat ; ces actions n’ont pas le même effet sur l’appelant.

Une mutation atteint l’appelant

def add_bonus(scores):
    scores.append(5)

marks = [80]
result = add_bonus(marks)
print(marks)
print(result)

Sortie :

[80, 5]
None

scores et marks font initialement référence à la même liste. L’ajout effectué par scores la modifie. Comme la fonction ne contient pas d’instruction de retour explicite, son résultat est None.

En revanche, def reset(scores): scores = [] crée une nouvelle liaison pour le seul paramètre local. Le nom marks de l’appelant fait toujours référence à son ancienne liste. Utilise scores.clear() pour vider cette liste effectivement partagée.

Conserver une liste renvoyée si nécessaire

Deux conceptions sont courantes : modifier une liste en place et renvoyer None, ou la laisser inchangée et renvoyer une nouvelle liste :

def drop_first(values):
    del values[0]

def tail(values):
    return values[1:]

Pour nums = [1, 2, 3], appeler drop_first(nums) laisse nums égal à [2, 3]. Écrire nums = drop_first(nums) lierait en revanche nums à None. En repartant de [1, 2, 3], shorter = tail(nums) donne à shorter la liste [2, 3] tandis que nums reste inchangé. Appeler tail(nums) sans conserver son résultat abandonne la nouvelle liste.

D’autres conceptions sont aussi utiles : sum() renvoie une valeur récapitulative, et pop() modifie une liste tout en renvoyant un élément. Indique clairement l’effet et la valeur de retour dans le nom ou la docstring d’une fonction.

Construire un résultat sans modifier l’entrée

def without_negatives(values):
    kept = []
    for value in values:
        if value >= 0:
            kept.append(value)
    return kept

original = [3, -2, 0, 7]
print(without_negatives(original))
print(original)

Sortie :

[3, 0, 7]
[3, -2, 0, 7]

Un appelant peut aussi protéger sa liste externe en passant une copie superficielle, comme dans drop_first(original[:]). Une opération qui modifie les listes internes nécessiterait aussi une copie à ces niveaux.

Éviter une valeur par défaut mutable partagée

def add_item(item, basket=[]):
    basket.append(item)
    return basket

La liste par défaut est créée une fois, lorsque l’instruction def s’exécute. add_item("a") renvoie ['a'], et l’appel suivant utilisant la valeur par défaut, add_item("b"), renvoie ['a', 'b']. Utilise None pour obtenir une nouvelle liste :

def add_item(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    return basket

Chaque appel sans panier crée maintenant sa propre liste. Passer un panier existant permet toujours de partager volontairement les modifications. Une fonction ne peut pas modifier un nombre ou une chaîne, ni remplacer les éléments d’un tuple, mais elle peut modifier une liste stockée dans un tuple, par exemple en appelant pair[0].append(9).

Le tri place les éléments selon leur ordre de comparaison. L’inversion renverse leur ordre actuel. Décide aussi si le programme doit modifier la liste existante ou la conserver et recevoir une nouvelle liste.

Trier en place ou conserver une nouvelle liste

nums = [3, 1, 2]
new = sorted(nums)
print(nums)
print(new)
nums.sort()
print(nums)

Sortie :

[3, 1, 2]
[1, 2, 3]
[1, 2, 3]

sorted() crée une nouvelle liste. sort() est une méthode de liste qui réorganise la liste existante et renvoie None. nums = nums.sort() fait perdre au nom sa référence à la liste et le lie à None. Écris nums.sort() seul sur sa ligne ou utilise nums = sorted(nums). print(nums.sort()) affiche None même si la liste a été réordonnée.

sorted() accepte n’importe quel itérable et renvoie toujours une liste. sorted((3, 1, 2)) donne [1, 2, 3], et sorted("cab") donne ['a', 'b', 'c']. Les chaînes et les tuples n’ont pas de méthode sort() qui agit en place.

Ordre décroissant et ordre inversé

Chaque ligne part de la liste d’origine. reverse=True demande un tri par ordre décroissant et doit être donné par son nom ; sorted(nums, True) lève TypeError. L’inversion parcourt simplement les positions existantes à rebours : elle ne produit donc pas nécessairement des valeurs décroissantes.

Vérifier les valeurs comparées

Les nombres sont triés selon leur valeur numérique, même lorsque les entiers et les flottants sont mélangés : sorted([2.5, -1, 2]) donne [-1, 2, 2.5].

Le texte est comparé caractère par caractère. sorted(["10", "9", "100"]) donne ['10', '100', '9']. Le premier caractère '1' vient avant '9', et une chaîne qui forme un préfixe vient avant une chaîne plus longue qui commence par ce préfixe. Convertis les chaînes numériques avec int() ou float() lorsque tu veux un ordre numérique.

Les majuscules A à Z viennent avant les minuscules a à z. sorted(["b", "B", "a"]) donne ['B', 'a', 'b']. L’ordre par défaut des chaînes repose sur les codes des caractères ; ce n’est pas un ordre de dictionnaire insensible à la casse.

Tous les éléments comparés doivent prendre en charge < entre eux. sorted([3, "two", 1]) lève TypeError. Nettoie ou convertis les données avant le tri.

Utiliser les positions après le tri

Pour un nombre impair de notes, le tri facilite la lecture de la valeur du milieu :

scores = [72, 95, 64, 88, 79]
ordered = sorted(scores)
median = ordered[len(ordered) // 2]
print(ordered)
print(median)

La sortie est [64, 72, 79, 88, 95] puis 79. La liste d’origine conserve l’ordre d’arrivée des notes. Ce calcul à partir d’un seul élément central s’applique aux listes non vides d’effectif impair.

Une fonction clé calcule la valeur de comparaison de chaque élément. Les éléments d’origine restent intacts dans le résultat trié. Cela permet à un programme de trier du texte selon sa longueur ou des enregistrements selon un champ choisi.

Passer une fonction, pas un appel de fonction

words = ["kiwi", "fig", "banana"]
print(sorted(words, key=len))

Sortie :

['fig', 'kiwi', 'banana']

Python appelle len une fois pour chaque élément et compare les longueurs obtenues, 4, 3 et 6. Passe key=len, sans parenthèses. key=len() essaie d’appeler immédiatement len sans argument et échoue.

Pour comparer en minuscules, utilise key=str.lower. Avec ["banana", "apple", "Cherry"], l’ordre par défaut est ['Cherry', 'apple', 'banana']. Avec key=str.lower, le résultat est ['apple', 'banana', 'Cherry']. Le C majuscule d’origine reste dans le résultat ; seules les clés de comparaison sont en minuscules.

Sélectionner un champ d’enregistrement

results = [("Ana", 90), ("Ben", 72), ("Cy", 85)]

def by_score(record):
    return record[1]

print(sorted(results, key=by_score))

Sortie :

[('Ben', 72), ('Cy', 85), ('Ana', 90)]

La fonction reçoit un enregistrement à la fois. record[1] sélectionne sa note. Ajoute reverse=True pour placer la note la plus élevée en premier. results.sort(key=by_score, reverse=True) utilise la même règle, mais modifie results lui-même.

key=by_score(results) est différent : cette expression appelle la fonction sur toute la liste et transmet son résultat comme argument de clé. Ici, ce résultat est le tuple ('Ben', 72), qui ne peut pas être appelé comme une fonction ; le tri lève donc TypeError.

Utiliser plusieurs champs

Sans clé, les tuples comparent leurs premiers éléments, puis leurs deuxièmes éléments pour départager les premiers éléments égaux. Trier [("Ben", 72), ("Ana", 90), ("Ana", 85)] donne [('Ana', 85), ('Ana', 90), ('Ben', 72)].

Une clé peut renvoyer un tuple pour choisir un autre ordre de champs :

def rank_key(record):
    return (-record[1], record[0])

results = [("Dee", 85), ("Ana", 90), ("Cy", 85)]
print(sorted(results, key=rank_key))

Sortie :

[('Ana', 90), ('Cy', 85), ('Dee', 85)]

Prendre l’opposé de la note donne des clés plus petites aux notes plus élevées. Les noms départagent ensuite les notes égales par ordre croissant. reverse=True appliqué à une clé (score, name) dont la note est positive inverserait les deux champs, y compris les noms, et ne respecterait donc pas cette règle qui combine deux sens de tri.

Conserver l’ordre des éléments à clés égales

Le tri de Python est stable : les éléments dont les clés sont égales conservent leur ordre d’entrée. Trier ["bb", "a", "cc", "d"] selon len donne ['a', 'd', 'bb', 'cc']. Parmi les deux mots d’une lettre ex aequo, 'a' reste en premier ; parmi ceux de deux lettres, 'bb' reste en premier. La stabilité permet aussi de trier d’abord selon un champ secondaire, puis selon le champ principal.

min() et max() acceptent aussi des fonctions clés. max(words, key=len) renvoie 'banana', et non sa longueur. Lorsque les clés sont égales, ces fonctions renvoient le premier élément correspondant rencontré.