IPEIGB AU : 2023/2024

CHAPITRE III:
Les ITERABLES en python :
Les séquences, les dictionnaires et les ensembles
1. Les séquences (chaînes, tuples, listes)
1.1. Propriétés communes aux séquences (hors “mutations”)
Les séquences en Python sont les objets des trois types suivants: les chaînes de caractères, les
listes, et les tuples. Les séquences ont un certain nombre de propriétés importantes en commun:
 elles sont composées d‟un nombre fini d‟éléments (la numérotation commence à 0).
 On peut compter à partir de la fin. seq[-1] désigne le dernier élément d‟une séquence.
 on peut effectuer des coupes (le terme anglais est slice).

 Les chaînes sont délimitées par des guillemets doubles ("abc") ou simples ('abc').
 Les listes sont des successions d‟objets séparés par des virgules), délimitées par des crochets [ et ].
Elles peuvent contenir des objets de type quelconque.
 Les tuples sont des successions d‟objets séparés par des virgules, délimitées par des parenthèses. Les
tuples peuvent contenir des objets de type quelconque.
 Les fonctions intégrées list, tuple et str permettent de passer d‟un type de séquence à l‟autre :
>>> L = [1,[2,3],"abc"] ; tuple(L) # une liste ,on la transforme en tuple
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> T= ("xyz",(1,3.14),[0,2]) ; list(T) # T, on le transforme en liste
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> c = "abcdef" ;list(c) ; tuple(c) # une chaîne, on la transforme en une liste et en tuple
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
1.2. Séquences mutables ou non
Les listes sont dites mutables, mais les chaînes et les tuples ne le sont pas.
Dire qu’un objet est mutable, c’est dire qu’on peut en modifier un (ou plusieurs) élément(s), sans
pour autant créer une nouvelle référence vers l’objet ainsi modifié.
Exemple 1 :
>>> L=[5,1,10,8,3];L ; id(L)
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> L[2]=4;L ; id(L)
………………………………………………………………………………………………………………………………………
Exemple 2 :
>>> ch='abcde';ch ; id(ch)
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………

Sections : MP1, PC1, T1& BG1 1

IPEIGB AU : 2023/2024

>>> ch[3]='h'
………………………………………………………………………………………………………………………………………
>>> ch=ch+'h';ch ; id(ch)
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………

1.3. Les listes :

Les listes peuvent être formées :
- en évaluant l‟expression list() ou []. On obtient la liste vide.
- en combinant des éléments [elt0, elt1,., eltn], ou en convertissant une séquence par list(seq).
- en “compréhension”, par
[expr for indice in iterable], ou [expr for indice in iterable if condition].
>>> [x**2 for x in range(1,10) if x%2 == 0]
………………………………………………………………………………………………………………………………………
>>> [100*i+j for i in range(1,5) for j in range(1,4)]
………………………………………………………………………………………………………………………………………
>>> [[100*i+j for i in range(1,5)] for j in range(1,4)]
………………………………………………………………………………………………………………………………………
 Opérations de mutation de listes

Attention : la plupart des instructions précédentes renvoient la valeur None mais mutent la liste.
>>> s = t = list(range(10,20)); t # place dans s et t la même liste (même adresse!)
………………………………………………………………………………………………………………………………………
>>> from copy import *
>>> u = copy(s); u # met dans u une copie indépendante de l’original
………………………………………………………………………………………………………………………………………
>>> s[3] = ’info’; t # remplace s[3] ; modification répercutée sur t
………………………………………………………………………………………………………………………………………
>>> del s[3]; t # supprime s[3] ; modification répercutée sur t
………………………………………………………………………………………………………………………………………
>>> s.insert(3,0); t # insère 0 en position 3 dans s (idem dans t)
………………………………………………………………………………………………………………………………………
>>> s[-1] ; s[ 2:7] ; s[ :4] ;s[3 :] ;s[ ::-1]
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> s[1:9:2] # lit une coupe de longueur 4 dans s
………………………………………………………………………………………………………………………………………
>>> s[1:9:2] = ’abcd’; t # remplace ces 4 élts par ceux de ’abcd’
………………………………………………………………………………………………………………………………………
>>> del s[1:5]; t # efface les éléments de positions 1 à 4
………………………………………………………………………………………………………………………………………

