Fondamentaux des structures de données en Python

Introduction

Dans ce laboratoire, nous allons apprendre les structures de données en Python. Les principales structures de données avec lesquelles nous allons travailler sont les suivantes : les listes, les tuples, les dictionnaires et les ensembles.

Objectifs

• Les listes
• Les compréhensions de liste (List Comprehensions)
• Les tuples
• Les dictionnaires
• Les ensembles

Les listes

En Python, les listes sont des conteneurs polyvalents capables de stocker différents types d'objets. Ici, nous allons explorer les opérations de base sur les listes, telles que la création, l'accès aux valeurs, la mise à jour des valeurs, l'ajout de valeurs et la suppression de valeurs.

Créer une liste

Les listes sont définies avec des valeurs séparées par des virgules et enfermées dans des crochets. Les éléments d'une liste n'ont pas besoin d'être du même type.

>>> l1 = [1, 2, 3, 'a', 'hello']
>>> l1
[1, 2, 3, 'a', 'hello']

>>> l2 = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
>>> l2
['monday', 'tuesday', 'wednesday', 'thursday', 'friday']

Accéder à une valeur

Utilisez l'indice de sous-script pour accéder aux valeurs dans la liste.

>>> print("l1[0] = ", l1[0])
l1[0] =  1

Vous pouvez utiliser la forme entre crochets pour extraire des caractères comme suit, ce qui s'appelle un "slice" (tranche). Un slice est une façon d'extraire une plage d'éléments d'une liste.

list_name[Start:End:Step]

Le premier indice (Start) est l'indice de départ et le deuxième indice (End) est l'indice de fin. Le troisième indice (Step) est le pas, où le pas est l'incrément (par défaut 1).

>>> print("l2[1:3] = ", l2[1:3])
l2[1:3] =  ['tuesday', 'wednesday']

Mettre à jour une valeur

Vous pouvez mettre à jour une valeur en utilisant l'indice de sous-script pour accéder à la valeur, puis en lui assignant une nouvelle valeur :

>>> l1[0] = 10
>>> l1
[10, 2, 3, 'a', 'hello']

Ajouter une valeur

Vous pouvez ajouter des valeurs à la liste en utilisant la méthode append().

list_name.append(value)

>>> l1.append('b')
>>> l1
[10, 2, 3, 'a', 'hello', 'b']

