CHAPITRE

4 Structures de données : listes, tuples, dictionnaires,

ensembles et chaı̂nes de caractères

4.1 Introduction
Dans le chapitre 2, nous avons déjà rencontré quelques types simples de Python comme les nombres
entiers, les nombres réels, etc. Dans ce présent chapitre, nous allons voir comment nous pouvons regrouper
plusieurs valeurs dans une collection comme une liste de nombres, ou un dictionnaire que nous pouvons
utiliser pour stocker et récupérer des paires clé-valeur.
Les structures de données sont des structures qui peuvent contenir certaines données ensemble. En d’autres
termes, elles sont utilisées pour stocker une collection de données connexes. Il existe cinq structures de données
intégrées dans Python : les listes, les tuples, les dictionnaires, les ensembles et les chaı̂nes de caractères. Nous
verrons comment utiliser chacun d’entre eux illustrée par des exemples.

4.2 Les listes

Une liste est une collection ordonnée d’éléments, c’est-à-dire que vous pouvez stocker une séquence
d’éléments dans une liste. Une liste peut être définie comme un agrégat d’éléments qui sont repérés par leur
position (ou indice).
Syntaxiquement, les éléments d’une liste doivent être placés entre crochets pour que Python comprenne
que vous spécifiez une liste. Une fois créée, vous pouvez ajouter, supprimer ou rechercher des éléments dans
la liste. Puisque nous pouvons ajouter et supprimer des éléments, nous disons qu’une liste est un type de
données modifiable, c’est-à-dire que ce type peut être modifié.
Exemples :
>>> l = [] # liste vide
>>> type(l)
<class 'list'>
>>> l
[]
>>> l.append('b') # ajout d'un élément à la fin
>>> l
['b']
>>> 'a' in l # teste l'appartenance de 'a' à la liste
False
>>> l.extend(['c','d','d','e']) # ajout des éléments d'une autre
... # liste à la fin (concaténation)
>>> l
['b', 'c', 'd', 'd', 'e']
>>> l.insert(0, 'a') # ajout d'un élément à une position donnée
>>> l
['a', 'b', 'c', 'd', 'd', 'e']

29
>>> 'a' in l # teste l'appartenance de 'a' à la liste
True
>>> len(l) # nombre d'éléments dans la liste
6
>>> l[2] # accès à un élément par sa position
'c'
>>> l[2:4] # accès à une sous-liste
['c', 'd']
>>> del l[3] # suppression d'un élément (par sa position)
>>> l
['a', 'b', 'c', 'd', 'e']
>>> l[3] = 'D' # modification d'un élément
>>> l
['a', 'b', 'c', 'D', 'e']
>>> max(l) # maximum de la liste (ordre lexicographique)
'e'
>>> min(l) # minimum de la liste (ordre lexicographique)
'D'
>>> l.reverse() # inverse l'ordre des éléments dans la liste
>>> l
['e', 'D', 'c', 'b', 'a']
>>> l.sort() # trier la liste (ordre lexicographique)
>>> l
['D', 'a', 'b', 'c', 'e']
>>> [6, 7, 6, 7, 6].count(6) # compter le nombre d'occurence
... # d'un élément
3
>>> list( (1,2,3) ) # contruire une liste (ici à partir d'un tuple)
[1, 2, 3]

4.3 Les tuples

Les tuples sont utilisés pour maintenir plusieurs objets ensemble. Contrairement aux listes, une ca-
ractéristique majeure des tuples est qu’ils sont immuables, c’est-à-dire que vous ne pouvez pas modifier les
tuples.
Les tuples sont définis en spécifiant des éléments séparés par des virgules dans une paire de parenthèses
optionnelle.
Exemple.

# note = 15.50, coefficient = 2.0, matière = 'bio-informatique'

>>> t = (15.50, 2.0, "bio-informatique")
>>> t
(15.50, 2.0, 'bio-informatique')
>>> _, c, _ = t # récupérer le coefficient
>>> print(c)
2.0
>>> n, _, m = t # récupérer la note n et la matière m
>>> t = (n, 3.0, m) # pour changer le coefficient en 3.0
>>> t
(15.50, 3.0, 'bio-informatique')

