Les listes

Nous avons vu plusieurs types de données depuis le début: int, float, str et plus récemment bool. Cependant, si nous voulons faire des opérations avec beaucoup de données, nous sommes limités... Par exemple, pour mettre en mémoire un ensemble de températures ou de noms d'utilisateur, c'est compliqué... Nous allons donc voir comment utiliser un grand ensemble de données efficacement et découvrir au passage des mécanismes de fonctionnement de ce que nous avons vu depuis le début en Python.

Nous voulons donc pouvoir manipuler plusieurs données. Comment le faisons-nous depuis maintenant ? Eh bien, nous utilisons des variables pour que l'ordinateur mémorise des données, puis nous manipulons ces variables. Tout ça est bien beau, mais pour beaucoup de valeurs, cela nous pose un problème... En effet, une variable est une boîte qui ne peut contenir qu'une seule valeur et il faut donc en créer une par valeur, ce qui est très long. Pourrions-nous alors mettre plusieurs valeurs dans une même boîte ?

Une manière de le faire en Python est d'utiliser les listes. Les listes sont en fait des types qui contiennent plusieurs valeurs, chacune étant désignée par un nombre nommé index. On peut voir ça comme plusieurs boîtes à la ligne ayant chacune un numéro pour l'identifier. Ainsi, nous pouvons ajouter des boîtes, en enlever, faire une même opération sur toutes les boîtes, etc.

Les listes font partie d'une grande famille de types, les conteneurs, qui peuvent contenir plusieurs valeurs, chacun d'une manière un peu différente. Il y en a énormément, mais que nous allons voir plus tard. Les listes sont les représentants de cette famille les plus connus et utilisés.

Les listes sont en réalité très utilisées en programmation et tous les langages de programmation dont j'ai entendu parler les implémentent, c'est-à-dire qu'ils permettent d'en créer. En Python, les listes s'écrivent à l'américaine, list. Pour les écrire, nous utilisons cette écriture:

[premiere_valeur, deuxieme_valeur, ...]

On écrit toutes les valeurs que l'on veut entre crochets, séparées par des virgules. On peut y mettre une, deux, trois valeurs... ou même aucune. Bah oui, si on n'a pas besoin d'en mettre au début, à quoi bon le faire ? On peut aussi mettre des valeurs de différents types dans une liste, même si souvent on utilisera plutôt le même type dans toute la liste...

Les listes étant des types, ont peut les mettre dans des variables. Voici par exemple une liste de courses (Ah oui ! Il faut que j'y aille tout à l'heure !):

liste_de_courses = ["oeufs", "lait", "éponge", "yaourt", "patates", "porte-conteneur"]

Nous pouvons ensuite accéder à un élément de la liste en mettant entre crochets l'index de l'élément. Ainsi, liste_de_courses[2] donnera "éponge", liste_de_courses[5] donnera "patates" et liste_de_courses[0] donnera "oeufs". En effet, les index d'une liste commencent à partir de 0, et ceux dans de nombreux langages. Ne l'oubliez pas, car j'ai vu beaucoup d'erreurs venant de ça !

Nous ne pouvons pas non plus mettre un index plus grand ou égal à la longueur de la liste, car aucun élément n'a ces index. Nous pouvons cependant mettre des index négatifs. Les éléments seront alors pris dans l'ordre inverse. Ainsi, liste_de_courses[-1] vaut "porte-conteneur". En effet, c'est le dernier élément de la liste, et un porte-conteneur est toujours utile à la maison !

Il existe beaucoup d'opérations avec les listes en Python. En voici une liste (quel jeu de mot !):

• ajouter un élément en fin de liste: liste.append(element)

• enlever l'élément de fin de liste et le renvoyer: liste.pop(). On peut écrire l'index d'un élément pour l'enlever.

• trouver l'index de la première apparition d'une valeur dans une liste: liste.index(valeur)

• mettre deux listes ensemble, côte-à-côte (on dit souvent concaténer les deux listes): liste_une + liste_deux

• répéter une liste un certain nombre de fois: liste * nombre_de_répétitions. On peut ainsi faire de longues listes sans avoir à le faire manuellement par exemple.

• trier une liste: liste.sort()

• obtenir la longueur d'une liste: len(liste)

• obtenir la somme des valeurs d'une liste: sum(liste)

Il existe encore plein d'autres opérations sur les listes, mais retenez surtout celles-ci: elles sont fondamentales et très utiles.

Les listes sont aussi utile car il est très facile de manipuler tous les éléments de la liste d'un seul coup.

