Listes en Python

Listes Python

Les séquences sont des collections ordonnées fondamentales en Python. Chaque élément d’une séquence possède un index attribué, commençant à 0.

Les types de séquences intégrés de Python incluent les chaînes de caractères, les tuples et les listes. Ce chapitre se concentre sur les listes, qui sont l’une des structures de données les plus polyvalentes et couramment utilisées.

Que sont les listes ?

Une liste est une séquence ordonnée et mutable (modifiable) d’éléments. Les listes sont définies en entourant les éléments séparés par des virgules entre crochets []. Les éléments d’une liste peuvent être de différents types de données.

Création de listes :

# Liste vide
empty_list = []

# Liste d'entiers
numbers = [1, 2, 3, 4, 5]

# Liste de chaînes de caractères
names = ["Alice", "Bob", "Charlie"]

# Liste avec des types de données mixtes
mixed_list = ['physics', 'chemistry', 1997, 2000]

# Liste imbriquée (liste contenant d'autres listes)
nested_list = [1, 2, ['a', 'b'], 3]

print(empty_list)
print(numbers)
print(names)
print(mixed_list)
print(nested_list)

Vous pouvez également créer des listes en utilisant le constructeur list(), souvent utilisé pour convertir d’autres itérables (comme des tuples ou des chaînes) en listes.

tuple_example = (1, 2, 3)
list_from_tuple = list(tuple_example)
print(list_from_tuple) # Sortie : [1, 2, 3]

string_example = "hello"
list_from_string = list(string_example)
print(list_from_string) # Sortie : ['h', 'e', 'l', 'l', 'o']

Accéder aux valeurs dans les listes

Accédez aux éléments en utilisant leur index entre crochets []. L’indexation commence à 0. Les index négatifs comptent à partir de la fin (-1 est le dernier élément). Le découpage (slicing) [début:fin:pas] fonctionne de la même manière qu’avec les chaînes.

#!/usr/bin/env python3

my_list = ['physics', 'chemistry', 1997, 2000, 'math']
numbers = [10, 20, 30, 40, 50, 60, 70]

# Indexation
print(f"my_list[0]: {my_list[0]}")     # Sortie : physics
print(f"my_list[-1]: {my_list[-1]}")   # Sortie : math

# Découpage [début:fin]
print(f"numbers[1:5]: {numbers[1:5]}") # Sortie : [20, 30, 40, 50]
print(f"numbers[:3]: {numbers[:3]}")   # Sortie : [10, 20, 30]
print(f"numbers[4:]: {numbers[4:]}")   # Sortie : [50, 60, 70]

# Découpage avec pas
print(f"numbers[::2]: {numbers[::2]}") # Sortie : [10, 30, 50, 70]

Mise à jour de listes (mutabilité)

Parce que les listes sont mutables, vous pouvez modifier leur contenu. Vous pouvez mettre à jour des éléments uniques ou des tranches (slices) en leur assignant de nouvelles valeurs.

#!/usr/bin/env python3

my_list = ['physics', 'chemistry', 1997, 2000]
print(f"Liste originale : {my_list}")

# Mettre à jour un seul élément
print(f"Valeur à l'index 2 : {my_list[2]}")
my_list[2] = 2001
print(f"Nouvelle valeur à l'index 2 : {my_list[2]}")
print(f"Liste après mise à jour : {my_list}")

# Mettre à jour une tranche
my_list[1:3] = ['biology', 2023] # Remplace les éléments aux index 1 et 2
print(f"Liste après mise à jour de la tranche : {my_list}")

# Insérer des éléments en utilisant le découpage (sans suppression)
my_list[1:1] = ['math', 'stats'] # Insérer à l'index 1
print(f"Liste après insertion par découpage : {my_list}")

Sortie :

Original list: ['physics', 'chemistry', 1997, 2000]
Value at index 2: 1997
New value at index 2: 2001
List after update: ['physics', 'chemistry', 2001, 2000]
List after slice update: ['physics', 'biology', 2023, 2000]
List after slice insertion: ['physics', 'math', 'stats', 'biology', 2023, 2000]

Ajout d’éléments aux listes

• append(item) : Ajoute un seul item à la fin de la liste.
• extend(iterable) : Ajoute tous les items d’un iterable (comme une autre liste, un tuple ou une chaîne) à la fin de la liste.
• insert(index, item) : Insère un item à l’index spécifié.

Exemple :

numbers = [1, 2, 3]
print(f"Liste initiale : {numbers}")

numbers.append(4)
print(f"Après append(4) : {numbers}")

numbers.extend([5, 6])
print(f"Après extend([5, 6]) : {numbers}")

numbers.insert(0, 0) # Insère 0 au début (index 0)
print(f"Après insert(0, 0) : {numbers}")

Sortie :

Initial list: [1, 2, 3]
After append(4): [1, 2, 3, 4]
After extend([5, 6]): [1, 2, 3, 4, 5, 6]
After insert(0, 0): [0, 1, 2, 3, 4, 5, 6]

Suppression d’éléments de liste

Plusieurs façons de supprimer des éléments :

• del nom_liste[index] : Supprime l’élément à l’index spécifié.
• del nom_liste[début:fin] : Supprime la tranche.
• pop([index]) : Supprime et retourne l’élément à l’index (par défaut, le dernier élément, -1).
• remove(value) : Supprime la première occurrence de la value spécifiée. Lève une ValueError si la valeur n’est pas trouvée.

Exemple :

#!/usr/bin/env python3

