Types composites

En algorithmique, nous avons vu deux types composites : les tableaux, qui rassemblent des données de même type et qui sont indicés, et les structures, qui rassemblent des données qui peuvent être de types différents, et qui sont dépourvues d'indices. Naturellement, rien n'empêche d'avoir le beurre et l'argent du beurre - la diversité des types et les indices - en combinant les deux dans des tableaux de structures.

Python nous propose quatre types composites. Ce sont :

• la liste
• le tuple
• l'ensemble
• le dictionnaire

Points communs

Tous ces types ont en commun de rassembler diverses valeurs. Toutefois, chaque type possède ses propres caractéristiques :

Le dictionnaire étant un composite assez particulier, il n'a pas été inclus dans ce tableau. Mais pas de panique, on s'y intéressera plus tard !

Opérations et opérateurs

• le découpage, via des indices placés entre crochets. Les mécanismes et la syntaxe sont exactement les mêmes que ceux exposés à propos des chaînes de caractère : si on spéfidie un seul argument, il s'agit de l'indice d'un élément unique ; si l'on spécifie deux arguments, il s'agit d'un sous-ensemble, où l'indice de début est inclus, celui de fin est exclu ; enfin, si l'on stipule trois éléments, le troisième est le pas.

• La concaténation, avec l’opérateur +
• la répétition, avec l’opérateur *
• l'appartenance, avec les opérateurs in et not in

Je ne reviens pas sur le découpage, que l'on a déjà rencontré. Voici en revanche quelques exemples des trois autres opérations. Si une variable Duck d'un type composite inclut au départ les éléments 'Riri', 'Fifi' et 'Loulou', et qu'une autre variable Bongo contient 'Pim', 'Pam', 'Poum' :

• Duck+'Zoé' contiendra 'Riri', 'Fifi', 'Loulou' et 'Zoé'
• Duck+Bongo contiendra 'Riri', 'Fifi', 'Loulou', 'Pim', 'Pam', 'Poum'
• Duck*2 contiendra 'Riri', 'Fifi', 'Loulou', 'Riri', 'Fifi', 'Loulou'
• 'Pam' in Bongo vaudra true
• 'Poum' in Duck vaudra false

Méthodes communes

• len(s) : renvoie la longueur de s, c'est-à-dire le nombre d'éléments qui le compose.
• max(s) : renvoie le plus grand élément de s
• min(s) : renvoie le plus petit élément de s
• s.index(i) : renvoie l'indice de la première occurrence de i dans s
• s.count(i) : renvoie le nombre d'occurrences de i dans s

Les listes

Il s'agit d'un type qui se rapproche du tableau de l'algorithmique. Une liste peut en théorie contenir des éléments de types différents. Toutefois, en pratique, on évite généralement de mettre cette possibilité à profit, et si l'on a besoin de ranger ensemble des éléments de type différents, on préfèrera opter pour d'autres outils.

Pour créer une liste, le plus simple est d'affecter une variable par une suite de valeurs placées entre crochets et séparées par des virgules, par exemple :

MaListe = [1, 4, 5, 7, 8, 3]

Pour modifier une liste existante, il existe mille possibilités, qui s'organisent en trois grands ensembles d'interventions.

Insertion d'éléments

Celle-ci peut s'effectuer par la méthode append, qui ajoute un (ou plusieurs) éléments à la fin d'une liste. Par exemple :

MaListe.append(50)

MaListe vaut désormais [1, 4, 5, 7, 8, 3, 50]

On peut également insérer un élément à un indice spécifique via la méthode insert. On parle bien d'une insertion : dans ce cas, le nouvel élément prend l'indicve spécifié, et toute la partie de la liste qui se trouvait à cet indice et au-delà est auytomatiquement décalée d'un cran. Ainsi, après :

MaListe.insert(4, 12)

MaListe vaut désormais [1, 4, 5, 7, 12, 8, 3, 50]

Suppression d'éléments

Pour supprimer un élément, il existe deux instructions, selon que l'on préfère désigner l'élément par sa valeur, ou par son indice. Dans le premier cas, on emploie la méthode remove, avec comme argument la valeur de l'élément à supprimer. Dans le second, on utilise l'instruction del (attention, ce n'est pas une méthode et par conséquent, la syntaxe n'est pas la même !), en spécifiant l'indice de l'élément à supprimer. Par exemple, après :

MaListe.remove(8)

MaListe vaut désormais [1, 4, 7, 3, 50]. Si j'enchaîne en écrivant :

del MaListe[2]

MaListe vaut désormais [1, 4, 3, 50]

Modification d'éléments