Sections : MP1, PC1, T1& BG1 2

IPEIGB AU : 2023/2024

>>> s.append(’xyz’); t # ajoute l’objet ’xyz’ { la fin de la liste

………………………………………………………………………………………………………………………………………
>>> s.extend(’uvw’); t # complète la liste par les éléments de ’uvw’
………………………………………………………………………………………………………………………………………
>>> s.pop(5) # renvoie s[5], et le supprime de la liste
………………………………………………………………………………………………………………………………………
>>> s.remove(16); t ; s.reverse(); t # supprime la première occurrence de 16 , inverse la liste s
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
Pour trier la liste contenue dans une variable s (reverse=True/False pour inverser l‟ordre du tri).
>>> L = [8, 3, 9, 7, 0, 6, 5]; L
………………………………………………………………………………………………………………………………………
>>> sorted(L);L # renvoie la liste triée mais l’original n’a pas été modifié
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> L.sort(); L # ici le tri s’effectue sur place
………………………………………………………………………………………………………………………………………
>>> L.sort(reverse=True); L
………………………………………………………………………………………………………………………………………
1.4. Les tuples
Les tuples sont des séquences non mutables d‟objets séparés par une virgule, et délimitées par
des parenthèses ( et ). Les tuples peuvent être formés :
- en évaluant l‟expression tuple() ou (). On obtient le tuple vide.
- en combinant des éléments (elt0, elt1,..., eltn), ou par tuple(seq).
- en “compréhension”, par tuple(expr for indice in iterable), ou (expr for indice in iterable if
condition) ;
>>> t = (123, ’abc’, 3.14); type(t) # on définit un tuple de longueur 3
………………………………………………………………………………………………………………………………………
>>> t[1] # on accède en lecture { l’élément en position 1
………………………………………………………………………………………………………………………………………
>>> t[1] = ’uvw’ # impossible de modifier un élément !!!
………………………………………………………………………………………………………………………………………
>>> t = tuple(x*x for x in range(1,5)); t ; id(t) # un tuple défini en compréhension
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> t[::-1] # le même tuple, mais { l’envers
………………………………………………………………………………………………………………………………………
>>> t = t + (20,); t ; id(t) # on ajoute l’élément 20 (NB la virgule!)
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> t[1:6:2] ; t[-1]
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> (1,2,3)+(4,5) # concaténation de deux tuples
………………………………………………………………………………………………………………………………………

1.5. Les chaînes de caractères

Les chaînes sont des séquences non mutables. On ne peut pas modifier un ou plusieurs
caractères. Si on ajoute un caractère (ou une autre chaîne) par concaténation, le résultat est la
création d‟une nouvelle chaîne à une nouvelle adresse en mémoire.

Sections : MP1, PC1, T1& BG1 3

IPEIGB AU : 2023/2024

Les chaînes possèdent un très grand nombre de méthodes, voici une simple sélection :

>>> ch = "issat mp-pc-t-bg" ;ch

………………………………………………………………………………………………………………………………………
>>> ch.endswith(‘g’); ch.startswith(‘iss’); ch.isalpha();ch.upper()
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> ch.find(‘s’) ;ch.rfind(‘s’)
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
 Méthodes importantes sur les chaînes (split, join)
La split permet de découper une chaîne en une liste de sous-chaînes. La méthode join est
l‟inverse de la méthode split.
>>> t = "être ou ne pas être, là est la question"
>>> t.split() ; t.split(’être’) ; t.split(‘,’)
……………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………
>>> ’’.join([’abc’,’def’,’ghi’]) ; ’*’.join([’abc’,’def’,’ghi’])
………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………….

Sections : MP1, PC1, T1& BG1 4

IPEIGB AU : 2023/2024

2. Les dictionnaires
Les dictionnaires sont des structures mutables, non ordonnées. Les dictionnaires peuvent être
formés :
 en évaluant l‟expression dict() ou {}. On obtient le dictionnaire vide
 en délimitant une séquence de paires clé : valeur : {clé1:val1, clé2:val2,..., clén:valn}
 en évaluant par exemple : dict([[clé1,val1],[clé2,val2],...,[clén,valn]])
 en “compréhension”, par exemple D = {x:x*2 for x in range(10)}
