Listes en Python : Tout ce que vous devez savoir

La documentation n'est pas adaptée aux débutants et les tutoriels laissent souvent des lacunes. Apprendre Python peut sembler écrasant, vous n'êtes donc pas seul. Pour y remédier, j'ai préparé un guide concis et direct pour améliorer rapidement vos compétences avec les listes Python—en moins de 30 minutes également !

Les listes sont une suite d'éléments qui vivent côte à côte en mémoire, comme une liste de courses sur un morceau de papier. Les listes offrent également des opérations (appelées méthodes) qui vous permettent d'effectuer des actions sur elles. Par exemple, pour ajouter un élément à une liste, utilisez my_shopping_list.append('lait'). Il existe de nombreuses méthodes, et nous couvrirons la plupart des importantes au fur et à mesure.

Notions de base sur les listes : création et accès aux éléments

Créer une liste

Pour créer une liste, il suffit d'assigner des crochets à une variable :

my_shopping_list = []
    

Vous pouvez initialiser des listes avec des éléments prédéfinis :

my_shopping_list = ["milk", "bread", "sugar"]
    

Vous pouvez stocker différents types dans des listes, et même d'autres listes :

my_shopping_list = ["milk", 1, [1, 2, 3], True]
    

Affectations Directes

Lorsqu'une liste existante contient des éléments, nous pouvons modifier directement ces éléments :

my_shopping_list = ["milk", "bread", "sugar"]
my_shopping_list[0] = "coffee"
print(my_shopping_list)
my_shopping_list[2] = "bananas"
print(my_shopping_list)
    

Le nombre entre crochets est appelé l'index, et nous l'utilisons pour accéder aux éléments individuels de la liste. Le premier élément est toujours 0, ensuite le deuxième est 1, et ainsi de suite.

Accéder aux éléments de la liste

Maintenant que votre liste contient des éléments, vous voudrez y accéder :

my_shopping_list = ["milk", "bread", "sugar"]
print(my_shopping_list[0])
print(my_shopping_list[1])
    

Inversement, Python vous permet d'accéder aux éléments en partant de la fin en utilisant des nombres négatifs :

my_shopping_list = ["milk", "bread", "sugar"]
print(my_shopping_list[-1])
print(my_shopping_list[-2])
    

Parcourir une liste

Une boucle en programmation générale est une structure qui répète une action N fois. Par exemple, si une liste contient trois éléments, la boucle la parcourra, nous permettant d’exécuter des actions sur chaque élément. Voici un exemple de boucle for :

my_shopping_list = ["milk", "bread", "sugar"]
for item in my_shopping_list:
    print(item)
    

Pour chaque élément dans "ma_liste_de_courses", la boucle l'assigne à la variable "élément". Nous pouvons simplement imprimer cette variable pour montrer comment cela fonctionne.

Il est possible d'effectuer n'importe quelle action sur chaque élément. Par exemple, ajouter un point d'exclamation à l'élément, puis l'imprimer :

my_shopping_list = ["milk", "bread", "sugar"]
for item in my_shopping_list:
    print(item + "!") # Exclamation point.
    

Récupération de parties d'une liste (alias découpage)

Récupérer des parties d'une liste s'appelle le découpage. Le découpage ne modifie pas la liste originale, il renvoie une nouvelle liste avec les éléments souhaités.

Si vous voulez récupérer les deux premiers éléments :

my_shopping_list = ["milk", "bread", "sugar"]
print(my_shopping_list[0:2])
    

Vous pouvez voir que nous fournissons les indexes 0 et 2, séparés par deux-points — c'est la même chose que de dire zéro, jusqu'à, mais n'incluant pas, deux.

Si vous ne fournissez pas de numéro après ou avant les deux-points, il retourne le reste de la liste. Par exemple, le code suivant renvoie le deuxième élément et le reste de la liste :

my_shopping_list = ["milk", "bread", "sugar"]
print(my_shopping_list[1:])
    

