Les Listes en Python

1. Introduction

1.1 Définition

Une liste en Python est une structure de données fondamentale qui offre une grande flexibilité pour stocker et manipuler des séquences d'éléments. C'est l'une des structures de données les plus utilisées dans le langage Python.

1.2 Contextualisation

Comparaison avec d'autres structures de données Python :

  • Listes : Mutables, ordonnées, permettent les doublons, non hashables.
  • Tuples : Immuables, ordonnés, permettent les doublons, hashables.
  • Ensembles : Mutables, non ordonnés, pas de doublons
  • Dictionnaires : Mutables, ordonnés (depuis Python 3.7), paires clé-valeur uniques

1.3 Cas d'utilisation

Les listes sont particulièrement adaptées pour :

  • Stocker des collections d'éléments ordonnés
  • Manipuler dynamiquement des données (ajout, suppression, modification)
  • Représenter des séquences de valeurs qui peuvent changer
  • Implémenter des structures comme des piles ou des files d'attente
  • Stocker des résultats intermédiaires dans des algorithmes

2. Caractéristiques Fondamentales

2.1 Propriétés de mutabilité

Les listes en Python sont des structures de données mutables, ce qui signifie qu'elles peuvent être modifiées après leur création. Cette propriété permet d'ajouter, supprimer ou modifier des éléments sans avoir à créer une nouvelle liste. 


# Demonstrating mutability of lists
my_list = [1, 2, 3]
print(f"Original list: {my_list}")

# Modifying elements
my_list[0] = 10
print(f"After modifying first element: {my_list}")

# Adding elements
my_list.append(4)
print(f"After appending: {my_list}")

# Removing elements
my_list.remove(2)
print(f"After removing element 2: {my_list}")

2.2 Ordonnancement

Les listes sont des collections ordonnées, ce qui signifie que l'ordre d'insertion des éléments est préservé. Cette propriété permet d'accéder aux éléments par leur position (index) et garantit que l'ordre des éléments reste constant sauf modification explicite. 


# Demonstrating ordered nature of lists
fruits = ["apple", "banana", "orange"]
print(f"Original order: {fruits}")

# Order is preserved when iterating
print("Iterating through the list:")
for i, fruit in enumerate(fruits):
print(f"Position {i}: {fruit}")

# Changing order explicitly
fruits.reverse()
print(f"After reversing: {fruits}")

2.3 Indexation et accès

Les listes Python offrent plusieurs méthodes d'accès aux éléments :

  • Indexation : Accès direct aux éléments par leur position
  • Slicing : Extraction de sous-listes
  • Dépacking : Assignation des éléments à plusieurs variables 

# Indexing, slicing and unpacking
numbers = [10, 20, 30, 40, 50]

# Indexing (positive and negative)
first = numbers[0]      # 10
last = numbers[-1]      # 50

# Slicing
subset = numbers[1:4]   # [20, 30, 40]
even_positions = numbers[::2]  # [10, 30, 50]

# Unpacking
a, b, *rest = numbers
print(f"a = {a}, b = {b}, rest = {rest}")  # a = 10, b = 20, rest = [30, 40, 50]

3. Création et Constructeur

3.1 Syntaxe de création

En Python, les listes peuvent être créées de plusieurs manières :

  • Utilisation des crochets [] (notation littérale)
  • Utilisation du constructeur list()
  • Compréhensions de liste

# Different ways to create lists

# Empty list
empty_list1 = []
empty_list2 = list()

# List with initial values
numbers = [1, 2, 3, 4, 5]
mixed_types = [1, "hello", 3.14, True]

# Using the list() constructor with other iterables
from_tuple = list((1, 2, 3))
from_string = list("Python")
from_range = list(range(5))

# List comprehension
squares = [x**2 for x in range(1, 6)]

print(f"From tuple: {from_tuple}")
print(f"From string: {from_string}")
print(f"From range: {from_range}")
print(f"Squares: {squares}")

3.2 Conversion

Le constructeur list() permet de convertir d'autres types de données itérables en listes : 


# Converting other data types to lists

# From tuple
tuple_data = (10, 20, 30)
list_from_tuple = list(tuple_data)

# From string
string_data = "Hello"
list_from_string = list(string_data)

# From set
set_data = {1, 2, 3, 4}
list_from_set = list(set_data)

