Et maintenant, ils sont plusieurs !

La solution naïve

Imaginons que notre algoblob ne soit pas tout seul. Ils sont plusieurs ... La solution naïve, ce serait de nommer les variables en ajoutant un nom ou un numéro devant chaque variable

abscisse1 = 10
abscisse2 = 20
abscisse3 = 50

Il est assez évident de voir qu'une telle solution n'est pas viable. Il faudrait changer le nombre de variables à chaque fois que l'on ajoute ou l'on enlève un algoblob, sans compter les copier coller pour les déplacements.... Il y a mieux : nous allons utiliser des listes

Les listes en python

Une liste en python, c'est un ensemble d'objets réunis dans une même structure. Si on considère qu'une variable est une boîte dans laquelle on place un contenu, une liste est une étagère où l'on range ces boites. (notez bien qu'une étagère est une grosse boîte: une liste est une variable aussi).

Comment crée t'on une liste ?

Pour créer une liste il suffit d'utiliser la notation avec les crochets

maListe=[]

On peut remplir la liste directement au moment de sa création. Vous savez par exemple qu'il faut manger 5 fruits et légumes par jour ? Voici une liste de légumes disponibles.

maListe=['carotte','patates','chou','navet','haricot']

On peut aussi ajouter du contenu dans une liste en utilisant la méthode append qui permet de rajouter un élément à la fin de la liste. Par exemple pour ajouter les courgettes dans ma liste de légume :

maListe.append('courgettes')

Comment accède t'on aux éléments d'une liste ?

Là aussi, on utilise la notation avec les crochets pour accéder à un élément précis de la liste, par son numéro.

Vous vous attendiez peut être à voir patates comme affichage, qui est le second élément de la liste. Mais la liste est numérotée à partir de 0.

Il faut noter qu'un élément de la liste est accessible en lecture comme en écriture. On peut remplacer chou par poivron

maListe[2] = 'poivron' 

Enlever un élément de la liste

Pour enlever un élément de la liste, on utilise la méthode pop. Utilisée avec un argument, elle retire l'élément qui a cet indice. Sans argument, elle retire le dernier élément de la liste.

maListe.pop() #retire 'courgettes'
maListe.pop(1) # retire 'patates'

Parcourir une liste

Ce qui est intéressant avec une liste, c'est que l'on peut parcourir une liste pour effectuer des opérations sur chaque élément de la liste. Faire des actions répétitives est au cœur de l'informatique.

la boucle for

Pour effectuer une action répétitive sur une liste, on utilise la boucle for. La syntaxe est assez simple.

maListe=['carotte','patates','chou','navet','haricot']
for legume in maListe :
    print(legume)
    

Lorsque l'on effectue la boucle for, la variable legume va prendre successivement toutes les valeurs des éléments de la liste et effectuer les instructions qui sont dans le bloc de code indenté en dessous.

Plus fort... nous allons utiliser une seconde liste. Celle des légumes que vous n'aimez pas. Il est possible de poser une condition sur l'appartenance à une liste ou pas. Le mot clef in a en effet deux usages :

• pour parcourir une boucle lorsqu'il est associé au mot clef for, par exemple for legume in maListe :
• pour déterminer l'appartenance à une liste s'il est associé à un test avec if ou elif, par exemple if legume in listePasBon :

Seconde façon d'utiliser la boucle for

Il y a une seconde façon d'utiliser la boucle for. On peut utiliser une liste particulière, qui est créé par l'appel à la fonction range. Cette fonction va faire une liste particulière qui est une liste d'entier (en fait, c'est plus compliqué, c'est un itérateur, mais on va faire comme ci ...). Pour parcourir notre liste, on va pouvoir utiliser les indices comme dans le code ci dessous. Notez que range(n) donne n nombres entier, en commençant à 0 et en finissant à n-1 (donc range(10) va de 0 à 9)

On va aussi se servir de la fonction len qui retourne la longueur d'une liste (abbréviation de length).

Mais pourquoi faire

Vous allez me dire que ... ce n'est pas très intéressant de pouvoir ajouter juste un numéro devant un élément de la liste. Mais il faut penser dans l'autre sens. Il faut penser à la création des éléments d'une liste. Par exemple, si nous voulons créer une liste qui contient les carrés des nombres de 1 à 12, cela sera assez facile

maListe = []
for i in range(12) :
    nombre = i+1 # i va de 0 à 11
    maListe.append( nombre * nombre )

Au passage, on pourrait s'éviter le décalage en utilisant la fonction range avec un départ (inclus) et une arrivée (exclue) :

maListe = []
for nombre in range(1,13) :
    maListe.append( nombre * nombre )

Et là, on se rend compte de l'intérêt de cette démarche : on va pouvoir remplir une liste de façon automatisée.

Notez bien qu'il serait aussi possible d'utiliser une boucle while avec un compteur. On ne le fait généralement pas car cela nécessite de rajouter une variable que l'on controle, là où la boucle for combiné au range effectuera ces opérations pour nous.

Ils se multiplient !

Et c'est bien ce que nous voulons faire : nous voulons que nos algoblobs se multiplient. Qu'il n'y en ait plus un seul, mais plusieurs ! Disons une douzaine par exemple. On va reprendre le code que l'on avait avant, mais au lieu d'avoir des variables, nous allons avoir des listes de variables et nous allons les parcourir.

Voilà, nos algoblobs sont nombreux et ils évoluent librement ... dans l'espace qui leur est alloué. Et la suite ? Ce n'est quand même pas très pratique ces tableaux qui trainent dans un peu tous les sens. On va essayer de regrouper les données en utilisant une autre structure composée : les dictionnaire. Les informations sur chaque algoblob seront stockées dans un dictionnaire, et notre liste des algoblobs sera juste une liste de dictionnaires.