18 questions les plus fréquentes sur les listes Python

Qu’est-ce qu’une liste Python, exactement ?

Les listes font partie des quatre structures de données intégrées en Python, avec les tuples, les dictionnaires et les ensembles (sets). Elles servent à stocker une collection ordonnée d’éléments, potentiellement de types différents (même si, en pratique, c’est souvent homogène). Les éléments sont séparés par des virgules et encadrés par des crochets. Comme dans cet exemple :

Vous voyez que la seconde variable biggerZoo est une liste similaire à la variable zoo. Cependant, biggerZoo contient en plus une autre liste avec différents types de singes.

Comme les listes stockent des collections ordonnées d’éléments ou d’objets, on dit que ce sont des types séquentiels, car elles se comportent comme une séquence. D’autres types considérés comme séquentiels sont les chaînes de caractères (strings) et les tuples.

Qu’ont de particulier les types séquentiels ? En bref, le programme peut itérer dessus ! C’est pour cela que les listes, chaînes, tuples et ensembles sont appelés des « itérables ».

Gardez ce concept en tête : il est fondamental et vous le retrouverez dans d’autres langages utilisés en data science, comme Scala.

Passons maintenant à la pratique ! Voici les questions sur les listes qui reviennent le plus souvent chez les programmeurs Python. Voici la liste de toutes celles auxquelles nous allons répondre dans ce tutoriel :

1. Quand utiliser des listes Python, et quand préférer des tuples, dictionnaires ou sets

À la lecture, l’introduction paraît simple. Mais lorsqu’on code un petit script Python ou un projet complet, le choix entre liste et autre type séquentiel n’est pas toujours évident.

Pourtant, choisir la bonne structure de données est essentiel.

Poursuivez la lecture pour en savoir plus.

2. Comment sélectionner un élément d’une liste

Pour bien travailler avec les listes, il faut savoir y accéder.

On accède typiquement aux listes pour modifier, mettre à jour, supprimer des valeurs, ou effectuer d’autres opérations. La façon d’accéder aux listes, et plus largement à tous les types séquentiels, est d’utiliser l’opérateur d’indexation [ ]. À l’intérieur, on met un entier.

Exemple :

Exécutez et observez le résultat. Le premier élément de biggerZoo est renvoyé. Attention : les indices commencent à 0, pas à 1.

# éléments de start jusqu'à end (end non inclus)
a[start:end]

# éléments de start jusqu'à la fin
a[start:]    

# éléments du début jusqu'à end (end non inclus)
a[:end]

# de start à end (non inclus), avec un pas donné
a[start:end:step]

3. Comment transformer des listes Python en d’autres structures

Parfois, une liste n’est pas idéale. Dans ce cas, vous voudrez la convertir vers une structure plus adaptée. Voici les transformations les plus courantes et leurs réponses.

helloWorld = ['hello','world','1','2']

4. Déterminer la taille d’une liste

Passez votre liste à la fonction len() pour obtenir sa longueur.

Testez ci‑dessous : nous avons déjà préparé une liste justAList.

Remarque : len() ne s’applique pas qu’aux listes, mais aussi aux autres séquences ou collections (dictionnaires, sets, chaînes, etc.). Retrouvez d’autres fonctions intégrées ici.

5. Quelle est la différence entre append() et extend() en Python ?

Repartons de la notion d’itérable évoquée en début d’article :

À retenir : une valeur est dite itérable si votre programme peut itérer dessus. Autrement dit, un itérable représente une séquence d’une ou plusieurs valeurs. Les listes sont des séquences — donc des itérables — comme tous les types séquentiels de Python.

Astuce : vérifiez qu’une variable est itérable si elle possède la méthode .__iter__, comme ci‑dessous :

Exécutez ce code et essayez d’autres exemples dans IPython !

Maintenant que la notion est claire, la différence devient simple : extend() prend un itérable (liste, set, tuple ou chaîne) et ajoute chacun de ses éléments à la liste, un par un.

append(), lui, ajoute son argument en un seul bloc à la fin de la liste. Donc, si vous lui passez un itérable, il sera ajouté comme un unique objet.

Étudiez les extraits suivants et expérimentez pour bien saisir la différence :

Vous voyez que extend() est plus efficace que d’appeler append() plusieurs fois.

6. Concaténer des listes en Python

Utilisez l’opérateur +. Il renvoie une nouvelle liste, concaténation des deux, sans modifier les originales.

Remarque : concaténer et « appender » peuvent prêter à confusion. append() diffère de +, qui ressemble à extend()… sans être identique. Avec append() et extend(), vous modifiez la liste d’origine, alors que + crée une nouvelle variable liste.

Testez et comparez avec les exemples précédents :