Par exemple, faisons un programme qui affiche tous les éléments d'une liste, en allant à la ligne à chaque fois pour faire plus simple. Pour parcourir tous les éléments, faisons comme d'habitude et créons une variable qui ira de 0 à len(liste) - 1 (comme l'index commence à 0 et non à 1, on enlève 1). On affichera ensuite l'élément correspondant:

liste = [1, 8, 6, 7, 3, 9]

a = 0

for i in range(len(liste)):

print(liste[a])

a += 1

Ceci fonctionne très bien, mais nous pouvons faire plus court. En effet, nous pouvons remplacer ce code par ça:

liste = [1, 8, 6, 7, 3, 9]

for i in range(len(liste)):

print(liste[i])

En effet, i est une variable ! En fait, une boucle itérative va donner à une variable successivement toutes les valeurs d'un conteneur et va à chaque fois exécuter la suite d'instructions. Dans le cas d'une répétition un nombre n de fois, la variable était en fait i et cette variable va avoir les valeurs de 0 à n-1, car range(n) est un conteneur qui contient, dans l'ordre, les valeurs de 0 à n-1. De plus, cette variable n'existe que dans la boucle. Elle ne peut pas être utilisée en dehors de celle-ci. C'est normale, car elle ne sert qu'à effectuer la répétition !

Parlons un peu de range. Cette fonction retourne un conteneur de type range (un type qui n'est utilisé que par cette fonction...) avec les entiers de 0 à n-1, mais peut aussi retourner les nombres entre le premier nombre (inclus) et le deuxième (exclu, attention !). Mieux, en ajoutant un nombre en troisième position, on peut modifier le "pas" utilisé, qui est de 1 par défaut. Au lieu d'ajouter 1 à chaque fois, la fonction va ainsi ajouter la valeur du pas à chaque fois (par exemple, ajouter 2, 3 ou même -1 pour inverser le sens de l'intervalle !).

Pour voir ce que fait la fonction, on peut convertir le type range en list avec la conversion que nous avons vu au premier chapitre. Voici un exemple en mode interactif:

>>> list(range(10))

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

>>> list(range(3, 10))

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

>>> list(range(3, 10, 2))

[3, 5, 7, 9]

>>> list(range(10, 3, -1)) #On peut utiliser des entiers négatifs.

[10, 9, 8, 7, 6, 5, 4]

>>> list(range(-5, 2))

[-5, -4, -3, -2, -1, 0, 1]

Nous avons donc utilisé la variable i pour sélectionner chaque élément de la liste, mais nous pouvons aussi directement donner à une variable les valeurs de liste ! Réécrivons donc notre programme:

liste = [1, 8, 6, 7, 3, 9]

for element in liste:

print(element)

Nous avons directement, au lieu de donner à la variable les valeurs des index de la liste, on lui donne les valeurs de la liste directement. Ce code est beaucoup plus simple et efficace. On ne pourrait cependant pas (tout du moins aussi bien) faire la même chose avec des boucles conditionnelles (de type while).

Les listes sont des types de données qui peut contenir plusieurs valeurs. Toutes ces valeurs seront alors identifiées par un nombre nommé l'index de la valeur.

On écrit les listes comme ceci en Python:

[premier_valeur, deuxieme_valeur, ...]

Pour accéder à une valeur par son index, on écrit ceci:

liste[index]

Attention, les index commencent par 0. Faites attention, c'est une erreur très très courante, et la plupart des langages adoptent cette règle !

Les listes font partie d'une famille de types nommée les conteneurs, qui peuvent contenir plusieurs valeurs, chacun d'une manière différente. Les listes en sont le plus grand représentant car très simples et utiles.

Il existe plusieurs opérations sur les listes. En voici plusieurs qui seront surement très utile:

• ajouter un élément en fin de liste: liste.append(element)

• enlever l'élément de fin de liste et le renvoyer: liste.pop(). On peut écrire l'index d'un élément pour l'enlever.

• trouver l'index de la première apparition d'une valeur dans une liste: liste.index(valeur)

• mettre deux listes ensemble (concaténer): liste_une + liste_deux

• répéter une liste un certain nombre de fois: liste * nombre_de_répétitions. On peut ainsi faire de longues listes sans avoir à le faire manuellement par exemple.

• trier une liste: liste.sort()

• obtenir la longueur d'une liste: len(liste)

Les listes sont aussi très simples à manipuler avec des boucles itératives, car en réalité, une boucle itérative est une structure qui donne à une variable successivement toutes les valeurs contenues dans un conteneur et exécute à chaque fois la suite d'instruction. Nous pouvons utiliser ceci pour répéter une suite d'opérations sur tous les éléments d'une liste.

range est une fonction qui renvoie un conteneur de type range qui correspond à un intervalle. En lui donnant un seul nombre, le résultat va contenir les nombres entre 0 (inclus) et le nombre (exclus). En précisant deux nombres, il va contenir l'intervalle entre le premier (inclus) et le deuxième (exclus), et en rajoutant à la fin un troisième nombre, on définit un "pas", qui est l'écart entre deux valeurs successives (un peu moins utile, mais à connaitre).

On peut utiliser les boucles itératives pour manipuler directement les éléments d'un conteneur, notamment d'une liste. Voici par exemple un programme qui affiche en allant à la ligne à chaque fois les éléments d'une liste.

liste_prix = [0.25, 0.9, 1.5, 25.7, 8.0, 9.0]

for prix in liste_prix:

print(prix)