D'une manière générale, on peut modifier un ou plusieurs éléments en les spécifiant et en les affectant avec une nouvelle valeur, selon les règles déjà vues précédemment. Si l'on repart de MaListe = [1, 4, 3, 50], alors :

MaListe[1 : 3] = [10, 20, 30]

Il existe de très nombreuses méthodes permettant de traiter les listes. Il ne s'agit évidemment pas d'en faire le tour. Deux d'entre elles méritent toutefois d'être signalées, car elles constituent des outils extrêmement puissants pour traiter de longues chaînes de caractère. La première, split, permet de transformer une chaîne en liste, en spécifiant un caractère de séparation.

chaine = "Ceci est un essai"
result = chaine.split(" ")

result contient à présent ['Ceci', 'est', 'un', 'essai']

On peut opérer le processus inverse, et donc transformer une liste en chaîne, avec la méthode join. Soit la liste alpha = ['A', 'B', 'C', 'D', 'E'], en faisant par exemple :

result = ":".join(alpha)

result contient alors 'A:B:C:D:E'

Des boucles sur les listes

Comme je l'avais évoqué dans un chapitre précédent, Python comprend plusieurs instructions de boucles spécifiques. L'une d'elles, très pratique, permet d'éviter de gérer l'indice de la liste et d'en récupérer directement les éléments. Admettons que notre liste soit serie = ['i', 'n', 's', 't', 'r', 'u', 'c']. On peut alors écrire directement :

for item in serie:

La variable item vaudra alors, à chaaque tour de boucle, successivement i, n, s, t, etc.

Les Tuples

Les tuples sont en tout point semblables aux listes, à cette différence près qu'ils sont immuables, c’est-à-dire qu'une fois un élément inséré dans un tuple, celui-ci n'est pas modifiable. La gamme des possibilités est donc beaucoup plus restreinte. Du point de vue de la syntaxe, le tuple se déclare avec des parenthèses (et non avec des crochets) :

MonTuple = ("Veaux", "Vaches", "Cochons", "Poulets")

Le tuple est évidemment un outil assez particulier. On s'en sert surtout soit pour stocker des constantes, qui ne devront pas changer de valeur au cours du programme, soit pour contourner les limites théoriques des fonctions et renvoyer ainsi plusieurs valeurs d'un seul coup.

Les Ensembles

Un ensemble est un groupement non ordonné d’éléments uniques. Le grand intérêt de l'affaire, c'est que le langage empêche automatiquement la présence de doublons : si on tente d'ajouter un élément (ou plusieurs) à un ensemble qui les contient déjà, il ne se passe tout simplement rien.

Pour déclarer et remplir un ensemble, on utilise une paire d'accolades :

Couleurs = {'Jaune', 'Vert', 'Rouge', 'Bleu', 'Violet'}

Au cas où l'on veuille éclarer un ensemble vide (pour le remplir par la suite), on ne peut pas se contenter d'une paire d'accolades. Il faut alors préciser :

CouleursVide = set()

À partir de là, on peut faire évoluer un ensemble en ajoutant (méthode add) ou en supprimant des éléments (méthode remove pour une suppression ponctuelle, clear pour le vider complètement). Toutefois, il n'est pas possible de modifier des éléments, car ceux-ci ne sont pas indicés, et donc pas accessibles par cette voie. En revanche, les ensembles se prêtent à de nombreuses opérations qui peuvent être très pratiques.

• comparaison : permet de demander si deux ensembles sont égaux (==) ou différents (!=). On peut aussi demander si un ensemble en inclut un autre (>) ou s'il est inclus dans un autre (<)
• union : permet de créer un nouvel ensemble représentant l’union entre deux ou plusieurs ensembles – les éléments qui font doublons seront automatiquement ramenés à un seul exemplaire. Syntaxe :
  resultat = ensemble1.union(ensemble2) ou
  resultat = ensemble1 | ensemble2
• intersection : permet de créer un nouvel ensemble comprenant les éléments présents dans les deux ensembles d'origine. Syntaxe :
  resultat = ensemble1.intersection(ensemble2) ou
  resultat = ensemble1 & ensemble2
• différence symétrique : permet de créer un nouvel ensemble comprenant les éléments présents dans un seul des deux ensembles d'origine. Syntaxe :
  resultat = ensemble1.symmetric_difference(ensemble2) ou
  resultat = ensemble1 ^ ensemble2
• différence : permet de créer un nouvel ensemble comprenant uniquement les éléments présents uniquement dans le premier des deux ensembles d'origine. Syntaxe :
  resultat = ensemble1.difference(ensemble2) ou
  resultat = ensemble1 - ensemble2