my_list = ['physics', 'chemistry', 1997, 2000, 'math', 1997]
print(f"Liste originale : {my_list}")

# Utilisation de del par index
del my_list[2] # Supprime l'élément à l'index 2 (1997)
print(f"Après del my_list[2] : {my_list}")

# Utilisation de pop (supprime et retourne le dernier élément par défaut)
last_item = my_list.pop()
print(f"Élément retiré : {last_item}")
print(f"Liste après pop() : {my_list}")

# Utilisation de pop avec index
item_at_1 = my_list.pop(1) # Supprime l'élément à l'index 1 ('chemistry')
print(f"Élément retiré à l'index 1 : {item_at_1}")
print(f"Liste après pop(1) : {my_list}")

# Utilisation de remove par valeur
my_list.remove(2000)
print(f"Liste après remove(2000) : {my_list}")

# Supprime la première occurrence de 1997 (si toujours présente)
if 1997 in my_list:
   my_list.remove(1997)
   print(f"Liste après remove(1997) : {my_list}")
else:
     print("1997 non trouvé pour suppression.")

Sortie :

Original list: ['physics', 'chemistry', 1997, 2000, 'math', 1997]
After del my_list[2]: ['physics', 'chemistry', 2000, 'math', 1997]
Popped item: 1997
List after pop(): ['physics', 'chemistry', 2000, 'math']
Popped item at index 1: chemistry
List after pop(1): ['physics', 2000, 'math']
List after remove(2000): ['physics', 'math']
1997 not found for removal.

Opérations de base sur les listes

Les listes prennent en charge les opérations de séquence courantes :

Expression Python	Résultats	Description
len([1, 2, 3])	3	Longueur : Nombre d’éléments
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	Concaténation : Crée une nouvelle liste
['Hi!'] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	Répétition : Crée une nouvelle liste avec des éléments répétés
3 in [1, 2, 3]	True	Appartenance : Vérifie si l’élément existe
for x in [1, 2, 3]: print(x)	1\n2\n3	Itération : Parcours des éléments

Fonctions et méthodes de liste intégrées

Python inclut des fonctions et des méthodes spécifiques aux listes :

Fonctions intégrées pour les listes :

Fonction	Description
len(liste)	Retourne le nombre d’éléments dans la liste.
max(liste)	Retourne l’élément avec la valeur maximale (les éléments doivent être comparables).
min(liste)	Retourne l’élément avec la valeur minimale (les éléments doivent être comparables).
sum(liste)	Retourne la somme des éléments (les éléments doivent être numériques).
list(itérable)	Convertit un itérable (tuple, chaîne, ensemble, etc.) en liste.
sorted(liste)	Retourne une nouvelle liste triée (la liste originale reste inchangée).
any(liste)	Retourne True si au moins un élément de la liste est True (ou s’évalue à True).
all(liste)	Retourne True si tous les éléments de la liste sont True (ou s’évaluent à True).

Méthodes de liste (modifient la liste sur place, sauf indication contraire) :

Méthode	Description
liste.append(obj)	Ajoute obj à la fin de la liste.
liste.extend(itérable)	Ajoute les éléments de l’itérable à la fin.
liste.insert(index, obj)	Insère obj à l’index.
liste.remove(valeur)	Supprime la première occurrence de valeur. Lève une ValueError si non trouvée.
liste.pop([index])	Supprime et retourne l’élément à l’index (par défaut : dernier). Lève une IndexError si la liste est vide ou l’index est hors limites.
liste.clear()	Supprime tous les éléments de la liste.
liste.index(valeur[, début[, fin]])	Retourne l’index de la première occurrence de valeur. Lève une ValueError si non trouvée.
liste.count(valeur)	Retourne le nombre de fois que valeur apparaît dans la liste.
liste.sort(clé=None, inverse=False)	Trie les éléments de la liste sur place. clé spécifie une fonction pour extraire la clé de comparaison, inverse=True pour le tri décroissant.
liste.reverse()	Inverse les éléments de la liste sur place.
liste.copy()	Retourne une copie superficielle de la liste.

Exemple de sort() vs sorted() :

numbers = [3, 1, 4, 1, 5, 9, 2]

# sorted() retourne une nouvelle liste
new_sorted_list = sorted(numbers)
print(f"Liste originale : {numbers}")
print(f"Nouvelle liste triée : {new_sorted_list}")

# sort() modifie la liste sur place
numbers.sort(reverse=True) # Trie par ordre décroissant
print(f"Liste originale après sort(reverse=True) : {numbers}")

Sortie :

Original list: [3, 1, 4, 1, 5, 9, 2]
New sorted list: [1, 1, 2, 3, 4, 5, 9]
Original list after sort(reverse=True): [9, 5, 4, 3, 2, 1, 1]

Compréhensions de liste (Création concise de listes)

Un moyen puissant et concis de créer des listes basées sur des itérables existants.

Syntaxe : [expression for élément in itérable if condition]

# Crée une liste de carrés de 0 à 9
squares = [x**2 for x in range(10)]
print(f"Carrés : {squares}") # Sortie : [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Crée une liste de nombres pairs de 0 à 19
even_numbers = [x for x in range(20) if x % 2 == 0]
print(f"Nombres pairs : {even_numbers}") # Sortie : [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# Convertit une liste de chaînes en majuscules
words = ['hello', 'world', 'python']
upper_words = [word.upper() for word in words]
print(f"Mots en majuscules : {upper_words}") # Sortie : ['HELLO', 'WORLD', 'PYTHON']