Cela renverra tout jusqu'à 2 :

my_shopping_list = ["milk", "bread", "sugar"]
print(my_shopping_list[:2])
    

Découpage inversé

Vous pouvez effectuer une découpe dans l'ordre inverse en utilisant des nombres négatifs pour les indices. Python traite les indices négatifs par rapport à la fin de la liste ; par exemple, -1 correspond au dernier élément et -2 correspond à l'avant-dernier élément.

L'exemple suivant commence à l'avant-dernier élément (-2) et se poursuit jusqu'à la fin de la liste.

my_shopping_list = ["milk", "bread", "sugar"]
print(my_shopping_list[-2:])
    

Modification de la liste : ajout, suppression et tri des éléments

Pour modifier la structure d'une liste (et non ses valeurs existantes), il est plus facile (et recommandé) d'utiliser les méthodes standard fournies par Python.

append()

Append signifie ajouter à la fin d'une liste.

my_shopping_list = ["milk", "bread", "sugar"]
my_shopping_list.append("bananas")
print(my_shopping_list)
my_shopping_list.append("cheese")
print(my_shopping_list)
    

insert()

Insérer est comme ajouter, sauf que cela ajoute des éléments à un index spécifié.

my_shopping_list = ["milk", "bread", "sugar"]
# 1
my_shopping_list.insert(0, "bananas")
print(my_shopping_list)
# 2
my_shopping_list.insert(2, "cheese")
print(my_shopping_list)
    

Vous pouvez voir qu'insérer à l'index 0 le place au début, et qu'insérer à l'index 2 le place au troisième élément.

remove()

Fournissez la méthode remove avec un exemple de ce que vous souhaitez supprimer, et elle supprimera la première instance qu'elle rencontre.

my_shopping_list = ["milk", "bread", "sugar"]
# 1
my_shopping_list.remove("milk")
print(my_shopping_list)
# 2
my_shopping_list.remove("sugar")
print(my_shopping_list)
    

Tri

Trier une liste en Python est simple, et vous avez deux options :

• Sur place : Modifie la liste.
• Hors place : Renvoie une nouvelle liste et ne modifie pas la liste originale.

La méthode sort se fait sur place et modifie la liste originale.

my_shopping_list = ["milk", "bread", "sugar"]
my_shopping_list.sort()
print(my_shopping_list)
    

Remarquez que les éléments sont triés par ordre alphabétique ? Remarquez également que nous n'avons pas réassigné "my_shopping_list", et pourtant l'affichage a montré une liste triée ? Il s'agit d'un tri sur place.

La méthode sorted est hors-place et ne modifie pas la liste originale.

my_shopping_list = ["milk", "bread", "sugar"]
my_sorted_list = sorted(my_shopping_list)
print(my_shopping_list) # 1
print(my_sorted_list) # 2
    

Remarquez que « my_shopping_list » reste inchangé ? La méthode « sorted » renvoie une nouvelle liste : « my_sorted_list ».

Utiliser les informations de la liste pour prendre des décisions intelligentes

Vérification de la longueur de la liste

L'opération de liste la plus courante est probablement de vérifier la longueur de la liste en utilisant la fonction len.

my_shopping_list = ["milk", "bread", "sugar"]
if len(my_shopping_list) > 0:
    print("The list is not empty.")
    

Comme vous pouvez le voir, la longueur de la liste est supérieure ou égale à zéro.

Utilisation des listes de manière conditionnelle

Il est possible d'utiliser des listes dans des instructions conditionnelles (par exemple, des instructions if). Une liste vide est évaluée comme fausse (équivalente à false) ; une liste remplie est évaluée comme vraie (équivalente à true).

if []:
    print("An empty list is truthy.") # It's not.
if ["foo"]:
    print("A populated list is truthy.")
    

C'est une méthode courante pour vérifier si une liste contient des éléments.

Comparer des listes

Pour comparer des listes, il est important de comprendre deux concepts clés :

