Manipuler les Listes en Python

PythonBeginner
Pratiquer maintenant

Introduction

Dans ce laboratoire, vous acquerrez une expérience pratique de la manipulation des listes en Python. Les listes sont une structure de données fondamentale pour stocker des collections d'éléments ordonnés. Vous apprendrez à créer, accéder, ajouter, supprimer et modifier des éléments de liste.

De plus, ce laboratoire vous guidera à travers des opérations plus avancées telles que le tri, la requête (querying) et l'imbrication des listes. À la fin de ce laboratoire, vous aurez une solide compréhension de la manière de travailler efficacement avec les listes pour gérer et traiter les données dans vos programmes Python.

Ceci est un Guided Lab, qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent que c'est un laboratoire de niveau débutant avec un taux de réussite de 100%. Il a reçu un taux d'avis positifs de 100% de la part des apprenants.

Créer et Accéder aux Listes

Dans cette étape, vous apprendrez à créer des listes et à accéder à leurs éléments. Les listes sont des collections d'éléments ordonnées et mutables, et constituent l'un des types de données les plus polyvalents de Python.

Les listes sont créées en utilisant des crochets [], les éléments étant séparés par des virgules. Commençons par créer quelques listes.

Dans l'explorateur de fichiers du WebIDE à gauche, trouvez et ouvrez le fichier list_creation.py situé dans le répertoire ~/project. Ajoutez le code suivant au fichier :

## Create an empty list
empty_list = []
print("Empty list:", empty_list)
print("Type of empty_list:", type(empty_list))

## Create a list of numbers
numbers = [10, 20, 30, 40, 50]
print("Numbers list:", numbers)

## Lists can contain elements of different data types
mixed_list = [1, 'hello', 3.14, True]
print("Mixed data type list:", mixed_list)

## You can also create a list from another iterable, like a string
string_list = list("python")
print("List from a string:", string_list)

Après avoir ajouté le code, enregistrez le fichier. Pour exécuter le script, ouvrez le terminal intégré dans le WebIDE et exécutez la commande suivante :

python ~/project/list_creation.py

Vous devriez voir la sortie suivante, démontrant différentes manières de créer une liste :

Empty list: []
Type of empty_list: <class 'list'>
Numbers list: [10, 20, 30, 40, 50]
Mixed data type list: [1, 'hello', 3.14, True]
List from a string: ['p', 'y', 't', 'h', 'o', 'n']

Ensuite, explorons comment accéder aux éléments d'une liste. Vous pouvez accéder aux éléments par leur index (position). L'indexation des listes commence à 0. Vous pouvez également utiliser des indices négatifs, où -1 fait référence au dernier élément.

Le découpage (slicing) vous permet d'accéder à une plage d'éléments. La syntaxe est list[start:stop:step].

Ajoutez le code suivant à la fin de votre fichier list_creation.py :

## Accessing list elements
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi']
print("\n--- Accessing Elements ---")
print("Fruits list:", fruits)

## Access the first element (index 0)
print("First element:", fruits[0])

## Access the last element (index -1)
print("Last element:", fruits[-1])

## Slicing: get elements from index 1 up to (but not including) index 4
print("Slice [1:4]:", fruits[1:4])

## Slicing: get all elements from the beginning up to index 3
print("Slice [:3]:", fruits[:3])

## Slicing: get all elements from index 2 to the end
print("Slice [2:]:", fruits[2:])

## Slicing: get a copy of the entire list
print("Slice [:] (a copy):", fruits[:])

## Slicing with a step: get every second element
print("Slice [::2]:", fruits[::2])

## Slicing to reverse the list
print("Reversed list [::-1]:", fruits[::-1])

Enregistrez le fichier et exécutez à nouveau le script depuis le terminal :

python ~/project/list_creation.py

Observez la nouvelle sortie pour comprendre le fonctionnement de l'indexation et du découpage :

Empty list: []
Type of empty_list: <class 'list'>
Numbers list: [10, 20, 30, 40, 50]
Mixed data type list: [1, 'hello', 3.14, True]
List from a string: ['p', 'y', 't', 'h', 'o', 'n']

