Les listes

(actualisé le )

Les listes - PYTHON - 1ERE - Spé NSI
par David Latouche
https://youtu.be/vBEWiT8c8rI

Généralités

Une liste est un conteneur composé d’une séquence ordonnée et modifiable d’éléments pouvant être de différents types, séparés par des virgules, l’ensemble étant délimité par des crochets :

  1. ma_liste = [élément_1, élément_2, élément_3, ...]

Exemples :

  1. #Déclaration d'une liste vide
  2. ma_liste = []
  3. # Déclaration d'une liste dont les éléments sont des chaînes de caractères
  4. jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi']
  5. # Déclaration d'une liste dont les éléments sont des entiers
  6. pair = [2,4,6,8]
  7. # Déclaration d'une liste dont les éléments sont de différents types
  8. liste_vrac = ['lundi', 2, 1.2345, True, [2,4,6,8], {'pays' : 'France', 'population' : 66990000}]

Télécharger

Remarque : bien qu’en théorie il soit possible de construire des listes composées d’éléments de différents types, dans la pratique il est recommandé d’y stocker une collection d’objets de même type.

Propriétés :

  • Les listes sont des collections ordonnées d’objets, ces objets pouvant être de types différents.
  • Les listes sont mutables, c’est-à-dire que l’on peut modifier leur contenu.
  • L’accès aux éléments de la liste ce fait par un simple appel nom_de_la_liste[indice].
  • La numérotation de l’indice commence à partir de zéro.
  • On peut utiliser une numérotation négative (comptée à partir du dernier élément de la liste).
Repérage des indices d’une liste

Exemples :

  1. # Une liste est un objet de type "list"
  2. jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi']
  3. print(type(jour))
  4. '''
  5. <class 'list'>
  6. '''
  7. # Appel d'un élément de la liste via un indice positif
  8. print(jour[0])
  9. '''
  10. 'lundi'
  11. '''
  12. print(jour[4])
  13. '''
  14. 'vendredi'
  15. '''
  16. # Appel d'un élément de la liste via un indice négatif
  17. print(jour[-1])
  18. '''
  19. 'vendredi'
  20. '''
  21. print(jour[-2])
  22. '''
  23. 'jeudi'
  24. '''
  25. # Modification d'un élément de la liste via un indice
  26. jour[4] = 'samedi'
  27. print(jour)
  28. '''
  29. ['lundi', 'mardi', 'mercredi', 'jeudi', 'samedi']
  30. '''

Télécharger

Slicing

En Python, la technique de "slicing" permet le découpage de structures de données séquentielles, typiquement les chaînes de caractères ou les listes.

Exemples de "slicing" en lecture :

  1. semaine = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche']
  2.  
  3. # Extraction des éléments d'indice 0 inclus à 5 exclu
  4. print(semaine[0:5])
  5. '''
  6. ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi']
  7. '''
  8. # Extraction des éléments d'indice 6 inclus à 8 exclu
  9. print(semaine[0:5])
  10. '''
  11. ['samedi', 'dimanche']
  12. '''
  13. # Extraction de tous les éléments sauf le dernier
  14. print(semaine[:-1])
  15. '''
  16. ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi']
  17. '''
  18. # Extraction des éléments d'indices pairs
  19. print(semaine[0::2])
  20. '''
  21. ['lundi', 'mercredi', 'vendredi', 'dimanche']
  22. '''
  23. # Extraction des éléments d'indices impairs
  24. print(semaine[1::2])
  25. '''
  26. ['mardi', 'jeudi', 'samedi']
  27. '''
  28. # Extraction de 3 en 3
  29. print(semaine[::3])
  30. '''
  31. ['lundi', 'jeudi', 'dimanche']
  32. '''
  33. # Extraction de la séquence inversée
  34. print(semaine[::-1])
  35. '''
  36. ['dimanche', 'samedi', 'vendredi', 'jeudi', 'mercredi', 'mardi', 'lundi']
  37. '''
  38. # Extraction des éléments de l'indice 0 inclus à 5 exclu par pas de 2
  39. print(semaine[0:5:2])
  40. '''
  41. ['lundi', 'mercredi', 'vendredi']
  42. '''

