Tableau ou liste de dictionnaires en Python

Une liste Python est le conteneur habituel pour réunir des dictionnaires : chaque élément de la liste peut contenir un enregistrement composé de paires clé-valeur. On parle parfois de tableau de dictionnaires, mais une liste Python et les types de tableaux spécialisés sont distincts. Les exemples ci-dessous montrent comment créer la liste, accéder aux enregistrements et à leurs valeurs, ajouter un enregistrement et modifier une valeur.

Créer une liste de dictionnaires en Python

Écrivez chaque dictionnaire comme un élément d’un littéral de liste. Chaque littéral crée un dictionnaire distinct ; les enregistrements peuvent donc avoir des clés différentes ou partager certaines clés. Choisissez un nom de variable explicite, comme records : list est déjà le nom d’une fonction intégrée de Python.

Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

records = [
    {"name": "Ada", "role": "engineer"},
    {"name": "Lin", "role": "designer"},
]
print(records)

[{'name': 'Ada', 'role': 'engineer'}, {'name': 'Lin', 'role': 'designer'}]

Accéder à un dictionnaire et à ses valeurs par index et par clé

Les index d’une liste Python commencent à 0 ; l’index 1 désigne donc le deuxième dictionnaire. Pour lire un champ, sélectionnez d’abord le dictionnaire à l’aide de son index dans la liste, puis utilisez la clé entre crochets. La recherche dans la liste et celle dans le dictionnaire se font en deux étapes au sein d’une même expression.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

records = [
    {"name": "Ada", "role": "engineer"},
    {"name": "Lin", "role": "designer"},
]
second_record = records[1]
role = records[1]["role"]
print(second_record)
print(role)

{'name': 'Lin', 'role': 'designer'}
designer

La clé doit exister dans le dictionnaire sélectionné pour que l’accès entre crochets fonctionne. Si une clé peut être absente, utilisez record.get("role") pour obtenir None par défaut, ou indiquez une valeur de remplacement, par exemple record.get("role", "unknown").

Ajouter un dictionnaire à une liste

Appelez append() pour ajouter un dictionnaire à la fin de la liste existante. Cette méthode modifie la liste sur place ; elle ne crée pas de nouvelle liste.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

records = [{"name": "Ada", "role": "engineer"}]
records.append({"name": "Lin", "role": "designer"})
print(records)

[{'name': 'Ada', 'role': 'engineer'}, {'name': 'Lin', 'role': 'designer'}]

Mettre à jour un dictionnaire de la liste

Sélectionnez un enregistrement par son index, puis affectez une valeur à l’une de ses clés. Si la clé n’existe pas, l’affectation l’ajoute : cette syntaxe permet donc soit de remplacer la valeur d’un champ, soit d’ajouter un champ.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

records = [{"name": "Ada", "role": "engineer"}]
records[0]["role"] = "lead engineer"
records[0]["team"] = "platform"
print(records)

[{'name': 'Ada', 'role': 'lead engineer', 'team': 'platform'}]

Créer une liste de dictionnaires avec une compréhension de liste

Une compréhension de liste est concise lorsque chaque enregistrement suit le même modèle. Placez un littéral de dictionnaire dans l’expression afin de créer un dictionnaire distinct à chaque itération. Par exemple, ceci crée quatre dictionnaires distincts initialisés avec les mêmes champs :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

records = [{"active": True, "score": 0} for _ in range(4)]
print(records)

[{'active': True, 'score': 0}, {'active': True, 'score': 0}, {'active': True, 'score': 0}, {'active': True, 'score': 0}]

Pour créer plutôt plusieurs dictionnaires vides, appelez dict() à chaque itération :

records = [dict() for _ in range(3)]
print(records)

[{}, {}, {}]

Une compréhension peut aussi calculer les valeurs des champs à partir d’un itérable :

records = [{"id": number, "label": f"item-{number}"} for number in range(3)]
print(records)

[{'id': 0, 'label': 'item-0'}, {'id': 1, 'label': 'item-1'}, {'id': 2, 'label': 'item-2'}]

Évitez de multiplier une liste contenant un seul dictionnaire modifiable pour créer plusieurs enregistrements. Par exemple, [{}] * 3 répète les références au même dictionnaire : toute modification d’un élément sera donc visible aux trois positions. Une compréhension contenant {} crée un nouveau dictionnaire à chaque itération.

Créer des dictionnaires dans une boucle

Utilisez une boucle lorsque chaque dictionnaire nécessite plusieurs étapes ou des champs conditionnels. Créez un nouveau dictionnaire à chaque itération, puis ajoutez-le à la liste.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

records = []
for number in range(3):
    record = {"id": number, "score": number * 10}
    records.append(record)

for record in records:
    print(record)

{'id': 0, 'score': 0}
{'id': 1, 'score': 10}
{'id': 2, 'score': 20}

À chaque passage dans la boucle, un enregistrement est créé à partir de la valeur courante de number ; append() ajoute ce dictionnaire à la liste avant le passage suivant.

Construire des dictionnaires avec le constructeur dict()

Sans argument, le constructeur dict() crée un dictionnaire vide ; avec des champs nommés, il construit un dictionnaire initialisé. Les noms des paramètres deviennent des clés de type chaîne :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

blank_record = dict()
person = dict(name="John", age=30, city="New York")
print(blank_record)
print(person)

{}
{'name': 'John', 'age': 30, 'city': 'New York'}

Vous pouvez appeler dict() séparément pour créer des dictionnaires dans une liste :

records = [
    dict(name="Ada", role="engineer"),
    dict(name="Lin", role="designer"),
]
for record in records:
    print(record)

{'name': 'Ada', 'role': 'engineer'}
{'name': 'Lin', 'role': 'designer'}

Les clés d’un dictionnaire doivent être hachables. C’est le cas des chaînes, des nombres et des tuples composés de valeurs hachables ; les types modifiables, comme les listes, ne peuvent pas servir de clés. Chaque clé ne peut apparaître qu’une seule fois dans un dictionnaire. Si un dictionnaire est construit à partir de paires clé-valeur répétées, la valeur la plus récente remplace la précédente. Avec les arguments nommés de dict(), chaque nom ne peut apparaître qu’une fois dans l’appel : si l’entrée peut contenir des clés répétées, utilisez un mapping ou une séquence de paires.