# From dictionary (gets the keys)
dict_data = {"a": 1, "b": 2, "c": 3}
list_from_dict_keys = list(dict_data)
list_from_dict_values = list(dict_data.values())
list_from_dict_items = list(dict_data.items())

print(f"From tuple: {list_from_tuple}")
print(f"From string: {list_from_string}")
print(f"From set: {list_from_set}")
print(f"From dict keys: {list_from_dict_keys}")
print(f"From dict values: {list_from_dict_values}")
print(f"From dict items: {list_from_dict_items}")

4. Opérations de Base

4.1 Accès aux éléments

Les listes Python offrent plusieurs méthodes d'accès et de manipulation des éléments :

  • Accès direct : Par index positif ou négatif
  • Modification : Assignation directe par index
  • Ajout : Méthodes append(), insert(), extend()
  • Suppression : Méthodes remove(), pop(), clear() 

# Basic list operations
fruits = ["apple", "banana", "orange", "grape"]

# Accessing elements
first_fruit = fruits[0]    # "apple"
last_fruit = fruits[-1]    # "grape"

# Modifying elements
fruits[1] = "pear"

# Adding elements
fruits.append("mango")           # Add at the end
fruits.insert(2, "kiwi")        # Add at specific position
fruits.extend(["lemon", "lime"]) # Add multiple elements

# Removing elements
fruits.remove("grape")           # Remove by value
popped_fruit = fruits.pop()      # Remove and return last element
popped_at_index = fruits.pop(1)  # Remove at specific index

print(f"Final list: {fruits}")

4.2 Méthodes de recherche

Python fournit plusieurs méthodes pour rechercher des éléments dans une liste :

  • index() : Trouve la position d'un élément
  • count() : Compte les occurrences d'un élément
  • in : Vérifie la présence d'un élément

# Search operations in lists
numbers = [1, 2, 3, 2, 4, 2, 5]

# Finding index of an element
first_position = numbers.index(2)      # Returns 1 (first occurrence)

# Counting occurrences
count_twos = numbers.count(2)          # Returns 3

# Checking existence
is_present = 4 in numbers             # Returns True
is_absent = 6 in numbers              # Returns False

print(f"Position of 2: {first_position}")
print(f"Count of 2: {count_twos}")
print(f"Is 4 present? {is_present}")
print(f"Is 6 present? {is_absent}")

4.3 Opérations de tri

Les listes Python peuvent être triées de différentes manières :

  • sort() : Trie la liste en place
  • sorted() : Crée une nouvelle liste triée
  • reverse() : Inverse l'ordre des éléments

# Sorting operations
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

# Sorting in place
numbers_copy = numbers.copy()
numbers_copy.sort()
print(f"Sorted in place: {numbers_copy}")

# Creating new sorted list
sorted_numbers = sorted(numbers)
print(f"New sorted list: {sorted_numbers}")

# Reverse sorting
numbers_copy.sort(reverse=True)
print(f"Reverse sorted: {numbers_copy}")

# Custom sorting
words = ["banana", "apple", "Cherry", "date"]
words.sort()                    # Case-sensitive sort
print(f"Default sort: {words}")

words.sort(key=str.lower)       # Case-insensitive sort
print(f"Case-insensitive sort: {words}")

5. Compréhensions de Liste

5.1 Syntaxe de base

Les compréhensions de liste sont une syntaxe concise et puissante pour créer des listes en Python. Elles permettent de transformer, filtrer et générer des données en une seule expression.

La syntaxe de base est : [expression for item in iterable] 


# Basic list comprehension examples

# Creating a list of squares
squares = [x**2 for x in range(1, 11)]
print(f"Squares: {squares}")

# Creating a list of even numbers
even_numbers = [x for x in range(20) if x % 2 == 0]
print(f"Even numbers: {even_numbers}")

# Creating a list with string manipulation
names = ["Alice", "Bob", "Charlie", "David"]
greetings = [f"Hello, {name}!" for name in names]
print(f"Greetings: {greetings}")

5.2 Compréhensions avec conditions

Les compréhensions de liste peuvent inclure des conditions pour filtrer les éléments :

  • Filtrage simple : [expression for item in iterable if condition]
  • Expressions conditionnelles : [expression_if if condition else expression_else for item in iterable] 

# List comprehensions with conditions

