# Python Dictionary : comment fonctionnent les listes associatives ?

Dans le [langage de programmation Internet](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/langages-de-programmation-web/ "Langages de programmation Web") Python, le dictionary (ou dictionnaire) est un type de données important qui permet de relier des termes à des significations. En utilisant des paires clé-valeur, vous pouvez créer autant de **tables, de collections de données ou d’inventaires**. Un Python Dictionary peut également être utilisé avec les [boucles for Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/loop-for-en-python/), les [instructions if-else Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-if-else/) et les [boucles while Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/boucle-while-en-python/ "Boucle while en Python").

## Qu’est-ce qu’un Python Dictionary ?

Un Python Dictionary est un type de données qui associe les termes et les significations. Dans cette structure, **les clés (*keys*) et les valeurs (*values*) peuvent être associées**, enregistrées et récupérées ultérieurement. Si l’on trouve parfois l’expression maladroite de « liste associative » en français pour désigner un Python Dictionary, on lui préférera la traduction plus éloquente de « dictionnaire ». Comme dans un dictionnaire, dans lequel un terme est associé à une explication ou à une traduction, une table de mappage est également créée dans un Python Dictionary et ne peut pas contenir de doublons. Chaque clé ne se présente ainsi qu’une seule fois.

## Python Dictionary : structure et requête

Un Python Dictionary est toujours entouré d’accolades. La clé et sa valeur associée sont reliées par deux points et les paires résultantes sont séparées par des virgules. En théorie, un Python Dictionary peut contenir un nombre infini de nombre de paires clé-valeur. La clé est à son tour placée entre guillemets. Vous avez certainement déjà pris connaissance de la syntaxe dans un [tutoriel Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/tutoriel-python/ "Tutoriel Python"). Sa rédaction peut s’apparenter à ceci :

```none
ages = {'Jim': 42, 'Jack': 13, 'John': 69}
```

Le Python Dictionary est lu en plaçant la clé correcte entre crochets. Le code est rédigé comme suit :

```none
age_jim = ages['Jim']
assert age_jim == 42
```

## Exemple de Python Dictionary

Un exemple simple permet d’illustrer la structure et le fonctionnement du Python Dictionary. Le code suivant consiste à affecter et à sortir des pays et leurs capitales. Le Python Dictionary se présente comme suit :

```none
capitals = { "UK": "London", "FR": "Paris", "DE": "Berlin" }
```

Pour interroger un élément spécifique maintenant, utilisez les crochets suivants :

```none
capitals["FR"]
assert capitals["FR"] == 'Paris'
```

Dans ce cas, la sortie correspond à la valeur appartenant à la clé « France », c’est-à-dire « Paris ».

### Structure alternative

Vous pouvez également créer un Python Dictionary sans contenu, puis le remplir ensuite. Pour ce faire, il convient de créer un Python Dictionary vide qui ressemble à ceci :

```none
capitals = { }
```

Remplissez maintenant le dictionnaire :

```none
capitals["UK"] = "London"
capitals["FR"] = "Paris"
capitals["DE"] = "Berlin"
```

Si vous interrogez maintenant le Python Dictionary « capitale », vous obtiendrez la sortie suivante :

```none
{ "UK": "London", "FR": "Paris", "DE": "Berlin" }
```

## Modifier le Python Dictionary ultérieurement

Vous pouvez également modifier votre Python Dictionary après-coup. Par exemple, vous pouvez écrire ceci pour ajouter des paires clé-valeur (« append » en anglais) :

```none
capitals[ "IT" ] = "Roma"
print(capitals)
```

La sortie correspondante est maintenant :

```none
{ "UK": "London", "FR": "Paris", "DE": "Berlin", "IT": "Roma" }
```

Si vous souhaitez modifier une valeur dans une paire clé-valeur, utilisez le code suivant :

```none
capitals = { "UK": "London", "FR": "Paris", "DE": "Berlin", "IT": "???" }
assert capitals["IT"] == "???"
capitals["IT"] = "Roma"
assert capitals["IT"] == "Roma"
```

La sortie sera alors de nouveau la suivante :

```none
{ "UK": "London", "FR": "Paris", "DE": "Berlin", "IT": "Roma" }
```

## Supprimer les paires clé-valeur du Python Dictionary

Trois possibilités se présentent pour supprimer une paire clé-valeur du Python Dictionary : del, pop et popitem.

### Supprimer avec del

Un inventaire simple peut être utilisé pour illustrer la méthode del. Supposons qu’une boulangerie propose 100 petits pains, 25 pains et 20 croissants à son ouverture. Le Python Dictionary correspondant se présenterait alors comme suit :

```none
stock = { "rolls": 100, "breads": 25, "croissants": 20 }
```

Si la boulangerie vend maintenant tous les croissants et veut les supprimer de sa liste, elle fait appel à la fonction del à cet effet :

```none
del stock["croissants"]
print(stock)
```

Cette méthode impose toutefois l’utilisation systématique d’une paire clé-valeur en relation avec la commande del. Dans le cas contraire, le Python Dictionary dans son entièreté serait supprimé. Ce problème Python apparait de manière relativement fréquente.

### Supprimer avec pop

La deuxième façon de supprimer des paires clé-valeur d’un Python Dictionary est la méthode pop. Ceci vous permet d’enregistrer la valeur supprimée dans une nouvelle variable. Ceci fonctionne comme suit :

```none
marbles = { "red": 13, "green": 19, "blue": 7, "yellow": 21}
red_marbles = marbles.pop("red")
print(f"We've removed {red_marbles} red marbles.")
print(f"Remaining marbles are: {marbles}")
```

La sortie se présente ensuite comme suit :

```none
We've removed 13 red marbles.
Remaining marbles are: {'green': 19, 'blue': 7, 'yellow': 21}
```

### Supprimer avec popitem

Utilisez popitem pour supprimer la dernière paire clé-valeur de votre Python Dictionary. Voici le code approprié :

```none
last = marbles.popitem()
print(last)
print(marbles)
```

Votre sortie se présente ensuite comme suit :

('yellow', 21)

{ "One": 1, "Two": 2, "Three": 3 }

## Autres méthodes pour le Python Dictionary

D’autres méthodes fonctionnant avec un Python Dictionary se proposent à vous. Voici une liste des options principales :

<table>
  <thead>
    <tr>
      <th>Méthode</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>clear</td>
      <td>clear supprime toutes les paires clé-valeur du Python Dictionary.</td>
    </tr>
    <tr>
      <td>copy</td>
      <td>copy crée une copie du dictionnaire en mémoire.</td>
    </tr>
    <tr>
      <td>get</td>
      <td>get permet de déterminer la valeur en saisissant la clé.</td>
    </tr>
    <tr>
      <td>keys</td>
      <td>keys vous permet de lire votre dictionnaire.</td>
    </tr>
    <tr>
      <td>update</td>
      <td>update vous permet de compléter un Python Dictionary par un autre. Les clés redondantes sont écrasées dans le dictionnaire ajouté.</td>
    </tr>
    <tr>
      <td>values</td>
      <td>values vous permet d’interroger toutes les valeurs de votre dictionnaire.</td>
    </tr>
  </tbody>
</table>


This is a markdown version of: [https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-dictionary/](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-dictionary/) for AI/LLM consumption.