Les listes - Des valeurs qui en contiennent d'autres

Si vous vous rappelez bien de ce que nous avons vu, les chaînes de caractère étaient capables de stocker tout et n'importe quoi... tant que nous transformions ce tout et n'importe quoi en caractères. Cela nous permettait de stocker des données, mais pas avec une très grande efficacité. Il existe donc des façons de faire plus adaptées, utilisant des types plus puissants.

La liste est un de ces types. En Python, une liste peut stocker n'importe quelle valeur, et une même liste peut contenir des valeurs de types différents.

Nous nous représenterons donc les listes comme des boîtes contenant des valeurs ordonnées, c'est à dire que ces valeurs suivent un ordre : il y'a une première valeur, qui en précède une deuxième, etc - cela dit, les listes ne sont pas triées, c'est à dire qu'un 3 peut venir avant un 2, par exemple.

Python nous permet de nous représenter les listes simplement, comme une suite de valeurs mises entre crochets, et séparées par des virgules. Par exemple, pour la liste composée des valeurs 1, 2 et 3, nous notons [1,2,3].

Les listes sont capables de contenir toute valeur que nous avons déjà rencontrée, sans en changer le type (un entier reste un entier, une chaîne reste une chaîne, etc.). Nous pouvons donc par exemple directement faire des calculs avec les éléments de ces listes. Mais comment accéder à ces éléments ? Je suis sûr que vous avez une petite idée, si en tout cas vous repensez à ce que nous faisions pour les chaînes de caractères.

Gagné. Il suffit d'écrire, à côté de la liste, l'index, entre crochets de l'élément auquel vous souhaitez accéder, de même que pour les chaînes. Petite démonstration :

Code : Python

Ici encore, le premier élément porte le numéro 0. Contrairement à ce qui se serait passé avec une chaîne de caractères, nous constatons que l'élément renvoyé reste un nombre, et pas un caractère. Si nous avions créé une chaîne "123", nous aurions récupéré le caractère "1". Les listes sont donc des structures de données plus appropriées que les chaînes pour la manipulation de groupes de données, dans nos programmes.

Pourtant, les chaînes ont leur utilité pour stocker des éléments. Nous les réutiliserons notamment lorsque nous manipulerons des fichiers, dans un futur proche . Mais à l'intérieur de nos programmes, les listes sont beaucoup plus souples d'utilisation.

En tout cas, vous devinez que l'on peut plus facilement réaliser des calculs avec les éléments d'une liste. Nous allons nous entraîner en écrivant le code d'une fonction qui prend en paramètre une liste de taille variable, et qui en calcule la moyenne. Rappelons que pour calculer la valeur moyenne d'une série de nombres, nous additionnons ces nombres, et nous divisons la somme obtenue par la longueur de la liste. À ce stade de notre réflexion, nous devons nous poser deux questions : comment parcourir une liste ? Et comment calculer ensuite sa longueur ?

Il serait plus adapté de se poser les questions dans l'autre sens. En fait, la longueur d'une liste se calcule exactement comme celle d'une chaîne, avec la fonction len. Et là, nous trouvons la réponse à la première de nos deux questions : il faut utiliser while bien sûr - c'est un réflexe que vous auriez du acquérir depuis que nous connaissons les chaînes .

Commençons par écrire le code qui calcule la somme des éléments d'une liste que nous appelons liste. Il nous suffit de parcourir toute la liste (de 0 à len(liste)) en additionnant à chaque fois les éléments que nous rencontrons (dans une variable qui servira à accumuler les calculs). Outre cet accumulateur, vous savez déjà qu'il nous faudra un compteur et la longueur de la liste, exactement comme pour les chaînes :

Code : Python

Cela se fait plutôt simplement. Nous pouvons de même écrire le code qui calcule la moyenne d'une liste : il nous suffit de rajouter à la fin l'opération accumulateur/longueur. Nous pouvons donc définir deux nouvelles fonctions, somme et moyenne, prenant toutes les deux une liste en argument. Cette fois-ci, nous n'utilisons plus de liste de test. Commençons par

Code : Python

L'indentation limite le while. Lorsqu'il est fini, le return (appartenant encore à la fonction puisqu'il est sur la même ligne d'indentation) renvoie l'accumulateur dans lequel nous avons faits nos calculs.