Télécharger

Exemples de "slicing" en écriture :

  1. hexa = ['0','1','2','7','8','9']
  2.  
  3. # Insérer un élément à l'indice 3 sans suppression des autres
  4. hexa[3:1]="3"
  5. print(hexa)
  6. '''
  7. ['0', '1', '2', '3', '7', '8', '9']
  8. '''
  9. # Insérer plusieurs éléments à l'indice 4 sans suppression des autres
  10. hexa[4:4]="456"
  11. print(hexa)
  12. '''
  13. ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
  14. '''
  15. # Étendre la liste
  16. hexa[len(hexa):]="ABCDEF"
  17. print(hexa)
  18. '''
  19. ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9','A','B','C','D','E','F']
  20. '''

Télécharger

Quelques méthodes et fonctions

La classe "list" possède des fonctions et des méthodes" pouvant s’appliquer sur une liste.

La fonction len() renvoie le nombre d’éléments d’une liste :

  1. # Affichage du nombre d'éléments de la liste
  2. pair = [2,4,6,8]
  3. print(len(pair))
  4. '''
  5. 4
  6. '''

Télécharger

La méthode append() ajoute un élément à la fin d’une liste :

  1. # Ajout de l'élément 10 à la fin de la liste
  2. pair.append(10)
  3. print(pair)
  4. '''
  5. [2,4,6,8,10]
  6. '''

Télécharger

La méthode remove() supprime un élément d’une liste à partir de sa valeur :

  1. # Suppression de l'élément 10 de la liste
  2. pair.remove(10)
  3. print(pair)
  4. '''
  5. [2,4,6,8]
  6. '''

Télécharger

La fonction del() supprime un élément d’une liste à partir de l’indice de celui-ci :

  1. # Suppression de l'élément d'indice 3 de la liste
  2. del(pair[3])
  3. print(pair)
  4. '''
  5. [2,4,6]
  6. '''

Télécharger

La méthode insert() insère un élément dans une liste à un indice déterminé :

  1. # Insertion de l'élément 8 à l'indice 3
  2. pair.insert(3,8)
  3. print(pair)
  4. '''
  5. [2,4,6,8]
  6. '''

Télécharger

La méthode sort() trie les éléments d’une liste selon un ordre croissant :

  1. # Tri croissant des éléments d"une liste
  2. loto = [47,13,45,2,27,33]
  3. loto.sort()
  4. print(loto)
  5. '''
  6. [2,13,27,33,45,47]
  7. '''

Télécharger

La méthode reverse() trie les éléments d’une liste selon un ordre décroissant :

  1. # Tri décroissant des éléments d"une liste
  2. loto.reverse()
  3. print(loto)
  4. '''
  5. [47,45,33,27,13,2]
  6. '''

Télécharger

La méthode count() compte le nombre d’éléments d’une liste :

  1. # Compte le nombre d'élément 0 présent dans la liste :
  2. doublons = [0,1,2,0,0,3,4,5,6,0,0,0,7,8,9]
  3. print(doublons.count(0))
  4. '''
  5. 6
  6. '''

Télécharger

La méthode clear() efface tous les éléments d’une liste :

  1. pi_sequence = [3,1,4,1,5,9,2,6,5,3,9]
  2. pi_sequence.clear()
  3. print(pi_sequence)
  4. '''
  5. []
  6. '''

Télécharger

La fonction list() permet de créer une liste à partir d’un tuple :

  1. mes_fruits = list(("pomme", "banane", "cerise"))
  2. print(mes_fruits)
  3. '''
  4. ['pomme', 'banane', 'cerise']
  5. '''

Télécharger

Test d’appartenance

L’opérateur in teste si un élément fait partie d’une liste.

  1. ma_liste = [1,3,5,7,9]
  2. 3 in ma_liste
  3. '''
  4. True
  5. '''
  6. 4 in ma_liste
  7. '''
  8. False
  9. '''

