Types de structures de données en Python : liste, tuple, ensembles et dictionnaire

Python est un langage préféré de tous les temps pour tous les passionnés de Data Science. La nature polyvalente et l'approche facile à comprendre aident les développeurs à se concentrer davantage sur la compréhension des tendances dans les données et à en tirer des informations significatives plutôt que de passer du temps à corriger un bogue mineur de point-virgule ou à fermer la tranche supérieure. Python étant le langage le plus populaire parmi les débutants, il s'adapte rapidement, il devient donc important de bien maîtriser ce langage.

Les structures de données sont un concept essentiel dans tout langage de programmation. Il définit comment les variables et les données peuvent être stockées et extraites de la mémoire de la meilleure façon possible, en fonction du type de données. Il définit également la relation entre les variables, ce qui aide à décider des opérations et des fonctions qui doivent être exécutées sur celles-ci. Comprenons comment Python gère les données.

Types de structure de données en Python

1. Liste

Il s'agit de la structure de données la plus simple et la plus couramment utilisée dans la programmation Python. Comme son nom l'indique, il s'agit d'une collection d'éléments à stocker. Les éléments stockés peuvent être de tout type numérique, chaîne, booléen, objets, etc., ce qui le rend hétérogène. Cela signifie qu'une liste peut contenir n'importe quel type de données et nous pouvons parcourir cette liste en utilisant n'importe quel type de boucle.

Les éléments stockés sont généralement associés à un index qui définit la position dans la liste. La numérotation de l'index commence à zéro. La liste est modifiable, ce qui signifie que les éléments de la liste peuvent être ajoutés, supprimés ou modifiés même après leur définition. Cette structure de données ressemble à des tableaux dans d'autres langages qui sont généralement homogènes, ce qui signifie qu'un seul type de données peut être stocké dans des tableaux. Certaines opérations de base sur les listes sont les suivantes :

• Pour déclarer une liste en Python, mettez-la entre crochets :

sample_list = ['upGrad', '1', 2]

• Pour initialiser une liste vide :

liste_échantillon = liste()

• Ajoutez des éléments à la liste :

sample_list.append('new_element')

• Supprimer des éléments de la liste :

sample_list.remove(<element name>) supprime l'élément spécifique

del sample_list[<element index num>] supprime l'élément à cet index

sample_list.pop(<element index num>) supprime l'élément de cet index et renvoie cet élément supprimé

• Pour changer d'élément à n'importe quel index :

sample_list[<any index>] = nouvel élément

• Découpage : Il s'agit d'une fonctionnalité importante qui peut filtrer les éléments de la liste dans des cas particuliers. Considérez que vous n'avez besoin que d'une plage spécifique de valeurs dans la liste, vous pouvez simplement le faire en :

sample_list[start : stop : step] où step définit l'écart entre les éléments et par défaut, il est 1.

Apprenez-en plus à propos de : Comment créer un arbre de décision parfait

2. Tuple

Il s'agit d'une autre structure de données qui stocke séquentiellement les données, ce qui signifie que les données ajoutées restent de manière ordonnée comme les listes. Dans le même ordre d'idées, Tuple peut également stocker des données hétérogènes, et l'indexation reste la même.

La principale différence entre les deux est que les éléments stockés dans le tuple sont immuables et ne peuvent pas être modifiés après la définition. Cela signifie que vous ne pouvez pas ajouter de nouveaux éléments, modifier des éléments existants ou supprimer des éléments du tuple. Les éléments ne peuvent être lus qu'à partir de celui-ci via l'indexation ou le déballage sans remplacement.

Cela rend tuple rapide par rapport à la liste en termes de création. Le tuple est stocké dans un seul bloc de mémoire mais une liste nécessite deux blocs, l'un est de taille fixe et l'autre de taille variable pour stocker les données. Il convient de préférer un tuple à une liste lorsque l'utilisateur est sûr que les éléments à stocker ne nécessitent aucune modification supplémentaire. Quelques éléments à prendre en compte lors de l'utilisation d'un tuple :

• Pour initialiser un tuple vide :