30
4.4 Les dictionnaires
Un dictionnaire est une structure de données dite associative, car elle permet de stocker une valeur en lui
associant une clé. Cette clé permet ensuite de retrouver la valeur associée. Les paires de clés et de valeurs
sont spécifiées dans un dictionnaire en utilisant la notation d = key1 : value1, key2 : value2, etc.. Notez que
les paires clé-valeur sont séparées par un deux-points( :) et que les paires sont elles-mêmes séparées par des
virgules et tout cela est entouré d’une paire d’accolades.
Exemple : Pour définir une structure composée d’une note, d’un coefficient et d’une matière, on pourra
alors utiliser un dictionnaire et trois clés (“valeur”, “coefficient” et “matière”) pour stocker et accéder aux
trois valeurs de notre structure.

>>> d = dict(note=15.50, coefficient=2.0, matière="bio-informatique")

# on peut l'afficher
>>> print(d)
{'valeur': 15.5, 'coefficient': 2.0, 'matière': 'bio-informatique'}
# accéder à un champ de l'enregistrement
>>> d["note"]
15.5
# modifier la valeur d'un champ
>>> d["coefficient"] = 3.0
>>> d
{'note': 15.5, 'coefficient': 3.0, 'matière': 'bio-informatique'}
>>> "note" in n1 # tester si "note" est une clé dans d
True
>>> "moyenne" in d # tester si "moyenne" est une clé dans d
False

4.5 Les ensembles

Un ensemble en Python est une collection d’objets sans répétition et sans ordre. Ce n’est PAS une séquence.
On les note comme en maths avec des accolades {}. Les éléments sont de types quelconques.
Exemples :
>>> e1 = {5,3,-8,2}
>>> e1
{-8, 2, 3, 5}
>>> e2 = {'o','e','y','u','a','i'}
>>> e2
{'u', 'o', 'i', 'e', 'a', 'y'}
>>> e3 = {5,'bio-informatique',(3,-2),7.4}
>>> e3
{'bio-informatique', 7.4, 5, (3, -2)}
Un ensemble est une collection non ordonnée d’objets uniques. La tentative d’insertion d’un doublon n’a
absolument aucun effet et ne lève même pas d’exception.
Il existe deux types d’ensembles en Python :
• Le set qui est un objet modifiable ;
• Le frozenset qui est un objet immuable (le mot anglais frozen signifie gelé en français).
Il y a deux manières pour déclarer un set :
1. En utilisant des accolades.
Exemple :

31
 >>> e1 = {"bio-informatique", "anglais", "biologie"}
>>> print(e1)
{'anglais', 'bio-informatique', 'biologie'}
Notez bien qu’il s’agit d’un ensemble non ordonné ce qui explique que print() retourne les éléments
dans un ordre aléatoire.
2. En transformant une liste en set grâce au constructeur set().
Exemple :
>>> e2 = set(["bio-informatique", "anglais", "biologie","anglais"])
>>> print(e2)
{'anglais', 'bio-informatique', 'biologie'}
Notez que le doublon (”anglais”) n’est pas pris en compte et ne lève même pas d’exception.
Il n’est pas possible de déclarer un ensemble vide avec la première méthode. Cela créé un dictionnaire.
Exemple :
>>> s = {}
>>> print(type(s))
<class 'dict'>

Pour créer un ensemble vide, pas d’autre choix que d’utiliser la deuxième méthode.
Exemple :
>>> s = set()
>>> print(type(s))
<class 'set'>
Un récapitulatif de quelques méthodes associées aux ensembles (sets) est illustré par des exemples donnés
dans le fragment de code suivant :

# Ajouter un élément avec set.add()

>>> s = {"bio-informatique", "anglais", "biologie"}
>>> s.add("mathématiques")
>>> print(s)
{'anglais', 'bio-informatique', 'biologie', 'mathématiques'}

# Ajouter tous les éléments d'un autre set avec set.update()

>>> s1 = {1,2,3}
>>> s2 = {4,5,5}
>>> s1.update(s2)
>>> print(s1)
{1, 2, 3, 4, 5}

# Supprimer un élément avec set.remove() et set.discard()

>>> s = {"bio-informatique", "anglais", "biologie"}
>>> s.remove("anglais")
>>> print(s)
{'bio-informatique', 'biologie'}

Le fragment de code suivant en mode interactif, donne un aperçu sur quelques opérateurs mathématiques
associées aux ensembles (sets) :

# Différence entre deux sets

>>> s1 = {"bio-informatique", "anglais", "biologie","mathématiques"}
>>> s2 = {"anglais", "mathématiques"}

32
>>> s3 = s1 - s2
>>> print(s3)
{'bio-informatique', 'biologie'}

# Union de deux sets