Télécharger

La variation avec not permet de vérifier qu’un élément n’est pas dans une liste.

Parcourir une liste

Pour parcourir les éléments d’une liste, il faut utiliser une boucle for.

  1. xmen = ['Wolverine','Cyclope','Tornade','Diablo','Phoenix']
  2.  
  3. # Parcourir une liste : méthode 1 (par éléments)
  4. for element in xmen :
  5.     print(element, end = " ")
  6. '''
  7. 'Wolverine' 'Cyclope' 'Tornade' 'Diablo' 'Phoenix'
  8. '''
  9.  
  10. # Parcourir une liste : méthode 2 (par indices)
  11. for indice in range(len(xmen)) :
  12.     print(xmen[indice], end = " ")
  13. '''
  14. 'Wolverine' 'Cyclope' 'Tornade' 'Diablo' 'Phoenix'
  15. '''

Télécharger

Lorsque l’on itère sur une séquence telle qu’une liste, la position et la valeur correspondante peuvent être récupérées en même temps en utilisant la fonction enumerate() :

  1. xmen = ['Wolverine','Cyclope','Tornade','Diablo','Phoenix']
  2.  
  3. for indice, valeur in enumerate(xmen):
  4.     print(indice, valeur)
  5.  
  6. '''
  7. 0 Wolverine
  8. 1 Cyclope
  9. 2 Tornade
  10. 3 Diablo
  11. 4 Phoenix
  12. '''

Télécharger

Pour faire des boucles sur deux séquences ou plus en même temps, les éléments peuvent être associés par la fonction zip() :

  1. questions = ['name', 'quest', 'favorite color']
  2. answers = ['lancelot', 'the holy grail', 'blue']
  3. for q, a in zip(questions, answers):
  4.     print('What is your {0}?  It is {1}.'.format(q, a))
  5. '''
  6. What is your name?  It is lancelot.
  7. What is your quest?  It is the holy grail.
  8. What is your favorite color?  It is blue.
  9. '''

Télécharger

Concaténation de listes

Il existe plusieurs façons de fusionner ou de concaténer deux ou plusieurs listes en Python. L’un des moyens les plus simples consiste à utiliser l’opérateur +.

  1. liste1 = ['0','1','2','3','4','5','6','7','8','9']
  2. liste2 = ['A','B','C','D','E','F']
  3. hexa = liste1 + liste2
  4. print(hexa)
  5. '''
  6. ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F']
  7. '''

Télécharger

Copie de liste

On ne peut pas créer une copie d’une liste simplement en tapant liste2 = liste1, car liste2 ne sera qu’une référence à liste1 et pas un objet indépendant. Ainsi, les modifications apportées dans liste1 seront automatiquement également apportées dans liste2.

  1. guitar_hero = ['Jimi Hendrix', 'Jimmy Page', 'Ritchie Blakmore',  'Kirk Hammett', 'Angus Young']
  2. guitar_hero_copie = guitar_hero
  3. guitar_hero.clear()
  4. print(guitar_hero_copie)
  5. '''
  6. []
  7. '''

Télécharger

Une façon simple de copier une liste consiste à utiliser la méthode copy ().

  1. fruits = ["Pomme", "Poire", "Banane"]
  2. fruits_copie = fruits.copy()
  3. fruits.clear()
  4. print(fruits)
  5. '''
  6. []
  7. '''
  8. print(fruits_copie)
  9. '''
  10. ["Pomme", "Poire", "Banane"]
  11. '''

Télécharger

Listes par compréhension

La compréhension de liste est une expression qui permet de construire une liste à partir de tout autre type itérable (liste, tuple, chaîne de caractères…). Le résultat obtenu est toujours une liste. L’écriture d’une telle expression est élégante et compacte. Une liste par compréhension revêt la forme suivante :

  1. ma_liste = [<expression> for <element> in <iterable>]

Illustration :

Le programme suivant permet de stocker dans une liste les 10 premiers multiples de 3 :

  1. multiples_3 = []
  2.  
  3. for n in range(1,11):
  4.     multiples_3.append(n*3)    
  5. print(multiples_3)
  6.  
  7. '''
  8. [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
  9. '''