# Filtering with a condition
numbers = list(range(1, 21))
odd_numbers = [x for x in numbers if x % 2 != 0]
print(f"Odd numbers: {odd_numbers}")

# Using conditional expressions
classify = ["even" if x % 2 == 0 else "odd" for x in range(10)]
print(f"Classification: {classify}")

# Combining multiple conditions
divisible_by_2_and_3 = [x for x in range(1, 31) if x % 2 == 0 and x % 3 == 0]
print(f"Divisible by both 2 and 3: {divisible_by_2_and_3}")

5.3 Compréhensions imbriquées

Les compréhensions de liste peuvent être imbriquées pour créer des structures plus complexes comme des matrices ou pour traiter des données multidimensionnelles. 


# Nested list comprehensions

# Creating a matrix (2D list)
matrix = [[i * j for j in range(1, 6)] for i in range(1, 6)]
for row in matrix:
print(row)

# Flattening a 2D list
matrix_2d = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix_2d for num in row]
print(f"Flattened matrix: {flattened}")

# Creating a dictionary with list comprehension
keys = ["a", "b", "c"]
values = [1, 2, 3]
dict_from_comp = {k: v for k, v in zip(keys, values)}
print(f"Dictionary from comprehension: {dict_from_comp}")

6. Copie et Références

6.1 Références et assignation

En Python, les variables de liste sont des références à des objets en mémoire. Lorsqu'une liste est assignée à une nouvelle variable, les deux variables font référence au même objet. Cela signifie que les modifications apportées via une variable affectent l'autre. 


# References and assignment

# Creating a list
original = [1, 2, 3, 4, 5]

# Assigning to a new variable (creates a reference, not a copy)
reference = original

# Modifying through the reference
reference.append(6)

# Both variables show the change
print(f"Original: {original}")
print(f"Reference: {reference}")

# Checking if they reference the same object
print(f"Same object? {original is reference}")

6.2 Méthodes de copie

Pour créer une copie indépendante d'une liste, Python offre plusieurs méthodes :

  • Copie superficielle : list.copy(), list[:], ou list(list)
  • Copie profonde : copy.deepcopy(list) pour les listes contenant des objets imbriqués 

# Different ways to copy lists
import copy

# Original list with nested elements
original = [1, 2, [3, 4], 5]

# Shallow copy methods
copy_method = original.copy()
slice_copy = original[:]
list_constructor = list(original)

# Deep copy
deep_copy = copy.deepcopy(original)

# Modifying the nested list in the original
original[2][0] = 99

print(f"Original: {original}")
print(f"Copy method: {copy_method}")
print(f"Slice copy: {slice_copy}")
print(f"List constructor: {list_constructor}")
print(f"Deep copy: {deep_copy}")

7. Itération

7.1 Boucles et itération

Les listes Python sont itérables, ce qui permet de parcourir leurs éléments de différentes manières :

  • Boucle for classique
  • Boucle for avec enumerate() pour accéder aux indices
  • Boucle while avec compteur 

# Different ways to iterate through lists
fruits = ["apple", "banana", "cherry", "date"]

# Basic for loop
print("Basic for loop:")
for fruit in fruits:
print(f"- {fruit}")

# For loop with enumerate
print("\nFor loop with enumerate:")
for index, fruit in enumerate(fruits):
print(f"{index}: {fruit}")

# While loop with counter
print("\nWhile loop:")
i = 0
while i < len(fruits):
print(f"[{i}] {fruits[i]}")
i += 1

7.2 Fonctions d'ordre supérieur

Python offre plusieurs fonctions d'ordre supérieur pour travailler avec les listes :

  • map() : Applique une fonction à chaque élément
  • filter() : Filtre les éléments selon une condition
  • reduce() : Réduit la liste à une seule valeur 

# Higher-order functions with lists
from functools import reduce

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Using map() to square each number
squared = list(map(lambda x: x**2, numbers))
print(f"Squared: {squared}")

# Using filter() to get even numbers
even = list(filter(lambda x: x % 2 == 0, numbers))
print(f"Even numbers: {even}")

# Using reduce() to calculate sum
total = reduce(lambda x, y: x + y, numbers)
print(f"Sum: {total}")

# Combining map and filter
even_squared = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers)))
print(f"Even squared: {even_squared}")

8. Performance

8.1 Complexité temporelle