--- Accessing Elements ---
Fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi']
First element: orange
Last element: kiwi
Slice [1:4]: ['apple', 'pear', 'banana']
Slice [:3]: ['orange', 'apple', 'pear']
Slice [2:]: ['pear', 'banana', 'kiwi']
Slice [:] (a copy): ['orange', 'apple', 'pear', 'banana', 'kiwi']
Slice [::2]: ['orange', 'pear', 'kiwi']
Reversed list [::-1]: ['kiwi', 'banana', 'pear', 'apple', 'orange']

Vous avez maintenant appris à créer des listes et à accéder à leur contenu.

Modifier les Listes : Ajouter, Supprimer et Changer des Éléments

Dans cette étape, vous apprendrez à modifier les listes. Puisque les listes sont mutables, vous pouvez ajouter, supprimer ou changer leurs éléments après leur création.

Concentrons-nous d'abord sur l'ajout d'éléments. Python fournit plusieurs méthodes :

  • append() : Ajoute un seul élément à la fin de la liste.
  • extend() : Ajoute tous les éléments d'un itérable (comme une autre liste) à la fin.
  • insert() : Ajoute un élément à un index spécifique.

Ouvrez le fichier list_modification.py dans l'explorateur de fichiers du WebIDE. Ajoutez-y le code suivant :

## --- Adding Elements ---
my_list = [1, 2, 3]
print("Original list:", my_list)

## Add an element using append()
my_list.append(4)
print("After append(4):", my_list)

## Add multiple elements using extend()
my_list.extend([5, 6])
print("After extend([5, 6]):", my_list)

## Insert an element at a specific position
my_list.insert(1, 1.5) ## Insert 1.5 at index 1
print("After insert(1, 1.5):", my_list)

Enregistrez le fichier et exécutez-le depuis le terminal :

python ~/project/list_modification.py

Votre sortie devrait montrer la liste s'allonger à chaque opération :

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

Ensuite, pratiquons la suppression d'éléments. Les méthodes clés incluent :

  • remove() : Supprime la première occurrence d'une valeur spécifiée.
  • pop() : Supprime et retourne l'élément à un index donné (ou le dernier élément si aucun index n'est spécifié).
  • del : Une instruction pour supprimer un élément ou une tranche (slice) par index.
  • clear() : Supprime tous les éléments de la liste.

Ajoutez le code suivant à la fin de list_modification.py :

## --- Removing Elements ---
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple']
print("\n--- Removing Elements ---")
print("Original fruits list:", fruits)

## Remove the last element using pop()
popped_item = fruits.pop()
print("After pop():", fruits)
print("Popped item:", popped_item)

## Remove an element by its value using remove()
fruits.remove('pear')
print("After remove('pear'):", fruits)

## Remove an element by its index using del
del fruits[1] ## Deletes 'apple' at index 1
print("After del fruits[1]:", fruits)

## Clear all elements from the list
fruits.clear()
print("After clear():", fruits)

Enfin, vous pouvez modifier les éléments existants en assignant une nouvelle valeur à un index ou à une tranche (slice). Ajoutez ce dernier bloc de code à list_modification.py :

## --- Changing Elements ---
letters = ['a', 'b', 'c', 'd', 'e']
print("\n--- Changing Elements ---")
print("Original letters list:", letters)

## Change a single element
letters[0] = 'A'
print("After changing index 0:", letters)

## Change a slice of elements
letters[1:3] = ['B', 'C']
print("After changing slice [1:3]:", letters)

Enregistrez le fichier et exécutez le script une dernière fois :

python ~/project/list_modification.py

La sortie complète démontrera toutes les techniques de modification que vous avez apprises :

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

--- Removing Elements ---
Original fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple']
After pop(): ['orange', 'apple', 'pear', 'banana', 'kiwi']
Popped item: apple
After remove('pear'): ['orange', 'apple', 'banana', 'kiwi']
After del fruits[1]: ['orange', 'banana', 'kiwi']
After clear(): []

--- Changing Elements ---
Original letters list: ['a', 'b', 'c', 'd', 'e']
After changing index 0: ['A', 'b', 'c', 'd', 'e']
After changing slice [1:3]: ['A', 'B', 'C', 'd', 'e']

Vous maîtrisez maintenant l'ajout, la suppression et la modification des éléments dans une liste Python.

Opérations Avancées sur les Listes : Tri, Interrogation et Imbrication

Dans cette dernière étape, vous explorerez des opérations de liste plus avancées, y compris le tri, la requête d'informations et le travail avec des listes imbriquées (nested lists).

