Listes : séquences ordonnées et modifiables

Qu'est-ce qu'une liste en Python ? Définition et caractéristiques

En Python, une liste est une structure de données qui permet de stocker une séquence ordonnée d'éléments. Ces éléments peuvent être de types différents (nombres, chaînes de caractères, booléens, autres listes, etc.).

Les principales caractéristiques des listes sont :

• Ordonnées : Les éléments d'une liste sont stockés dans un ordre précis, et cet ordre est conservé.
• Modifiables (mutables) : Vous pouvez modifier le contenu d'une liste après sa création (ajouter, supprimer, modifier des éléments).
• Indexées : Vous pouvez accéder à chaque élément d'une liste par sa position (son indice), en commençant par 0 pour le premier élément.
• Hétérogènes : Une liste peut contenir des éléments de types différents.
• Dynamiques : La taille d'une liste peut changer au cours de l'exécution du programme.

Les listes sont l'une des structures de données les plus utilisées en Python, en raison de leur flexibilité et de leur facilité d'utilisation.

Créer une liste : différentes méthodes

Il existe plusieurs façons de créer une liste en Python :

• Utiliser des crochets `[]` : C'est la méthode la plus courante. Vous pouvez créer une liste vide ou une liste contenant des éléments initiaux.
• Utiliser la fonction `list()` : Vous pouvez convertir un itérable (comme une chaîne de caractères, un tuple, ou un ensemble) en liste.
• Utiliser une compréhension de liste : Comme nous l'avons vu dans la section précédente.

Exemples :

# Liste vide
liste_vide = []

# Liste avec des éléments initiaux
nombres = [1, 2, 3, 4, 5]
couleurs = ["rouge", "vert", "bleu"]

# Liste hétérogène
mixte = [1, "Bonjour", True, 3.14]

# Liste à partir d'une chaîne de caractères
lettres = list("Python")  # ['P', 'y', 't', 'h', 'o', 'n']

# Liste à partir d'un tuple
mon_tuple = (1,2,3)
ma_liste = list(mon_tuple) # [1, 2, 3]

# Liste créée avec une compréhension de liste
carres = [x**2 for x in range(10)]

Accéder aux éléments d'une liste : indexation et slicing

Vous pouvez accéder aux éléments individuels d'une liste par leur indice (leur position dans la liste), en utilisant des crochets `[]`. L'indexation commence à 0 (le premier élément a l'indice 0, le deuxième élément a l'indice 1, etc.).

Exemples :

nombres = [10, 20, 30, 40, 50]

print(nombres[0])  # Affiche 10 (le premier élément)
print(nombres[2])  # Affiche 30 (le troisième élément)
print(nombres[-1]) # Affiche 50 (le dernier élément, les indices négatifs comptent à partir de la fin)

Si vous essayez d'accéder à un indice qui n'existe pas (par exemple, un indice supérieur ou égal à la longueur de la liste), Python lèvera une erreur `IndexError`.

Vous pouvez modifier un élément existant en utilisant l'indexation et l'opérateur d'affectation `=` :

nombres[1] = 25
print(nombres)  # Affiche [10, 25, 30, 40, 50]

Le **slicing** (tranchage) permet d'extraire une sous-liste d'une liste. La syntaxe est la suivante : `liste[debut:fin:pas]`.

