20

Données Structurées et Structures contrôle

 20

Structure de données
Les types prédéfinis que nous avons vus sont insuffisants pour traiter des
données plus complexes. Ainsi Python offre d’autres types de bases appelés
les conteneurs. Ces derniers sont des objets destinés à contenir d’autres
types d’objets. On peut en citer les plus importantes :

• Les listes
• Les tuples
• Les dictionnaires
• Les ensembles
 20

3
Listes
Une liste permet de stocker une séquence
dynamiquement modifiable d'éléments hétérogènes. Les éléments sont
indicés par des entiers commençant à partir de 0.
→ Création d’une liste
On utilise les crochets [elem0,elem1...] pour définir le contenu d'une liste.

>>> maListe = [7, 3.4, "b", "hello !", True]

On peut créer une liste vide avec des crochets vides [ ] ou avec la
fonction list().
>>> listeVide1 = []
→ Adressage
Pour accéder au contenu d'une liste, on indique l’indice de l’élément
entre crochets [ ].
>>> maListe[1]
Pour modifier un élément de la liste, on indique l’indice de l’élément
entre crochets [ ] suivit de la nouvelle affectation.
>>> maListe[0] = 7
 20

4
Listes : insertion
Pour insérer un élément à la fin de la liste, on emploie la méthode
.append(). Par contre si l’on veut spécifier la position exacte de
l’insertion on utilise la méthode .insert().
>>> maListe.append(5)
>>> maListe.insert(2, "Shaun")
Pour insérer plusieurs éléments on utilise la méthode .extend() ou la
concaténation.
>>> maListe.extend(["Bitzer", 23, 5])
>>> maListe += ["Shirley", "Timmy"]
Listes : suppression
Pour supprimer un élément d’une liste, on précise à la fonction del()
l’élément à supprimer. On peut aussi soit préciser à la méthode .remove()
la valeur de l’élément à supprimer, soit préciser à la méthode .pop()
l’indice de l’élément à supprimer.
>>> del(maListe[5])
>>> maListe.remove("Shaun")
>>> maListe.pop(1)
 20

5
Listes : méthodes et fonctions
On peut appliquer plusieurs méthodes et fonctions aux
éléments d’une liste parmi lesquelles :
len() renvoie la taille d’une liste
min(), max() renvoient respectivement la valeur minimale et maximale de la
liste
.index(elem) renvoie l’indice de la première occurrence de elem
.sort() ordonne dans l’ordre croissant
.reverse() retourne (renverse) une liste

Listes : slicing
La technique du slicing est une forme avancée de l'indexation permettant
d'accéder aux éléments par intervalles et tranches. Sa syntaxe générale est
: maListe[debut:fin:pas].

>>> maListe = [7, 15, 9, 1, 12, 4, 15]

>>> maListe[2:5:1]
[9, 1, 12]
 20

Listes multidimensionnelles

Pour créer des listes à deux dimensions, on peut appliquer l’imbrication de

listes. Et pour accéder aux éléments de listes on précise dans l’ordre les
indices de l’élément.

>>> liste2D = [[1,2,3], [4,5,6], [7,8,9]]

>>> liste2D[1][2]
6
>>> liste2D[1]
[4, 5, 6]

Nous verrons plus loin comment utilise-t-on les listes simples et

multidimensionnelles pour représenter des vecteurs et des matrices. Cela
permet notamment d’implémenter des algorithmes d’opération d’algèbre
linéaire.
 20

Tuples

Le tuple Python est l'implémentation en lecture seule de la liste, c'est-à-

dire une collection immuable (non modifiable) d'éléments hétérogènes. Les
tuples possèdent les mêmes méthodes que la liste, à l'exception de celles
permettant une modification.

>>> monTuple = 1, 4, "Shaun"

 Les tuples s’utilisent de la même manière que les listes, mais leur
parcours est plus rapide.
 Les tuples consomment moins de mémoire
 Les tuples sont utiles pour définir des constantes.
 20

8
Dictionnaires
Un dictionnaire est une structure de données dite associative, car elle
permet de stocker une valeur en lui associant une clé.
→ Création d’un dictionnaire
Syntaxiquement, on utilise les accolades { } pour définir les éléments du
dictionnaire, c'est-à-dire les paires clé : valeur.

>>> monDict = {'nom': "Shaun", 'age': 3, 'famille' : ["Timmy", "Shirley"]}

On peut également créer un dictionnaire par élément après élément.

>>> monDict = {}
>>> monDict['nom'] = "Shaun"
>>> monDict['age'] = 3
>>> monDict['famille'] = ["Timmy", "Shirley"]

Ou encore en utilisant le constructeur dict() :

>>> monDict = dict(nom = "Shaun", age = 3, famille = ["Timmy", "Shirley"])
 20

9
Dictionnaires
Comme pour les listes, on peut effectuer plusieurs opérations avec les
dictionnaires.
→ Adressage
L'accès à une valeur du dictionnaire s'effectue en lui passant entre
crochets [ ] la clé correspondante.

>>> monDict['nom']
'Shaun'
Pour modifier la valeur d’un dictionnaire, on associe à la clef
correspondante la nouvelle valeur.

>>> monDict['age'] = 5
→ Fusionner deux dictionnaires
Pour fusionner deux dictionnaires, on utilise la méthode
.update().
>>> monDict.update({'proprietaire': "Joe", 'couleur': "noire"})
 20

10
Dictionnaires
Comme pour les listes, on peut effectuer plusieurs opérations avec les
dictionnaires.
Suppression
Pour supprimer une paire (clé, valeur) on emploie la fonction del() ou la
méthode .pop().
>>> del(monDict['famille'])
>>> monDict.pop('famille')

Comment dupliquer les données d’une liste, d’un dictionnaire