En réalité, Python laisse déjà à notre disposition une fonction nommée sum, calculant la somme des éléments d'une liste. Par exemple sum([3,65,-4]) renverra 64. Mais il ne fournit aucune fonction calculant la moyenne - nous allons la définir :

Code : Python

Cette définition est très courte, puisqu'elle fait appel à deux autres fonctions. Vous notez que l'on n'utilise pas de variable - à quoi cela servirait-il ? Le code est un petit peu dense pour nous, humbles débutants, mais parfaitement lisible.

Jusqu'à maintenant, nous n'avons utilisé que des listes contenant des nombres entiers. Pourtant, les listes en Python sont des structures de données capables de contenir tous les types : [1,45.6,"jambon beurre"] est une liste valide. Cela présente a priori un avantage, la souplesse. En effet, la fonction sum, par exemple, supporte aussi bien les listes contenant des nombres entiers que des nombres à virgule, voire les deux : sum([15, 12.5, -4.3]) est parfaitement valide.

Ainsi, quand nous serons bien plus avancés que maintenant, nous pourrons manipuler des listes contenant des données qui supportent des opérations en commun, comme ici les entiers (type int) et les nombres à virgule (type float). Nous pouvons par exemple utiliser le code suivant :

Code : Python

Dans cet exemple, bien que les éléments de listeCompliquee soient de types différents, ils peuvent tous être utilisés avec len. Si on avait écrit sommeDesLongueurs(listeCompliquee), on aurait eu le résultat 16. Cependant, en écrivant autreListe = [[1,2,3,4,5], 42, "hello"] puis sommeDesLongueurs(autreListe), on aurait eu une erreur.

En effet, cette nouvelle liste contient un entier, 42, et len ne peut pas être appliquée à un entier. C'est pour cela qu'il faudra faire très attention lorsque vous manipulerez des données de plusieurs types à la fois : si vous utilisez des opérations particulières et que vos listes contiennent des données qui ne supportent pas ces opérations, c'est le drame .

Python ne détecte pas ces erreurs avant l'exécution. Vous pouvez donc, avec un peu de malchance, écrire des programmes qui fonctionneront très bien chez vous quand vous les testerez, et planteront chez d'autres personnes à cause d'une bête erreur de typage. On dit que Python possède un typage dynamique : il donne des types aux données qu'il manipule pendant l'exécution du programme. Si cela vous intéresse, je vous invite à consulter le tutoriel de bluestorm sur le typage.

Nous avons remarqué des points communs entre les chaînes de caractères, que nous créons avec str, et les listes. Tout d'abord, toutes deux sont des ensembles contenant d'autres valeurs, même si ce ne sont que des caractères (appartenant également à str) dans le cas des chaînes. Ensuite, toutes les deux sont ordonnées : un premier élément vient avant un second, etc. Ces deux types possèdent donc une longueur, qui peut être obtenue avec len.

On dit que les listes et les chaînes de caractères sont des séquences. Les séquences ne sont pas un vrai type de données, en Python, mais on utilise quand même le concept pour parler des opérations qu'elles supportent.

Ces opérations sont par exemple le calcul de leur longueur, l'accès à leurs éléments (qui sont placés dans un certain ordre, nous verrons des séquences qui ne sont pas ordonnées, ou des structures de données ordonnées qui ne sont pas des séquences), le fait de pouvoir être séparées en plusieurs morceaux (ce que l'on verra dans quelques chapitres), le fait d'être parcourues (pour le moment avec une boucle while)...

Ce ne sont que des exemples. Nous en découvrirons bien plus. Pour l'instant, vous devez comprendre que Python, qui est (au moins à la base) un langage de script, permet de manipuler simplement des données complexes, pour simplifier la vie du programmeur. Vous devez aussi comprendre que Python, qui est un langage moderne, demande des connaissances que nous n'avons pas encore. Aussi, si nous ne savons pas encore faire beaucoup de choses avec les listes, ça n'est qu'une question de temps, puisque nous ré-expliquerons des choses à leur sujet dans au moins deux chapitres futurs .

Revenons sur la capacité des séquences à être parcourues. Jusqu'à présent, comme dans le chapitre sur les chaînes ou celui-ci, nous avons utilisé des boucles while. Il est temps de découvrir une nouvelle boucle : la boucle for, qui s'utilise conjointement au mot clef in. Son principe est précisément de parcourir une séquence en formant une boucle - elle va donc nous simplifier grandement la vie . Si vous avez déjà utilisé d'autres langages de programmation, comme C# ou PHP, vous reconnaîtrez la boucle foreach. Il ne faut en revanche pas la confondre avec la boucle for-each de Scheme, ni avec les boucles for qu'on retrouve en C, C++, PHP, JavaScript, BASIC... bien qu'on puisse l'utiliser pour les mêmes choses.