• Égalité : Les listes ont-elles les mêmes contenus ?
• Identité : Les listes sont-elles le même objet exact en mémoire ?

L'égalité se concentre sur le fait de savoir si les listes contiennent les mêmes éléments ; si c'est le cas, les listes sont considérées comme égales. Pour vérifier l'égalité, nous utilisons l'opérateur « == ».

one = [1]
two = [2]
also_one = [1]
if one == two:
    print("Different lists are equal.") # They're not.
if one == one:
    print("A list is equal to itself.")
if one == also_one:
    print("Different lists with the same items are equal.")
    

Une vérification d'identité compare les adresses mémoire de deux objets (listes) afin de déterminer s'ils pointent vers exactement le même emplacement en mémoire. Nous utilisons l'opérateur is pour effectuer des vérifications d'identité :

one = []
two = []
if one is two:
    print("Different lists have the same identity.") # They don't.
if one is one:
    print("A list has the same identity as itself.")
    

Adhésion à la liste

Vous voudrez souvent savoir si une liste contient quelque chose, et vous pouvez le faire avec l'opérateur spécial in.

my_shopping_list = ["milk", "bread", "sugar"]
if "milk" in my_shopping_list:
    print("Got milk!")
if "cookies" in my_shopping_list:
    print("Got cookies!") # Nope.
    

Transformer les listes : Transformer des éléments en autre chose

Utilisez map() pour modifier les éléments

Map est un moyen courant de transformer des listes dans la plupart des langages de programmation. En Python, map est une fonction qui parcourt une liste et applique une fonction (que vous fournissez) à chaque élément. Votre fonction reçoit chaque élément en tant qu'argument, et vous êtes libre de faire ce que vous voulez avec. La valeur que vous retournez remplace cet élément dans la liste.

En bref : Map applique une fonction fournie par l'utilisateur à chaque élément. Utilisez cette fonction pour transformer chaque valeur.

my_shopping_list = ["milk", "bread", "sugar"]
def apply_uppercase(item):
    return item.upper()

map_object = map(apply_uppercase, my_shopping_list)
mapped_list = list(map_object) # Turn it back into a list.
print(mapped_list)
    

Utilisez filter() pour supprimer des éléments

Le filtre fonctionne de manière similaire à map, sauf qu'il supprime des éléments de la liste. La fonction reçoit chaque valeur et détermine s'il faut conserver ou supprimer l'élément. Retourner true signifie conserver la valeur, et false signifie supprimer.

my_shopping_list = ["milk", "bread", "sugar"]
def sugar_free(item):
    # Keep everything that isn't sugar.
    return item != "sugar" # True: Keep; False: Discard.
filter_object = filter(sugar_free, my_shopping_list)
mapped_list = list(filter_object) # Turn it back into a list.
print(mapped_list)
    

Conseils Bonus : Vous voudrez lire ceci

Compréhensions de listes

Les compréhensions de listes sont un moyen compact de générer une liste à partir d'une autre liste. Elles fonctionnent de manière similaire à map (vu précédemment).

my_shopping_list = ["milk", "bread", "sugar"]
# 1
copied_list = [item for item in my_shopping_list]
print(copied_list)
# 2
changed_list = [item.upper() for item in my_shopping_list]
print(changed_list)
  
    

La deuxième compréhension de liste est la même que :

my_shopping_list = ["milk", "bread", "sugar"]
# Functionally the same as #2.
changed_list = []
for item in my_shopping_list:
    changed_list.append(item.upper())
    print(changed_list)
  
    

Cette image montre comment une compréhension de liste se rapporte à une liste Python normale.

• Jeton 1 : Je l'ai souligné, et il est lié à l'autre jeton souligné. Ce jeton est la variable sur laquelle vous opérez ; c'est cette valeur que vous modifiez.
• Jeton 2 : se réfère à la déclaration de la variable ; c'est ici que vous attribuez un nom au jeton, qui est « item » dans cet exemple.
• Jeton 3 : fait référence à la liste sur laquelle vous bouclez (itérer).