Pour dupliquer les données d'une liste List1=[...], il est important de
comprendre qu'avec Python une simple assignation List2 = List1 n'effectue
pas de copie des données : les 2 variables List1 et List2 référenceront en
effet la même liste. Pour recopier les données d'une liste ou d’un
dictionnaire, on peut appliquer les méthodes suivantes :
List2 = list(List1)
Dict2 = dict(Dict1)
 20

17
Les méthodes .keys(), .values() et .items()

La méthode .keys() retourne un objet contenant l’ensemble des clefs des

éléments d'un dictionnaire. Cette méthode est très utilisée dans les
boucles for.
monDict = dict(nom="Seck", age=35, famille=["Thiam","Seye"])
clefs = monDict.keys()
#dict_keys(['nom', 'age', 'famille'])
La méthode .values() retourne un objet contenant l’ensemble des valeurs des
éléments d'un dictionnaire. Cette méthode est très utilisée dans les
boucles for.
valeurs = monDict.values()
#dict_values(['Seck', 3, ['Thiam', 'Seye']])
La méthode .items() retourne un objet contenant l’ensemble des paires
(clefs,valeurs) des éléments d'un dictionnaire. Cette méthode est très
utilisée dans les boucles for.
paires = monDict.items()
#dict_items([('nom','Seck'), ('age',35), ('famille',['Thiam', 'Seye'])])
 20

11
Structures de contrôle
Les structures de contrôle décrivent l’enchaînement des instructions. Elles
permettent des traitements séquentiels, conditionnels ou répétitifs
(itératifs).

Dans les langages impératifs tels que le Python, les instructions d’un même
bloc sont exécutées séquentiellement, c’est-à-dire, les unes après les
autres, donc dans l’ordre où elles sont écrites. Les blocs d’instructions
sont matérialisés par leur indentation (décalage depuis la marge de
gauche). C’est par exemple ce que nous avons fait pour définir le corps de
fonctions.

Nous avons déjà travailler avec des programmes écrits dans des fichiers
source.
 20

12

Exécution conditionnelle if - elif – else

L'exemple ci-dessous illustre la forme complète de cette structure. Les
parties elif et else sont facultatives. Pour des tests multiples, on peut
bien entendu cascader plusieurs parties elif. Notez bien la présence du
caractère : (double point) précédant le début de chaque bloc.

a, b = 4, 5
if a > b:
print(a, "est supérieur à ", b)
elif a == b:
print(a, "est égal à ", b)
else:
print(a, "est inférieur à ", b)

Après exécution du script, on obtient la sortie suivante :

4 est inférieur à 5
 20

13
Boucle while

La boucle while permet d'exécuter un bloc d'instruction aussi longtemps que

la condition (expression logique) qui lui est appliquée est vraie.

i = 0
while i < 5:
print(i)
i += 1

Après exécution du script, on obtient la sortie suivante :

0
1
2
3
4
 20

14
Boucle for

La boucle for permet d’exécuter une séquence d’instructions un nombre connu

de fois. Il est ainsi possible de parcourir élément par élément une
structure de données itératives. Pour itérer sur une suite de nombres
entiers, on utilise souvent la fonction range().
for i in range(5):
print(i)

Après exécution du script, on obtient la sortie suivante :

0
1
2
3
4
 20

15
Instruction continue et break

Dans une boucle for ou une boucle while :

 l'instruction continue passe à l'itération suivante de la boucle courante
 l'instruction break sort de la boucle courante
Ex : afficher les nombres impairs et leurs carrés jusqu'à ce que le carré
atteigne 25.
for n in range(0, 10):
if (n % 2) == 0:
continue
carre = n**2
if carre
>25:
break
print(n, carre)
1 1
3 9
5 25
 20

16
Les fonctions range() , enumerate()

La fonction range(début, fin, pas) crée une séquence de nombres entiers

notamment utilisable par boucle for:
 debut ≤ nombre ≤ fin-1 si le pas est positif,
 debut ≥ nombre ≥ fin+1 si le pas est négatif.
Par défaut, les paramètres début et pas prennent respectivement les valeurs 0
et 1.
seq1 = range(0,5,1) # 0, 1, 2, 3, 4
seq2 = range(5,0,-1) # 5, 4, 3, 2, 1
La fonction enumerate(sequence) retourne l'indice et la valeur des éléments
d'une séquence (liste, tuple…). Cette fonction est également très utilisée
dans les boucles for.
seq = [1, 3, 12, 10, 2]
enum = enumerate(seq) # (0, 1), (1, 3), (2, 12), (3, 10), (4, 2)
 20

18
L’opérateur d’appartenance in

L’opérateur in teste si une valeur appartient à un objet itérable (chaine de

caractère, liste, tuple, dictionnaire…).

>>> L = [1, 2, 3, 4, 5]
>>> 3 in L
True
>>> 8 in L
False
>>> 8 not in L
True

L’opérateur in est très utilisé dans les conditions if et les boucles pour
itérer sur une liste.
 20

19

Parcourir une liste à l’aide de la boucle for

La boucle for permet d'itérer les valeurs d'une liste, d'un tuple, d'une
chaîne ou de tout autre objet itérable.

L = [10, 20, 30]

for n in L:
print(n)
10
20
30

for index,val in enumerate(L):

print(index, val)
0 10
1 20
3 30
 20

20

Parcourir un dictionnaire à l’aide de la boucle for

La boucle for permet d'itérer les valeurs d'une liste, d'un tuple, d'une
chaîne ou de tout autre objet itérable.

monDict = dict(nom="GUEYE", age=35, famille=["Thiam","Seck"])

for n in monDict:
print(n)
nom
age
famille

for clef,val in monDict.items():

print(clef, val)
nom Shaun
age 3
famille ['Timmy', 'Shirley']