La complexité temporelle des opérations sur les listes Python est importante à comprendre pour écrire du code efficace :

  • Accès par index : O(1) - Temps constant
  • Recherche (in, index) : O(n) - Temps linéaire
  • Insertion/Suppression en fin de liste (append/pop) : O(1) - Temps constant amorti
  • Insertion/Suppression au début ou au milieu : O(n) - Temps linéaire
  • Tri (sort) : O(n log n) - Temps quasi-linéaire 

# Performance demonstration
import time

# Function to measure execution time
def measure_time(func, *args):
start = time.time()
result = func(*args)
end = time.time()
return (end - start) * 1000  # Convert to milliseconds

# Create a large list
large_list = list(range(100000))

# Measure access time (O(1))
access_time = measure_time(lambda lst: lst[50000], large_list)
print(f"Access time: {access_time:.4f} ms")

# Measure search time (O(n))
search_time = measure_time(lambda lst: 99999 in lst, large_list)
print(f"Search time: {search_time:.4f} ms")

# Measure append time (O(1) amortized)
append_time = measure_time(lambda lst: lst.append(100000), large_list.copy())
print(f"Append time: {append_time:.4f} ms")

# Measure insert at beginning time (O(n))
insert_time = measure_time(lambda lst: lst.insert(0, -1), large_list.copy())
print(f"Insert at beginning time: {insert_time:.4f} ms")

8.2 Optimisations

Quelques conseils pour optimiser l'utilisation des listes en Python :

  • Préférer les compréhensions de liste aux boucles pour la création et la transformation
  • Utiliser collections.deque pour les insertions/suppressions fréquentes au début
  • Préallouer la taille des listes lorsque c'est possible
  • Utiliser numpy.array pour les opérations numériques intensives 

# Optimization examples
import time
from collections import deque

# Comparing list vs deque for frequent insertions at the beginning
def test_list_insertions(n):
lst = []
start = time.time()
for i in range(n):
lst.insert(0, i)
return time.time() - start

def test_deque_insertions(n):
dq = deque()
start = time.time()
for i in range(n):
dq.appendleft(i)
return time.time() - start

# Run comparison
n = 10000
list_time = test_list_insertions(n)
deque_time = test_deque_insertions(n)

print(f"List insertions: {list_time:.4f} seconds")
print(f"Deque insertions: {deque_time:.4f} seconds")
print(f"Deque is {list_time/deque_time:.1f}x faster")

# Preallocating list size
start = time.time()
growing_list = []
for i in range(10000):
growing_list.append(i)
growing_time = time.time() - start

start = time.time()
preallocated = [None] * 10000
for i in range(10000):
preallocated[i] = i
preallocated_time = time.time() - start

print(f"Growing list: {growing_time:.4f} seconds")
print(f"Preallocated: {preallocated_time:.4f} seconds")

9. Cas d'Utilisation Pratiques

9.1 Implémentation de structures de données

Les listes Python peuvent être utilisées pour implémenter diverses structures de données :

  • Pile (Stack) : Utilisation de append() et pop()
  • File (Queue) : Utilisation de append() et pop(0) (mais collections.deque est plus efficace)
  • Graphe : Représentation par liste d'adjacence 

# Implementing data structures with lists

# Stack implementation
class Stack:
def __init__(self):
self.items = []

def push(self, item):
self.items.append(item)

def pop(self):
if not self.is_empty():
return self.items.pop()
return None

def peek(self):
if not self.is_empty():
return self.items[-1]
return None

def is_empty(self):
return len(self.items) == 0

def size(self):
return len(self.items)


# Implementing data structures with lists

# Queue implementation (inefficient with large data)
class Queue:
def __init__(self):
self.items = []

def enqueue(self, item):
self.items.append(item)

def dequeue(self):
if not self.is_empty():
return self.items.pop(0)  # O(n) operation
return None

def is_empty(self):
return len(self.items) == 0

def size(self):
return len(self.items)




# Implementing data structures with lists


# Graph representation using adjacency list
class Graph:
def __init__(self):
self.adjacency_list = {}

def add_vertex(self, vertex):
if vertex not in self.adjacency_list:
self.adjacency_list[vertex] = []

def add_edge(self, vertex1, vertex2):
self.add_vertex(vertex1)
self.add_vertex(vertex2)
self.adjacency_list[vertex1].append(vertex2)
self.adjacency_list[vertex2].append(vertex1)  # For undirected graph