Commençons par le tri. La méthode sort() modifie la liste sur place (in-place). Vous pouvez trier par ordre croissant ou décroissant.

Ouvrez le fichier list_operations.py dans le WebIDE. Ajoutez le code suivant pour démontrer le tri :

## --- Sorting Lists ---
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print("--- Sorting Lists ---")
print("Original numbers list:", numbers)

## Sort the list in-place (ascending)
numbers.sort()
print("After sort():", numbers)

## Sort the list in descending order
numbers.sort(reverse=True)
print("After sort(reverse=True):", numbers)

## The reverse() method simply reverses the order, it does not sort
letters = ['a', 'b', 'c', 'd']
print("\nOriginal letters list:", letters)
letters.reverse()
print("After reverse():", letters)

Enregistrez le fichier et exécutez-le depuis le terminal :

python ~/project/list_operations.py

La sortie montre les listes triées et inversées :

--- Sorting Lists ---
Original numbers list: [3, 1, 4, 1, 5, 9, 2, 6]
After sort(): [1, 1, 2, 3, 4, 5, 6, 9]
After sort(reverse=True): [9, 6, 5, 4, 3, 2, 1, 1]

Original letters list: ['a', 'b', 'c', 'd']
After reverse(): ['d', 'c', 'b', 'a']

Ensuite, interrogeons une liste pour trouver des informations.

  • count() : Retourne le nombre de fois où une valeur apparaît.
  • index() : Retourne l'index de la première occurrence d'une valeur.

Ajoutez le code suivant à list_operations.py :

## --- Querying Lists ---
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
print("\n--- Querying Lists ---")
print("Fruits list:", fruits)

## Count the occurrences of an element
apple_count = fruits.count('apple')
print("Count of 'apple':", apple_count)

## Find the index of the first occurrence of an element
banana_index = fruits.index('banana')
print("Index of first 'banana':", banana_index)

Enfin, examinons les listes imbriquées (nested lists). Une liste imbriquée est une liste qui contient d'autres listes comme éléments. Ceci est utile pour créer des structures 2D comme une matrice ou une grille.

Ajoutez ce dernier bloc de code à list_operations.py :

## --- Nested Lists ---
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print("\n--- Nested Lists ---")
print("Matrix:", matrix)

## Access an entire inner list (a row)
first_row = matrix[0]
print("First row:", first_row)

## Access a specific element in the nested list
## To get the element '6', we access row 1, then column 2
element = matrix[1][2]
print("Element at matrix[1][2]:", element)

Enregistrez le fichier et exécutez le script une dernière fois :

python ~/project/list_operations.py

La sortie complète démontrera le tri, la requête et l'accès aux listes imbriquées :

--- Sorting Lists ---
Original numbers list: [3, 1, 4, 1, 5, 9, 2, 6]
After sort(): [1, 1, 2, 3, 4, 5, 6, 9]
After sort(reverse=True): [9, 6, 5, 4, 3, 2, 1, 1]

Original letters list: ['a', 'b', 'c', 'd']
After reverse(): ['d', 'c', 'b', 'a']

--- Querying Lists ---
Fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
Count of 'apple': 2
Index of first 'banana': 3

--- Nested Lists ---
Matrix: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
First row: [1, 2, 3]
Element at matrix[1][2]: 6

Vous maîtrisez maintenant plusieurs techniques avancées pour travailler avec les listes Python.

Résumé

Dans ce laboratoire, vous avez appris les bases de la manipulation des listes en Python. Vous avez commencé par créer des listes en utilisant les crochets [] et le constructeur list(). Vous vous êtes exercé à accéder aux éléments de la liste par indexation et découpage (slicing), ce qui est essentiel pour récupérer des éléments spécifiques ou des sous-ensembles d'une liste.

Vous avez ensuite exploré comment modifier les listes en ajoutant des éléments avec append(), extend() et insert(), en supprimant des éléments avec remove(), pop() et del, et en changeant des éléments via l'assignation par index et par tranche. Enfin, vous avez couvert des opérations avancées, y compris le tri sur place avec sort(), l'inversion avec reverse(), la requête d'informations avec count() et index(), et la structuration des données avec des listes imbriquées (nested lists). Vous êtes maintenant bien équipé pour utiliser les listes efficacement dans vos projets Python.