7. Trier une liste en Python

Deux approches simples pour trier en ordre croissant ou décroissant :

• La méthode sort()
• Ou la fonction sorted() à laquelle vous passez une liste

sorted() s’applique à tout itérable : chaînes, sets, dictionnaires, etc.

Astuce : essayez vous‑même ! Nous avons déjà créé deux listes, rooms et orders, que vous pouvez trier avec les deux techniques :)

Remarque : la liste originale est modifiée après tri. À privilégier quand vous n’avez plus besoin de l’ordre d’origine.

8. Cloner ou copier une liste

Plusieurs méthodes :

• Trancher la liste et l’affecter à une nouvelle variable : newList = oldList[:]
• Utiliser la fonction intégrée list() : newList = list(oldList)
• Utiliser le module copy :
  • Méthode copy() : newList = copy.copy(oldList)
  • Si la liste contient des objets et que vous voulez aussi les copier, utilisez copy.deepcopy() : copy.deepcopy(oldList)

Essayez ci‑dessous : nous avons créé une liste groceries à copier et partager.

Remarque : avec les copies « simples », les sous‑listes pointées par plusieurs listes restent partagées. deepcopy() évite cela. Exécutez :

Si vous maîtrisez déjà bien les listes, la section suivante apporte des réponses simples à des questions plus avancées.

Et si vous vous demandez ce qu’il y a au‑delà des listes, et quels avantages des bibliothèques peuvent apporter par rapport aux listes natives, la prochaine section va vous intéresser.

Continuez la lecture !

9. Comment fonctionnent les compréhensions de listes en Python ?

En bref, c’est une façon élégante de construire des listes. Bonne nouvelle pour les matheux : la syntaxe rappelle les notations mathématiques. Jugez plutôt :

Ici, on prend les nombres de 0 à 9 (10 exclu) et on les multiplie tous par 2. Exécutez pour vérifier le résultat.

Pas compliqué. Montons d’un cran !

Faisons la même liste, mais seulement pour les nombres divisibles par 2. Facile avec une compréhension conditionnelle :

On ajoute une condition if. Si elle est vraie, le nombre est multiplié par 2. Ici, la condition est « divisible par 2 sans reste ».

De façon plus générale, vous pouvez transformer vos listes en d’autres listes — ce qui peut sembler plus abstrait.

Exemple :

Ici, vous avez déjà une liste myList que vous transformez par compréhension : pour chaque élément x de myList, on applique une opération.

Vous voyez (lambda x: x*x). Pour faire simple : une fonction lambda est une fonction anonyme, définie à l’exécution. Retenez surtout x*x.

La fonction prend un élément et le multiplie par lui‑même. Étant anonyme, on lui passe l’argument explicitement : d’où (lambda x: x*x)(x).

Autrement, on pourrait écrire :

f = lambda x: x*x
[f(x) for x in range(10)]

On définit d’abord la fonction lambda (carré de x), puis on l’applique à chaque élément.

Remarque : il existe aussi des compréhensions d’ensembles (set) et de dictionnaires.

C’est déjà pas mal, mais il y a encore beaucoup à explorer sur les compréhensions.

Continuez avec les questions suivantes pour en savoir plus sur les compréhensions imbriquées et des exemples pratiques.

10. Compter les occurrences d’un élément dans une liste

Les listes n’imposant pas l’unicité, vous voudrez parfois compter combien de fois un élément donné apparaît, voire le nombre d’occurrences de chaque élément.

Voici les deux cas :

11. Découper une liste en blocs de taille égale

Pour découper une liste en parties de même taille, combinez zip() et iter() :

Explications :

• iter() renvoie un itérateur sur une séquence.
• [iter(x)] * 3 produit une liste de trois itérateurs sur x.
• Le * devant zip() « dépaquette » la séquence en arguments, ce qui passe le même itérateur trois fois à zip(), qui tire un élément à chaque fois.

Pas clair ? Déroulons :

1. Vous avez trois itérateurs, que l’on peut voir comme :

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

2. Au premier passage, zip() prend un élément séquentiellement, ce qui donne :

[1][2][3]

Remarque : les itérateurs retiennent la position courante.

3. Au second passage, on ajoute :

[1, 4], [2, 5], [3, 6]

4. Au dernier, même logique :

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

5. En zippant ces trois listes, on obtient :

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

Pour encapsuler cette logique dans une fonction :

Votre fonction chunks() reçoit une liste et une taille de bloc, puis « yield » des tranches successives de cette taille.

La boucle range(0, len(list), chunkSize) part de 0 jusqu’à la longueur de la liste, avec un pas égal à chunkSize.

Pour chaque valeur, vous « yieldez » la tranche [i:i+chunkSize].