• `debut` : L'indice de début de la tranche (inclus). S'il est omis, il est considéré comme 0.
• `fin` : L'indice de fin de la tranche (exclu). S'il est omis, il est considéré comme la longueur de la liste.
• `pas` : Le pas (l'intervalle entre les éléments). S'il est omis, il est considéré comme 1.

Exemples :

nombres = [10, 20, 30, 40, 50, 60, 70, 80, 90]

print(nombres[2:5])    # Affiche [30, 40, 50] (du troisième au cinquième élément)
print(nombres[:4])     # Affiche [10, 20, 30, 40] (du début jusqu'au quatrième élément)
print(nombres[5:])     # Affiche [60, 70, 80, 90] (du sixième élément jusqu'à la fin)
print(nombres[::2])    # Affiche [10, 30, 50, 70, 90] (un élément sur deux)
print(nombres[::-1])   # Affiche [90, 80, 70, 60, 50, 40, 30, 20, 10] (inverse la liste)

Méthodes courantes pour manipuler les listes

Les listes Python offrent de nombreuses méthodes pour les manipuler. Voici quelques-unes des méthodes les plus courantes :

• `append(element)` : Ajoute un élément à la fin de la liste.
• `insert(index, element)` : Insère un élément à une position donnée.
• `extend(iterable)` : Ajoute tous les éléments d'un itérable à la fin de la liste.
• `remove(element)` : Supprime la première occurrence d'un élément de la liste.
• `pop(index=-1)` : Supprime et retourne l'élément à une position donnée (par défaut, le dernier élément).
• `index(element, start=0, end=len(list))` : Retourne l'indice de la première occurrence d'un élément dans la liste (entre `start` et `end` optionnels).
• `count(element)` : Retourne le nombre d'occurrences d'un élément dans la liste.
• `sort(key=None, reverse=False)` : Trie la liste en place (modifie la liste originale). `key` permet de spécifier une fonction pour extraire une clé de tri, et `reverse=True` permet de trier en ordre décroissant.
• `reverse()` : Inverse l'ordre des éléments de la liste en place.
• `copy()` : Retourne une copie superficielle de la liste.
• `clear()` : Supprime tous les éléments de la liste.

Exemples :

nombres = [1, 2, 3]

nombres.append(4)      # [1, 2, 3, 4]
nombres.insert(1, 5)    # [1, 5, 2, 3, 4]
nombres.extend([6, 7])  # [1, 5, 2, 3, 4, 6, 7]
nombres.remove(2)      # [1, 5, 3, 4, 6, 7]
valeur = nombres.pop(2) # valeur = 3, nombres = [1, 5, 4, 6, 7]

print(nombres.index(5)) # 1 (indice de la première occurence de 5)

nombres.sort()          # Trie la liste en place : [1, 4, 5, 6, 7]
nombres.reverse()       # Inverse la liste en place : [7, 6, 5, 4, 1]

Pièges à éviter et bonnes pratiques

Voici quelques pièges à éviter et bonnes pratiques lors de la manipulation de listes en Python :

• Modification d'une liste pendant l'itération : Il faut faire très attention lorsque vous modifiez une liste (en ajoutant ou supprimant des éléments) pendant que vous itérez dessus avec une boucle `for`. Cela peut entraîner des comportements inattendus. Il est souvent préférable de créer une nouvelle liste ou d'utiliser une compréhension de liste.
• Copies de listes : Affecter une liste à une autre variable ne crée pas une copie de la liste, mais une nouvelle référence vers la même liste. Pour créer une copie indépendante, utilisez la méthode `copy()` (copie superficielle) ou la fonction `deepcopy()` du module `copy` (copie profonde).
• Utilisation de `+` pour la concaténation dans une boucle : Utiliser l'opérateur `+` pour concaténer des listes à l'intérieur d'une boucle peut être inefficace, car cela crée une nouvelle liste à chaque itération. Il est préférable d'utiliser la méthode `extend()` ou une compréhension de liste.
• Recherche d'éléments avec `in` : L'opérateur `in` permet de vérifier si un élément est présent dans une liste. Cependant, cette opération a une complexité linéaire (O(n)), ce qui signifie que le temps nécessaire augmente proportionnellement à la taille de la liste. Pour des recherches fréquentes dans de grandes listes, il peut être préférable d'utiliser une autre structure de données, comme un ensemble (`set`) ou un dictionnaire (`dict`).

En suivant ces conseils, vous éviterez les erreurs courantes et vous écrirez du code plus efficace et plus lisible.