Introduction aux listes Python

Les listes représentent une structure de données polyvalente en Python, capable de contenir des éléments de types hétérogènes avec une gestion dynamique de la taille. Ce guide couvre les principes essentiels, les opérations courantes et les fonctionnalités avancées des listes, accompagné d'exemples de code.

Création et accès aux éléments

Une liste est définie en séparant des valeurs par des virgules entre crochets. Pour accéder aux éléments, utilisez un index basé sur zéro, ou un index négatif pour un accès inversé.

# Création d'une liste avec des données diverses
collection = ['Langage C', 'Python', 2023, 2024]
nombres = [10, 20, 30, 40, 50]

# Accès par index positif
print(collection[0])  # Résultat : Langage C
print(collection[2])  # Résultat : 2023

# Accès par index négatif
print(collection[-1])  # Résultat : 2024
print(nombres[-3])    # Résultat : 30

Opérations de découpage

Le découpage permet d'extraire des sous-ensembles de listes avec la syntaxe [début:fin:pas], où début est inclus, fin est exclu, et pas définit l'incrément.

# Exemple de liste pour le découpage
palette = ['rouge', 'orange', 'jaune', 'vert', 'bleu', 'indigo', 'violet']

# Découpage du début jusqu'à un index spécifique
print(palette[:3])  # Résultat : ['rouge', 'orange', 'jaune']

# Découpage d'un index jusqu'à la fin
print(palette[4:])  # Résultat : ['bleu', 'indigo', 'violet']

# Découpage entre deux index
print(palette[1:6])  # Résultat : ['orange', 'jaune', 'vert', 'bleu', 'indigo']

# Découpage avec des index négatifs
print(palette[-3:])  # Résultat : ['bleu', 'indigo', 'violet']

# Découpage avec un pas pour sélectionner des éléments alternés
print(palette[::2])  # Résultat : ['rouge', 'jaune', 'bleu', 'violet']

# Inversion de la liste en utilisant un pas négatif
print(palette[::-1])  # Résultat : ['violet', 'indigo', 'bleu', 'vert', 'jaune', 'orange', 'rouge']

Modification des listes

Les listes sont mutables, ce qui permet de modifier leurs éléments en place. On peut ajouter des éléments avec append() ou insert(), et les supprimer avec del, pop(), ou remove().

# Modification d'un élément par index
sites = ['Google', 'Bing', 'Yahoo', 2019, 2022]
sites[3] = 2023
print("Élément modifié : ", sites[3])  # Résultat : Élément modifié : 2023

# Ajout d'éléments
langues = ['Python', 'Java', 'C++']
langues.append('JavaScript')
print("Après append : ", langues)  # Résultat : Après append : ['Python', 'Java', 'C++', 'JavaScript']

# Utilisation de insert et extend
sequences = [100, 200, 300]
sequences.insert(2, 150)
sequences.extend([400, 500])
print(sequences * 2)  # Résultat : [100, 200, 150, 300, 400, 500, 100, 200, 150, 300, 400, 500]

# Suppression d'éléments
lettres = ['a', 'b', 'c', 'd', 'e', 'f']
del lettres[1]
lettres.pop(2)
lettres.remove('e')
print(lettres)  # Résultat : ['a', 'd', 'f']

Recherche et comptage

Les méthodes count() et index() aident à localiser des éléments et compter leurs occurrences.

# Exemple de comptage et d'indexation
valeurs = [1, 2, 3, 3, 4, 5]
print(valeurs.count(3))  # Résultat : 2
print(valeurs.index(2))  # Résultat : 1

Tri des listes

Le tri peut être effectué en place avec sort() ou sans modification avec sorted().

# Tri avec mélange aléatoire
import aleatoire as a
donnees = [5, 2, 8, 1, 9, 3]
a.shuffle(donnees)
print(donnees)
donnees.sort(reverse=True)
print(donnees)  # Résultat : Liste triée par ordre décroissant

Fusion et déballage

Les listes peuvent être combinées avec l'opérateur + ou répétées avec *. La fonction zip() permet de fusionner des séquences.

# Fusion de listes
liste_a = [1, 2, 3]
liste_b = [4, 5, 6]
print(list(zip(liste_a, liste_b)))  # Résultat : [(1, 4), (2, 5), (3, 6)]

# Opérations sur les listes
print(len([1, 2, 3, 4]))  # Résultat : 4
print([1, 2] + [3, 4])    # Résultat : [1, 2, 3, 4]
print(['hello'] * 3)      # Résultat : ['hello', 'hello', 'hello']
print(2 in [1, 2, 3])     # Résultat : True

Parcours et énumération

La fonction enumerate() fournit l'index et la valeur lors de l'itération. Plusieurs méthodes de parcours sont disponibles.

# Utilisation de enumerate
for idx, lettre in enumerate('abcdef'):
    print(idx, lettre)

# Parcours d'une liste de différentes manieres
elements = ['x', 'y', 'z', 'w']
for el in elements:
    print(el)
for i in range(len(elements)):
    print(i, elements[i])
for index, val in enumerate(elements):
    print(index, val)

Listes imbriquées et comparaison

Les listes peuvent contenir d'autres listes pour des structures complexes. La comparaison suit l'ordre lexicographique des éléments.

# Liste imbriquée
structures = [[10, 20], [30, 40]]
print(structures)  # Résultat : [[10, 20], [30, 40]]

# Comparaison de listes
import operateur as op
seq1 = [1, 2]
seq2 = [2, 3]
seq3 = [2, 3]
print("op.eq(seq1, seq2) : ", op.eq(seq1, seq2))
print("op.eq(seq3, seq2) : ", op.eq(seq3, seq2))

Fonctions et méthodes des listes

Python offre un ensemble complet de foncsions intégrées et de méthodes pour manipuler les listes. Voici un tableau récapitulatif :

Ces fonctions et méthodes offrent une gestion complète des listes, facilitant l'écriture de code efficace et concis en Python.