Comprendre les listes en Python 3

Introduction

A list is a data structure in Python that is a mutable, or changeable, ordered sequence of elements. Each element or value that is inside of a list is called an item. Just as strings are defined as characters between quotes, lists are defined by having values between square brackets [ ].

Les listes sont excellentes à utiliser lorsque vous souhaitez travailler avec de nombreuses valeurs liées. Elles vous permettent de regrouper des données qui vont ensemble, de condenser votre code et d’effectuer les mêmes méthodes et opérations sur plusieurs valeurs à la fois.

En pensant aux listes Python et à d’autres structures de données qui sont des types de collections, il est utile de considérer toutes les différentes collections que vous avez sur votre ordinateur : votre assortiment de fichiers, vos listes de lecture de chansons, vos favoris de navigateur, vos e-mails, la collection de vidéos auxquelles vous pouvez accéder sur un service de streaming, et plus encore.

Prérequis

Vous devez avoir Python 3 installé et un environnement de programmation configuré sur votre ordinateur ou votre serveur. Si vous n’avez pas d’environnement de programmation configuré, vous pouvez vous référer aux guides d’installation et de configuration pour un environnement de programmation local ou pour un environnement de programmation sur votre serveur approprié à votre système d’exploitation (Ubuntu, CentOS, Debian, etc.).

Listes de chaînes de caractères

Pour commencer, créons une liste contenant des éléments du type de données chaîne de caractères :

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

Lorsque nous imprimons la liste, la sortie répond exactement comme la liste que nous avons créée :

print(sea_creatures)