>>> s1 = {"bio-informatique", "anglais", "biologie","mathématiques"}
>>> s2 = {"chimie", "mathématiques"}
>>> s3 = s | s2
>>> s3
{'chimie', 'anglais', 'bio-informatique', 'biologie', 'mathématiques'}

# Intersection de deux sets

>>> s1 = {"bio-informatique", "anglais", "biologie","mathématiques"}
>>> s2 = {"chimie", "mathématiques"}
>>> s3 = s1 & s2
>>> s3
{'mathématiques'}

Il n’est pas possible de placer un set dans un autre set car les éléments d’un set doivent être immuables.
Cela signifie que ce genre de code va lever une exception :

>>> s = {1, 2,{3,4}} # présence d'un set

Traceback (most recent call last):
File "<pyshell#96>", line 1, in <module>
s = {1, 2,{3,4}}
TypeError: unhashable type: 'set'

s = {1, ([3, 4], 2)}

Traceback (most recent call last):
File "<pyshell#97>", line 1, in <module>
s = {1, ([3, 4], 2)}
TypeError: unhashable type: 'list'

Pour remédier à cet inconvénient, on a inventé le frozenset que l’on pourrait traduire par ensemble gelé.
Les frozensets sont des sets immuables. Par conséquent, certaines méthodes telles que add() ou remove()
ne peuvent pas leur être associées. En revanche, ils peuvent appartenir à un set ou être utilisés comme clés de
dictionnaire.
Exemples :

>>> s = {1, 2, 3}
>>> fr_s = frozenset(s) # déclaration d'un frozenset
>>> print(type(fr_s))
<class 'frozenset'>

# Notez bien que le constructeur frozenset() fonctionne également avec un tuple ou une liste:
>>> tup = (1, 2, 3)
>>> fr_s = frozenset(tup)
>>> print(type(fr_s))
<class 'frozenset'>
>>> liste = [1, 2, 3]
>>> fr_s = frozenset(liste)
>>> print(type(fr_s))
<class 'frozenset'>

33
# un frozenset peut appartenir à un set car il est devenu immuable:
>>> liste = [1, 2, 3]
>>> fr_s = frozenset(liste)
>>> s = {fr_s, 4, 5}
>>> print(s)
{5, frozenset({1, 2, 3}), 4}

4.6 Les chaı̂nes de caractères

Une chaı̂ne de caractères (appelée string en anglais) est une suite de caractères, c’est-à-dire un ensemble
de symboles faisant partie du jeu de caractères, défini par le code ASCII 1 .
En Python, les chaı̂nes de caractères peuvent se définir à partir des simples ’ ou des doubles ” quotes :
Exemples :
>>> a = "Bonjour"
>>> b = 'Bonjour'

On peut tester l’égalité des valeurs avec l’opérateur == :

>>> a == b
True
On peut vérifier que a et b sont deux références distinctes vers le même objet :

>>> a is b
True
On peut utiliser les délimiteurs dans la chaı̂ne de caractère elle même, mais il faut les échapper avec \ :

>>> s = "J\'ai bien compris"

>>> print(s)
"J'ai bien compris"

On peut insérer des caractères spéciaux utilisés pour l’affichage : la tabulation ’\t’ et le retour à la ligne
’\n’. Ces caractères apparaissent tels quels dans la chaı̂ne de caractères mais sont interprétés correctement à
l’affichage :

>>> s = "Code\t Désignation\t Prix\n"

>>> s
'Code\t Désignation\t Prix\n'
>>> print(s)
Code Désignation Prix

>>>

Les chaı̂nes multilignes utilisent un triple séparateur :

Exemple :
>>> s = """Ce script illustre comment
déclarer une cha^
ıne
de caractères multilignes"""
1. ASCII (American Standard Code for Information Interchange - Code Américain Standard pour l’échange d’informations).
Le code ASCII de base représentait les caractères sur 7 bits (c’est-à-dire 128 caractères possibles, de 0 à 127).

34
>>> s
'Ce script illustre comment\ndéclarer une cha^
ıne\nde caractères multilignes'
>>> print(s)
Ce script illustre comment
déclarer une cha^
ıne
de caractères multilignes
Python est un langage permettant la redéfinition des opérateurs, ce qui permet de les adapter au contexte
de l’objet. Pour les chaı̂nes de caractères, les opérateurs + et * ont été redéfinis :
Exemples :
>>> 'Hello ' + 'world ' + '!'
'Hello world !'
>>> 'Hi '*3
'Hi Hi Hi '
Dans le code suivant, nous illustrons quelques méthodes associées au chaı̂nes de caractères :