>>> l2.append('statuday')
>>> l2
['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'statuday']

Supprimer une valeur

Vous pouvez supprimer des valeurs de la liste en utilisant le mot-clé del. Cette méthode supprime l'élément à l'indice spécifié de la liste.

del list_name[index]

>>> del l1[0]
>>> l1
[2, 3, 'a', 'hello', 'b']

Et vous pouvez également utiliser la méthode remove() pour supprimer la valeur spécifiée de la liste.

list_name.remove(value)

>>> l1.remove('a')
>>> l1
[2, 3, 'hello', 'b']

Autres fonctions sur les listes

Vous pouvez utiliser la fonction len() pour obtenir la longueur d'une liste.

>>> print("Length of l1 = ", len(l1))
Length of l1 =  5

Et la fonction sorted() pour trier la liste.

>>> print("Sorted of l2 = ", sorted(l2))
Sorted of l2 =  ['friday', 'monday', 'thursday', 'tuesday', 'wednesday']

Compréhensions de liste (List Comprehensions)

La compréhension de liste est une manière concise et puissante de créer des listes en Python en itérant sur un itérable existant, comme une liste, et en appliquant une expression à chaque élément pour créer une nouvelle liste.

Le format d'une compréhension de liste peut être compris comme une boucle for. Et la syntaxe d'une compréhension de liste est la suivante :

new_list = [expression for item in old_list]
new_list = [expression for item in old_list if condition]

• new_list : La liste résultante générée à partir de l'expression pour chaque élément de l'ancienne liste.
• expression : L'opération ou la transformation appliquée à chaque élément de l'ancienne liste pour générer la nouvelle liste.
• item : La variable représentant chaque élément de l'ancienne liste.
• old_list : La liste existante utilisée pour générer la nouvelle liste.
• condition (optionnel) : Une condition de filtre qui peut être appliquée pour inclure seulement certains éléments de l'ancienne liste en fonction d'un critère spécifié.

Pratique des compréhensions de liste

Practiquons les compréhensions de liste dans le shell Python :

>>> ls = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> even_list = [item for item in ls if item % 2 == 0]
>>> even_list
[2, 4, 6, 8, 10]

Dans cet exemple, even_list ne contiendra que les nombres pairs de la liste ls.

Les compréhensions de liste offrent une manière concise et lisible de manipuler les listes, rendant le code Python plus expressif et efficace.

Les tuples

Les tuples sont similaires aux listes en Python, à la différence que les éléments d'un tuple sont immuables, c'est-à-dire qu'ils ne peuvent pas être modifiés après leur création. Les éléments des tuples sont enfermés dans des () et séparés par des ,.

Créer un tuple

Créez un tuple avec les éléments suivants :

>>> tup1 = ('Google', 'Run', 'Python')
>>> tup2 = (1, 2, 3, 4, 5)
>>> empty_tup = ()

>>> tup1
('Google', 'Run', 'Python')
>>> tup2
(1, 2, 3, 4, 5)
>>> empty_tup
()

Accéder aux éléments d'un tuple

Accédez aux éléments des tuples en utilisant l'indexation :

>>> print(tup1[0])
Google

>>> print(tup2[1:3])
(2, 3)

>>> print(empty_tup[0])
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
IndexError: tuple index out of range      ## Une erreur se produit car le tuple est vide.

Fusionner des tuples

Bien que les tuples ne puissent pas être modifiés, ils peuvent être fusionnés :

>>> tup3 = tup1 + tup2
>>> print(tup3)
('Google', 'Run', 'Python', 1, 2, 3, 4, 5)

Les tuples offrent un moyen fiable de stocker des données qui ne doivent pas être modifiées, assurant la stabilité et l'intégrité de vos programmes Python.

Les dictionnaires

Les dictionnaires en Python sont des structures de données polyvalentes et mutables qui stockent des paires clé-valeur.

Chaque paire clé-valeur est séparée par deux points, et chaque paire est séparée par une virgule, le dictionnaire entier étant enfermé dans des accolades {}.

d = {key1 : value1, key2 : value2, key3 : value3 }

Les clés dans un dictionnaire doivent être uniques, mais les valeurs peuvent être dupliquées.

Créer un dictionnaire

Créez des dictionnaires avec des paires clé-valeur :

>>> dict1 = {'name': 'James', "age": 23, "phone": "12345"}
>>> dict2 = {}

>>> dict1
{'name': 'James', 'age': 23, 'phone': '12345'}
>>> dict2
{}

Accéder aux éléments d'un dictionnaire

Accédez aux paires clé-valeur en utilisant la clé entre crochets [] ou la fonction get() :

>>> print(dict1["name"])
James

>>> print(dict2["name"])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'name'

>>> print(dict2.get("name"))
None

L'utilisation de dict[key] pour accéder à une clé qui n'existe pas dans le dictionnaire lève une exception KeyError. Cependant, dict.get(key) renvoie None si la clé n'est pas trouvée dans le dictionnaire.

Modifier un dictionnaire

Ajoutez ou modifiez des entrées dans un dictionnaire en assignant des valeurs aux clés :

>>> dict2["name"] = "Lily"
>>> dict1["name"] = "Bob"

>>> dict2["name"]
'Lily'
>>> dict1["name"]
'Bob'

Supprimer des éléments d'un dictionnaire

Supprimez des paires clé-valeur en utilisant del dict[key] ou effacez l'intégralité du dictionnaire en utilisant dict.clear() :

>>> del dict1["name"]
>>> print(dict1)

{'age': 23, 'phone': '12345'}

>>> dict2.clear()
>>> print(dict2)

{}

Les dictionnaires offrent une façon flexible de stocker et de manipuler des données, ce qui les rend essentiels pour diverses tâches en programmation Python.

Les ensembles (Sets)

Les ensembles en Python sont des collections non ordonnées d'éléments uniques. Ils peuvent être créés en utilisant des accolades {} ou la fonction set().

Créer un ensemble

Pour créer un ensemble vide, vous devez utiliser set() au lieu de {}, car {} est utilisé pour créer un dictionnaire vide. Créez des ensembles en utilisant différentes méthodes :

>>> set1 = set()
>>> print(set1)
set()

>>> set2 = {'apple', 'orange', 'banana'}
>>> print(set2)
{'banana', 'apple', 'orange'}

>>> set3 = set("Hello World!")
>>> print(set3)
{'o', 'H', 'W', ' ', 'd', 'r', '!', 'e', 'l'}

Ajouter un élément

Ajoutez des éléments à un ensemble en utilisant les méthodes add() ou update() :

>>> set1.add('apple')
>>> print(set1)
{'apple'}

>>> set2.update({'orange', 'pear'})
>>> print(set2)
{'apple', 'orange', 'banana', 'pear'}

Supprimer un élément

Supprimez des éléments d'un ensemble en utilisant les méthodes discard() ou remove().
La méthode discard() ne lève pas d'erreur si l'élément n'est pas présent dans l'ensemble, tandis que la méthode remove() le fait.

>>> set1.remove('apple')
>>> print(set1)
set()

>>> set1.discard('banana')
>>> print(set1)
set()

Les ensembles offrent un moyen pratique de travailler avec des collections d'éléments uniques en Python, ce qui les rend utiles pour diverses tâches telles que la suppression de doublons ou le test d'appartenance.

Résumé

Félicitations! Vous avez terminé le laboratoire (Lab) sur les structures de données.

Dans ce laboratoire, vous avez appris les structures de données de base de Python ainsi que le moment et la manière d'utiliser ces structures de données pour résoudre des problèmes.