Vérifiez si l'index existe dans la liste Python

Les listes Python utilisent une indexation à partir de zéro : le premier élément se trouve donc à l’indice 0. Pour un indice non négatif, vérifiez 0 <= index < len(items) avant d’accéder à la liste. Si vous cherchez déjà à récupérer un élément, interceptez IndexError autour de cet accès. Python accepte aussi les indices comptés depuis la fin d’une liste : la plage complète des indices valides va de -len(items) à len(items) - 1.

Vérifier un indice avec un test de limites

Utilisez un test de limites lorsque vous devez valider un indice avant d’accéder à une liste ou de la modifier. Le test 0 <= index < len(items) inclut le premier indice et exclut la longueur de la liste, car len(items) correspond à la position située juste après le dernier élément.

Exécutez cet exemple. Les noms de fruits et le message affichés restent en anglais, comme dans le code d’origine :

items = ["Apple", "Banana", "Pineapple"]
index = 1

if 0 <= index < len(items):
    print(f"{items[index]} is at index {index}.")
else:
    print(f"No item at index {index}.")

Banana is at index 1.

Ce test est clair lorsque vous attendez un indice entier ou compatible avec un entier et non négatif. La comparaison vérifie uniquement la plage de la valeur ; elle ne garantit pas que celle-ci constitue un indice valide pour une liste. Par exemple, 1.0 satisfait 0 <= index < len(items), mais items[1.0] déclenche TypeError. Vérifiez séparément le type de l’indice avant de considérer un résultat positif comme la preuve que l’accès fonctionnera. Ce test n’accepte pas non plus les indices négatifs, même si l’accès à une liste Python les autorise. Si les appelants peuvent fournir des valeurs négatives, utilisez la plage complète dans la fonction utilitaire ci-dessous ou normalisez l’indice selon les besoins de votre application.

La condition renvoie False lorsque l’indice est en dehors de la liste. Cet exemple montre les deux résultats pour une même liste de trois éléments ; les messages affichés restent en anglais :

items = ["Apple", "Banana", "Pineapple"]
for index in (1, 3):
    if 0 <= index < len(items):
        print(f"{index}: {items[index]}")
    else:
        print(f"{index}: no item")

1: Banana
3: no item

Vérifier un indice en interceptant IndexError

Lorsque votre objectif est de récupérer l’élément, tentez d’y accéder et interceptez IndexError. Limitez la portée du bloc try afin que le gestionnaire ne couvre que l’opération susceptible de déclencher cette erreur d’indexation. Ce gestionnaire ne masque pas les autres erreurs, comme TypeError, qui survient lorsque l’indice n’est pas un entier.

Dans l’exemple, le message affiché reste en anglais, comme dans le code d’origine.

items = ["Apple", "Banana", "Pineapple"]
index = 2

try:
    item = items[index]
except IndexError:
    print("No item at that index.")
else:
    print(f"Found {item} at index {index}.")

Found Pineapple at index 2.

Cette méthode vérifie l’accès et récupère la valeur en une seule opération. Un test de limites distinct ne garantit pas qu’un accès ultérieur réussira si une autre partie du programme modifie la liste entre la vérification et l’utilisation. Si ce risque est pertinent, interceptez l’erreur au moment de l’accès.

L’exemple montre la gestion d’un indice situé après la dernière position ; son message affiché reste en anglais :

items = ["Apple", "Banana", "Pineapple"]
index = 3

try:
    item = items[index]
except IndexError:
    print(f"No item at index {index}.")

No item at index 3.

Créer une fonction réutilisable pour vérifier un indice

Placez la plage complète des indices de liste dans une fonction utilitaire si vous devez effectuer la même vérification à plusieurs endroits. Pour une liste de longueur n, Python accepte les indices de -n à n, sans inclure n.

Dans cet exemple, les libellés et les valeurs affichés restent en anglais, comme dans le code d’origine.

def index_exists(items, index):
    return -len(items) <= index < len(items)


fruits = ["Apple", "Banana", "Pineapple"]
for index in (2, -1, 3, -4):
    print(f"{index}: {index_exists(fruits, index)}")

2: True
-1: True
3: False
-4: False

Cette fonction suppose que l’indice est un entier ou une valeur compatible avec un entier et ne vérifie que sa plage, y compris les indices négatifs valides. Un flottant comme 1.0 peut satisfaire cette comparaison, même si items[1.0] déclenche TypeError. Vérifiez séparément le type de l’indice avant de considérer True comme la preuve que l’accès fonctionnera. Après un résultat positif, utilisez items[index] pour récupérer l’élément. Si la liste peut changer entre la vérification et l’accès, le résultat peut devenir obsolète ; utilisez plutôt un bloc try autour de l’accès.

Gérer les indices négatifs et non valides

Les indices négatifs comptent depuis la fin : -1 désigne le dernier élément et -len(items) le premier. Une liste vide n’a aucun indice valide : sa longueur est nulle et aucun entier ne se trouve dans l’intervalle qui inclut -0 mais exclut 0. Un accès à une liste avec un indice hors limites déclenche IndexError.

Les indices doivent aussi être des entiers ou des valeurs compatibles avec des entiers. Un flottant comme 1.0 peut satisfaire une comparaison de plage sans être un indice valide pour une liste ; son utilisation pour accéder à la liste déclenche TypeError. Une chaîne de caractères n’est pas non plus un indice valide. Intercepter uniquement IndexError ne gère pas ces erreurs de type. Si votre fonction reçoit des données provenant de l’extérieur de votre code, vérifiez leur type séparément avant de vous fier à un test de limites, ou gérez précisément les erreurs que votre interface promet d’accepter. Ne convertissez pas des valeurs arbitraires en entiers sans avoir déterminé si la troncature ou l’analyse de la valeur correspond à l’intention de l’appelant.

Choisir la bonne méthode

Utilisez un test de limites lorsque vous souhaitez choisir une branche avant d’accéder à un indice non négatif, ou vérifiez la plage complète des indices négatifs et positifs si votre interface accepte les indices négatifs. Utilisez try/except IndexError lorsque l’accès lui-même constitue l’opération et que vous souhaitez réagir à l’absence d’élément. Une fonction utilitaire est pratique si vous répétez la même vérification de plage, mais elle ne récupère pas l’élément et ne protège pas un accès ultérieur contre une modification de la liste.

IndexError indique précisément qu’un indice entier se trouve en dehors des positions disponibles dans la liste. Un indice non entier déclenche TypeError ; gardez cette distinction à l’esprit lorsque vous validez des données non fiables. Ces méthodes vous permettent de choisir entre vérifier une position à l’avance et gérer un échec au moment de l’accès.