Structures de données
April 15, 2025
0.1 Listes et Dictionnaires
En Python, les listes et les dictionnaires sont deux structures de données couramment utilisées pour
stocker et organiser des informations. Voici comment vous pouvez les utiliser :
0.1.1 Listes
Une liste est une collection ordonnée d’éléments, et chaque élément peut être de n’importe quel
type de données. Les listes sont définies en utilisant des crochets [].
Exemple de création d’une liste et d’accès à ses éléments :
ma_liste = [1, 2, 3, 4, 5]
print(ma_liste[0]) # Accéder au premier élément (indice 0)
print(ma_liste[2]) # Accéder au troisième élément (indice 2)
Vous pouvez également ajouter, supprimer ou modifier des éléments d’une liste :
ma_liste.append(6) # Ajouter un élément à la fin de la liste
ma_liste.insert(2, 7) # Insérer 7 à l'indice 2
ma_liste.remove(3) # Supprimer la première occurrence de 3
ma_liste.pop(4) # Supprimer l'élément à l'indice 4
ma_liste[1] = 10 # Modifier un élément
Créations de liste En Python, vous pouvez créer des listes de différentes manières. Voici
quelques méthodes courantes pour créer des listes :
Création manuelle : Vous pouvez créer une liste en spécifiant ses éléments entre crochets [].
Par exemple :
ma_liste = [1, 2, 3, 4, 5]
Utilisation de la fonction list() : Vous pouvez créer une liste à partir d’une autre séquence
(comme une chaîne de caractères, un tuple, ou même une autre liste) en utilisant la fonction list().
Par exemple :
chaîne = "Python"
liste_de_caractères = list(chaîne)
1
Compréhensions de liste : Les compréhensions de liste sont une manière concise de créer des
listes en Python en appliquant une expression à chaque élément d’une séquence. Par exemple, pour
créer une liste des carrés des nombres de 1 à 5 :
carrés = [x**2 for x in range(1, 6)]
Utilisation de la fonction range() : Vous pouvez créer une liste d’entiers consécutifs en util-
isant la fonction range() et en convertissant le résultat en liste. Par exemple, pour créer une liste
des nombres de 0 à 9 :
nombres = list(range(10))
Listes vides : Vous pouvez créer une liste vide en utilisant [] ou en utilisant le constructeur
list(). Par exemple :
liste_vide = []
autre_liste_vide = list()
Concaténation de listes : Vous pouvez créer une liste en concaténant deux ou plusieurs listes
existantes. Par exemple :
liste1 = [1, 2, 3]
liste2 = [4, 5, 6]
nouvelle_liste = liste1 + liste2
Répétition de listes : Vous pouvez créer une liste en répétant une liste existante plusieurs fois
à l’aide de l’opérateur *. Par exemple :
liste_originale = [1, 2]
liste_répétée = liste_originale * 3 # Crée une liste [1, 2, 1, 2, 1, 2]
Accès aux éléments de la liste Pour accéder aux éléments d’une liste en Python, vous utilisez
l’indice de l’élément. Les indices commencent à 0 pour le premier élément et augmentent de 1 pour
chaque élément suivant. Voici comment accéder aux éléments d’une liste :
Accès à un élément par indice : Vous pouvez accéder à un élément spécifique en utilisant son
indice entre crochets []. Par exemple, pour accéder au premier élément de la liste ma_liste :
[2]: ma_liste = [10, 20, 30, 40, 50]
premier_element = ma_liste[2] # Accès au premier élément (indice 0)
print(premier_element) # Cela affichera 10
30
Accès à un élément par indice négatif : Vous pouvez également utiliser des indices négatifs
pour accéder aux éléments à partir de la fin de la liste. Par exemple, -1 fait référence au dernier
élément, -2 au deuxième élément depuis la fin, et ainsi de suite :
[2]: dernier_element = ma_liste[-1] # Accès au dernier élément
avant_dernier_element = ma_liste[-2] # Accès à l'avant-dernier élément
2
Slicing (tranche) : Vous pouvez extraire une portion (ou tranche) de la liste en spécifiant une
plage d’indices. Le slicing est effectué en utilisant : entre les indices de début et de fin (le dernier
indice spécifié n’est pas inclus). Par exemple :
[3]: ma_liste = [10, 20, 30, 40, 50]
sous_liste = ma_liste[1:4] # Crée une nouvelle liste avec les éléments 20, 30␣
↪et 40
Accès à plusieurs éléments : Vous pouvez également accéder à plusieurs éléments en utilisant
des indices ou des plages d’indices dans une liste. Par exemple :
[4]: ma_liste = [10, 20, 30, 40, 50]
elements = [ma_liste[0], ma_liste[2], ma_liste[4]] # Accès à des éléments␣
↪spécifiques
L’accès aux éléments d’une liste est fondamental en programmation, car cela vous permet de ma-
nipuler les données stockées dans la liste de manière efficace. Veillez à utiliser des indices valides
pour éviter les erreurs d’indice hors limites.
Modification de listes En Python, vous pouvez modifier des listes de plusieurs manières, no-
tamment en ajoutant, supprimant ou modifiant des éléments. Voici quelques opérations courantes
pour la modification de listes :
Ajouter des éléments :
• append(): Ajoute un élément à la fin de la liste.
ma_liste = [1, 2, 3]
ma_liste.append(4) # Ajoute 4 à la fin de la liste
• insert(): Insère un élément à un emplacement spécifique en utilisant un indice.
ma_liste = [1, 2, 3]
ma_liste.insert(1, 4) # Insère 4 à l'indice 1 (entre 1 et 2)
• Extension de liste (+= ou extend()): Vous pouvez ajouter les éléments d’une autre liste à la
fin de la liste existante.
ma_liste = [1, 2, 3]
autre_liste = [4, 5]
ma_liste += autre_liste # Équivalent à ma_liste.extend(autre_liste)
Supprimer des éléments :
• remove(): Supprime la première occurrence d’un élément par sa valeur.
ma_liste = [1, 2, 3, 2]
ma_liste.remove(2) # Supprime la première occurrence de 2
• pop(): Supprime un élément à un indice spécifique et le renvoie.
ma_liste = [1, 2, 3]
element_supprime = ma_liste.pop(1) # Supprime l'élément à l'indice 1 (2) et le renvoie
3
• del: Supprime un élément ou une plage d’éléments par indice.
ma_liste = [1, 2, 3, 4, 5]
del ma_liste[2] # Supprime l'élément à l'indice 2 (3)
Modifier des éléments :
• Vous pouvez simplement réassigner une nouvelle valeur à un élément en utilisant son indice.
ma_liste = [1, 2, 3]
ma_liste[1] = 4 # Remplace l'élément à l'indice 1 (2) par 4
• Vous pouvez également utiliser le slicing pour modifier une plage d’éléments.
ma_liste = [1, 2, 3, 4, 5]
ma_liste[1:3] = [6, 7] # Remplace les éléments 2 et 3 par 6 et 7
#### Méthodes de liste utiles
Python propose un ensemble de méthodes prédéfinies pour les listes qui sont très utiles pour effectuer
des opérations courantes sur les listes. Voici quelques-unes des méthodes de liste les plus utiles :
• append() : Ajoute un élément à la fin de la liste.
ma_liste = [1, 2, 3]
ma_liste.append(4) # ma_liste devient [1, 2, 3, 4]
• extend() : Étend la liste en ajoutant les éléments d’une autre liste à la fin.
ma_liste = [1, 2, 3]
autre_liste = [4, 5]
ma_liste.extend(autre_liste) # ma_liste devient [1, 2, 3, 4, 5]
• insert() : Insère un élément à un indice spécifique.
ma_liste = [1, 2, 3]
ma_liste.insert(1, 4) # ma_liste devient [1, 4, 2, 3]
• remove() : Supprime la première occurrence d’un élément par sa valeur.
ma_liste = [1, 2, 3, 2]
ma_liste.remove(2) # ma_liste devient [1, 3, 2]
• pop() : Supprime un élément à un indice spécifique et le renvoie.
ma_liste = [1, 2, 3]
element_supprime = ma_liste.pop(1) # ma_liste devient [1, 3] et element_supprime vaut 2
• index() : Renvoie l’indice de la première occurrence d’un élément par sa valeur.
ma_liste = [10, 20, 30, 20]
indice = ma_liste.index(20) # indice devient 1
• count() : Renvoie le nombre d’occurrences d’un élément dans la liste.
ma_liste = [1, 2, 2, 3, 2]
occurrences = ma_liste.count(2) # occurrences devient 3
4
• sort() : Trie la liste en place par ordre croissant (par défaut) ou décroissant.
ma_liste = [3, 1, 2]
ma_liste.sort() # ma_liste devient [1, 2, 3]
• reverse() : Inverse l’ordre des éléments de la liste.
ma_liste = [1, 2, 3]
ma_liste.reverse() # ma_liste devient [3, 2, 1]
• copy() : Crée une copie superficielle (shallow copy) de la liste.
ma_liste = [1, 2, 3]
copie = ma_liste.copy() # Crée une copie indépendante de ma_liste
Ces méthodes facilitent la manipulation et la modification des listes en Python. Elles sont très
utiles dans de nombreux scénarios de programmation.
0.1.2 Les Dictionnaires
Introduction aux dictionnaires et à leur structure clé-valeur Un dictionnaire en Python
est une structure de données qui permet de stocker et d’organiser des informations de manière
flexible en utilisant une relation clé-valeur. Contrairement aux listes, qui sont indexées par des
indices numériques, les dictionnaires sont indexés par des clés. Chaque élément dans un dictionnaire
est constitué d’une paire clé-valeur, où la clé est unique et permet d’accéder à la valeur associée.
Création d’un dictionnaire :
Les dictionnaires sont définis en utilisant des accolades {} ou la fonction dict(). Les paires clé-
valeur sont séparées par des deux-points :, et les paires sont séparées par des virgules.
mon_dictionnaire = {"clé1": "valeur1", "clé2": "valeur2", "clé3": "valeur3"}
Accès aux valeurs :
Pour accéder à une valeur dans un dictionnaire, vous utilisez la clé correspondante entre crochets
[] :
valeur = mon_dictionnaire["clé1"] # Accède à la valeur associée à "clé1"
Modification de valeurs :
Vous pouvez modifier la valeur associée à une clé en réaffectant une nouvelle valeur à cette clé :
mon_dictionnaire["clé2"] = "nouvelle_valeur" # Modifie la valeur associée à "clé2"
Ajout de nouvelles paires clé-valeur :
Vous pouvez ajouter de nouvelles paires clé-valeur à un dictionnaire en spécifiant une nouvelle clé
et sa valeur :
mon_dictionnaire["nouvelle_clé"] = "nouvelle_valeur" # Ajoute une nouvelle paire clé-valeur
Suppression de paires clé-valeur :
Vous pouvez supprimer une paire clé-valeur en utilisant l’instruction del :
del mon_dictionnaire["clé3"] # Supprime la paire clé-valeur associée à "clé3"
5
Méthodes de dictionnaire utiles :
• keys(): Renvoie une liste des clés du dictionnaire.
• values(): Renvoie une liste des valeurs du dictionnaire.
• items(): Renvoie une liste de paires clé-valeur sous forme de tuples.
• get(): Renvoie la valeur associée à une clé, en gérant les clés inexistantes.
• in (opérateur d’appartenance): Permet de vérifier si une clé existe dans le dictionnaire.
Exemple d’utilisation d’un dictionnaire en Python :
[5]: informations_personnelles = {
"nom": "Bio",
"prénom": "Mourou",
"âge": 26,
"ville": "Natitingou"
}
print(informations_personnelles["nom"]) # Affiche "Bio"
print(informations_personnelles["âge"]) # Affiche 26
informations_personnelles["profession"] = "Ingénieur" # Ajoute une nouvelle␣
↪paire clé-valeur
del informations_personnelles["ville"] # Supprime la clé "ville"
Bio
26
Les dictionnaires sont extrêmement utiles pour stocker et récupérer des données associées à des clés,
ce qui les rend adaptés à de nombreuses applications, telles que la gestion de données structurées,
les paramètres de configuration, les résultats de requêtes de base de données, etc.