La syntaxe de la boucle for est très simple : Code : Python En fait, la boucle for va simplement parcourir élément par élément la séquence plusieursValeurs, en créant une variable uneValeur qui prendra successivement la valeur de chaque élément de la séquence . Cette variable sera utilisable après dans le corps de la boucle. Reprenons un exemple utilisé dans le chapitre sur les boucles :

Code : Python

Pour que vous puissiez bien comprendre ce que nous apporte for, voici la nouvelle version :

Code : Python

Notre code en est grandement simplifié . Tout ce qui pouvait servir à nous repérer dans la chaîne, comme par exemple longueurChaine, ou bien le compteur, etc. a disparu.

Si nous décomposons l'action de la boucle, nous voyons qu'au premier tour on stocke un premier caractère de maChaine dans la variable caractere, puis qu'au deuxième on stocke le suivant, et ainsi de suite. Après, le corps de la boucle est normalement exécuté, avec à l'intérieur la variable caractere, qui est dite locale (bien que Python, ainsi que certains autres langages, permettent sa réutilisation à l'extérieur de la boucle, c'est déconseillé - les versions futures de Python empêcheront d'ailleurs cette pratique).

Nous pouvons écrire un autre exemple, qui affiche tous les éléments d'une liste (un par ligne) :

Code : Python

Si une liste contient une autre séquence, celle-ci ne sera pas parcourue. Par exemple, reprenez l'exemple précédent avec listeCompliquee = ["barbecue", [1,2,3,4,5], "zoo"]. En exécutant la boucle for, nous aurons

Code : Console

Alors que nous aurions pu écrire :

Code : Python

qui cette fois-ci parcourt tous les éléments de toutes les séquences de listeCompliquee. Essayez d'écrire la version avec des boucles while et des compteurs : plus compliqué n'est-ce pas ?

Comme le laisse supposer le titre de cette partie, le mot clef in peut être utilisé seul. Il donne alors la possibilité de vérifier qu'une séquence contient ou non un élément, et s'utilise de façon assez naturelle. C'est un opérateur, de même que == ou >, c'est à dire qu'il se place entre l'élément (placé à gauche) et la séquence (à droite).

Il sert aussi bien sur les chaînes de caractères que sur les éléments d'une liste. On peut également l'utiliser pour vérifier qu'une chaîne est comprise dans une autre. Voici quelques exemples :

Code : Python

Rien de compliqué, donc .

Nous avons dit plus haut que cette boucle for pouvait se rapprocher de la boucle for du C (et d'autres langages), ou du moins de son utilisation habituelle, comme "boucle ayant un compteur de tour intégré". Dans ces langages, il est fréquent de voir cette boucle utilisée pour faire parcourir à une variable une succession de valeurs numériques, par exemple de 1 à 10, en incrémentant à chaque fois une variable d'un pas de 1. On peut naturellement choisir d'autres pas, certains négatifs.

Puisque la boucle for de Python parcourt une séquence, on pourrait l'utiliser pour imiter celle du C. Il suffirait, par exemple, pour aller de 1 à 10, d'écrire

Code : Python

cependant cela deviendrait vite lassant, et surtout cela ne nous permettrait pas de parcourir un nombre de valeur décidé par l'utilisateur (puisque cette méthode implique d'utiliser une liste fixe). Bref, vous l'aurez compris, il existe une fonction en Python qui s'occupe de générer cette liste pour nous : la fonction range.

Son utilisation est très simple : si vous lui passez un paramètre n, elle générera une liste de 0 à (n - 1). Par exemple, range(5) nous donnera la liste [0, 1, 2, 3, 4]. Il suffit donc d'écrire

Code : Python

pour avoir un programme qui comptera pour nous jusqu'à 4.

Mais si vous souhaitez commencer à 1, il est tout à fait possible de le préciser. La fonction range peut prendre deux arguments a et n, pour générer une liste de a à (n - 1). On peut donc obtenir [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] en écrivant range(1, 11).

Enfin, il est possible de préciser le pas séparant chaque valeur en passant un troisième argument, comme dans l'exemple suivant :

Code : Python

Naturellement, vous pouvez passer à range des variables plutôt que des valeurs constantes.

Il est temps de commencer à parler des choses sérieuses : ici nous allons aborder la mutabilité des listes . Derrière ce terme barbare se cache une propriété intéressante des listes : on peut les modifier, modifier ce qu'elles contiennent, sans pour autant les reconstruire (en les réaffectant avec le symbole = donc).

Pour l'instant, nous n'avons utilisé les listes que pour les présenter. Nous apprendrons à vraiment les utiliser comme moyen efficace de stocker nos données dans le chapitre suivant, qui abordera un côté de Python dont nous n'avons pour le moment pas parlé.

Nous ne savons donc manipuler que des listes qui existent "déjà", c'est à dire que nous n'en créons pas de nouvelles comme on pourrait le faire, par exemple, avec les valeurs que saisirait un utilisateur - nous utilisons des listes que nous écrivons entièrement dans notre programme. Cependant, la mutabilité nous permet de modifier ces listes, sans en créer d'autres.

Pour accéder à un élément d'une liste nombres ayant l'index i, nous écrivons nombres[i]. La mutabilité des listes autorise à modifier ce même élément tout simplement en écrivant :

Code : Python

Nous pouvons donc utiliser notre connaissance pour modifier des listes déjà existantes. Par exemple, nous allons doubler tous les éléments d'une liste, en les y re-stockant à chaque fois. Notez que, comme nous avons besoin de modifier la liste, nous sommes obligés d'utiliser un for sur autre chose que ses éléments (ici, nous utilisons la boucle for pour générer les indices) :
Code : Python

Vous pouvez tout comprendre : la première ligne crée une liste toute bête, stockée dans une variable nombres. La seconde peut être lue comme "De 0 jusqu'à la longueur de nombres" (cela concerne donc tous les éléments de nombres), et la troisième "Nous doublons l'élément de nombres et nous le replaçons au même endroit de nombres".

Nous pouvons naturellement définir une fonction qui fait ça à notre place, comme celle qui suit. Le code est le même, à part que l'on traite une liste nombres passée cette fois-ci en argument, et que l'on est obligé de la retourner à la fin :

Code : Python

Nous pouvons alors tester notre jolie fonction dans la ligne de commande Python :

Code : Console

Le début est tout à fait normal, puisque nous définissons une liste nombres, que nous passons ensuite à la fonction double. Nous obtenons donc sa valeur de retour, c'est à dire la liste doublée. Cependant, lorsque nous demandons à Python d'afficher le contenu de nombres, toute la liste a été modifiée. Jusqu'à présent, nous ne connaissions pas ce comportement. En effet, à chaque fois que nous passions une variable à une fonction, celle-ci pouvait retourner une nouvelle valeur, mais pas modifier l'ancienne. Exemple :

Code : Console

Dans le cas de cette dernière fonction, vous devez bien comprendre que nous modifions x à l'intérieur du corps de la fonction. Nous pouvons nous représenter les variables Python comme des laisses que nous attachons autour des valeurs, et qui nous servent à nous les rappeler après (la comparaison est un peu brutale, mais c'est comme si vous tiriez sur la laisse de votre chien pour qu'il revienne ). En suivant cette comparaison, nous comprenons que lorsque nous exécutons x = quelque_chose, cela signifie qu'une variable x est attachée à une valeur quelque_chose dans ce que nous appellerons le contexte de la fonction : ça n'est plus une valeur appartenant à l'ensemble du programme que contient x, mais une valeur qui est calculée dans la fonction, qui appartient à la fonction - l'utilisation du symbole = donne donc à x une nouvelle valeur. On dit que x est une variable locale à la fonction.

En revanche, pour la fonction double qui prenait une liste en argument, nous utilisions bien un symbole =, mais pas seulement : en fait, c'est sur un élément de la liste que nous l'utilisons. Un peu dur hein ? Lorsque vous faites nombres[i] =, la valeur sur laquelle pointe nombres est inchangée, cela reste la même liste - mais vous remplacez un de ses éléments par un autre ! C'est en fait comme si vous pouviez modifier la variable x locale à une fonction, en continuant d'y accéder après.

Le contenu de la liste est donc modifiable ; on dit que la liste est mutable. Nous verrons qu'il y'a d'autres façon de modifier les listes sans les affecter de nouveau, et nous verrons d'autres valeurs en Python qui sont également mutables. Par opposition, les valeurs telles que les entiers, les flottants, les booléens ou les chaînes de caractères (comme nous allons le voir) sont dites immutables : vous ne pouvez pas les modifier, vous pouvez seulement en créer de nouvelles avec une nouvelle affectation de la variable qui les contient.

En effet, essayons de changer un élément d'une chaîne :

Code : Console

Nous verrons plus tard que Python offre de nombreux mécanismes beaucoup plus intéressants et puissants pour manipuler les séquences que cette fonction double que nous avons créée. Nous verrons aussi que les cas dans lesquels nous modifions nos listes à l'intérieur même des fonctions sont plutôt rares, mais que c'est une caractéristique du langage qu'il faut savoir exploiter.

• Les listes sont des valeurs pouvant en contenir d'autres, quels que soient leurs types (y compris d'autres listes). Elles appartiennent au type list, se délimitent par des crochets.
• Les listes, comme les chaînes de caractères, sont des séquences : elles ont un ordre, contiennent des éléments, et ont une longueur. Si la longueur est 0, c'est que l'on est en présence d'une liste vide [].
• Les séquences se parcourent à l'aide de for...in, comme dans :
  Code : Python

  1 2	for element in sequence: code utilisant element...

