Les listes

Les listes sont des incontournables de la programmation. Tant qu'on a que quelques informations à stocker, on peut les mettre dans des variables mais on ne peut pas s'amuser à rentrer une à une 1000 informations dans une variable individuelle... A la place, on les met dans une liste que l'on pourra manipuler et c'est cette liste qu'on sauvegarde dans une variable.

1. Création d'une liste
   1. Commençons par les bases : Créer une liste.
      • En rentrant les données à la main :
        • Par exemple :
        • ma_liste_de_nombres = [ 1, 4, 9, 3, 1, 2 ]
        • ma_liste_de_courses = [ "stylos rouges" , "piles" , "souris pour la salle info" , "claviers" ]
        • ma_liste_de_coordonnées_de_vecteurs = [ (1,1) , (0,1) , (1,6)]
        • ma_liste_bordélique = ["un texte", 18, 5.4, True, (1,0)]
      • On remarquera qu'on peut mettre un peu de tout dans une liste et en plus mélanger les types (chaines de caractères, nombres, booléens ...).
      • Un dernier exemple qui est celui que vous allez utiliser le plus : la liste qui ne contient rien !
        • la_liste_vide = []
      • Ajouter des objets dans une liste :
        • Il y a plusieurs façons de s'y prendre :
        • .append(obj) : à rajouter derrière la liste à qui on veut rajouter obj. Important : Elle modifie directement la liste et ne renvoie rien.
          • >>>ma_liste_de_course.append("brosse pour effacer")
          • >>>ma_liste_de_course
          • [ "stylos rouges" , "piles" , "souris pour la salle info" , "claviers", "brosse pour effacer" ]
          • Je suis obligé de retaper le nom de ma liste pour la voir car elle a été modifiée directement.
          • En partant de la liste vide, on peut ainsi créer un nouvelle liste en ajoutant élément par élément. Ca peut sembler absurde ou du moins très long mais dans une boucle for ou while, c'est une manière très pratique de créer une liste de données qu'on calcule ou qui nous arrive au fur et à mesure.
        • .extend(autre_liste) : à rajouter derrière la liste à qui on veut rajouter à la suite la deuxième_liste. Comme pour append, elle modifie directement la liste et ne renvoie rien.
          • >>>ma_liste_de_nombres.extend([ 6, 12, 14])
          • >>>ma_liste_de_nombres
          • [ 1, 4, 9, 3, 1, 2, 6, 12, 14 ]
        • liste1 + liste2 : Comme pour les chaines de caractères, le signe + va permettre de mettre les deux listes bout à bout, tout comme extend mais à un énorme différence près : avec extend, la première liste devient le résultat alors que dans ce cas ci, il faut mettre le résultat dans une variable pour le sauvegarder. C'est comme pour 3+5, si on ne met pas le résultat dans une variable, on ne pourra rien en faire.
          • Pour résumer, la fonction extend correspond à :
            • >>>liste = liste + autre_liste
          • mais du coup, on perd les informations qui sont dans liste à l'origine ce qui n'est pas toujours ce que l'on veut. Il faudra donc choisir au mieux la façon dont on rajoute les éléments dans une liste.
            • >>>liste_chiffres_pairs=[0 ,2 ,4 ,6 ,8 ]
            • >>>liste_chiffres_impairs=[1, 3, 5, 7 ,9]
            • >>>liste_chiffres_pairs + liste_chiffres_impairs
            • [0 ,2 ,4 ,6 ,8, 1, 3, 5, 7 ,9 ]
          • Le résultat s'affiche contrairement au cas où on aurait utilisé .extend mais comme on n'a pas mis le résultat dans une variable, on ne peut pas l'utiliser ensuite...
        • liste * n : crée une nouvelle liste où la liste est répétée en boucle n fois.
          • >>> [1] * 5
          • [1, 1, 1, 1, 1]
          • >>> [1, 2, 3]* 3
          • [1, 2, 3, 1, 2, 3, 1, 2, 3 ]
      • En utilisant la fonction range :
        • C'est une fonction qui donne directement une liste de nombres :
      • range(n) : crée une liste de n nombres allant de 0 à n-1. Et oui en informatique, il va falloir prendre l'habitude de toujours commencer à 0 et du coup finir à n-1 si on veut n nombres en tout.
      • range(n1,n2) : crée une liste de nombres allant de n1 à n2-1.
      • range(n1,n2,pas) : crée une liste de nombres allant de n1 à n2-1 en sautant de pas en pas.
        • Par exemple :
          • range(4) est la liste de nombres [0, 1, 2, 3 ]
          • range(3,6) est la liste de nombres [3, 4, 5 ]
          • range(1,9,3) est la liste de nombres [1, 4, 7] (de 3 en 3 en partant de 1)
          • range(3,0,-1) est la liste [3, 2, 1 ] (un pas négatif permet de compter à l'envers ce qui est très pratique des fois)
      • Création de liste par compréhension :
        • On peut s'en passer dans un premier temps mais c'est de loin la manière la plus puissante de créer une nouvelle liste à partir de listes existantes. Voir le paragraphe dédié plus bas.
2. Opérations sur les listes
   1. Maintenant qu'on sait créer des listes, encore faut-il pouvoir les manipuler. Voici un résumé des principales actions sur les listes.
   • liste[n] : Permet de récupérer l'élément d'indice n. Attention : le premier élément est d'indice 0 !
     • >>> ma_liste_de_courses = [ "stylos rouges" , "piles" , "souris pour la salle info" , "claviers" ]
     • >>> ma_liste_de_courses[1]
     • "piles"
     • >>> ma_liste_de_courses[-1]
     • "claviers"
     • Comme pour les chaines de caractères, un nombre négatif nous permet de partir de la fin.
   • liste[n1:n2] : Permet de récupérer la liste des éléments d'indice compris entre n1 et n2-1.
     • >>> ma_liste_de_courses[1 : 3]
     • ["piles" , "souris pour la salle info"]
     • >>> ma_liste_de_courses[:3]
     • [ "stylos rouges" , "piles" , "souris pour la salle info" ]
     • Comme pour les chaines de caractères, si on omet n1, on part du début et si on omet n2, on va jusqu'à la fin de la liste.
   • liste[n]= val : Permet de modifier la valeur de l'élément d'indice n.
     • >>> ma_liste_de_courses[1] = "piles rechargeables"
     • >>> ma_liste_de_courses
     • [ "stylos rouges" , "piles rechargeables" , "souris pour la salle info" , "claviers" ]
   • len(liste) : Donne la longueur de la liste (le nombre d'éléments.
     • >>> len(ma_liste_de_courses)
     • 4
   • liste.remove(element) : Retire element de la liste. Attention, il ne retire que la première occurrence, si element apparait plusieurs fois, il faut l'enlever plusieurs fois.
   • liste.reverse() : Renverse l'ordre de la liste.
   • liste.count(element) : Donne le nombre de fois où element se trouve dans la liste.
   • sum(liste) : Donne la somme des éléments de la liste lorsque c'est une liste de nombres bien entendu.
   • liste.sort(): Trie liste dans l'ordre croissant. Si on veux avoir un tri dans l'ordre décroissant il faut écrire liste.sort(reverse=True).
   • sorted(liste) : Renvoie liste triée dans l'ordre croissant. Si on veux avoir un tri dans l'ordre décroissant il faut écrire sorted(liste,reverse=True).
     • Ces deux fonctions font semblablement la même à une grosse différence près : liste.sort() modifie liste ce qui veut dire qu'on perd notre liste de départ alors que sorted(liste) ne modifie pas liste, elle crée une nouvelle liste des éléments de liste triée
   • element in liste : Renvoie True si element est dans la liste et False sinon.
     • >>> "claviers" in ma_liste_de_courses
     • True
     • >>> "stylos" in ma_liste_de_courses
     • False
     • Remarquez bien que "stylos" n'est pas dans la liste car c'est "stylos rouges" qui y est, ce qui n'est pas la même chaine de caractères.
3. Liens entre listes et les parties précédentes du cours.
   • Lien avec la structure conditionnelle if... else... :
     • Supposons que je retrouve des piles, je veux alors les retirer de ma liste de courses si je les avaient notées et que je viens de me rappeler que j'ai besoin d'une brosse car elle a encore disparue de la salle je vais donc la rajouter si elle n'y est pas déjà. Cela donnerait :
     • if "piles" in ma_liste_de_courses:
       • ma_liste_de_courses.remove("piles")
     • if "brosse" not in ma_liste_de_courses :
       • ma_liste_de_courses.append("brosse")
   • Lien avec la boucle for :
     • On peut énumérer les éléments d'une liste dans une boucle pour répéter des opérations pour chaque élément de la liste.
     • Par exemple si je veux afficher les carrés des nombres d'une liste :
       • >>> liste_nombres = [1, 3, 7]
       • >>> for nombre in liste_nombres :
       • >>> print(nombre**2)
       • 1
       • 9
       • 49
     • Des fois, quand on énumère dans une boucle for, on a besoin à la fois de l'élément dans notre liste mais aussi de son indice. On peut utilise la fonction enumerate et alors faire comme ceci :
       • >>> for indice, element in enumerate(liste):
         • #choses à faire avec l'indice et l'élément
   • Lien avec les chaines de caractères :
     • texte.split(separateur). Crée une liste des mots du texte qui sont compris entre les separateur. Si on met juste .split(), il prend comme séparateur un espace. Donnons des exemples pour clarifier :
       • >>> "ab-cd-e/fg-h-ij kl".split( "-" )
       • [ "ab", "cd", "e/fg", "h", "ij kl" ]
       • >>> "Deux mots, un-autre-mot , Unmot".split()
       • [ "Deux", "mots,", "un-autre-mot", ",", "Unmot" ]
     • Remarquez bien dans les deux exemples qu'il ne considère comme séparateur que ce qu'on lui donne comme séparateur entre parenthèse (un espace si on ne lui donne rien).
     • separateur.join(liste) : L'exact contraire de split(). Crée un texte à partir d'une liste de mots en intercalant entre chaque mot le separateur.
       • >>> "/".join( ["Janvier", "Février", "Mars", "Avril" ])
       • "Janvier/Février/Mars/Avril"
       • >>> "<=>".join( [ "x² - 1 = 0", "x² = 1", "x = 1 ou x = -1"])
       • "x² - 1 = 0 <=> x² = 1 <=> x = 1 ou x = -1"
       • >>> "".join([ "3", ".", "1", "4", "1", "5", "9" ])
       • "3.14159"
     • On remarquera sur le dernier exemple qu'une chaine vide nous permet de coller tous les éléments de la liste.
4. Listes en compréhension
   1. Une des forces de Python : la possibilité de créer une liste à partir d'autres en rajoutant des conditions à la volée et le tout en une ligne !
   2. Donnons des exemples :
   3. Pour augmenter de 3 tous les éléments d'une liste de nombres :
      1. >>> ma_liste_de_nombres = [1, 2, 3, 4, 5]
      2. >>> [ n + 3 for n in ma_liste_de_nombres ]
      3. [ 4, 5 ,6, 7, 8 ]
   4. Remarque, j'aurais pu mettre écrire directement [ n+3 for n in range(1,6)].
   5. Si je veux la somme des carrés des entiers de 1 à 10, je peux par exemple faire :
      1. >>> sum( [ n**2 for n in range(1,11) ] )
      2. 385
   6. Si je veux les longueurs des mots d'une liste de mots :
      1. >>> ma_liste_de_mots = [ "Cosinus", "Sinus", "Tangente", "Cotangente" ]
      2. >>> [ len(mot) for mot in ma_liste_de_mots]
      3. [7, 5, 8, 10]
   7. Et si pour cette même liste, je veux rajouter hyperbolique à chaque mot :
      1. >>>[ mot +" hyperbolique" for mot in ma_liste_de_mots ]
      2. [ "Cosinus hyperbolique", "Sinus hyperbolique", "Tangente hyperbolique", "Cotangente hyperbolique"]
   8. On peut même rajouter des conditions :
   9. Si je veux la liste des carrés des nombres pairs inférieurs à 15 (je rappelle qu'un nombre n est pair si et seulement si n%2==0)
      1. >>> [ n**2 for n in range(16) if n%2==0]
      2. [0, 4, 16, 36, 64, 100, 144, 196]
   10. Si je veux récupérer la première lettre des mots d'une liste commençant par une voyelle :
       1. >>> ma_liste_de_mots= ["maths", "info", "python", "exposant", "alpha", "fonction", "parabole", "equilateral", "orthogonal", "cercle", "isocèle" ]
       2. >>> [ mot[0] for mot in ma_liste_de_mots if mot[0] in "aeiouy"]
       3. ['i', 'e', 'a', 'e', 'o', 'i']
   11. J'explique rapidement : mot[0] récupère la première lettre de mot. Pour vérifier que c'est une voyelle, je vérifie qu'elle appartient à "aeiouy". Voir le cours sur les chaines de caractères.
5. Compléments :
   • Problèmes de copies de listes :
   1. Quand on manipule souvent les listes, à un moment donné, on tombe sur le problème suivant :
      1. >>> ma_liste=[ 1, 2, 3]
      2. >>> sauvegarde= ma_liste
      3. >>> ma_liste[0]=4
      4. >>> print(sauvegarde)
      5. [4 ,2, 3]
   2. Le problème ne saute peut-être pas aux yeux mais pourtant : J'ai une liste que je veux modifier mais avant je la sauvegarde (dans la variable sauvegarde ). Puis je modifie le premier terme de ma liste d'origine et en affichant ma sauvegarde, je vois que ma sauvegarde est modifiée aussi !
   3. Le problème vient du fait que ma liste d'origine est stockée quelque part et toutes les variables qui y font référence renvoient vers ce seul et même stockage. Donc si je modifie d'un coté, ca modifie pour tout le monde.
   4. Pour éviter ce problème, il suffit lors de la sauvegarde d'écrire sauvegarde= list(ma_liste) ou bien sauvegarde= ma_liste.copy(). Cela créera une vraie copie de notre liste qui sera sans lien avec celle d'origine.
      • Listes de listes :
        • Dans une liste, on peut mettre beaucoup de choses différentes et entre autre des listes ce qui est bien pratique si on veut stocker comme dans un tableau.
        • Par exemple une grille de morpion pourrait s’écrire :
          • >>> grille = [["O", "X", "O"], ["O", "X", "X"], ["X", "O", "O"]]
        • Pour récupérer l'élément de la deuxième ligne troisième colonne il suffit que j'écrive grille[1][2] car les listes commencent à 0 donc il faut penser à décaler d'un cran et de plus, grille[1] est la liste ["O", "X", "X"], c'est donc naturel que pour récupéré le troisième élément, on écrive grille[1][2].
        • Les listes de listes servent souvent à représenter un tableau mais on n'est pas obligé de s’arrêter à une profondeur de deux. On peut faire des listes de listes de listes...
6. Exercices :
   1. Vous pouvez trouver les exercices ici : Lien vers les exercices