Voici quelques méthodes applicables à un objet dic de type dictionnaire.

>>> ages = {'mohamed':41, 'Amine':25, 'sarra':34} ; ages # un dict de trois entrées ;

………………………………………………………………………………………………………………………………………
>>> 'Amine' in ages; ages['sarra'] # teste la présence de clés ; demander l’âge de sarra
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> ages['karim'] = 33 ; del ages['mohamed'] ;ages # crée un nouvel enregistrement
………………………………………………………………………………………………………………………………………
>>> for elt in ages: print(elt) # itérer un dictionnaire, c’est itérer les clés
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> ages.items() ; list(ages) ; list(ages.keys()) ; list(ages.values()) ; max(ages.values())
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> [(n,a) for n,a in ages.items()] # voici la liste des enregistrements
………………………………………………………………………………………………………………………………………

3. Les ensembles
Un ensemble peut contenir des valeurs de type quelconque non ordonnés (on ne peut pas y
accéder par un indice).On forme un ensemble en utilisant le constructeur set.

Sections : MP1, PC1, T1& BG1 5

IPEIGB AU : 2023/2024

>>> e = {1,5,2,3,2,7,5,2,1,3,2} ;e
………………………………………………………………………………………………………………………………………
>>> e = set([1,5,2,3,2,7,5,2,1,3,2]) ;e
………………………………………………………………………………………………………………………………………
>>> set(’abracadabra’) # l’ensemble des caractères distincts d’une chaîne
………………………………………………………………………………………………………………………………………
Les objets de type “ensemble” sont mutables. Voici quelques méthodes applicables à un objet
ens de type ensemble (set). On note elt une valeur susceptible d‟appartenir ou d‟être ajoutée à
l‟ensemble ens :

On continue sur la lancée de l‟exemple précédent

>>> e.discard(5) ;e ; e.add(0) ;e ; 4 in e
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
Les objets de type “ensemble” ont des méthodes pour les opérations ensemblistes usuelles :

Voici quelques exemples (on voit que l‟ordre des éléments d‟un ensemble est imprévisible) :

>>> m3=set(range(0,50,3)); m5=set(range(0,50,5)); m7=set(range(0,50,7))

>>> m3 ; m5 ; m7# les multiples de 3, 5 et 7 dans l’intervalle [0,50[
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
>>> m5 | m7 ; m3 - m7 ; m3 ^ m5 ; m3 & m5
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………

Sections : MP1, PC1, T1& BG1 6

IPEIGB AU : 2023/2024

Travaux dirigés :
les séquences, les dictionnaires et les ensembles

EXERCICE 1 :
Une coupe C i, j  de la liste L est la suite (sous liste) des éléments L i  , L i  1 , , L  j  1 ,
où 0 ≤ i ≤ j ≤ N. Noter que C i, j  est de longueur j  i.
La coupe C i, j  est un palindrome si elle est égale à la coupe obtenue en prenant ses éléments
à l‟envers, c.à.d. si L i   L  j  1 , L i  1  L  j  2 , L i  2  L  j  3,
Travail demandé :
Écrire un programme Python définissant les fonctions suivantes :
1. def Verif_Palindrome(L,pos,lg) : qui à partir de pos et lg retourne True si la coupe
C  pos, pos  lg de la liste L est un palindrome et False sinon.
2. def Palindrome7(L) : qui à partir de la liste L retourne le nombre des coupes palindromes
de longueur 7 ainsi que l‟indice de début du premier palindrome trouvé.

EXERCICE 2 :
On relève dans certains jours de l‟année les degrés de température. Une observation sera une
liste de 3 valeurs [<jour >, < mois >, < degré >]. Par exemple, une température de 20°C
enregistrée le 13 février correspond à la liste [13, 2, 20]. Le but de l‟exercice est de manipuler
une liste de telles observations qui est une liste de listes et pour simplifier on supposera que
toutes les observations sont enregistrées pendant des années non bissextiles.
Soit la liste Nb_Jour_Mois=[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] contenant les
nombres de jours des mois d‟une année non bissextile. Cette liste, supposée déjà définie, sera
passée comme paramètre en cas de besoin.
Travail demandé :
Écrire un programme Python définissant les fonctions suivantes :
1. def Valide(obs) : qui retourne true si à une observation Obs donnée correspond un mois et
un jour corrects, et retourne false sinon.
2. def Num_Jour(obs) : qui permet de retourner le numéro du jour dans l‟année d‟une
observation Obs donnée et supposée valide.
Exemple : L‟observation [12, 2, 10] enregistrée correspond au 43ème jour de l‟année.
3. def Avant(obs1,obs2) : qui, à partir de deux observations Obs1 et Obs2 supposées valides,
retourne true si l‟observation Obs1 a eu lieu avant l‟observation Obs2 et retourne false sinon.
4. def Ajout_Obs(obs,L) : qui ajoute, à la fin d‟une liste d‟observations L donnée, une
observation Obs donnée, si celle-ci est valide et non déjà enregistrée.