def get_neighbors(self, vertex):
return self.adjacency_list.get(vertex, [])

9.2 Manipulation de données

Les listes sont couramment utilisées pour la manipulation et l'analyse de données :

  • Traitement de données tabulaires
  • Analyse statistique
  • Transformation et nettoyage de données

# Data manipulation examples

# Sample dataset: Student records [name, age, grade]
students = [
["Alice", 22, 85],
["Bob", 19, 92],
["Charlie", 21, 78],
["Diana", 20, 95],
["Eve", 22, 88]
]

# Extracting columns
names = [student[0] for student in students]
ages = [student[1] for student in students]
grades = [student[2] for student in students]

# Basic statistics
avg_age = sum(ages) / len(ages)
avg_grade = sum(grades) / len(grades)
max_grade = max(grades)
min_grade = min(grades)

print(f"Average age: {avg_age:.1f}")
print(f"Average grade: {avg_grade:.1f}")
print(f"Grade range: {min_grade} - {max_grade}")

# Filtering data
high_performers = [student for student in students if student[2] >= 90]
print(f"High performers: {high_performers}")

# Transforming data (adding pass/fail status)
with_status = [[*student, "Pass" if student[2] >= 80 else "Fail"] for student in students]

# Sorting by grade
sorted_by_grade = sorted(students, key=lambda student: student[2], reverse=True)
print("Top students:")
for student in sorted_by_grade[:3]:
print(f"{student[0]}: {student[2]}")

10. Exercices

10.1 Exercice 1: Manipulation de base

Créez une liste de nombres de 1 à 10, puis effectuez les opérations suivantes :

  • Ajoutez le nombre 11 à la fin de la liste
  • Insérez le nombre 0 au début de la liste
  • Supprimez le nombre 5 de la liste
  • Triez la liste en ordre décroissant
  • Créez une nouvelle liste contenant uniquement les nombres pairs de la liste originale 

# Exercice 1: Solution

# Créer une liste de nombres de 1 à 10
numbers = list(range(1, 11))
print(f"Liste initiale: {numbers}")

# 1. Ajouter 11 à la fin
numbers.append(11)
print(f"Après ajout de 11: {numbers}")

# 2. Insérer 0 au début
numbers.insert(0, 0)
print(f"Après insertion de 0: {numbers}")

# 3. Supprimer le nombre 5
numbers.remove(5)
print(f"Après suppression de 5: {numbers}")

# 4. Trier en ordre décroissant
numbers.sort(reverse=True)
print(f"Après tri décroissant: {numbers}")

# 5. Créer une liste des nombres pairs
even_numbers = [num for num in numbers if num % 2 == 0]
print(f"Nombres pairs: {even_numbers}")

10.2 Exercice 2: Manipulation avancée

Vous avez une liste de dictionnaires représentant des produits dans un inventaire. Chaque dictionnaire contient les clés 'nom', 'prix', et 'quantité'. Réalisez les opérations suivantes :

  • Créez une liste des noms de produits dont la quantité est inférieure à 5
  • Calculez la valeur totale de l'inventaire (prix × quantité pour chaque produit)
  • Trouvez le produit le plus cher
  • Ajoutez une clé 'valeur' à chaque dictionnaire, contenant le prix × quantité
  • Triez les produits par valeur décroissante

# Exercice 2: Solution

# Liste de produits
produits = [
{"nom": "Ordinateur", "prix": 1200, "quantité": 5},
{"nom": "Écran", "prix": 250, "quantité": 8},
{"nom": "Clavier", "prix": 80, "quantité": 12},
{"nom": "Souris", "prix": 50, "quantité": 25},
{"nom": "Disque dur", "prix": 120, "quantité": 3},
{"nom": "Câble HDMI", "prix": 15, "quantité": 4}
]

# 1. Liste des produits avec quantité < 5
produits_faible_stock = [p["nom"] for p in produits if p["quantité"] < 5]
print(f"Produits en faible quantité: {produits_faible_stock}")

# 2. Valeur totale de l'inventaire
valeur_totale = sum(p["prix"] * p["quantité"] for p in produits)
print(f"Valeur totale de l'inventaire: {valeur_totale} €")