sample_tuple = tuple()

• Pour déclarer un tuple, placez les éléments entre crochets :

sample_tuple = ('upGrad', 'Python', 'ML', 23432)

• Pour accéder aux éléments du tuple :

sample_tuple[<index_num>]

3 ensembles

En mathématiques, un ensemble est une collection bien définie d'éléments uniques qui peuvent ou non être liés les uns aux autres. Dans le tuple et la liste, on peut stocker de nombreux éléments en double sans échec, mais la structure de données définie ne prend que des éléments uniques.

Les éléments d'un ensemble sont stockés de manière désordonnée, ce qui signifie que les éléments sont stockés de manière aléatoire dans l'ensemble et qu'il n'y a pas de position ou d'index défini pris en charge, ni le découpage en tranches n'est autorisé dans un ensemble. L'ensemble est lui-même modifiable mais les éléments doivent être immuables car la façon dont les ensembles fonctionnent hache ces éléments et dans ce processus, seuls les éléments immuables peuvent être hachés.

Des éléments peuvent être ajoutés ou supprimés de l'ensemble, mais ne peuvent pas être modifiés car il n'y a pas de concept d'indexation et, par conséquent, les éléments peuvent être modifiés. Comme en mathématiques, ici aussi toutes les opérations sur les ensembles peuvent être effectuées telles que l'union, l'intersection, la différence, la disjonction. Voyons comment l'implémenter :

• Pour initialiser un ensemble vide :

sample_set = set()

• Ajoutez des éléments à l'ensemble :

sample_set.add(item) Ceci ajoute un seul élément à l'ensemble

sample_set.update(items) Cela peut ajouter plusieurs éléments via une liste, un tuple ou un autre ensemble

• Supprimez des éléments de l'ensemble :

sample_set.discard(item) Supprime l'élément sans avertissement si l'élément n'est pas présent

sample_set.remove(item) Génère une erreur si l'élément à supprimer n'est pas présent.

• Opérations d'ensemble (supposons deux ensembles initialisés : A et B) :

Un | B ou A.union(B) : fonctionnement de l'union

A & B ou A.intersection(B) : opération d'intersection

A - B ou A.difference(B) : Différence de deux ensembles

A ^ B ou A.symmetric_difference(B) : Différence symétrique des ensembles

Découvrez : les cadres de données en Python

4. Dictionnaire

Il s'agit de la structure de données la plus utile en Python, qui permet de stocker les éléments de données sous forme de paire clé-valeur. La clé doit être une valeur immuable et la valeur peut être un élément mutable. Ce concept ressemble à ce à quoi ressemble un véritable dictionnaire, où nous avons les mots comme clés et leurs significations comme valeurs. Un dictionnaire stocke ces paires de manière non ordonnée, et il n'y a donc pas de concept d'index dans cette structure de données. Certaines choses importantes liées à cela:

• Pour initialiser un dictionnaire vide :

sample_dict = dict()

• Pour ajouter des éléments au dictionnaire :

sample_dict[clé] = valeur

Une autre façon de procéder est sample_dict = {clé : valeur}

Si vous imprimez ce dictionnaire, le résultat serait : {'key1' : valeur, 'key2' : valeur … }

• Pour obtenir les clés et les valeurs du dictionnaire :

sample_dict.keys() : renvoie la liste des clés

sample_dict.values() : renvoie la liste des valeurs

sample_dict.items() : renvoie l'objet de vue des paires clé-valeur sous forme de tuple dans la liste

Apprenez des cours de science des données dans les meilleures universités du monde. Gagnez des programmes Executive PG, des programmes de certificat avancés ou des programmes de maîtrise pour accélérer votre carrière.

Conclusion

Il est important de maîtriser les connaissances de base des structures de données en Python. Étant dans l'industrie des données, différentes structures de données peuvent aider à obtenir une meilleure solution de contournement des algorithmes sous-jacents. Cela rend le développeur plus conscient des meilleures pratiques de codage pour obtenir les résultats efficacement. L'utilisation de chaque structure de données est fortement basée sur la situation et nécessite une pratique rigoureuse.