EXERCICE 3 :
Un polynôme est représenté par une liste de listes de deux éléments [a,d] où a est le coefficient
non nul du monôme Xd.
Exemple :
Le polynôme P = 2X55-5X15+X-1 est représenté par la liste (liste de listes) suivante :
L= [[2,55] , [-5,15] , [1,1] , [-1,0] ].
NB : Dans la suite on suppose que les polynômes sont ordonnés selon les puissances
décroissantes en X.
Travail demandé :
Écrire un programme Python définissant les fonctions suivantes :

Sections : MP1, PC1, T1& BG1 7

IPEIGB AU : 2023/2024

1. def AffPoly(L) : qui prend comme paramètres une liste L représentant un polynôme P, et
retourne la chaine de caractère qui représente l‟expression mathématique de P.
Exemple : >>>AffPoly( [ [-5,2] , [6,1] , [2,0] ]) retourne ch = „-5X^2+6X+2‟
2. def EvalPoly(L,V) : qui prend comme paramètres une liste L représentant un polynôme P, et
un réel V et retourne la valeur de P(V).
Exemple :>>> EvalPoly( [ [-5,2] , [6,1] , [2,0] ] ,2) retourne la valeur -6
3. def Deriv(L) : qui prend comme paramètres une liste L représentant un polynôme P, et
retourne la liste représentant le polynôme dérivé de P.
Exemple :>>> Deriv( [ [-5,2] , [6,1] , [2,0] ]) retourne la liste [ [-10,1] , [6,0] ]
4. def MultMon(L,a,n) : qui prend comme paramètres une liste L représentant un polynôme P,
un réel a (non nul), et un entier strictement positif n et retourne la liste représentant le
polynôme Q avec Q = P.a.Xn
Exemple :>>> MultMon( [ [-5,2] , [6,1] , [2,0] ] ,2,5) retourne la liste [ [-10,7] , [12,6] , [4,5] ]
5. def AddMon(L,a,n) : qui prend comme paramètres une liste L représentant un polynôme P,
un réel a (non nul), et un entier strictement positif n et retourne la liste représentant le
polynôme H avec H = P + a.Xn
Exemple >>>AddMon( [ [-5,2] , [6,1] ,[2,0] ] ,2 ,3) retourne [ [2,3] , [-5,2] , [6,1] , [2,0] ]

EXERCICE 4:
Le poids d‟une chaine est la somme des produits de la position de chaque voyelle dans cette
chaine par son rang dans l‟alphabet français. Si la chaine ne contient pas de voyelles alors son
poids est égal à zéro.
Dans la suite on suppose la chaine ALPHA='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
NB : les voyelles et leurs rangs dans l‟alphabet sont représentées dans un dictionnaire voy:
voy= { 'A':1 , 'E':5 , 'I':9 , 'O':15 , 'U':21 , 'Y':25 }
 CH.isalpha() retourne True si la chaine CH est formées par des caractères alphabétiques.
 CH.upper() retourne la chaine CH en majuscule.
 CH.index('car') retourne l‟indice de car dans la chaine CH.