Conversions

Il est possible de convertir n'importe lequel de ces trois types en n'importe lequel des deux autres, selon une syntaxe classique du cast. Par exemple :

mon_ensemble = set(ma_liste)
mon_tuple = tuple(mon_ensemble)
ma_liste = liste(mon_set)

Combinaisons

Il est possible de combiner ces différents types. Ainsi, une liste de listes correspond peu ou prou à un tableau en deux dimensions. Mais on peut également imaginer une liste de tuples, ou toute autre combinaison. Pour prendre le cas d'une liste de tuples, la syntaxe de la création manuelle ressemblerait à quelque chose comme :

personnes = [("Alice", 25), ("Bob", 30), ("Charlie", 22)]

On maniera ensuite cette liste comme n'importe quelle autre, en prenant cependant soin de considérer la nature particulière de ses éléments. Ainsi, l'ajout d'un nouvel individu sera :

personnes.append(("Dany", 72))

On notera la présence d'une double paire de parenthèses : une pour le append, qui est une méthode, et une

Dictionnaires

Un dernier type composite est donc le dictionnaire. Ce type établit une correspondance entre deux séries de données (on parle aussi de « tableaux associatifs » ou de « tables de hachage »). Mais là où dans où une liste, les valeurs sont repérées par des nombres entiers (les indices), les dictionnaires sont indexés par des clés, qui peuvent être de n'importe quel type immuable, comme des chaînes de caractères, des nombres ou des tuples. Les listes, en revanche, ne peuvent pas servir de clé puisqu'elles peuvent être modifiées.

Les dictionnaires assemblent donc des éléments par paires clé : valeur. Un point essentiel est que les clés doivent impérativement être uniques : on imagine le problème si un même nombre, ou une même chaîne, correspondait à deux valeurs différentes (ou davantage) dans le dictionnaire ; c'est un peu comme si dans un tableau, il pouvait y avoir plusieurs éléments d'indice 7...

La syntaxe qui permet de créer et remplir un dictionnaire consiste à définir une suite de paires, c'est-à- dire de deux éléments séparés par le signe :. Ces paires sont elles-mêmes séparées par des virgules, et le tout est entouré par des accolades. Cela donne par exemple :

Matricule = {'Jack': 4098, 'Robert': 4139, 'Houria': 7894}

Ici, la clé est donc une chaîne de caractères (le prénom), et la valeur associée est un numérique (le matricule). On peut naturellement accomplir diverses opérations sur un dictionnaire. La première d'entre elles consiste à récupérer un élément d'après sa clé. Cela s'effectie exactement avec la même syntaxe que celle qu'on emploie avec une liste. Simplement, entre les crochets, au lieu de placer l'indice, on stipule la valeur de la clé. Ainsi, dans notre exemple, Matricule['Robert'] vaut 4139.

Pour ajouter une (paire de) valeurs, il suffit d'affecter une valeur en définissant l'emplacement par la clé :

Matricule['James'] = 007

NB : si lors de cette opération, la clé ('James') existe déjà dans le dictionnaire, l'instruction ne provoquera aucune erreur : la valeur précédente correspondant à cette clé sera simplement écrasée – ce qui nous indique donc que l'instruction pour modifier un dictionnaire est exactement la même que pour un ajout. Tout cela fait qu'avant d'ajouter une nouvelle paire, on peut avoir besoin de vérifier que la clé n'est pas déjà présente. Cela s'effectue par l'opérateur in (ou not in), que nous avons déjà rencontré :

if 'James' not in Matricule

...alors ce sera un ajout et non une modification. Pour supprimer une (paire de) valeurs, on écrira :

del Matricule['James']

Il est même possible de vider d'un coup son dictionnaire, par la méthode clear.

Lorsque l'on veut parcourir de manière systématique les éléments d'un dictionnaire, on dispose de trois instructions de boucles spécialement conçues à cette fin, selon que l'on veuille récupérer les clés, les valeurs ou les deux à la fois. Pour récupérer l'ensemble des clés :

for k in Matricule.keys():

...où la variable k contiendra successivement toutes les valeurs des clés, donc dans notre exemple, Jack, Robert, Houria. Pour récupérer l'ensemble des valeurs associées aux clés :

for v in Matricule.values():

v vaudra donc successivement 4098, 4139, 7894, etc. Enfin, il est même possible de récupérer les deux à la fois, d'un seul coup d'un seul !

for k, v in Matricule.items():

À chaque tour de boucle, on aura la dans k la valeur de la clé, et dans v la valeur correspondante.