CHAPITRE 2

Les structures de contrôles et de données

2.1 Les structures de contrôles et de répétition

Le plus souvent, on est appelé à écrire un code Python en prenant compte certaines conditions ou en répétant la
même instruction un certain nombre de fois. Ceci nous ramène alors à utiliser des conditions ou des boucles d'itérations.

2.1.1 Les structures conditionnelles

Les conditions sont un concept essentiel en programmation. Elles vont vous permettre de faire une action précise
si, par exemple, une variable est positive, une autre action si cette variable est négative, ou une troisième action si la
variable est nulle.
Exemple 2.1.1 : Comme un bon exemple vaut mieux que plusieurs lignes d'explications, voici un exemple clair
d'une condition qui demande un nombre à l'utilisateur puis l'informe si le nombre saisi est positif ou négatif.
1 a = int ( input ( ' Donner un ré el : ') )
2 if a >= 0:
3 print ( ' Le nombre saisi est positif ')
4 else :
5 print ( ' Le nombre saisi est n é gatif ')

Les opérations logiques possibles, pour tester des quantités, sont citées dans la liste suivante :
Symbole Opération Symbole Opération
< inférieur > supérieur
<= inférieur ou égal >= supérieur ou égal
== égal != diérent
and et or ou
Dans les deux exemples suivants, on nous donne un nombre réel a et on teste si le nombre est dans un intervalle [2; 8]
ou non en utilisant l'opérateur and puis l'opérateur or.
1 a = 5 1 a = 5
2 if a >= 2 and a <= 8: 2 if a < 2 or a > 8:
3 print ( " a est dans l ' intervalle . " ) 3 print ( " a n ' est pas dans l ' intervalle . " )
4 else : 4 else :
5 print ( " a n ' est pas dans l ' intervalle . " ) 5 print ( " a est dans l ' intervalle . " )
Il est parfois nécessaire de faire plusieurs tests dans un programme (il n'existe pas que deux réponses mais plusieurs).
Dans ce cas, la structure de la condition change en if/elif/..../else comme le montre l'exemple suivant du produit de
deux réels.

9
 Exemple 2.1.2 :
1 a = int ( input ( ' Donner le premier nombre : ')
2 b = int ( input ( ' Donner le deuxi è me nombre : ')
3 if a < 0 and b < 0:
4 print ( ' Le produit est positif ')
5 elif a > 0 and b < 0:
6 print ( ' Le produit est n é gatif ')
7 elif a > 0 and b > 0:
8 print ( ' Le produit est positif ')
9 else :
10 print ( ' Le produit est n é gatif ')

Activité 2.1.3 :
1. Un magasin de reprographie facture 25fc les dix premières photocopies, 20fc les vingt suivantes et 15fc E
au-delà. Écrire un algorithme qui demande à l'utilisateur le nombre de photocopies eectuées et qui ache
la facture correspondante.
2. Reprendre l'exemple de la fonction qui calcule les racines d'un polynôme du second degré, avec cette fois la
prise en compte du fait qu'il y a deux racines distinctes, une racine double ou aucune racine dans R.

2.1.2 L'utilisation des boucles

Les boucles constituent un moyen de répéter un certain nombre de fois des instructions de votre programme.
Prenons un exemple simple, même s'il est assez peu réjouissant en lui-même : écrire un programme achant la table
de multiplication par 7, de 1 × 7 à 10 × 7. On peut répéter 10 fois la fonction print mais ça restera quand pénible,
proche d'une punition. Cette manière de faire reste alors assez peu pratique et il accomplit une tâche bien répétitive.
Pour qu'un programme reste très adapté, il est préférable d'utiliser les boucles.

La boucle while. Cette boucle permet de répéter un bloc d'instructions tant qu'une condition est vraie (while
signie  tant que  en anglais). Sous Python , la syntaxe de while est :
1 while condition :
2 # instruction 1
3 # instruction 2
4 # ...
5 # instruction N

On peut maintenant, avec peu de lignes, acher la table de multiplication de 7 avec la boucle while comme le montre
l'exemple suivant
1 nb = int ( input ( " Donner un entier naturel : " ) )
2 i = 1 # incr é mentant
3

4 while i <= 10: # Tant que i est inf é rieur ou é gal à 10

5 print ( nb , " * " , i , " = " , nb * i )
6 i += 1 # equivalent à i = i +1

Prenons maintenant l'exemple d'un code qui calcule la factorielle d'un entier naturel (on suppose que l'utilisateur va
saisir un entier naturel). On a alors le code
1 n = int ( input ( " Donner un entier naturel : " ) )
2 fact = 1
3 i = 1
4 while i <= n :
5 fact *= i # é quivalent à fact = fact * i

10
6 i += 1 # equivalent à i = i +1
7 print ( " La factorielle de " ,n , " est " , fact )

Activité 2.1.4 :
✿ Écrire un programme qui demande à l'utilisateur un entier naturel n et calcule la somme des entiers naturels
inférieurs ou égaux à n.
✿ Écrire un programme qui demande à l'utilisateur un entier naturel n et calcule le produit des entiers naturels,
autres que 0, inférieurs ou égaux à n.

La boucle for. Dans beaucoup de cas, on connaît le nombre d'itérations à eectuer. Il est alors plus pratique
d'utiliser une boucle pour à la place de la boucle tant que. De plus, ces boucles intègrent une variable de boucle très
utile pour l'indexation (des composantes d'un vecteur ou d'une matrice par exemple). La syntaxe de ces boucles est
donnée sous Python par
1 for element in sequence :
2 # instruction 1
3 # instruction 2
4 # .............
5 # instruction N

où sequence est une liste ou un ensemble des données que element va devoir parcourir. Si la sequence est une liste
d'entiers naturels formant une suite arithmétique (c'est-à-dire que le pas d'incrémentation entre deux itérations est
xe), on peut alors utiliser la fonction range à la place. Par exemple, reprenons l'exemple de la table de multiplication
de n :
1 nb = int ( input ( " Donner un entier naturel : " ) )
2 for i in range (1 ,11 ,1) : # Une incr é mentation avec un pas de 1
3 print ( nb , " * " , i , " = " , nb * i )

Activité 2.1.5 :
1. Reprendre l'exemple de la factorielle d'un entier naturel en utilisant une boucle for.
2. Écrire un algorithme qui demande un nombre de départ, et qui ensuite ache les dix nombres suivants. Par
exemple, si l'utilisateur entre le nombre 17, le programme achera les nombres de 18 à 27.

π2
Un autre exemple consisterait à calculer une valeur approchée de , qui a été donnée par la formule de Dirichlet :
6
+∞
X
π2 1
= .
6 k2
k=1

Sachant qu'il est impossible de faire une somme jusqu'à l'inni, on peut décider de s'arrêter à un rang n donné en
fonction de la précision exigée. On aura alors
1 n = 100
2 somme = 0
3 for k in range (1 , n +1 ,1) :
4 somme = somme + 1/( k **2)
5 print ( " La valeur approch é e par Dirichlet est " , somme )

Considérons par exemple un autre code Python qui doit acher les multiples de 5 inférieurs ou égaux à 50. On fera
dans ce cas :
1 for k in range (0 ,51 ,1) :
1 for k in range (0 ,51 ,5) :
2 if i %5 == 0:
2 print ( i )
3 print ( i )

11
 Remarque. Si le pas d'itérations dans la boucle for est égal à 1, on peut alors l'omettre et Python l'aectera par
défaut. Et si, de plus, la première itération de la boucle commence par 0, on peut aussi l'omettre et dans ce cas la
fonction range aura un seul argument qui est le dernier indice de la boucle. Par exemple, les deux codes suivants
1 for k in range (0 ,51) : 1 for k in range (51) :
2 if i %5 == 0: 2 if i %5 == 0:
3 print ( i ) 3 print ( i )
produisent le même résultat que le code précédent qui a tout spécié explicitement dans la boucle.
D'une manière générale, la boucle for permet de faire des itérations sur un élément, comme une chaîne de caractères
par exemple ou une liste, dont nous verrons plus tard comment les dénir et les utiliser.
1 v = " Hello word " 1 liste = [1 ,5 ,10 ,15 ,20 ,25]
2 for lettre in v : 2 for i in liste :
3 print ( lettre ) 3 print ( " i = " ,i )

L'instruction break. L'instruction break permet de casser (ou arrêter) l'exécution d'une boucle (while ou for).

Elle fait sortir de la boucle et passer à l'instruction qui suit juste après la boucle. Il est très utile dans des codes où
par exemple, on demande à l'utilisateur de saisir une information et tant que l'information saisie n'est pas vraie, on
lui redemande la même chose.
1 for i in range (10) :
2 print ( " debut iteration " , i )
3 print ( " bonjour " )
4 if i == 2:
5 break
6 print ( " fin iteration " , i )
7 print ( " apres la boucle " )

Considérons maintenant un autre exemple où on demande à l'utilisateur de saisir un entier naturel multiple de 3 et
tant qu'il ne le fait pas, on lui redemande la même chose.
1 while 1: # 1 ( True ) est toujours vrai
2 nombre = input ( " Donner un multiple de 3 : " )
3 if nombre %3 != 0:
4 print ( " ce n ' est pas un multiple de 3 ! ")
5 else :
6 print ( " Enfin , un multiple de 3. Merci ! " )
7 break

2.2 Les structures des données

Naturellement, lors de la programmation, on a besoin de déclarer des variables qui peuvent contenir plus d'une
seule information, plus d'une seule valeur. Comme par exemple, quand on veut créer un ensemble des coordonnées.
Ces variables existent sous Python sous l'appellation de listes, tableaux ou d'une manière générale des structures de
données. Le principe de base d'une structure de données, c'est de stocker des éléments auxquels le programmeur veut

pouvoir accéder plus tard. On appelle les diérentes utilisations possibles de la structure de données des opérations.
Les chaînes de caractères en font également partie. Nous verrons essentiellement des listes, des dictionnaires et des
ensembles. Il existe toutefois, d'autres formes de structures de données telles que les listes chaînées ou encore les piles
et les.

2.2.1 Les chaînes de caractères

Nous avons vu comment aecter à une variable une valeur numérique (entier ou réel). Nous pouvons alors le faire
en donnant directeur la valeur dans le code ou en demandant à l'utilisateur de saisir la valeur voulue puis la récupérer
avec la fonction input() . Toutefois, il ne sera pas toujours question des valeurs entières dont on aura besoin. On peut

12
 par exemple vouloir utiliser des noms des villes, des écoles, des prénoms des personnes ainsi de suite. On devrait alors
pourvoir le faire sur Python . Si on aecte directement à une variable une chaîne de caractères, Python considérera
qu'il s'agit d'un nom d'une variable et ira chercher la valeur qui lui est aectée. Si la variable n'existe pas, Python
achera une erreur.
1 ecole = fst # Python affiche une erreur et dira que la variable fst n ' existe pas .
2 fst = 12
3 ecole = fst # Python affecte à é cole la valeur 12.

Il faut savoir alors qu'une chaîne de caractères (un mot, une phrase) est vue comme une liste de caractères. Pour dire
à Python que nous voulons aecter une chaîne de caractères à une variable, il faut mettre la chaîne de caractère entre
 quotes  . Exemple
1 ecole = " fst " # On affecte à ecole la cha î ne fst .
2 date = " 03 Mars 2018 "

Si la valeur que l'utilisateur doit saisir est une chaîne de caractères, rien de si simple vu que Python considère, par
défaut, tout ce qui est saisi par l'utilisateur comme une chaîne de caractères. Par exemple, si on veut demander à un
utilisateur de saisir son nom, on ferait
1 nom = input ( " Quel est votre nom : " )
2 print ( " Bonjour " , nom )

Activité 2.2.1 : (Tranche d'âge d'une personne) Écrire un code Python qui demande à un utilisateur de saisir
son nom, son prénom et son age. On mettre ses valeurs dans les variables nom, prenom et age. Ensuite, on achera
sur l'écran l'un des messages suivants selon l'age de l'utilisateur.
1. Si l'age est inférieur à 5, on achera Bonjour nom prenom, vous tes encore un enfant.
2. Si l'age est compris entre 5 et 12, on achera Bonjour nom prenom, vous êtes un pré-adolescent.
3. Si l'age est compris entre 12 et 18, on achera Bonjour nom prenom, vous êtes un adolescent.
4. Si l'age est compris entre 18 et 40, on achera Bonjour nom prenom, vous êtes un majeur.
5. Si l'age est supérieur à 40, on achera Bonjour nom prenom, vous êtes maintenant un vieux.

Caractères spéciaux. Certaines caractères, lorsqu'ils sont utilisés dans une chaîne de caractères, on ne les verra pas
apparaître. On les appelle les caractères spéciaux. Ces caractères désignent soit le passage à la ligne, une tabulation,
les guillemets, ... Ils sont tous introduits par la contre-barre (ou anti-slash) que Python considère comme une marque
pour les caractères spéciaux. La contre-barre est appelée caractère d'échappement qui, employé dans une chaîne, il
doit toujours être suivi d'un autre caractère. Voici quelques exemples de caractères spéciaux :
✿ \n permet d'insérer des marques de passage à la ligne dans une chaîne non délimitée par des quotes simples.
1 chaine = " Une cha î ne \ nsur plusieurs \ nlignes . "
2 print ( chaine )
3 Une cha î ne
4 sur plusieurs
5 lignes

✿ \t permet d'insérer des marques de tabulation (un grand espace) dans une chaîne.
1 chaine = " Une cha î ne \ n \ tsur plusieurs lignes \ n \ t \ tavec tabulations "
2 print ( chaine )
3 Une cha î ne
4 sur plusieurs lignes
5 avec tabulations

✿ \" permet d'insérer des guillemets dans une chaîne délimitée par des guillemets.

13
 1 chaine = " Une cha î ne avec des \" gillemets \". "
2 print ( chaine )
3 Une cha î ne avec des " gillemets " .

✿ \' permet d'insérer des apostrophes dans une chaîne délimitée par des apostrophes.
1 chaine = ' Une cha î ne avec des \' apostrophes \ '. '
2 print ( chaine )
3 Une cha î ne avec des ' apostrophes '.

✿ \\ permet d'insérer des contre-barres dans une chaîne.

1 chaine = ' Une cha î ne avec trois contre - barres \\\\\\. '
2 print ( chaine )
3 Une cha î ne avec trois contre - barres \\\.

Opérations sur les chaînes. Puisqu'une chaîne de caractères est vue comme une liste de plusieurs caractères.
Sa longueur est alors le nombre de caractères dans la chaîne tout en comptant les espaces. On peut par conséquent
appliquer quelques fonctions spéciques aux vecteurs comme l'extraction des sous-chaînes, la longueur de la chaîne, la
concaténation de deux chaînes, ainsi de suite.
1 chaine = " Bonjour tout le monde "
2 n = len ( chaine ) # Renvoie 21 ( le nombre de caract è res , les espaces inclus ) .
3 x = ' Hello '
4 y = " world ! "
5 z = x + y # concat è ne deux cha î nes ici z = " Hello world !"
6 t = z *2 # R é p è te deux fois la cha î ne z , ici on a t = ' Hello world ! Hello world ! '
7 " abc " == ' abc ' # Teste si les deux cha î nes sont les mê mes , ici renvoie vrai ( true )
8 " abc " != " ABC " # Teste si les deux cha î nes sont diff é rentes , ici renvoie vraie ( true )
9 chaineMaj = chaine . upper () # Convertit la cha î ne en majuscule
10 chaineMin = chaine . lower () # Convertit la cha î ne en minuscule
11 chaine1 = " 12453 "
12 nombre = float ( chaine1 ) # convertit la cha î ne en un nombre r é el .

1 chaine = " Bonjour tout le monde "

2 x = chaine [0] # renvoie le premier é l é ment de la cha î ne , ici B
3 x = chaine [6] # renvoie le 7 e é l é ment de la cha î ne , ici " r "
4 x = chaine [n -2] # renvoie le 2 e é l é ment de la cha î ne à partir de la droite
5 x = chaine [ -2] # fait la m ê me chose que tout à l ' heure .
6 sousChaine = chaine [0:6] # Renvoie les 7 premiers terme de la cha î ne ( ici Bonjour )
7 sousChaine = chaine [:6] # renvoie la m ê me chose que tout à l ' heure
8 sousChaine = chaine [5: n ] # donne la derni è re partie de la cha î ne à partir du 6 e caract è re
9 sousChaine = chaine [5:] # renvoie la m ê me chose que tout à l ' heure

Modications des chaînes de caractères. Certains langages de programmation permettent de changer un carac-
tère dans une chaîne. Par exemple, changer la lettre i de la chaîne helli world! en la remplaçant par un o. Python ne
le permet pas. Les chaînes de caractères ne sont pas mutables. C'est-à-dire qu'une fois construite, il n'est pas possible
de modier une chaîne : ni changement de caractère, ni suppression, ni insertion.
1 x = " helli world ! "
2 x [4] = "o "
3 Traceback ( most recent call last ) :
4 File " < pyshell #13 > " , line 1 , in < module >
5 x [4] = 'o '
6 TypeError : ' str ' object does not support item assignment

Pour s'y prendre, il faut alors construire de nouvelles chaînes à partir de la chaîne de départ en utilisant les outils à
notre disposition : concaténation et extraction de sous-chaînes.

14
 1 x = " helli world ! "
2 x [:4] + " o " + x [5:] # remplace le 5 e caract è re par o
3 ' hello world ! '
4

5 x = " hellon world ! "

6 x [:5] + x [6:] # supprime le 6 e caract è re de la cha î ne
7 ' hello world ! '
8

9 x = " hello orld ! "

10 x [:6] + " w " + x [6:] # ins è re w à la 7 e position de la cha î ne de caract è res
11 ' hello world ! '

2.2.2 Les listes et tuples

Une liste est un nouveau type de variable qui peut contenir des entiers, des ottants, des chaînes de caractères
voire des listes. Il est naturellement intégré dans python. Une liste est une collection ordonnée d'objets python de
diérentes natures. En Python , on écrit les listes en plaçant leurs éléments entre deux crochets [ et ], les éléments
étant séparés par des virgules. La fonction print permet d'acher les éléments de la liste. Voici un exemple de liste :
1 liste0 = [] # Une liste vide ( qui ne contient aucun é l é ment
2 liste1 = [1 , 2, 3] # Une liste d ' entiers naturels
3 liste2 = [ true , false , true , false ] # Une liste des bool é ens
4 liste3 = [1.5 , -3.2 , 12.0] # Une liste des flottants
5 liste4 = [ ' Bonjour ' , ' tout ' , ' le monde '] # Une liste des cha î nes de caract è res

Les exemples ci-dessus ont montré des listes dont les éléments ont tous le même type. On parle alors de listes homogènes.
Certains langages de programmation imposent que les listes soient homogènes. Ce n'est pas le cas de Python qui accepte
sans problème les listes hétérogènes.
1 [1 , ' timoleon ' , true , -5.26] # Une liste h é t é rog è ne , comportant tous les types possibles .

Cependant, travailler avec des listes hétérogènes est plus dicile qu'avec des listes homogènes. Dans le cadre de ce
cours, nous nous limiterons aux listes homogènes.

Création de listes. Une liste peut-être créée par plusieurs manières : par énumération explicite des éléments, avec
la fonction list , par concaténation, par répétition ou en compréhension.
1 liste = [1 ,2 ,3 ,4 ,5] # Par é num é ration explicite
2 liste = list ( ' Timoleon ') # Utilisation de list
3 liste = list ( range (1 ,20 ,2) ) # Utilisation de list
4 liste = [1 ,2 ,3 ,4] + [5 ,6] # é num é ration et concat é nation
5 liste = [1 ,2 ,3] * 4 # Ré p é tition
6 liste = [ i * i for i in range (10) ] # En compr é hension

Remarque. En règle générale, une expression en Python doit s'écrire sur une seule ligne. Une exception à cette
règle existe pour les listes (mais pas seulement). Lorsque l'énumération des éléments est trop longue pour tenir
raisonnablement sur une seule ligne, il est possible de l'écrire sur plusieurs.
1 [ ' janvier ' , 'f é vrier ', ' mars ' , ' avril ',
2 ' mai ' , ' juin ' , ' juillet ' , 'ao û t ' ,
3 ' septembre ' , ' octobre ' , ' novembre ' , 'dé cembre ']

Pour ajouter un ou plusieurs éléments à une liste déjà existante, on utilise la méthode append(). Ces éléments sont
sont aectés à la n de la liste. La méthode len() retourne un entier naturel qui correspond au nombre d'éléments
contenus dans la liste passée en argument.

15
1 liste = [8 , 8.3 , " Abdou " ]
2 liste . append ( " Khadidja " )
3 print ( liste )
4 len ( liste ) # Renvoie ici 4

Une liste contient des éléments indicés à partir de 0. Si nous avons une liste qui a n éléments alors le dernier indice
est n − 1. Pour accéder à un élément d'une liste, on utilise son indice. On place l'indice de l'élément recherché entre
crochets.
1 liste = [1 ,2 ,7.8 ,8 , ' Hamada ' , ' Said ']
2 liste [4] # Affiche le 5 e é l é ment
3 liste [2] # Affiche le 3 e é l é ment

Pour insérer un élément au début ou au milieu d'une liste, on utilise la méthode insert(indice, nouvelElement).
Cette méthode intercale l'élément passé en argument à l'indice passé en argument. Et pour concaténer deux listes,
on utilise la méthode liste1.extend(liste2), qui permet d'ajouter la deuxième liste à la n de la première liste pour
former une seule liste.
1 liste1 = [1 ,2 ,7.8 ,8]
2 liste2 = [ ' Hamada ' , ' Said ']
3 liste2 . insert (0 , ' Karim ')
4 liste1 . extend ( liste2 )

Attention ! Il ne faut pas confondre extend() et append(). En eet, la méthode extend() eectue une concaté-
nation de listes tandis que append() rajoute l'élément passé en argument, à la n de la liste sur laquelle la méthode
est appliquée. Donc, si l'élément renseigné dans append() est une liste, il sera ajouté comme une liste dans une liste.
Voyons dans l'exemple suivant, ce que l'on aurait obtenu si on utilise les deux méthodes
1 jours = [ " Lundi " , " Mardi " , " Mercredi " ]
2 jours1 = [ " Jeudi " , " Vendredi " ]
3 jours2 = jours . extend ( jours1 )
4 print ( jours2 )
5 jours3 = jours . append ( jours1 )
6 print ( jours3 )

jours3 est donc une liste qui contient une autre liste plus petite. Nous avons vu qu'il était possible d'accéder à un
élément en utilisant l'indice entouré de crochets. Mais comment faire pour accéder par exemple à  Vendredi  qui est
un élément de la petite liste qui se trouve en dernière position de la liste principale ? C'est très simple !
1 jours3 = [ " Lundi " , " mardi " , " mercredi " , [ " Jeudi " , " Vendredi " ]]
2 element = jours [2]
3 print ( element )
4 element = jours [3][1]
5 print ( element )

Il existe d'autres opérations que l'on peut eectuer dans des listes telles que
✿ list.sort() qui eectue le tri d'une liste dans l'ordre numérique croissant (ou dans l'ordre alphabétique croissant).
Si on lui donne l'argument reverse = True, dans ce cas le tri est décroissant. La syntaxe est
1 prenoms = [ ' Gabrielle ' , ' Alphonse ' , ' Kevin ' , ' Loana ']
2 prenoms . sort ()
3 prenoms . sort ( reverse = True )

✿ list.index() qui retourne l'indice de l'élément passé en argument. Si l'élément n'existe pas dans la liste, Python
lève une exception (renvoie une erreur). Si l'élément est présent plusieurs fois, la méthode retourne l'indice de
la première occurrence. Si une valeur est présente plusieurs fois, il est possible de passer en argument l'indice à
laquelle doit débuter la recherche sous la forme list.index(valeur, i).

16
 1 prenoms = [ ' Gabrielle ' , ' Alphonse ' , ' Kevin ' , ' Loana ' , ' Gabrielle ']
2 k = prenoms . index ( ' Kevin ')
3 i = prenoms . index ( ' Gabrielle ')
4 m = prenoms . index ( ' Gabrielle ' , 3)
5 l = prenoms . index ( ' Arriel ')

✿ list.reverse() qui inverse l'ordre des valeurs de la liste, le premier devient le dernier et le dernier devient le
premier.
1 prenoms = [ ' Gabrielle ' , ' Alphonse ' , ' Kevin ' , ' Loana ']
2 prenoms . reverse ()
3 print ( prenoms )

✿ list.remove() qui supprime la première occurrence de la valeur passée en argument. Voici un exemple avec une
liste contenant deux fois le nom  Kevin 
1 prenoms = [ ' Gabrielle ' , ' Alphonse ' , ' Kevin ' , ' Loana ' , ' Kevin ']
2 prenoms . remove ( ' Kevin ')
3 print ( prenoms )

✿ list.count() qui compte le nombre de fois où une occurrence apparaît dans une liste et elle retourne la valeur
correspondante.
1 prenoms = [ ' Gabrielle ' , ' Alphonse ' , ' Kevin ' , ' Loana ' , ' Kevin ']
2 n = prenoms . count ( ' Kevin ')
3 print ( n )

Enn, pour tester l'appartenance d'une valeur à une liste, on utilise l'instruction conditionnelle if lcdot in. Elle valide
la présence ou l'absence de la valeur recherchée dans la liste en renvoyant un booléen (True ou False).
1 prenoms = [ ' Gabrielle ' , ' Alphonse ' , ' Kevin ' , ' Loana ']
2 if ' Kevin ' in prenoms :
3 print ( " Le test d ' appartenance est positif . " )
4 else :
5 print ( " Ce pr é nom est absent de la liste . ")

1 prenoms = [ ' Gabrielle ' , ' Alphonse ' , ' Kevin ' , ' Loana ']
2 result = ' Baptiste ' in prenoms # Retourne un bool é en ( True ou False )
3 print ( result )

Les tuples. Un tuple est un ensemble d'éléments comparable aux listes mais qui, une fois déclaré, ne peut plus être
modié. Il s'agit donc d'une séquence immuable d'objets indicés qui peuvent être des nombres entiers ou décimaux,
des chaînes de caractères, des listes, des tuples, etc. D'un point de vue syntaxique, un tuple est un ensemble d'éléments
séparés par des virgules. Cet ensemble d'éléments est entouré de parenthèses mais ce n'est pas une obligation. Cela
permet toutefois d'améliorer la lisibilité du code.
1 tuple_1 = (8 , " Solange " , 5.3)
2 tuple_2 = 8 , " Solange " , 5.3
3 a , b = 5 ,6
4 (a , b ) = (5 ,6)
5 c = (10 ,)

Attention ! Si nous oublions la virgule (et malgré la présence de parenthèses), le type de la variable ne sera pas un
tuple.

17