Travail à faire :
Écrire un programme Python définissant les fonctions suivantes :
1. def Saisie(msg): qui permet de saisir et de retourner une chaine CH non vide et formée
uniquement par des lettres alphabétiques majuscules.
2. def Pos_Rang_Voyelle(CH): qui à partir d‟une chaine CH retourne un dictionnaire,
contenant la position de chaque voyelle dans CH comme clé et son rang dans l‟alphabet
français comme valeur.
Exemple : La chaine 'PROGRAMME' contient 3 voyelles 'O', 'A' , 'E' : leurs positions
respectives sont 3,6 ,9 et leur rangs respectives dans l‟alphabet sont 15,1 et 5
>>> Pos_Rang_Voyelle( 'PROGRAMME' ) retourne { 3 : 15 , 6 : 1 , 9 : 5 }
3. def Poids(CH) : qui à partir d‟une chaine CH, permet de calculer et de retourner le poids de
cette chaine en utilisant le principe décrit ci-dessus.
Exemple : >>> Poids ('PROGRAMME' ) retourne 96 puisque (3*15)+(6*1)+(9*5)=96
4. Ecrire un programme principal qui calcul et affiche le poids d‟une chaine CH formée
uniquement par des lettres alphabétiques majuscules.

EXERCICE 5:
Un administrateur d‟un site web veut assurer un maximum de sécurité pour les utilisateurs du
site. Pour ceci il décide de réaliser une application qui évalue la force des mots de passe des
différents utilisateurs du site, sachant qu‟un mot de passe est une chaine de caractères qui ne
comporte pas d‟espaces et de lettres accentuées.

Sections : MP1, PC1, T1& BG1 8

IPEIGB AU : 2023/2024

La force d‟un mot de passe varie, selon la valeur d‟un score calculé :
 Si le score <20, la force du mot de passe est „Très faible‟
 Sinon si le score<40, la force d‟un mot de passe est „Faible‟
 Sinon si le score <80, la force du mot de passe est „Forte‟
 Sinon la force du mot de passe est „Très forte‟

Le score se calcule en additionnant des bonus et en retranchant des pénalités.

Les bonus attribués sont:
 Nombre total de caractères * 4
 (Nombre total de caractères –nombre de lettres majuscules) * 2
 (Nombre total de caractères –nombre de lettres minuscules) * 3
 Nombre de caractères non alphabétiques * 5
Les pénalités imposées sont:
 La longueur de la plus longue séquence de lettres minuscules * 2
 La longueur de la plus longue séquence de lettres majuscules * 3

Exemple:
Pour le mot de passe „P@cMP_promo2021‟, le score se calcule comme suit:
 Le nombre total de caractères = 15
 Le nombre de lettres majuscules = 3
 Le nombre de lettres minuscules=6
 Le nombre de caractères non alphabétiques =6
 La somme des bonus = 15*4 + (15-3) *2 + (15-6) *3+6*5=141
 La longueur de la plus longue séquence de lettres minuscules („promo‟) =5
 La longueur de la plus longue séquence de lettres majuscules („MP‟) =2
 La somme des pénalités = 5*2+2*3=16
 Le score final = 141-16=125;
Alors le mot de passe est considéré comme „Très forte’ puisque 125>80
Travail demandé :
Écrire un programme Python définissant les fonctions suivantes :
1. def NbC_Min_Maj(password) : ayant comme argument une chaine password, retourne le
nombre de caractères minuscules et le nombre de caractères majuscules.
Exemple : >>> NbC_Min_Maj(‘P@cMP_promo2021’) retourne (6,3)
2. def NbC_NonAlpha(password) : qui à partir d‟ une chaine password, retourne le nombre
de caractères non alphabétiques.
Exemple : >>> NbC_NonAlpha (‘P@cMP_promo2021’) retourne 6
3. def Long_Maj(password) : retourne la longueur de la plus longue séquence de lettres
majuscules d‟une chaine password.
Exemple : >>> Long_Maj (‘P@cMP_promo2021’) retourne 2
4. def Long_Min(password) : retourne la longueur de la plus longue séquence de lettres
minuscules d‟une chaine password.
Exemple : >>> Long_Min (‘P@cMP_promo2021’) retourne 5
5. def Score(password) : qui calcul et renvoie le score final et la force d‟un mot de passe
password en utilisant la méthode proposée ci-dessus.
Exemple : >>> Score(‘P@cMP_promo2021’) retourne (125, 'Très forte')

EXERCICE 6 : cryptage/décryptage RSA

On se propose de développer en Python la méthode de cryptage/décryptage RSA.
Le cryptage/décryptage RSA est fondé sur l'utilisation d'une paire de clés composée d'une clé
publique pour crypter et d'une clé privée pour décrypter des données confidentielles.