# 3. Produit le plus cher
produit_plus_cher = max(produits, key=lambda p: p["prix"])
print(f"Produit le plus cher: {produit_plus_cher['nom']} ({produit_plus_cher['prix']} €)")

# 4. Ajouter la clé 'valeur' à chaque produit
for produit in produits:
produit["valeur"] = produit["prix"] * produit["quantité"]

# 5. Trier par valeur décroissante
produits_tries = sorted(produits, key=lambda p: p["valeur"], reverse=True)

# Afficher les résultats
print("\nProduits triés par valeur:")
for p in produits_tries:
print(f"{p['nom']}: {p['valeur']} € ({p['quantité']} × {p['prix']} €)")

10.3 Exercice 3: Traitement de données

Vous disposez d'une liste de chaînes de caractères représentant des données de température. Chaque chaîne est au format "ville:température". Effectuez les opérations suivantes :

  • Convertissez cette liste en une liste de tuples (ville, température)
  • Calculez la température moyenne
  • Trouvez la ville la plus chaude et la plus froide
  • Regroupez les villes par plage de température (0-10°C, 11-20°C, 21-30°C) 

# Exercice 3: Solution

# Données de température
donnes_temp = [
"Paris:21", "Lyon:19", "Marseille:25", "Lille:14", 
"Bordeaux:22", "Strasbourg:16", "Nantes:20", "Toulouse:24"
]

# 1. Conversion en tuples (ville, température)
temperatures = [(ville_temp.split(":")[0], int(ville_temp.split(":")[1])) 
for ville_temp in donnes_temp]
print("Données converties:")
for ville, temp in temperatures:
print(f"{ville}: {temp}°C")

# 2. Température moyenne
temp_values = [temp for _, temp in temperatures]
temp_moyenne = sum(temp_values) / len(temp_values)
print(f"\nTempérature moyenne: {temp_moyenne:.1f}°C")

# 3. Ville la plus chaude et la plus froide
ville_plus_chaude = max(temperatures, key=lambda x: x[1])
ville_plus_froide = min(temperatures, key=lambda x: x[1])
print(f"Ville la plus chaude: {ville_plus_chaude[0]} ({ville_plus_chaude[1]}°C)")
print(f"Ville la plus froide: {ville_plus_froide[0]} ({ville_plus_froide[1]}°C)")

# 4. Regroupement par plage de température
plages_temp = {
"0-10°C": [],
"11-20°C": [],
"21-30°C": []
}

for ville, temp in temperatures:
if 0 <= temp <= 10:
plages_temp["0-10°C"].append(ville)
elif 11 <= temp <= 20:
plages_temp["11-20°C"].append(ville)
elif 21 <= temp <= 30:
plages_temp["21-30°C"].append(ville)

print("\nVilles par plage de température:")
for plage, villes in plages_temp.items():
print(f"{plage}: {', '.join(villes)}")

11. Résumé et Comparaisons

Points clés à retenir sur les listes Python :

  • Structure de données mutable et ordonnée
  • Accès indexé et support du slicing
  • Nombreuses méthodes intégrées pour la manipulation
  • Support des opérations de base (concaténation, répétition)
  • Différentes façons de copier (référence, shallow copy, deep copy)
  • Syntaxe concise avec les list comprehensions

Bonnes Pratiques

  • Utilisez des noms descriptifs pour vos listes
  • Privilégiez les listes homogènes pour une meilleure performance
  • Évitez de modifier les listes pendant l'itération
  • Préférez extend() à + pour concatener des listes
  • Utilisez les list comprehensions pour un code plus concis

12. Conclusion

Les listes sont l'une des structures de données les plus polyvalentes et les plus utilisées en Python. Leur flexibilité et leur large éventail de méthodes intégrées en font un outil essentiel pour tout développeur Python.

Points clés à retenir :

  • Les listes sont mutables, ordonnées et peuvent contenir des éléments de types différents
  • Elles offrent un accès rapide par index et de nombreuses méthodes de manipulation
  • Les compréhensions de liste fournissent une syntaxe élégante pour créer et transformer des listes
  • Les listes sont particulièrement adaptées au traitement de données séquentielles
  • Comprendre les performances des opérations sur les listes est crucial pour écrire du code efficace

Maîtriser les listes et leurs opérations vous permettra de résoudre efficacement une grande variété de problèmes de programmation.

That's all folks