Structures de données : listes, tuples, dictionnaires et ensembles
Découvrez les structures de données fondamentales de Python : listes (modifiables), tuples (immuables), dictionnaires (paires clé-valeur) et ensembles (éléments uniques). Apprenez à manipuler et à choisir la structure adaptée à vos besoins.
Listes : des séquences ordonnées et modifiables
Les listes sont l'une des structures de données les plus utilisées en Python. Elles vous permettent de stocker une séquence ordonnée d'éléments, qui peuvent être de types différents. Les listes sont modifiables, ce qui signifie que vous pouvez ajouter, supprimer ou modifier des éléments après la création de la liste.
Vous pouvez créer une liste en utilisant des crochets (`[]`) et en séparant les éléments par des virgules. Par exemple : `ma_liste = [1, 'a', 3.14, True]`. Vous pouvez accéder à un élément d'une liste en utilisant son index (sa position dans la liste), en commençant par 0. Par exemple, `ma_liste[0]` renvoie `1`.
Python propose de nombreuses méthodes pour manipuler les listes : `append()` pour ajouter un élément à la fin, `insert()` pour insérer un élément à une position donnée, `remove()` pour supprimer un élément, `pop()` pour supprimer et renvoyer un élément, `sort()` pour trier la liste, `reverse()` pour inverser l'ordre des éléments, etc.
Nous verrons comment utiliser ces méthodes, comment parcourir une liste avec une boucle `for`, comment utiliser le slicing (découpage) pour extraire des sous-listes, et comment imbriquer des listes (créer des listes de listes).
Tuples : des séquences ordonnées et immuables
Les tuples sont similaires aux listes, mais ils sont immuables, ce qui signifie que vous ne pouvez pas modifier leur contenu après leur création. Les tuples sont souvent utilisés pour représenter des données qui ne doivent pas être modifiées, comme les coordonnées d'un point, ou les valeurs de retour d'une fonction.
Vous pouvez créer un tuple en utilisant des parenthèses (`()`) et en séparant les éléments par des virgules. Par exemple : `mon_tuple = (1, 'a', 3.14, True)`. Vous pouvez accéder à un élément d'un tuple en utilisant son index, comme pour les listes.
Bien que vous ne puissiez pas modifier un tuple directement, vous pouvez créer un nouveau tuple à partir d'un tuple existant, en utilisant la concaténation (`+`) ou le slicing.
Nous verrons les avantages et les inconvénients des tuples par rapport aux listes, et quand utiliser l'un ou l'autre.
Dictionnaires : des paires clé-valeur
Les dictionnaires sont une autre structure de données fondamentale en Python. Ils vous permettent de stocker des données sous forme de paires clé-valeur. Les clés doivent être uniques et immuables (généralement des chaînes de caractères ou des nombres), et les valeurs peuvent être de n'importe quel type.
Vous pouvez créer un dictionnaire en utilisant des accolades (`{}`) et en séparant les paires clé-valeur par des deux-points (`:`). Par exemple : `mon_dictionnaire = {'nom': 'Alice', 'age': 30, 'ville': 'Paris'}`. Vous pouvez accéder à une valeur en utilisant sa clé. Par exemple, `mon_dictionnaire['nom']` renvoie `'Alice'`.
Python propose de nombreuses méthodes pour manipuler les dictionnaires : `keys()` pour obtenir la liste des clés, `values()` pour obtenir la liste des valeurs, `items()` pour obtenir la liste des paires clé-valeur, `get()` pour accéder à une valeur en spécifiant une valeur par défaut si la clé n'existe pas, `pop()` pour supprimer et renvoyer une paire clé-valeur, etc.
Nous verrons comment utiliser ces méthodes, comment parcourir un dictionnaire avec une boucle `for`, comment ajouter, modifier et supprimer des paires clé-valeur, et comment imbriquer des dictionnaires (créer des dictionnaires de dictionnaires).
Ensembles (sets) : des collections non ordonnées d'éléments uniques
Les ensembles (sets) sont des collections non ordonnées d'éléments uniques. Ils sont utiles lorsque vous avez besoin de stocker un ensemble de valeurs, sans vous soucier de l'ordre, et en vous assurant qu'il n'y a pas de doublons.
Vous pouvez créer un ensemble en utilisant des accolades (`{}`) ou la fonction `set()`. Par exemple : `mon_ensemble = {1, 2, 3}` ou `mon_ensemble = set([1, 2, 2, 3])` (notez que le deuxième exemple ne contient que les éléments `1`, `2` et `3`, car les doublons sont automatiquement supprimés).
Python propose des opérations ensemblistes, comme l'union (`|`), l'intersection (`&`), la différence (`-`), et la différence symétrique (`^`). Ces opérations vous permettent de combiner et de comparer des ensembles de manière efficace.
Nous verrons comment utiliser ces opérations, comment ajouter et supprimer des éléments d'un ensemble, et comment tester l'appartenance d'un élément à un ensemble avec l'opérateur `in`.
Choisir la bonne structure de données
Maintenant que vous connaissez les principales structures de données de Python, il est important de savoir quand utiliser l'une plutôt que l'autre. Le choix de la structure de données dépend des caractéristiques de vos données et des opérations que vous devez effectuer.
Si vous avez besoin d'une séquence ordonnée d'éléments, et que vous devez pouvoir modifier cette séquence, utilisez une liste. Si vous avez besoin d'une séquence ordonnée d'éléments, mais que vous n'avez pas besoin de la modifier, utilisez un tuple.
Si vous avez besoin d'associer des clés à des valeurs, utilisez un dictionnaire. Si vous avez besoin de stocker un ensemble de valeurs uniques, sans vous soucier de l'ordre, utilisez un ensemble.
Nous verrons des exemples concrets pour illustrer ces choix, et nous discuterons des avantages et des inconvénients de chaque structure de données en termes de performance et d'utilisation de la mémoire.