Sections : MP1, PC1, T1& BG1 9

IPEIGB AU : 2023/2024

Texte clair Texte crypté

Texte original
Clé publique Cryptage Clé privée Décryptage clair

La création des clés s‟effectue de la manière suivante. Soient p et q deux grands nombres
premiers.
 Calculer l‟indicatrice z   p  1 *  q  1 ;
 Calculer n  p * q ;
 L‟entier c égal au premier entier premier supérieur à z (la fonction prédéfinie python
nextprime du module sympy retourne l‟entier premier suivant);
Exemple :
>>> from sympy import nextprime
>>> nextprime(11)
13
 calculer l‟entier d  c ( 1) mod z.
La clé publique est la liste  n, c  et la clé privée est la liste  n, d  .
L‟entier crypté y associé à un entier x est donné par : y  x c mod n.
L‟entier x est retrouvé en décryptant l‟entier y par : x  y d mod n.
Travail demandé :
Écrire un programme Python définissant les fonctions suivantes :
PARTIE A : cryptage et décryptage d’entier(s)
1. def Cle_RSA(p,q) : qui prend en entrée deux grands nombres p et q (supposés premiers) et
retourne le deux listes contenant les deux clés (publique et privée).
2. def CryptDecryptE(a,CL) : qui prend en entrée un entier a et une liste CL contenant la clé
publique (ou privée) et retourne l‟entier crypté (ou décrypté) associé à a.
3. def CryptDecryptList(L,CL) : qui prend en entrée une liste d‟entiers L et une liste CL
contenant la clé publique (ou privée) et retourne la liste des entiers cryptés (ou décryptés)
associés aux entiers de L par CryptDecryptE.
PARTIE B : cryptage et décryptage d’une chaîne de caractères
Le cryptage/décryptage d‟une chaîne de caractères consiste à crypter/décrypter les codes ASCII
correspondants aux caractères de la chaîne. Sachant qu‟une chaîne est une structure composée et
que les fonctions python suivantes sont prédéfinies :
 len (Ch) retourne la longueur de la chaîne de caractères Ch.
Exemple : >>>len("abc") retourne 3.
 ord (C) retourne l‟entier correspondant au caractère C (c.à.d son code ASCII).
Exemple : >>> ord("a") retourne 96.
 chr (n) retourne le caractère correspondant au code ASCII n.
Exemple : >>>chr(96) retourne "a".
 Ch1+Ch2 retourne la chaîne de caractères concaténation des chaînes Ch1 et Ch2.
Exemple : >>>"a"+"b" donne la chaîne "ab".

4. def Codage(CH) : qui prend une chaîne CH et retourne la liste des codes ASCII
correspondants.
5. def Decodage(L) : qui prend une liste d‟entiers L (codes ASCII) et retourne la chaîne de
caractères correspondante.

Sections : MP1, PC1, T1& BG1 10

IPEIGB AU : 2023/2024

6. def CryptageC(CH,CL) : qui prend une chaîne CH et une clé CL et retourne la liste des
entiers cryptés associés aux codes ASCII de CH.
7. def DecryptageC(L,CL) : qui prend une liste d‟entiers cryptés L et une clé CL et retourne la
chaîne claire.

EXERCICE 7 :
Les SMS sont de trois types : SMS normal, SMS publicitaire et SMS SPAM.
Dans le but de gérer les SMS, on va utiliser un dictionnaire dont les clés sont les numéros de
téléphone et les valeurs sont des listes contenant 3 éléments [date,heure,contenu].
Un dictionnaire de SMS est de la forme suivante :
DSMS = { Num_tel_SMS1 : [ date , heure , contenu ] ,
Num_tel_SMS2 : [ date , heure , contenu ] ,
…………………………………………
Num_tel_SMS_N : [ date , heure , contenu ] }
Chaque élément dans le dictionnaire représente un SMS. Les numéros de téléphone ont tous soit
8 chiffres pour les SMS normal, soit 5 chiffres pour les SMS SPAM commençant avec 85. Les
dates sont toujours formées de 10 caractères et l'heure de 5 caractères. On considère qu'un SMS
est publicitaire s'il contient le caractère $.
Exemple :
DSMS= { 98221458 : [ '31/03/2016' , ' 10h23 ' , ' Salut, t’es où ? ' ] ,
24938527 : [ '31/03/2016' , '11h10' , 'RDV Rappelle-moi après! ' ] ,
52332011 : [ '01/04/2016' , '09h03' , 'T’as pas la solution de l’exo 2 ? ' ] ,
96937121 : [ '01/04/2016' , '09h40' , 'N’oublie pas d’apporter les documents ' ] ,
92883542 : [ '28/04/2016' , '06h30' , 'RDV dans 5 min devant la gare. ' ] ,
85133 : [ '29/04/2016' , '03h20' , 'Samsung S9 est dans carrefour' ] ,
25954338 : [ '03/05/2016' , '16h23' , '$ADIDAS : disponible chez Go Sport' ] }
Travail demandé :
Écrire un programme Python définissant les fonctions suivantes :