Télécharger

La boucle for est construite selon la structure générique suivante :

  1. for <element> in <iterable>:
  2.     <expression>

Télécharger

En comparant l’expression générique précédente avec la situation précédente, on remarque les correspondances suivantes :

  • element <—> n
  • iterable <—> (1,11),
  • expression <—> n*3.

Insérer ces valeurs dans la liste en compréhension produira le résultat suivant :

  1. multiples = [n*3 for n in range(1,11)]
  2. print(multiples)
  3. '''
  4. [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
  5. '''

Télécharger

Les listes par compréhension permettent donc de rendre l’écriture du code plus compacte.

Exemples :

  1. # Liste d'entiers : méthode 1 (sans compréhension de liste)
  2. entiers_1 = []
  3. for i in range(10) :
  4.      entiers_1.append(i)
  5. print(entiers_1)
  6. '''
  7. [0,1,2,3,4,5,6,7,8,9]
  8. '''
  9.  
  10. # Liste d'entiers : méthode 2 (avec compréhension de liste)
  11. entiers_2 = [i for i in range(10)]
  12. print(entiers_2)
  13. '''
  14. [0,1,2,3,4,5,6,7,8,9]
  15. '''
  16.  
  17. # Liste de caractères (compréhension de liste)
  18. prenom = "Logan"
  19. liste_prenom = [lettre for lettre in prenom]
  20. print(liste_prenom)
  21. '''
  22. ['L', 'o', 'g', 'a', 'n']

Télécharger

Les conditions dans les listes par compréhension :

On peut également insérer une condition if pour filtrer certaines valeurs de la liste résultante. En ce cas, la liste en compréhension prends la forme suivante :

  1. ma_liste = [<expression> for <element> in <iterable> if <condition>]

Exemples :

  1. # Liste des entiers pairs (compréhension de liste)
  2. entiers_pairs = [i for i in range(10) if i%2 == 0]
  3. print(entiers_pairs)
  4. '''
  5. [0,2,4,6,8]
  6. '''
  7.  
  8. # Liste des entiers impairs (compréhension de liste)
  9. entiers_impairs = [i for i in range(10) if i%2 != 0]
  10. print(entiers_impairs)
  11. '''
  12. [1,3,5,7,9]
  13. '''
  14.  
  15. # Liste des entiers impairs au carré (compréhension de liste)
  16. entiers_impairs = [i*i for i in range(10) if i%2 != 0]
  17. print(entiers_impairs)
  18. '''
  19. [1,9,25,49,81]
  20. '''

Télécharger

Un exemple encore plus complet de liste par compréhension comportant une structure conditionnelle est d’introduire en son sein une expression du type .. if .. else ..

Dans ce cas, l’ordre dans lequel vous déclarez tous ces états dans cette liste sera différent d’une condition if classique. Si cette condition if est nécessaire, elle sera inscrite en fin de la compréhension. Toutefois, dans le cas d’une expression .. if .. else ..,les positions respectives de la boucle for et de l’expression conditionnelle sont interchangeables. Une écriture possible est la suivante :

  1. ma_liste = [<expression_1> if <condition> else <expression_2> for <element> in <iterable>]

Exemples :

Commençons par écrire cette expression conditionnelle verbeuse .. if .. else .. sans utiliser de liste par compréhension pour calculer par exemple les carrés des nombres pairs et les cubes des nombres impairs, selon un écart prédéfini.

  1. squares_cubes = []
  2.  
  3. for n in range(1,11):
  4.     if n%2 == 0:
  5.         squares_cubes.append(n**2)
  6.     else:
  7.         squares_cubes.append(n**3)
  8.          
  9. print(squares_cubes)
  10. '''
  11. [1, 4, 27, 16, 125, 36, 343, 64, 729, 100]
  12. '''

Télécharger

L’expression conditionnelle ci-dessous suit la structure suivante :

  1. for <element> in <iterable>:
  2.     if <condition>:
  3.         <expression_1>
  4.     else:
  5.         <expression_2>

Télécharger

Placer les valeurs correspondantes au bon endroit donnera cette liste en compréhension :

  1. squares_cubes = [n**2 if n%2 == 0 else n**3 for n in range(1,11)]
  2.  
  3. print(squares_cubes)
  4. '''
  5. [1, 4, 27, 16, 125, 36, 343, 64, 729, 100]
  6. '''

Télécharger

Les boucles imbriquées dans les listes par compréhension :

Il est aussi possible d’utiliser des boucles imbriquées à l’intérieur d’une liste par compréhension . Il n’y a aucune limitation sur la quantité de boucles for à glisser dedans. Cependant, ayez à l’esprit que l’ordre de ces boucles doit être exactement le même à la fois dans le code original et la liste par compréhension. Par ailleurs, vous pouvez insérer une condition if optionnelle après chaque boucle for. Une liste en compréhension comprenant quelques boucles imbriquées for aura donc une structure de la forme suivante  :

  1. ma_liste = [<expression> for <element_a> in <iterable_a> (optional if <condition_a>)
  2.                                          for <element_b> in <iterable_b> (optional if <condition_b>)
  3.                                          for <element_c> in <iterable_c> (optional if <condition_c>)
  4.                                         ... etc ...]

Télécharger

Exemple :

  1. multiplications = []
  2.  
  3. for i in range(1, 4):
  4.     for n in range(1, 11):
  5.         multiplications.append(i*n)
  6.  
  7. print(multiplications)
  8. '''
  9. [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
  10. '''

Télécharger

Ces boucle imbriquées for peuvent être ré-écrites de cette façon :

  1. for <element_a> in <iterable_a>:
  2.     for <element_b> in <iterable_b>:
  3.         <expression>

Télécharger

Une fois que la boucle a été formulée sous cette forme, la convertir en liste par compréhension est alors facilitée :

  1. multiplications = [i*n for i in range(1,4) for n in range(1,11)]
  2.  
  3. print(multiplications)
  4. '''
  5. [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
  6. '''

Télécharger

Liste de listes

Pour représenter une table à double entrée, nous pouvons utiliser une liste bidimensionnelle c’est-à-dire une liste de listes. Chaque sous-liste correspond à une colonne du tableau.

Supposons que nous voulions retranscrire en Python le tableau suivant sous la forme d’une liste de listes :

Accéder aux éléments :

L’accès à un élément de la liste de liste se fait de la manière suivante : tableau[i][j] où i désigne l’indice de la sous liste et j l’indice de l’élément dans cette dernière. Ainsi :

  1. tableau = [['1', '4', '7'], ['2', '5', '8'], ['3', '6', '9'] ]
  2.  
  3. print(tableau[0][0])
  4. '''
  5. 1
  6. '''
  7. print(tableau[0][1])
  8. '''
  9. 4
  10. '''
  11. print(tableau[1][2])
  12. '''
  13. 8
  14. '''
  15. print(tableau[2][2])
  16. '''
  17. 9
  18. '''

Télécharger

Parcourir l’ensemble des éléments :

On peut parcourir une liste de listes à l’aide d’une double boucle for :

  1. tableau = [['1', '4', '7'], ['2', '5', '8'], ['3', '6', '9'] ]
  2.  
  3. for ligne in range(len(tableau[0])) :
  4.     print()
  5.     for colonne in range(len(tableau)) :
  6.                    print(tableau[colonne][ligne], end = " ")
  7. '''
  8. 1 2 3
  9. 4 5 6
  10. 7 8 9
  11. '''

Télécharger

Convertir une liste de listes en une liste :

On peut convertir une liste de listes en une liste (aplatissement) en utilisant une liste par compréhension :

  1. tableau_plat = [element for colonne in tableau for element in colonne]
  2. print(tableau)
  3. '''
  4. ['1', '4', '7', '2', '5', '8', '3', '6', '9']
  5. '''

Télécharger

Imbrication de listes par compréhension :

Un exemple typique est de créer la transposée d’une matrice (permutation des lignes et des colonnes). Sans aucune liste par compréhension, vous aurez besoin de deux boucles for pour créer la transposition :

  1. matrice = [
  2.     [1, 2, 3, 4],
  3.     [5, 6, 7, 8],
  4.     [9, 10, 11, 12],
  5. ]
  6. print(matrice)
  7. '''
  8. [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
  9. '''
  10.  
  11. transpose = []
  12.  
  13. for element in range(len(matrice[0])):
  14.     temp = []
  15.     for ligne in matrice:
  16.         temp.append(ligne[element])
  17.     transpose.append(temp)
  18.      
  19. print(transpose)
  20. '''
  21. [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
  22. '''

Télécharger

Dans le cadre de listes en compréhension, la boucle du plus haut niveau parvient à la fin et celle de plus bas niveau revient vers le début. Voici donc le code sous forme d’une liste par compréhension :

  1. matrice = [
  2.     [1, 2, 3, 4],
  3.     [5, 6, 7, 8],
  4.     [9, 10, 11, 12],
  5. ]
  6.  
  7. transpose = [[ligne[element] for ligne in matrice] for element in range(len(matrice[0]))]
  8.  
  9. print(transpose)
  10. '''
  11. [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
  12. '''

Télécharger

Liste de dictionnaires

Une liste de dictionnaire permet de construire facilement une mini base de données simplifiée.

Accéder aux différents éléments

  1. pays = [{"Nom" : "Allemagne", "Capital" : "Berlin", "Population" : 81174000}, {"Nom" : "France", "Capital" : "Paris", "Population" : 66152000}, {"Nom" : "Royaume-Uni", "Capital" : "Londres", "Population" : 64767000}]
  2. print(pays[0]["Nom"])
  3. '''
  4. Allemagne
  5. '''
  6. print(pays[0]["Capital"])
  7. '''
  8. Berlin
  9. '''
  10. print(pays[0]["Population"])
  11. '''
  12. 81174000
  13. '''
  14. print(pays[2]["Nom"])
  15. '''
  16. Royaume-Uni
  17. '''
  18. print(pays[2]["Capital"])
  19. '''
  20. Londres
  21. '''
  22. print(pays[]["Population"])
  23. '''
  24. 64767000
  25. '''

Télécharger

Parcourir tous les éléments d’une liste de dictionnaires :

Le parcours d’une structure imbriquée telle qu’une liste de dictionnaires nécessite plusieurs boucles :

  1. pays = [{"Nom" : "Allemagne", "Capital" : "Berlin", "Population" : 81174000}, {"Nom" : "France", "Capital" : "Paris", "Population" : 66152000}, {"nom" : "Royaume-Uni", "Capital" : "Londres", "Population" : 64767000}]
  2. # Parcours de la liste
  3. for p in pays :
  4.     print("-------------------------")
  5.     #Parcours d'un dictionnaire
  6.     for cle, valeur in p.items():
  7.         print(cle," : ", valeur)
  8. '''
  9. -------------------------
  10. Nom  :  Allemagne
  11. Capital  :  Berlin
  12. Population  :  81174000
  13. -------------------------
  14. Nom  :  France
  15. Napital  :  Paris
  16. Population  :  66152000
  17. -------------------------
  18. nom  :  Royaume-Uni
  19. Capital  :  Londres
  20. Population  :  64767000
  21. '''

Télécharger

Transformer une liste de tuples en un dictionnaire

Le constructeur dict() fabrique un dictionnaire directement à partir d’une liste de paires clé-valeur stockées sous la forme de tuples :

  1. liste_telephone = [('Dave', '0607xxxxxx'), ('Pamela', '0608xxxxxx'), ('John', '0609xxxxxx')]
  2. dico_telephone = dict(liste_telephone)
  3. print(dico_telephone)
  4. '''
  5. {'Dave': '0607xxxxxx', 'Pamela': '0608xxxxxx', 'John': '0609xxxxxx'}
  6. '''

Télécharger

Dans la même rubrique

Partager cette page