Commencer avec les structures de données Python en 5 étapes

Début avec les structures de données Python en 5 étapes

Introduction aux structures de données en Python

Lorsqu’il s’agit d’apprendre à programmer, quel que soit le langage de programmation particulier que vous utilisez pour cette tâche, vous constaterez qu’il existe quelques sujets majeurs de votre discipline nouvellement choisie dans lesquels la plupart de ce à quoi vous êtes exposé peut être catégorisé. Quelques-uns de ces sujets, dans l’ordre général de leur compréhension, sont : la syntaxe (le vocabulaire du langage) ; les commandes (mettre le vocabulaire ensemble de manière utile) ; le contrôle du flux (comment nous guidons l’ordre d’exécution des commandes) ; les algorithmes (les étapes que nous prenons pour résoudre des problèmes spécifiques… comment ce mot est-il devenu si déroutant ?) ; et enfin, les structures de données (les dépôts de stockage virtuels que nous utilisons pour la manipulation des données pendant l’exécution des algorithmes (qui sont, encore une fois… une série d’étapes).

Essentiellement, si vous voulez mettre en œuvre la solution à un problème, en assemblant une série de commandes dans les étapes d’un algorithme, à un moment donné, les données devront être traitées, et les structures de données deviendront essentielles. Ces structures de données fournissent un moyen d’organiser et de stocker des données efficacement, et sont essentielles pour créer un code rapide, modulaire, capable d’exécuter des fonctions utiles et de s’adapter à l’échelle. Python, un langage de programmation particulier, dispose de ses propres structures de données intégrées.

Ce tutoriel se concentrera sur ces quatre structures de données fondamentales en Python :

Listes – Ordonnées, modifiables, permettant des éléments en double. Utiles pour stocker des séquences de données.
Tuples – Ordonnés, immuables, permettant des éléments en double. Pensez à eux comme à des listes immuables.
Dictionnaires – Non ordonnés, modifiables, mappés par paires clé-valeur. Utiles pour stocker des données au format clé-valeur.
Ensembles – Non ordonnés, modifiables, contenant des éléments uniques. Utiles pour les tests d’appartenance et l’élimination des doublons.

Au-delà des structures de données fondamentales, Python propose également des structures plus avancées, telles que des tas, des files d’attente et des listes chaînées, qui peuvent améliorer davantage vos compétences en programmation. Ces structures avancées, construites sur les fondamentales, permettent une manipulation de données plus complexe et sont souvent utilisées dans des scénarios spécialisés. Mais vous n’êtes pas limité ici ; vous pouvez utiliser toutes les structures existantes comme base pour implémenter vos propres structures. Cependant, la compréhension des listes, des tuples, des dictionnaires et des ensembles reste primordiale, car ce sont les éléments constitutifs des structures de données plus avancées.

Ce guide vise à fournir une compréhension claire et concise de ces structures de base. Au fur et à mesure que vous commencez votre parcours en Python, les sections suivantes vous guideront à travers les concepts essentiels et les applications pratiques. De la création et de la manipulation de listes à l’utilisation des capacités uniques des ensembles, ce tutoriel vous dotera des compétences nécessaires pour exceller dans votre programmation.

Étape 1 : Utilisation des listes en Python

Qu’est-ce qu’une liste en Python ?

Une liste en Python est un type de données ordonné et modifiable pouvant stocker divers objets, permettant des éléments en double. Les listes sont définies en utilisant des crochets [ ], les éléments étant séparés par des virgules.

Par exemple :

fibs = [0, 1, 1, 2, 3, 5, 8, 13, 21]

Les listes sont incroyablement utiles pour organiser et stocker des séquences de données.

Création d’une liste

Les listes peuvent contenir différents types de données, comme des chaînes de caractères, des entiers, des booléens, etc. Par exemple :

mixed_list = [42, "Bonjour le monde!", False, 3.14159]

Manipulation d’une liste

Les éléments d’une liste peuvent être consultés, ajoutés, modifiés et supprimés. Par exemple :

# Accéder au 2e élément (l'indexation commence à '0')
print(mixed_list[1])

# Ajouter un élément
mixed_list.append("Ceci est nouveau")

# Changer un élément
mixed_list[0] = 5

# Supprimer le dernier élément
mixed_list.pop(0)

Méthodes utiles pour les listes

Quelques méthodes intégrées pratiques pour les listes incluent:

sort() – Trie la liste sur place
append() – Ajoute un élément à la fin de la liste
insert() – Insère un élément à l’index spécifié
pop() – Supprime l’élément à l’index spécifié
remove() – Supprime la première occurrence de la valeur spécifiée
reverse() – Inverse la liste sur place

Exemple pratique avec des listes

# Créer un panier d'achat sous forme de liste
panier = ["pommes", "oranges", "raisins"]

# Trier la liste
panier.sort()

# Ajouter un nouvel élément
panier.append("myrtilles")

# Supprimer le premier élément
panier.pop(0)

print(panier)

Résultat:

['raisins', 'oranges', 'myrtilles']

Étape 2: Comprendre les tuples en Python

Qu’est-ce que les tuples?

Les tuples sont un autre type de structure de données séquentielle en Python, similaire aux listes. Cependant, contrairement aux listes, les tuples sont immuables, ce qui signifie que leurs éléments ne peuvent pas être modifiés une fois créés. Ils sont définis en encadrant les éléments entre parenthèses ( ).

# Définition d'un tuple
mon_tuple = (1, 2, 3, 4)

Quand utiliser des tuples

Les tuples sont généralement utilisés pour des collections d’éléments qui ne doivent pas être modifiés. Les tuples sont plus rapides que les listes, ce qui les rend idéaux pour les opérations en lecture seule. Voici quelques cas d’utilisation courants:

Stocker des constantes ou des données de configuration
Valeurs de retour de fonction avec plusieurs composants
Clés de dictionnaire, car elles sont hashables

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

L’accès aux éléments d’un tuple se fait de la même manière que pour les listes. L’indexation et les tranches fonctionnent de la même manière.

# Accéder aux éléments
premier_element = mon_tuple[0]
tuple_tranche = mon_tuple[1:3]

Opérations sur les tuples

Étant donné que les tuples sont immuables, de nombreuses opérations de liste telles que append() ou remove() ne s’appliquent pas. Cependant, vous pouvez toujours effectuer certaines opérations:

Concaténation: Combinez des tuples en utilisant l’opérateur +.

tuple_concatene = mon_tuple + (5, 6)

Répétition: Répétez un tuple en utilisant l’opérateur *.

tuple_repete = mon_tuple * 2

Appartenance: Vérifiez si un élément existe dans un tuple avec le mot-clé in.

existe = 1 in mon_tuple

Méthodes de tuple

Les tuples ont moins de méthodes intégrées par rapport aux listes, en raison de leur nature immuable. Certaines méthodes utiles incluent:

count(): Compte le nombre d’occurrences d’un élément particulier.

nombre_de_uns = mon_tuple.count(1)

index(): Trouve l’index de la première occurrence d’une valeur.

index_de_premier_un = mon_tuple.index(1)

Emballage et déballage de tuples

L’emballage et le déballage de tuples sont des fonctionnalités pratiques en Python:

Emballage: Attribution de plusieurs valeurs à un seul tuple.

packed_tuple = 1, 2, 3

Déballage: Attribution des éléments du tuple à plusieurs variables.

a, b, c = packed_tuple

Immuables mais pas strictement

Alors que les tuples eux-mêmes sont immuables, ils peuvent contenir des éléments mutables tels que des listes.

# Tuple avec liste mutable
complex_tuple = (1, 2, [3, 4])

Notez que bien que vous ne puissiez pas modifier le tuple lui-même, vous pouvez modifier les éléments mutables à l’intérieur.

Étape 3: Maîtriser les dictionnaires en Python

Qu’est-ce qu’un dictionnaire en Python?

Un dictionnaire en Python est un type de données mutable non ordonné qui stocke des correspondances de clés uniques vers des valeurs. Les dictionnaires sont écrits entre accolades { } et sont constitués de paires clé-valeur séparées par des virgules.

Par exemple:

student = {"name": "Michael", "age": 22, "city": "Chicago"}

Les dictionnaires sont utiles pour stocker des données de manière structurée et accéder aux valeurs par clés.

Création d’un dictionnaire

Les clés du dictionnaire doivent être des objets immuables tels que des chaînes de caractères, des nombres ou des tuples. Les valeurs du dictionnaire peuvent être n’importe quel objet.

student = {"name": "Susan", "age": 23}

prices = {"milk": 4.99, "bread": 2.89}

Manipulation d’un dictionnaire

Les éléments peuvent être accédés, ajoutés, modifiés et supprimés via des clés.

# Accéder à une valeur par clé
print(student["name"])

# Ajouter une nouvelle clé-valeur
student["major"] = "informatique"  

# Modifier une valeur
student["age"] = 25

# Supprimer une clé-valeur
del student["city"]

Méthodes utiles pour les dictionnaires

Quelques méthodes intégrées utiles comprennent:

keys() – Retourne une liste de clés
values() – Retourne une liste de valeurs
items() – Retourne des tuples (clé, valeur)
get() – Retourne la valeur pour une clé, évite les erreurs KeyError
pop() – Supprime une clé et retourne la valeur
update() – Ajoute plusieurs clés-valeurs

Exemple pratique avec des dictionnaires

scores = {"Francis": 95, "John": 88, "Daniel": 82}

# Ajouter un nouveau score
scores["Zoey"] = 97

# Supprimer le score de John
scores.pop("John")  

# Obtenir le score de Daniel
print(scores.get("Daniel"))

# Imprimer tous les noms d'étudiants 
print(scores.keys())

Étape 4: Explorer les ensembles en Python

Qu’est-ce qu’un ensemble en Python?

Un ensemble en Python est une collection non ordonnée et mutable d’objets uniques et immuables. Les ensembles sont écrits entre accolades { } mais contrairement aux dictionnaires, ils n’ont pas de paires clé-valeur.

Par exemple:

numbers = {1, 2, 3, 4}

Les ensembles sont utiles pour les tests d’appartenance, l’élimination des doublons et les opérations mathématiques.

Création d’un ensemble

Les ensembles peuvent être créés à partir de listes en les passant au constructeur set():

ma_liste = [1, 2, 3, 3, 4]
mon_ensemble = set(ma_liste) # {1, 2, 3, 4}

Les ensembles peuvent contenir des types de données mixtes tels que des chaînes de caractères, des booléens, etc.

Manipulation d’un ensemble

Des éléments peuvent être ajoutés et supprimés des ensembles.

numbers.add(5) 

numbers.remove(1)

Opérations utiles sur les ensembles

Quelques opérations utiles sur les ensembles incluent :

union() – Retourne l’union de deux ensembles
intersection() – Retourne l’intersection des ensembles
difference() – Retourne la différence entre les ensembles
symmetric_difference() – Retourne la différence symétrique

Exemple pratique avec des ensembles

A = {1, 2, 3, 4}
B = {2, 3, 5, 6}

# Union - combine les ensembles 
print(A | B) 

# Intersection 
print(A & B)

# Difference  
print(A - B)

# Symmetric difference
print(A ^ B)

Étape 5 : Comparaison des listes, des dictionnaires et des ensembles

Comparaison des caractéristiques

Voici une comparaison concise des quatre structures de données Python que nous avons mentionnées dans ce tutoriel.

Structure	Ordonnée	Modifiable	Éléments en double	Cas d’utilisation
Liste	Oui	Oui	Oui	Stockage de séquences
Tuple	Oui	Non	Oui	Stockage de séquences immuables
Dictionnaire	Non	Oui	Clés : NonValeurs : Oui	Stockage de paires clé-valeur
Ensemble	Non	Oui	Non	Élimination des doublons, tests d’appartenance

Quand utiliser chaque structure de données

Considérez ceci comme une ligne directrice souple pour déterminer quelle structure utiliser en premier dans une situation particulière.

Utilisez des listes pour des données basées sur une séquence ordonnée. Utile pour les piles/les files d’attente.
Utilisez des tuples pour des séquences ordonnées immuables. Utile lorsque vous avez une collection fixe d’éléments qui ne doivent pas être modifiés.
Utilisez des dictionnaires pour des données clé-valeur. Utile pour stocker des propriétés liées.
Utilisez des ensembles pour stocker des éléments uniques et effectuer des opérations mathématiques.

Exemple pratique utilisant les quatre structures de données

Jetons un coup d’œil à la façon dont ces structures peuvent toutes fonctionner ensemble dans un exemple qui est un peu plus complexe qu’une seule ligne.

# Faire une liste de noms de personnes
noms = ["John", "Mary", "Bob", "Mary", "Sarah"]

# Faire un tuple d'informations supplémentaires (par exemple, email)
info_supplementaire = ("[email protected]", "[email protected]", "[email protected]", "[email protected]", "[email protected]")

# Faire un ensemble pour supprimer les doublons
noms_uniques = set(noms)

# Faire un dictionnaire de paires nom-âge
personnes = {}
for nom in noms_uniques:
  personnes[nom] = random.randint(20,40)

print(personnes)

Sortie:

{'John': 34, 'Bob': 29, 'Sarah': 25, 'Mary': 21}

Cet exemple utilise une liste pour une séquence ordonnée, un tuple pour stocker des informations supplémentaires immuables, un ensemble pour supprimer les doublons, et un dictionnaire pour stocker des paires clé-valeur.

Aller plus loin

Dans ce tutoriel complet, nous avons examiné en détail les structures de données fondamentales en Python, y compris les listes, les tuples, les dictionnaires et les ensembles. Ces structures constituent les éléments de base de la programmation Python, fournissant un cadre pour le stockage, le traitement et la manipulation des données. Comprendre ces structures est essentiel pour écrire un code efficace et évolutif. De la manipulation de séquences avec des listes, à l’organisation des données avec des paires clé-valeur dans des dictionnaires, et en assurant l’unicité avec des ensembles, ces outils essentiels offrent une immense flexibilité dans la manipulation des données.

Comme nous l’avons vu à travers des exemples de code, ces structures de données peuvent être combinées de différentes manières pour résoudre des problèmes complexes. En exploitant ces structures de données, vous pouvez ouvrir les portes à une large gamme de possibilités dans l’analyse des données, l’apprentissage automatique, et au-delà. N’hésitez pas à explorer la documentation officielle des structures de données de Python pour plus d’informations.

Bon codage!

Matthew Mayo (@mattmayo13) est titulaire d’une maîtrise en informatique et d’un diplôme d’études supérieures en exploration de données. En tant que rédacteur en chef de VoAGI, Matthew vise à rendre accessibles des concepts complexes de science des données. Ses intérêts professionnels incluent le traitement du langage naturel, les algorithmes d’apprentissage automatique et l’exploration de l’IA émergente. Il est motivé par une mission de démocratisation des connaissances au sein de la communauté des sciences des données. Matthew code depuis l’âge de 6 ans.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!

Python

Was this article helpful?

93 out of 132 found this helpful