1. def SMS_spam(DSMS) : qui à partir d‟un dictionnaire de SMS, retourne un dictionnaire

contenant seulement les SMS SPAM.
Exemple : >>> SMS_spam(DSMS) retourne
{ 85133 : ['29/04/2016', '03h20', 'Samsung S9 est dans carrefour']}
2. def SMS_pub(DSMS) : qui à partir d‟un dictionnaire de SMS, retourne un dictionnaire
contenant seulement les SMS publicitaires.
Exemple : >>> SMS_pub(DSMS) retourne
{ 25954338 : ['03/05/2016', '16h23', '$ADIDAS : disponible chez Go Sport']}
3. def ListeNoire (DSMS) : qui à partir d‟un dictionnaire de SMS, extrait dans une liste les
numéros de téléphone qui ont envoyé soit des SMS SPAM soit des SMS publicitaires.
Exemple : >>> ListeNoire (DSMS) retourne [85133, 25954338]
4. def Recherche (mot,DSMS) : qui ayant comme argument une chaine de caractères mot et
un dictionnaire de SMS , retourne une liste des numéros de téléphone qui ont envoyé un
message contenant ce mot.
Exemple : >>> Recherche ('RDV',DSMS) retourne [24938527, 92883542]

Sections : MP1, PC1, T1& BG1 11

IPEIGB AU : 2023/2024

Exercice 8 :
On veut traiter les notes d‟un étudiant dans chaque matière. Pour enregistrer les relevés des
notes, on va utiliser un dictionnaire dont les clés sont les noms des matières et les valeurs
correspondantes sont les listes des notes obtenues dans chaque matière.
Exemple :
R = {'maths':[8.5,12],'anglais':[13,8,9.5],'physique':[13,8,10,9.5]}
Travail demandé :
Écrire un programme Python définissant les fonctions suivantes :
1. def Ajouter_Note(R, mat, note) : qui permet d‟ajouter une note dans une matière qui existe
dans un relevé de notes R.
>>> Ajouter_Note(R,'maths',11 ) retoune
{'maths':[8.5,12,11],'anglais':[13,8,9.5],'physique':[13,8,10,9.5]}

2. def Moy_Matiere(R, mat) : qui permet de retourner la moyenne d‟un étudiant dans une
matière mat (on considère que toutes les notes ont le même coefficient).
>>> Moyenne_Matiere(R,'anglais') retoune 10.16

3. def Moy_Generale(R) : qui calcule la moyenne générale d‟un étudiant (on considère que
toutes les matières ont le même coefficient).
>>> Moyenne_Generale(R) retourne 10.30

4. def Meilleure_Note(R) : qui permet de retourner la meilleure note obtenue par un étudiant
ainsi que l‟ensemble de(s) matière(s) dans laquelle ou lesquelles il a obtenu cette note.
>>> Meilleure_Note(R) retourne (13,{'physique','anglais'})

5. def Meilleure_Moy(R) qui permet de retourner la meilleure moyenne obtenue par un

étudiant ainsi que la liste de(s) matière(s) dans laquelle ou lesquelles il a obtenu cette note.
Indication : Vous pouvez utiliser un dictionnaire stockant chaque matière comme clé et sa
moyenne comme valeur correspondante.
>>> Meilleure_Moy(R) retourne {10.625, ['maths']}

Sections : MP1, PC1, T1& BG1 12