• L'opérateur in peut aussi s'utiliser seul pour tester l'appartenance d'un élément à une séquence.
• La fonction range permet de générer des listes de nombres ; si on ne lui passe qu'un paramètre n, elle génère une liste de nombres de 0 à (n - 1) ; si on lui en passe 2, elle génère une liste de nombres du premier paramètre jusqu'au nombre avant le deuxième ; si on lui passe un troisième paramètre, ce dernier sert comme pas séparant chaque valeur de la liste de retour.
• Les listes sont mutables : leurs éléments peuvent changer de valeur et elles peuvent être modifiées à l'intérieur d'une fonction sans pour autant qu'on ai besoin de retourner une nouvelle valeur.

Beaucoup d'exercices classiques, pour vous faire manipuler les listes .

• Créez une fonction affiche qui... affiche les éléments d'une liste un par un, mais sur une même ligne (à la fin, revenez à la ligne). Utilisez pour cela une particularité de l'instruction print .
• Créez une fonction max et une fonction min qui prennent toutes les deux en argument une liste, et en renvoie respectivement le plus grand et le plus petit élément.
• Ecrivez une fonction max2 qui renvoie cette fois-ci le deuxième plus grand élément d'une liste. N'oubliez pas de traiter le cas où tous les éléments de la liste sont égaux (dans ce cas, la fonction renvoie arbitrairement -1. Nous verrons plus tard dans le cours comment gérer proprement les erreurs). Pensez également au cas où le plus grand élément de la liste est au tout début.
• Reprenez le code de la fonction double, et modifiez-le pour qu'elle prenne désormais en argument le nombre par lequel on souhaite multiplier les éléments de la liste. Si ce nombre est 0, retournez une liste vide. Appelez cette nouvelle fonction "multiplie" .
• Utilisez la fonction multiplie pour écrire une fonction table, qui affiche (sans la renvoyer, à l'aide d'un print) une table de multiplication sur plusieurs lignes. Par exemple, table(4) devrait afficher les 10 premiers multiples de 1, puis les 10 premiers multiples de 2, puis de 3 et enfin de 4.
• Créez une fonction qui renvoie le premier indice du maximum de la liste. Appelez-la min_indice. Créez maintenant une fonction qui renvoie le dernier indice du maximum de la liste. Appelez-la max_indice. Enfin, créez une fonction qui renvoie une liste de deux éléments, le premier et le dernier indice. Est-il raisonnable d'utiliser les deux fonctions définies avant ?
• Créez une fonction qui prend deux listes en argument, et trouve le nombre d'éléments communs que ces deux listes possèdent. Nous ne corrigerons pas cet exercice, demandez de l'aide sur le forum du site si vous n'y arrivez pas - plusieurs façons de faire peuvent être déployées, comparons les .

La plupart des exercices étaient accessibles. Si vous n'avez pas réussi à en résoudre la moitié, reprenez tranquillement le chapitre .

Secret (cliquez pour afficher)

Secret (cliquez pour afficher)


Secret (cliquez pour afficher)

Secret (cliquez pour afficher)

Secret (cliquez pour afficher)

Secret (cliquez pour afficher)

1
2

def moyenne(uneListe):
   return sum(uneListe)/len(uneListe)