Comprendre les listes en Python 3

Introduction

Une liste est une structure de données en Python qui est une séquence ordonnée d'éléments mutable, ou modifiable. Chaque élément ou valeur qui se trouve dans une liste est appelé un item. Tout comme les chaînes de caractères sont définies comme des caractères entre des guillemets, les listes sont définies par des valeurs entre des crochets carrés [ ].

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

Lorsqu'on réfléchit 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 playlists 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.

Conditions préalables

Vous devez avoir Python 3 installé et un environnement de programmation configuré sur votre ordinateur ou serveur. Si vous n'avez pas d'environnement de programmation configuré, vous pouvez consulter les 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

Pour commencer, créons une liste qui contient des éléments de type de données chaîne :

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

Lorsque nous imprimons la liste, la sortie ressemble exactement à la liste que nous avons créée :

print(sea_creatures)

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

En tant que séquence ordonnée d'éléments, chaque élément d'une liste peut être appelé individuellement, par indexation. Les listes sont un type de données composite 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 devez stocker beaucoup de valeurs ou parcourir des valeurs, et que vous souhaitez pouvoir modifier ces valeurs facilement, vous voudrez probablement travailler avec des types de données de liste.

Dans ce tutoriel, nous allons passer en revue certaines des façons dont nous pouvons travailler avec des listes en Python.

Indexation des listes

Chaque élément d'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 sea_creatures, la répartition des index ressemble à ceci :

Le premier élément, la chaîne 'shark', commence à l'index 0, et la liste se termine à l'index 4 avec l'élément 'anemone'.

Parce que chaque élément d'une liste Python a un numéro d'index 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'index :

print(sea_creatures[1])

cuttlefish

Les numéros d'index pour cette liste vont de 0 à 4, comme indiqué dans le tableau ci-dessus. Donc, pour appeler chacun des éléments individuellement, nous nous référerions aux numéros d'index 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'index supérieur à 4, cela sera hors limites car ce ne sera pas valide :

print(sea_creatures[18])

IndexError: list index out of range

En plus des indices positifs, nous pouvons également accéder aux éléments de la liste avec un indice négatif, en comptant à rebours depuis la fin de la liste, en commençant par -1. Cela est particulièrement utile si nous avons une longue liste et que nous voulons localiser un élément près de la fin de la liste.

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

Donc, si nous voulons imprimer l'élément 'squid' en utilisant son numéro d'index négatif, nous pouvons le faire comme ceci :

print(sea_creatures[-3])

squid

Nous pouvons concaténer des é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])

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 des numéros d'index qui correspondent à des éléments d'une liste, nous pouvons accéder à chaque élément d'une liste de manière discrète et travailler avec ces éléments.

Modification d'éléments dans des listes

Nous pouvons utiliser l'indexation pour modifier des éléments dans la liste, en assignant un numéro d'index à 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 chaîne de l'élément à l'index 1 de 'cuttlefish' à 'octopus', nous pouvons le faire comme ceci :

sea_creatures[1] = 'octopus'

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

print(sea_creatures)

['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)

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

Maintenant, 'blobfish' a remplacé 'squid' à l'index négatif -3 (qui correspond à l'index positif 2).

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

Trancher des listes

Nous pouvons également appeler quelques éléments de la liste. Disons que nous aimerions imprimer uniquement 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 deux-points [x:y] :

print(sea_creatures[1:4])

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

Lors de la création d'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 s'affichent.

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

print(sea_creatures[:3])

['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:])

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

Nous pouvons également utiliser des indices négatifs lors de la découpe des listes, de manière similaire aux indices positifs :

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

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

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

La syntaxe de cette construction est list[x:y:z], où z fait référence au pas. Créons une liste plus grande, puis découpons-la et donnons au pas une valeur de 2 :

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

print(numbers[1:11:2])

[1, 3, 5, 7, 9]

Notre construction numbers[1:11:2] imprime les valeurs entre les index inclusifs de 1 et exclusif de 11, puis la valeur de pas de 2 indique au programme d'imprimer seulement chaque deuxième élément.

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

print(numbers[::3])

[0, 3, 6, 9, 12]

En imprimant la liste nombres avec un pas de 3, seul chaque troisième élément est imprimé :

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

Le découpage des listes avec des indices à la fois positifs et négatifs et l'indication du pas nous donne le contrôle pour manipuler les listes et obtenir le résultat que nous essayons d'atteindre.

Modification des 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 de leurs formes composées += et *=.

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

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

print(sea_creatures + oceans)

['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)

['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 playlist 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)

['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 répliquer nos listes autant de fois que nous le spécifions.

Nous pouvons également utiliser des formes composées des opérateurs + et * avec l'opérateur d'affectation =. Les opérateurs composés += et *= peuvent être utilisés pour remplir des 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 substitut, et nous aimerions ajouter cet élément substitut 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)

['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']

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

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

sharks = ['shark']

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

['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 d'origine.

Retirer 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.

Dans la liste sea_creatures, supprimons l'élément 'octopus'. Cet élément se trouve à la position d'index 1. Pour supprimer l'élément, nous utiliserons l'instruction del, puis nous appellerons la variable de liste et le numéro d'index de cet élément :

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

del sea_creatures[1]
print(sea_creatures)

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

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

Nous pouvons également spécifier une plage avec l'instruction del. Disons que nous voulons retirer non seulement l'élément 'octopus', mais aussi 'blobfish' et 'mantis shrimp'. Nous pouvons appeler une plage dans sea_creatures avec l'instruction del pour y parvenir:

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

del sea_creatures[1:4]
print(sea_creatures)

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

En utilisant une plage avec l'instruction del, nous avons pu supprimer les éléments entre le numéro d'index 1 (inclus) et le numéro d'index 4 (exclus), nous laissant 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.

Construire une liste avec des éléments de liste

Les listes peuvent être définies avec des éléments composés de listes, chaque liste entre crochets étant enclavée à l'intérieur des crochets plus grands de la liste parente :

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

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

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

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

Sammy
shark

La première liste, puisqu'elle est égale à un élément, aura le numéro d'index 0, qui sera le premier nombre dans la construction, et la deuxième liste aura le numéro d'index 1. Dans chaque liste imbriquée intérieure, il y aura des numéros d'index 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'

Lorsqu'on travaille avec des listes de listes, il est important de garder à l'esprit qu'il faudra se référer à plus d'un numéro d'index pour accéder à des éléments spécifiques au sein de la liste imbriquée correspondante.

Conclusion

Le type de données liste est un type de données flexible qui peut être modifié au cours de votre programme. Ce tutoriel a couvert les fonctionnalités de base des listes, y compris l'indexation, la découpe, la modification et la concaténation des listes.

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