Output
['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

En tant que séquence ordonnée d’éléments, chaque élément dans une liste peut être appelé individuellement, via l’indexation. Les listes sont un type de données composé de parties plus petites et sont très flexibles car elles peuvent avoir des valeurs ajoutées, supprimées et modifiées. Lorsque vous avez besoin de stocker beaucoup de valeurs ou de parcourir des valeurs, et que vous souhaitez pouvoir modifier facilement ces valeurs, vous voudrez probablement travailler avec des types de données de liste.

Dans ce tutoriel, nous verrons quelques façons de travailler avec des listes en Python.

Indexation des listes

Chaque élément dans une liste correspond à un numéro d’index, qui est une valeur entière, commençant par le numéro d’index 0.

Pour la liste créatures_marines, le découpage des index ressemble à ceci :

Le premier élément, la chaîne 'shark', commence à l’indice 0, et la liste se termine à l’indice 4 avec l’élément 'anémone'.

Parce que chaque élément dans une liste Python a un numéro d’indice correspondant, nous pouvons accéder et manipuler les listes de la même manière que nous le faisons avec d’autres types de données séquentiels.

Maintenant, nous pouvons appeler un élément discret de la liste en faisant référence à son numéro d’indice :

print(sea_creatures[1])

Output
cuttlefish

Les numéros d’indice pour cette liste vont de 0 à 4, comme indiqué dans le tableau ci-dessus. Donc, pour appeler n’importe lequel des éléments individuellement, nous ferions référence aux numéros d’indice de cette manière :

sea_creatures[0] = 'shark'
sea_creatures[1] = 'cuttlefish'
sea_creatures[2] = 'squid'
sea_creatures[3] = 'mantis shrimp'
sea_creatures[4] = 'anemone'

Si nous appelons la liste sea_creatures avec un numéro d’indice supérieur à 4, cela sera hors de portée car il ne sera pas valide :

print(sea_creatures[18])

Output
IndexError: list index out of range

En plus des numéros d’indice positifs, nous pouvons également accéder aux éléments de la liste avec un numéro d’indice négatif, en comptant à rebours à partir de la fin de la liste, en commençant par -1. Ceci est particulièrement utile si nous avons une longue liste et que nous voulons cibler un élément vers la fin d’une liste.

Pour la même liste sea_creatures, la répartition des index négatifs ressemble à ceci :

Donc, si nous voulons imprimer l’élément 'calmar' en utilisant son numéro d’index négatif, nous pouvons le faire de cette manière :

print(sea_creatures[-3])

Output
squid

Nous pouvons concaténer les éléments de chaîne dans une liste avec d’autres chaînes en utilisant l’opérateur + :

print('Sammy is a ' + sea_creatures[0])

Output
Sammy is a shark

Nous avons pu concaténer l’élément de chaîne à l’index numéro 0 avec la chaîne 'Sammy est un '. Nous pouvons également utiliser l’opérateur + pour concaténer 2 ou plusieurs listes ensemble.

Avec les numéros d’index correspondant aux éléments à l’intérieur d’une liste, nous pouvons accéder à chaque élément d’une liste discrètement et travailler avec ces éléments.

Modification des éléments dans les listes

Nous pouvons utiliser l’indexation pour changer les éléments à l’intérieur de la liste, en définissant un numéro d’index égal à une valeur différente. Cela nous donne un plus grand contrôle sur les listes car nous pouvons modifier et mettre à jour les éléments qu’elles contiennent.

Si nous voulons changer la valeur de la chaîne de l’élément à l’index 1 de 'seiche' à 'pieuvre', nous pouvons le faire comme ceci:

sea_creatures[1] = 'octopus'

Maintenant, lorsque nous imprimons animaux_marins, la liste sera différente:

print(sea_creatures)

Output
['shark', 'octopus', 'squid', 'mantis shrimp', 'anemone']

Nous pouvons également changer la valeur d’un élément en utilisant un numéro d’index négatif à la place:

sea_creatures[-3] = 'blobfish'
print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']

Maintenant 'poisson-globe' a remplacé 'calmar' au numéro d’index négatif de -3 (qui correspond au numéro d’index positif de 2).

Être capable de modifier les éléments dans les listes nous donne la possibilité de changer et de mettre à jour les listes de manière efficace.

Découpage de listes

Nous pouvons également extraire quelques éléments de la liste. Disons que nous voulons seulement imprimer les éléments du milieu de sea_creatures, nous pouvons le faire en créant une tranche. Avec les tranches, nous pouvons appeler plusieurs valeurs en créant une plage de numéros d’index séparés par un deux-points [x:y] :

print(sea_creatures[1:4])

Output
['octopus', 'blobfish', 'mantis shrimp']

En créant une tranche, comme dans [1:4], le premier numéro d’index est l’endroit où la tranche commence (inclusif), et le deuxième numéro d’index est l’endroit où la tranche se termine (exclusif), c’est pourquoi dans notre exemple ci-dessus, les éléments aux positions 1, 2 et 3 sont les éléments qui sont imprimés.

Si nous voulons inclure l’une ou l’autre extrémité de la liste, nous pouvons omettre l’un des nombres dans la syntaxe liste[x:y]. Par exemple, si nous voulons imprimer les 3 premiers éléments de la liste sea_creatures — qui seraient 'requin', 'pieuvre', 'poisson blob' — nous pouvons le faire en tapant :

print(sea_creatures[:3])

Output
['shark', 'octopus', 'blobfish']

Cela a imprimé le début de la liste, s’arrêtant juste avant l’index 3.

Pour inclure tous les éléments à la fin d’une liste, nous inverserions la syntaxe :

print(sea_creatures[2:])

Output
['blobfish', 'mantis shrimp', 'anemone']

Nous pouvons également utiliser des numéros d’index négatifs lors du découpage de listes, tout comme des numéros d’index positifs :

print(sea_creatures[-4:-2])
print(sea_creatures[-3:])

Output
['octopus', 'blobfish']
['blobfish', 'mantis shrimp', 'anemone']

Un dernier paramètre que nous pouvons utiliser avec le découpage s’appelle pas, qui fait référence au nombre d’éléments à avancer après que le premier élément soit récupéré de la liste. Jusqu’à présent, nous avons omis le paramètre de pas, et Python utilise par défaut un pas de 1, de sorte que chaque élément entre deux numéros d’index est récupéré.

La syntaxe de cette construction est liste[x:y:z], avec z se référant au pas. Faisons une liste plus grande, puis découpons-la et donnons une valeur de 2 au pas :

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

print(numbers[1:11:2])

Output
[1, 3, 5, 7, 9]

Notre construction nombres[1:11:2] affiche les valeurs entre les numéros d’index inclusivement de 1 et exclusivement de 11, puis la valeur de pas de 2 indique au programme d’imprimer uniquement chaque autre élément.

Nous pouvons omettre les deux premiers paramètres et utiliser uniquement le pas comme paramètre avec la syntaxe liste[::z] :

print(numbers[::3])

Output
[0, 3, 6, 9, 12]

En imprimant la liste nombres avec le pas réglé à 3, seuls les éléments tous les trois sont imprimés :

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

Le découpage de listes avec des numéros d’index positifs et négatifs et l’indication du pas nous permet de contrôler les listes et d’obtenir la sortie que nous essayons d’atteindre.

Modification de listes avec des opérateurs

Les opérateurs peuvent être utilisés pour apporter des modifications aux listes. Nous allons examiner l’utilisation des opérateurs + et * ainsi que leurs formes composées += et *=.

L’opérateur + peut être utilisé pour concaténer deux listes ou plus ensemble:

sea_creatures = ['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']
oceans = ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

print(sea_creatures + oceans)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

Parce que l’opérateur + peut concaténer, il peut être utilisé pour ajouter un élément (ou plusieurs) sous forme de liste à la fin d’une autre liste. N’oubliez pas de placer l’élément entre crochets:

sea_creatures = sea_creatures + ['yeti crab']
print (sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

L’opérateur * peut être utilisé pour multiplier des listes. Peut-être avez-vous besoin de faire des copies de tous les fichiers dans un répertoire sur un serveur, ou de partager une liste de lecture avec des amis — dans ces cas, vous auriez besoin de multiplier des collections de données.

Multiplions la liste sea_creatures par 2 et la liste oceans par 3:

print(sea_creatures * 2)
print(oceans * 3)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']
['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

En utilisant l’opérateur *, nous pouvons reproduire nos listes le nombre de fois spécifié.

Nous pouvons également utiliser les formes composées des opérateurs + et * avec l’opérateur d’assignation =. Les opérateurs composés += et *= peuvent être utilisés pour remplir les listes de manière rapide et automatisée. Vous pouvez utiliser ces opérateurs pour remplir des listes avec des espaces réservés que vous pouvez modifier ultérieurement avec des entrées fournies par l’utilisateur, par exemple.

Ajoutons un élément sous forme de liste à la liste sea_creatures. Cet élément servira de espace réservé, et nous aimerions ajouter cet élément espace réservé plusieurs fois. Pour ce faire, nous utiliserons l’opérateur += avec une boucle for.

for x in range(1,4):
    sea_creatures += ['fish']
    print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish', 'fish']

À chaque itération de la boucle for, un élément de liste supplémentaire de 'poisson' est ajouté à la liste originale sea_creatures.

L’opérateur *= se comporte de manière similaire:

sharks = ['shark']

for x in range(1,4):
    sharks *= 2
    print(sharks)

Output
['shark', 'shark']
['shark', 'shark', 'shark', 'shark']
['shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

Les opérateurs + et * peuvent être utilisés pour concaténer des listes et multiplier des listes. Les opérateurs composés += et *= peuvent concaténer des listes et multiplier des listes et passer la nouvelle identité à la liste originale.

Supprimer un élément d’une liste

Les éléments peuvent être supprimés des listes en utilisant l’instruction del. Cela supprimera la valeur à l’indice que vous spécifiez dans une liste.

De la liste sea_creatures, supprimons l’élément 'poulpe'. Cet élément est situé à la position d’indice 1. Pour supprimer l’élément, nous utiliserons l’instruction del, puis nous appellerons la variable de liste et le numéro d’indice de cet élément:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1]
print(sea_creatures)

Output
['shark', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

Maintenant, l’élément à la position d’indice 1, la chaîne 'poulpe', n’est plus dans notre liste sea_creatures.

Nous pouvons également spécifier une plage avec l’instruction del. Disons que nous voulions supprimer non seulement l’élément 'poulpe', mais aussi 'poisson-globe' et 'crevette-mante'. Nous pouvons appeler une plage dans sea_creatures avec l’instruction del pour accomplir ceci:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1:4]
print(sea_creatures)

Output
['shark', 'anemone', 'yeti crab']

En utilisant une plage avec l’instruction del, nous avons pu supprimer les éléments entre l’index 1 (inclus) et l’index 4 (exclus), ce qui nous laisse avec une liste de 3 éléments après la suppression de 3 éléments.

L’instruction del nous permet de supprimer des éléments spécifiques du type de données liste.

Construction d’une liste avec des éléments de liste

Les listes peuvent être définies avec des éléments qui sont constitués de listes, chaque liste entre crochets étant enfermée à l’intérieur des crochets plus larges de la liste parente :

sea_names = [['shark', 'octopus', 'squid', 'mantis shrimp'],['Sammy', 'Jesse', 'Drew', 'Jamie']]

Ces listes imbriquées sont appelées listes imbriquées.

Pour accéder à un élément dans cette liste, nous devrons utiliser plusieurs indices :

print(sea_names[1][0])
print(sea_names[0][0])

Output
Sammy
shark

La première liste, puisqu’elle est égale à un élément, aura l’indice 0, qui sera le premier numéro dans la construction, et la deuxième liste aura l’indice 1. À l’intérieur de chaque liste imbriquée, il y aura des indices séparés, que nous appellerons dans le deuxième numéro d’index:

sea_names[0][0] = 'shark'
sea_names[0][1] = 'octopus'
sea_names[0][2] = 'squid'
sea_names[0][3] = 'mantis shrimp'

sea_names[1][0] = 'Sammy'
sea_names[1][1] = 'Jesse'
sea_names[1][2] = 'Drew'
sea_names[1][3] = 'Jamie'

Lorsque vous travaillez avec des listes de listes, il est important de garder à l’esprit que vous devrez faire référence à plus d’un numéro d’index afin d’accéder à des éléments spécifiques dans la liste imbriquée pertinente.

Conclusion

Le type de données list est un type de données flexible qui peut être modifié tout au long de votre programme. Ce tutoriel a couvert les fonctionnalités de base des listes, notamment l’indexation, le découpage, la modification et la concaténation des listes.

À partir de là, vous pouvez en savoir plus sur le travail avec les listes en Python en lisant « Comment utiliser les méthodes de liste », et sur les compréhensions de liste pour créer des listes basées sur des listes existantes. Pour en savoir plus sur les types de données en général, vous pouvez lire notre tutoriel « Compréhension des types de données ».