Exemple : à l’indice 0, vous donnez [0:2]. À l’itération suivante (pas oblige), l’indice 2 produit [2:4].

Remarque : on utilise pprint() pour un affichage lisible.

Vous pouvez aussi utiliser une compréhension de liste plutôt qu’une fonction :

12. Parcourir une liste en Python

On parcourt facilement une liste avec une boucle for. La boucle exécute une action pour chaque élément.

En Python, cela ressemble à :

Vous avez une liste mylist, et vous demandez à Python d’imprimer les sous‑listes de longueur 3. Ici, ce seront [1,2,3] et [8, 9,10].

Remarque : x peut s’appeler element, listElement, etc. Essayez dans la console.

Vous ne voyez pas les indices dans ce résultat. Pour itérer avec les indices, faites :

Ici, enumerate(myList) renvoie un couple (indice, valeur). On récupère donc i, val dans la boucle.

Remarque : vous pouvez aussi utiliser une compréhension de liste pour boucler. L’affichage est immédiat sans passer par print() :

13. Aplatir une liste de listes

Pour produire une liste simple à partir d’une liste de listes, vous pouvez utiliser sum(). Pensez à passer la liste et une liste vide comme point de départ :

Deux autres approches :

• Utiliser reduce() avec une lambda. reduce() agrège l’itérable en une valeur, selon la fonction fournie. Ici, on concatène cumulativement : [1,2] + [3,4], puis ce résultat + [5,6]. Visuellement :

([1,2]+[3,4])+[5,6]

À retenir : l’opérateur + concatène les listes.

• Autre option : une compréhension de liste imbriquée. On parcourt chaque sublist puis chaque item de cette sous‑liste pour l’extraire.

On peut la réécrire avec des boucles for classiques :

list1 = []

for sublist in list:
  for item in sublist:
    list1.append(item)

14. Obtenir l’intersection de deux listes Python

15. Supprimer les doublons d’une liste Python

Comme indiqué plus haut, si vous voulez une collection d’éléments uniques et non ordonnée, utilisez un set.

Pour créer un set à partir de n’importe quel itérable, passez‑le à set(). Pour revenir ensuite à une liste, passez le set à list().

À retenir : un itérable peut être une liste, un dictionnaire, etc. Vérifiez qu’une variable est itérable avec .__iter__.

Exemple clair de suppression de doublons avec set() :

Comme on le voit dans le dernier résultat, l’ordre d’origine n’est pas conservé après soustraction de smallNumbers. Les sets étant non ordonnés, tout ordre est perdu. La conversion retour en liste crée un ordre arbitraire.

Si l’ordre compte, il faudra une autre approche. Cette page détaille le sujet.

16. Pourquoi utiliser NumPy plutôt que des listes Python ?

Quatre raisons principales reviennent chez les programmeurs Python :

• les tableaux NumPy sont plus compacts que des listes,
• l’accès (lecture/écriture) y est plus rapide,
• NumPy est souvent plus pratique grâce aux nombreuses opérations vectorielles et matricielles disponibles,
• et il est plus efficace car implémenté de façon optimisée.

17. Créer des tableaux NumPy vides

Pour créer un tableau NumPy vide :

Pour initialiser un tableau, plusieurs options :

Consultez cette documentation pour d’autres moyens d’initialiser un tableau NumPy.

18. Faire des calculs avec des listes en Python

Très souvent, au‑delà du stockage, on réalise des opérations mathématiques sur les listes. Voici les questions les plus fréquentes à ce sujet.

cost = [0.424, 0.4221, 0.4185, 0.4132, 0.413]
cases = [10, 20, 30, 40, 50]

list1=[1, 2, 3]
list2=[4, 5, 6]

Et ensuite dans votre parcours Data Science avec Python ?

Vous avez terminé ce tutoriel interactif sur les listes. C’était dense, mais vous y êtes arrivé !

Les listes ne sont qu’une brique essentielle. Il y a tant à explorer ! Notre cours Intro to Python for Data Science est parfait pour approfondir et découvrir comment Python est utilisé en data science : des bases jusqu’à une introduction à NumPy. Idéal pour les débutants !

Si vous êtes déjà plus avancé, jetez un œil à notre cours Intermediate Python For Data Science, conçu pour passer au niveau supérieur. Il aborde d’autres bibliothèques (matplotlib, pandas), des concepts comme la logique, le contrôle de flux, et inclut une étude de cas pour consolider vos acquis.

Vous utilisez déjà Python pour la data science et voulez aller plus loin ? Intéressez‑vous à notre cours Importing Data Into Python ou lisez notre série de tutoriels sur l’importance du prétraitement dans le pipeline de machine learning !