Déballer les listes

Obtenir des éléments d'une liste peut être une affaire compliquée :

my_shopping_list = ["milk", "bread", "sugar"]
milk = my_shopping_list[0]
bread = my_shopping_list[1]
sugar = my_shopping_list[2]
    

Préférez plutôt le déballage de liste, une méthode propre pour extraire chaque élément dans des variables :

my_shopping_list = ["milk", "bread", "sugar"]
milk, bread, sugar = my_shopping_list
print(milk, bread, sugar)
    

Les positions des noms de variables correspondent aux positions dans la liste, et le nombre de variables doit correspondre au nombre d’éléments. Voici ce qui se passe lorsqu’il y a un nombre insuffisant de variables :

Pour remédier à cela, nous pouvons utiliser l'opérateur étoile (un astérisque) sur un élément. Dans ce scénario, la variable étoilée représente plusieurs variables sous forme de liste — en gros, c'est tout ce qui n'est pas explicitement assigné à une variable. Gardez à l'esprit que l'ordre est important :

my_shopping_list = ["milk", "bread", "butter", "bananas", "sugar"]
milk, bread, *misc, sugar = my_shopping_list
print(milk, bread, misc, sugar)
    

Copie profonde

Lorsque vous utilisez des objets complexes (instances de classes, listes, etc.), il est important de comprendre qu'ils ne sont pas de simples valeurs. Lorsque vous stockez un objet dans une variable, il s'agit en réalité d'une adresse mémoire qui pointe vers un endroit en mémoire où l'objet se trouve.

Prenez l'exemple suivant :

# We will change this, and only this list.
milk_and_bread = ["milk", "bread"]
# Add milk and bread to both shopping lists.
list_a = ["list_a", milk_and_bread]
list_b = ["list_b", milk_and_bread]
# Original.
print("BEFORE CHANGE")
print(list_a)
print(list_b)
# Now change "milk" to "apples".
# Notice that we do not change list_a or list_b
milk_and_bread[0] = "apples"
# Both have changed.
print("\nAFTER CHANGE")
print(list_a)
print(list_b)
    

Les modifications se reflètent dans les deux listes car "milk_and_bread" est un objet, et Python agit toujours sur les objets via leur adresse mémoire (c'est-à-dire la référence). Lorsque nous ajoutons un objet à une liste, nous ajoutons en fait une référence à la liste. Maintenant, lorsque nous modifions l'objet, le résultat se reflète partout.

La raison pour laquelle cela est important est que cela peut être une source de bogues. Lorsque vous considérez les valeurs complexes comme des références, plutôt que simplement comme des variables, il est plus facile d'éviter ce problème. Il n'est pas toujours possible d'éviter un tel problème, et une solution consiste à effectuer une copie profonde de la liste :

from copy import deepcopy
milk_and_bread = ["milk", "bread"]
# Add mild and bread to both shopping lists,
# but notice that I apply deepcopy to the entire list.
list_a = deepcopy(["list_a", milk_and_bread])
list_b = deepcopy(["list_b", milk_and_bread])
# Original.
print("BEFORE CHANGE")
print(list_a)
print(list_b)
# Now change milk to apples.
# This will do nothing, because list_a and list_b
# have copies.
milk_and_bread[0] = "apples"
# Neither have changed.
print("\nAFTER CHANGE")
print(list_a)
print(list_b)
    

Une copie profonde va examiner chaque objet et les copier tous. C'est récursif.

Les sujets abordés ici devraient répondre à la plupart de vos besoins concernant les listes, mais ils ne couvrent pas le cadre plus large de Python. Pour continuer à apprendre, vous pourriez trouver nos autres articles utiles, comme "Des super jeux qui vous apprennent Python" ou "Des scripts Python simples mais utiles pour commencer". Enfin, notre guide sur l'écriture de code à la manière Python inclut des sujets supplémentaires sur les listes, y compris les fonctions all et every.