Les programmes informatiques doivent parfois être capables de manipuler efficacement des données dont la nature est connue, mais le nombre variable. Par exemple, un statisticien peut avoir un ensemble d'âges, et vouloir calculer l'âge moyen d'une population. Chaque année, il utilise le même programme, sans le modifier : la quantité de nombres enregistrés est variable, mais ce qui est important c'est qu'à chaque fois elle soit considérée comme un tout, un ensemble sur lequel on opère. On pourrait prendre pour autre exemple une liste d'utilisateurs d'un site, etc.

La notion clef est celle d'ensemble de données. Pour manipuler des données, on utilise en informatique des objets dont c'est le rôle, les structures de données.

La première que nous allons étudier est la liste. Elle consiste en une succession d'objets rangés un par un (comme s'ils étaient en file indienne). L'ordre est naturellement important. On la note à l'aide de crochets en Python, en séparant les objets contenus par des virgules. Une liste peut aussi être vide, on la note alors [].

>>> L = [1, 2, 3, "salut !"]

Les listes peuvent contenir des objets de différents types, il faudra donc faire attention dans vos programmes aux opérations que vous faites sur leur contenu.

Les listes proposent naturellement des opérations accessibles sous forme de méthodes. Contrairement aux chaînes, les méthodes des listes modifient la liste elle-même : on dit que la liste est modifiable, ou mutable. Nous reviendrons sur ce concept quand nous parlerons des fonctions.

L'opération la plus élémentaire qu'une liste supporte est l'ajout d'un objet à la fin de la liste, à l'aide de la méthode append. Elle prend en argument l'objet à ajouter à la liste :

>>> L.append(4)
>>> L
[1, 2, 3, 'salut !', 4]

Notez que les listes sont faites pour que cette opération soit aussi rapide que possible. Il est également possible d'ajouter un objet à un indice donné dans la liste, mais c'est une opération moins naturelle avec les listes, et dès que vous le pourrez, il sera plus conseillé d'utiliser append. En bref, voici insert :

>>> L.insert(0, 0)
>>> L.insert(4, 4)
>>> L
[0, 1, 2, 3, 4, 'salut !', 4]

La syntaxe est insert(indice, objet). Notez que l'indice commence à 0 (début de la liste).

On peut supprimer un objet d'une liste en utilisant remove, qui prend en argument l'objet à supprimer. Si celui-ci n'est pas trouvé dans la liste, une erreur est signalée. On peut également faire sortir un objet d'une liste avec la méthode pop, qui prend en argument l'indice de l'objet (par défaut, c'est l'objet situé à la fin de la liste). Contrairement à remove, pop renvoie l'objet en question.

>>> L.remove("salut !")
>>> L.pop()
4
>>> L
[0, 1, 2, 3, 4]

Enfin, on peut fusionner une liste avec une autre (c'est à dire ajouter à une première liste tous les éléments d'une seconde) avec la méthode extend, et renverser une liste avec la méthode reverse :

>>> L.extend([5, 6, 7])
>>> L
[0, 1, 2, 3, 4, 5, 6, 7]
>>> L.reverse()
>>> L
[7, 6, 5, 4, 3, 2, 1, 0]

Voilà pour les opérations élémentaires. Il existe une opération de tri qui n'a rien d'élémentaire (le tri est un problème important en informatique, il serait trompeur de le présenter aussi trivialement), accessible via la méthode sort, sur laquelle nous reviendrons. De plus, les méthodes count et index des chaînes sont encore présentes, et se comportent de la même façon. Essayez-les !

Il existe quelques méthodes appartenant aux chaînes qui font intervenir des listes. La première est la méthode split, qui prend éventuellement un caractère de séparation (par défaut, toute espace) et un nombre entier, et qui découpe une chaîne en plusieurs sous-chaînes à chaque fois qu'elle rencontre le caractère de séparation en se limitant au nombre de fois passé en argument (par défaut, toute la chaîne). rsplit fait le même travail, en commençant par la droite de la chaîne (ce qui ne change le résultat que si vous ne découpez qu'une partie de la chaîne bien sûr). Les sous-chaînes renvoyées sont stockées, dans l'ordre, à l'intérieur d'une liste :

>>> s = "Cette chaîne, par exemple, va être découpée."
>>> s.split()
['Cette', 'chaîne,', 'par', 'exemple,', 'va', 'être', 'découpée.']
>>> l = s.split(",")
>>> l
['Cette chaîne', ' par exemple', ' va être découpée.']

Le pendant de la méthode split est la méthode join, qui prend en argument une liste d'éléments à recoller. Ceux-ci seront séparés par la chaîne à laquelle on applique la méthode (ce qui est une syntaxe un peu étrange, je vous l'accorde) :

>>> ",".join(l)
'Cette chaîne, par exemple, va être découpée.'
>>> ",".join(l) == s     # Est-ce que notre chaîne recollée est égale à la chaîne originale ?
True                     # Manifestement oui.

Cependant, si cette ligne vous surprend, c'est simplement parce que vous manquez d'habitude. Les chaînes littérales sont a priori des objets comme les autres, même si elles ne sont pas stockées dans des variables. Il est tout de même possible de leur appliquer des méthodes, comme on l'aurait fait pour des fonctions.

À ce stade, vous vous demandez peut-être si d'autres méthodes des listes ou des chaînes sont à découvrir. La réponse est oui : il serait inutile de détailler entièrement les opérations supportées par une classe, et il vous sera bien plus profitable d'apprendre à chercher de l'aide que d'en recevoir directement, sans effort préalable.

De manière générale, quand vous vous posez une question sur un langage, une technologie ou autre, cherchez de l'aide dans la documentation même du projet. Si vous ne trouvez pas, alors avant de poser la question sur un forum, cherchez encore, sur le forum ou un moteur de recherche. Il y a sans doute d'autres gens qui ont eu votre problème avant vous...

La documentation de Python est heureusement bien faite. Outre les pages en ligne (également fournies avec la distribution officielle), il y a deux outils en ligne de commande qui méritent qu'on apprenne à les utiliser. Le premier est la fonction dir : elle prend en argument un objet dont elle renvoie la liste des champs et méthodes. Essayez par exemple avec une chaîne (prenez une chaîne quelconque ou bien la classe str) : vous aurez droit à une liste assez importante de noms, dont beaucoup vous sont inconnus. Ignorez tous ceux dont le nom commence par un ou plusieurs _, nous en reparlerons.

Cependant, la fonction dir ne vous renseigne pas sur le comportement d'une méthode. Pour accéder à un document succinct présentant une classe, utilisez plutôt la fonction help en lui passant en argument la classe en question (par exemple help(str)). Allez par exemple vous documenter sur la méthode zfill de la classe str !

Exercice :

• Relisez les deux derniers chapitres. Ils contiennent beaucoup d'informations importantes.