>>> s = "Hello!"

# On peut connaitre la longueur d'une séquence avec la fonction len()

>>> len(s)
6

# Le premier caractère de la cha^ıne est à l'indice 0, le dernier est à l'indice len(s)-1:

>>> s[0] # premier élément de la cha^
ıne
'H'
>>> s[len(s)-1] # dernier élément de la cha^ıne
'!'

# Les indices négatifs sont possibles, on parcourt alors la cha^

ıne à partir de la fin:
>>> s[-1] # dernier élément de la liste
'!'
>>> s[-3]
'l'
>>> s[-6]
'H'

# Si on essaye d'accéder à un élément qui n'existe pas, une erreur se produit:

>>> s[6]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range

# On peut découper la cha^

ıne de caractères. Cette opération s'appelle le slicing:
>>> s[0:3]
'Hel'

# Les cha^
ınes de caractère sont des séquences immutables. On ne peut pas les modifier:
>>> s[0] = 'A'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

35
# Itérer sur une cha^
ıne de caractères
>>> s = "alpha"
>>> for c in s:
print(c)

a
l
p
h
a

# mettre la première lettre en majuscule

>>> s.capitalize()
'Alpha'

# mettre toute la cha^

ıne en majuscule
>>> s.upper()
'ALPHA'

# mettre toute la cha^

ıne en minuscule
>>> s.lower()
'alpha'
# rechercher une sous-cha^
ıne, s'il existe ça envoie
# la position du premier caractère de la sous-cha^
ıne
>>> s.find('pha')
2

Lorsque l’on doit effectuer un traitement sur les chaı̂nes de caractères, la bonne démarche est de se
documenter sur les méthodes proposées par Python. Si le traitement est complexe et ne peut être réalisé à
partir des méthodes fournies par le langage, alors on peut penser à implémenter ses propres fonctions.

4.7 Série 4
Exercice 4.1.

Soit la liste des nombres entiers suivante :

entiers = [12, 3, 2, 43, 16, 50, 69, 70, 8, 9].

Écrire la suite d’instructions qui récupèrent les entiers pairs dans une nouvelle liste.
Exercice 4.2.
Reprenant la liste des entiers de l’Exercice 1. Écrire la suite d’instructions qui remplacent les entiers impairs
de la liste par des entiers pairs.
Exercice 4.3.

Soient les deux listes suivantes :

pays = [’India’, ’Pakistan’, ’Nepal’, ’China’, ’Bangladesh’]

capitale = [’New Delhi’, ’Islamabad’,’Kathmandu’, ’Beijing’, ’Dhaka’]

36
 Écrire la suite d’instructions qui associent chaque pays de la liste pays à sa capitale de la liste capitale, et
renvoient le résultat dans une liste de tuples.
Exercice 4.4.
Reprenant les deux listes de l’Exercice 4.3 :

Écrire la suite d’instructions qui crée un dictionnaire dont les pays sont les clés et les capitales sont les
valeurs.
Exercice 4.5.

Soit la chaı̂ne de caractères suivante :

ch = ‘Les chaı̂nes de caractères sont faciles à manipuler en python’

1. Écrire la suite d’instructions qui renvoie dans une liste tous les mots de cette chaı̂ne.
2. Écrire la suite d’instructions qui renvoie dans une liste tous les mots qui commencent par la lettre ‘c’.
Exercice 4.6.
Soit la liste suivante :

modules = [’bio-informatique’, ’anglais’, ’chimie’, ’statistiques’, ’mathématiques’].

Écrire la suite d’instructions qui renvoie dans une chaı̂ne de caractères les éléments de la liste séparés par
des points-virgules.

4.8 Conclusion
Les structures de données complexes (ou évolutives) jouent un rôle très important pour faciliter le stockage
et la manipulation des objets.
Les listes, les chaı̂nes et les tuples sont des séquences ordonnées d’objets. Contrairement aux chaı̂nes qui ne
contiennent que des caractères. Les listes et les tuples peuvent contenir n’importe quel type d’objet. Les listes
et les tuples sont comme des tableaux, la seule différence que les tuples sont immuables (fixes) alors que les
listes sont mutables donc elles peuvent être étendues ou réduites à volonté. Les ensembles sont une séquence
non ordonnée modifiable d’éléments uniques, tandis que les frozensets sont des ensembles immuables.

Dans le chapitre suivant, nous allons apprendre à utiliser les fonctions, une façon adéquate pour réutiliser
des fragments de codes et diminuer la taille d’un programme.

37