Notions de Base : Rappel

Aide-Mémoire pour la préparation de l’épreuve

d’Informatique du Concours National d’Entrée aux
Ecoles d’Ingénieurs MP-PC-T 2020

Elaboré par :

Houcemeddine Filali (IPEIM)

Laila Hammami (IPEIN)
Houssemeddine Bouzidi (IPEIM)
Wafa Meftah (IPEIS)
Hayet Latrach (IPEIT)
Mohamed Hammami (IPEIEM)
Besma Fayech (ENSIT)

-- Avril 2020 --
[Tapez ici]

Préambule

Ce document est destiné aux étudiants de deuxième année MP-PC-T des Instituts
Préparatoires aux Etudes d’Ingénieurs.

Dans les circonstances exceptionnelles liées à la crise sanitaire mondiale et nationale du

Covid19, un ensemble de supports de révision pour le programme d’informatique du
concours national d’entrée aux écoles d’ingénieurs ont été élaborés essentiellement par les
membres de la commission informatique du concours, suite à une action bénévole.

Le but de ces supports est d’accompagner les étudiants de tout le territoire Tunisien dans
leur révision en leur fournissant à tous les mêmes documents, afin d’assurer une équité
entre eux, qu’ils bénéficient ou non d’un enseignement ou tutorat à distance.

Toutefois, ces documents sont considérés comme des aide-mémoires et ne remplacent pas
les cours assurés en présentiel.

Le document présent comporte un rappel sur les notions de base associées à Python comme
la manipulation des itérables, les structures de contrôle, les fichiers mais également sur la
récursivité et la complexité algorithmique.

Notions de base : Rappel

[Tapez ici]

Table des matières

I Introduction ........................................................................................................................................................................ 1
II Variable et affectation ........................................................................................................................................................ 1
III Opérateurs .......................................................................................................................................................................... 2
IV Classes élémentaires........................................................................................................................................................... 2
V Opérations d'entrée/sortie ................................................................................................................................................. 3
VI Structures de contrôle ........................................................................................................................................................ 4
VII Classes itérables .............................................................................................................................................................. 5
VII.1 Opérations communes aux itérables ........................................................................................................................... 5
VII.2 Les séquences ............................................................................................................................................................. 6
VII.2.1 Opérations communes aux séquences .............................................................................................................. 6
VII.2.2 La classe str ....................................................................................................................................................... 7
VII.2.3 La classe list ....................................................................................................................................................... 8
VII.2.4 La classe tuple ................................................................................................................................................... 8
VII.3 Les itérables non ordonnés ......................................................................................................................................... 9
VII.3.1 La classe set ....................................................................................................................................................... 9
VII.3.2 La classe dict.................................................................................................................................................... 10
VIII Construction des itérables en compréhension .............................................................................................................. 11
VIII.1 Listes en compréhension ........................................................................................................................................... 11
VIII.2 Tuples en compréhension ......................................................................................................................................... 11
VIII.3 Ensembles en compréhension ................................................................................................................................... 12
VIII.4 Dictionnaires en compréhension ............................................................................................................................... 12
IX Import de bibliothèques ou modules ................................................................................................................................ 12
X Les sous-programmes ........................................................................................................................................................ 13
XI Gestion des exceptions ..................................................................................................................................................... 15
XII Gestion des fichiers ....................................................................................................................................................... 15
XII.1 Fichiers textes ........................................................................................................................................................... 15
XII.2 Fichiers binaires ........................................................................................................................................................ 17
XIII La récursivité................................................................................................................................................................. 17
XIV Complexité algorithmique............................................................................................................................................. 18
XIV.1 Calcul du coût ............................................................................................................................................................ 18
XIV.2 Complexité asymptotique ......................................................................................................................................... 19
XIV.3 Classes de complexité asymptotique ......................................................................................................................... 19
Bibliographie et Netographie ................................................................................................................................................... 20

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 1

I Introduction
Python est un langage de programmation multi-paradigmes (procédural, orienté objet et fonctionnel) et
dynamiquement typé. Sa version standard est libre et est disponible sur le site officiel de Python « python.org ».
La version Pyton3.X est adoptée par le programme officiel du cycle préparatoire. Cette version inclut un grand
nombre de modules pré-programmés fournis d’office, tels que math, cmath, random, etc., mais n'inclut pas les
modules tels que numpy, scipy et matplotlib qu'il faut importer explicitement au besoin. Un module regroupe des
ensembles de variables et de fonctions apparentées, que l’on appelle également bibliothèque.
Anaconda est une solution comportant l’interpréteur Python livré avec plusieurs environnements de développement
intégrés (IDLE, spyder, Jupyter) et inclut une panoplie de modules (numpy, scipy et matplotlib) mais qui nécessite
beaucoup de ressources.

II Variable et affectation
Une variable est une référence associée à un objet déjà créé en mémoire. Elle n'a pas de type et n'est pas déclarée.
Toute variable doit être affectée avant son utilisation. L'identificateur (nom) de la variable ne peut contenir que des
caractères alphanumériques et le caractère '_' et ne débutant pas par un chiffre.

L’affectation permet d’associer un nom à un objet (instance d'une classe) en mémoire :

>>> nom = objet nom id(nom)== id(nom1)

Objet
ou bien
Ainsi une affectation de la forme : nom is nom1
nom1 Classe de l’objet
>>> nom1 = nom
référence le même objet avec autre nom (nom1). type(nom)

On obtient le type d'un objet à l'aide de la fonction type(objet) et son adresse mémoire désignant son identité à
l'aide de id(objet).

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 2

III Opérateurs

Description Opérateurs Exemples/Remarques

Affectation v = valeur x = 5
v1=v2=v3= valeur x = y= z = t = 5
v1,v2,v3=valeur1,valeur2,valeur3 x, y, z = 1, '2', 5
Parenthèses () (x+y)*2 #donne 6

Opérations arithmétiques
Puissance x**y # ou pow(x,y) 1j**2 #donne -1+0j
Signes +;-

Opérateurs multiplicatifs x*y ;x / y # produit et 4/2 #donne

division réelle de x par y 2.0(float)
x//y ; x%y #quotient et 4//2# donne 2 (int)
reste de division entière de x 4%2 # donne 0
par y
Opérateurs additifs x+y ; x -y

Opérateurs relationnels

Comparaison d’identité is
is not

Comparaison de valeur x==y ; x!=y 2!=5 # donne True

2==5 # donne False
Comparaison riche < ; > ; <= ; >=

Opérateurs logiques
Produisent un booléen and ; or ; not
(bool)
Opérateurs avec assignation

Produisent le même x += y # x = x + y
résultat que l'affectation x -= y # x = x  y
du résultat de l'opération x *= y # x = x * y
effectuée
x /= y # x = x / y
x //= y # x = x // y
x %= y # x = x % y
x **= y # x = x ** y

IV Classes élémentaires
Les classes élémentaires sont immuables (non modifiables). Les opérations appliquées aux instances de ces classes
génèrent de nouvelles instances comme le montre l'exemple suivant :

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 3

>>> x=5
>>> id(x)
2053437424
>>> x+=1 # x référence une nouvelle instance
>>> id(x)
2053437440

Classes élémentaires Description Exemples / Remarques

NoneType Classe de l’objet None (objet type(None) # donne NoneType
n'ayant pas de valeur)
Bool Booléens type(True) # donne bool
bool(20) # donne True
True et False sont les seules
bool(0) # donne False
instances de cette classe.
x=y=2; x==y # donne True
x,y=1,2; x==y # donne False
Int Entiers relatifs (Z) y=2 ; type(y) # donne Int
x = int('52') # x prend 52
int(22.5) # donne 22
Float Nombres flottants (IR ) y=3.5 ; type(y) #donne Float
x = float('22.2')#x prend 22.2
x = -1e33 #x prend -1e+33
Complex Nombres complexes (C) z = 3+1j #ou z = complex(3,1)
type(z) # donne Complex
complex(5) # donne(5+0j)
z.real # donne 3.0 (float)
z.imag # donne 1.0 (float)
z.conjugate() # donne 3-1j
Remarque
bool (x) # retourne False si l'évaluation de x est nulle et True autrement
int(x) # retourne un entier si x est un nombre ou une chaine de caractère contenant
un nombre entier.
float(x) # retourne un réel si x est un nombre ou une chaine de caractère contenant
un nombre réel.

complex(x,y) # retourne un nombre complex formé par la partie réelle x et la partie

imaginaire y.

V Opérations d'entrée/sortie

Description Syntaxe Exemples

Sortie print(expr1, … , exprn) print('bienvenue à la formation')

Entrée nom = input() >>> nom= input('votre nom svp: ')

nom = input("message") votre nom svp: Foulen
Input prend (optionnel) et
>>> print('Bonjour',nom)
retourne une chaîne de
caractères Bonjour Foulen

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 4

VI Structures de contrôle
Un bloc de code est un groupe d’instructions Python indentées précédées par ":". Un bloc peut en inclure d'autres.

Description Syntaxe Exemples

Structure conditionnelle
Permet de conditionner if cond : #maximum de 3 entiers x, y, z
l'exécution d'un ou plusieurs bloc1 if x > y and x >z :
blocs d’instructions, mais un elif cond2 : print(x)
seul est exécuté. bloc2 elif y > z:
… print(y)
else : else :
blocn print(z)
Boucle conditionnelle

Permet d’exécuter un bloc while cond_exécution : #pgcd de x et y

tant que la condition bloc while x % y != 0 :
d'exécution de la boucle est x, y = y, x % y
à True. print(y)
La condition est toujours
testée avant l’exécution du
bloc de la boucle.
Permet d’exécuter un bloc while True : #saisie d’une voyelle
jusqu’à ce que la condition bloc while True:
d’arrêt devienne True. La if cond_arrêt : v=input('saisir une voyelle:')
condition d’arrêt est break if v in ['a','e','i','o','u','y']:
toujours testée après break
l’exécution du bloc de la
boucle.
Boucle NON conditionnelle
Permet d’exécuter le bloc for v in itérable: #calcul du produit des éléments d’une
bloc liste
pour chaque élément v de
l’itérable. Un itérable est une p = 1
collection d’objets (voir for v in [1,8,7]:
section VII sur les itérables). p*=v

Expression conditionnelle
Python offre la possibilité de expr1 if cond1 else #maximum de 2 valeurs x ,y
former des expressions dont expr2 m = x if x > y else y
l’évaluation est soumise à
une condition. Le résultat #les éléments négatifs de L1 sont
est l’évaluation de remplacés par 0 dans L2 (voir
expression1 si la condition l’itérable liste dans la section VII)
est True, et celle de L1=[-1,0,5,3]
expression2 sinon. expr1 if cond1 else L2=[0 if x<0 else x for x in L]
Cette construction ne permet expr2 if cond2 else
pas l’utilisation du mot expr3 x=int(input("?"))
réservé elif mais on peut ">0" if x>0 else "<0" if x<0 else "=0"
emboîter deux expressions
conditionnelles.

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 5

VII Classes itérables

Les classes itérables ou conteneurs permettent de conserver une collection d’objets. Ces classes peuvent se ramifier
selon deux critères :
 La mutabilité : classes modifiables (list, set, dict) et classes non modifiables (range, str et tuple).
 L’ordre : classes ordonnées appelées encore séquences (str, tuple, list, range) et classes non ordonnées (set
et dict).

VII.1 Opérations communes aux itérables

Le tableau suivant présente quelques opérations communes applicables aux instances des itérables.

Description Syntaxe Exemples / Remarques

Taille d’un itérable len(iter) lst = [1,2,5]
len(lst) #donne 3
Test d’appartenance d’un x in iter 5 in (1,5,[1,3]) # donne True
élément x à un itérable x not in iter 3 not in (1,5,[1,3]) # donne True
"li b" in "ali baba" # donne True
"Ali" in "ali baba" # donne False
Somme des éléments d’un sum(iter) sum([1,5,2,10]) # donne 18
itérable (itérable de valeurs
numériques uniquement).
Valeur maximale/ minimale max(iter) max([1,5,2,10]) # donne 10
min(iter) l = (1+3j,2+5j,11j); max(l)# Error
TypeError pour un itérable
comportant des objets non min(1,5,2,10) # donne 1
comparables
Tri d’un itérable d’objets sorted(iter) d = {'med':10, 'ali':20, 'lilia':5}
comparables (TypeError si sorted(d) # donne ['ali', 'lilia',
l’itérable comporte un objet 'med']
non comparable) sorted(d, reverse = True) # donne
Renvoie une liste contenant l'ordre inverse['med', 'lilia', 'ali']
les éléments dans l’ordre.
Parcours d’un itérable for item in iter : lst = [1,2,5]
#opérations for e in lst:
manipulant item print(e)
Énumération des éléments enumerate(iter) ch = "cem"
d’un itérable enumerate(iter, for i, v in enumerate(ch):
start_index)
print(i, v)
# donne en sortie
0 c
1 e
2 m

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 6

VII.2 Les séquences

Les itérables ordonnés, appelés encore séquences (tuple, liste et chaîne), conservent l’ordre dans lequel les
éléments ont été créés. Ainsi, chaque élément d’une séquence possède un indice indiquant sa position relative
par rapport aux autres éléments. Les indices commencent à partir de 0 pour un parcours de la gauche vers la
droite.

Un intervalle défini par range, également considéré comme une séquence, est un itérable ou conteneur formé
par une succession d’entiers.

range(debut, fin, pas) génère l’intervalle [debut, fin [ par pas entier relatif égal à pas.

VII.2.1 Opérations communes aux séquences

Le tableau suivant liste quelques opérations communes à toutes les séquences.

Description Syntaxe Exemples / Remarques

Indexage simple s[i] s = 'python'
avec 0 ≤ 𝑖 ≤ 𝑙𝑒𝑛(𝑠) − 1 ou s[0] #donne 'p'
−𝑙𝑒𝑛(𝑠) ≤ 𝑖 ≤ −1 s[len(s)-1] #ou s[-1] donne'n'
s[len(s)] # IndexError
Morcelage (Slicing) # fin non inclus s = 'python'
s[dep:fin:pas]
s[ ::-1] # donne 'nohtyp'
#pas par défaut égal à 1 s[ :2] # donne 'py'
s[dep:fin]
s[2:] # donne 'thon'
#du début avec pas=1
s[ :fin] s[::2] # donne 'pto'
#jusqu'à la fin avec pas=1
s[dep :]
Concaténation s1 + s2 [1,2] + [3] # donne [1,2,3]
(1,2) + (3,) # donne (1,2,3)
'med' + 'ali'# donne 'medali'

Répétition n * s # ou bien s * n [0] * 3 # donne [0,0,0]

avec n entier Naturel (1,2) * 2 # donne (1,2,1,2)
'bon' * 2 # donne 'bonbon'

Comptage du nombre s.count(item) lst = [0,1,0,1,1,1]

d’occurrences lst.count(1) # donne 4
ch ="ali baba"
ch.count("a") # donne 3
Retour de l’index d’un # première occurrence lst.index(0) # donne 0
item s.index(item)
lst.index(0,1)# donne 2
Déclenche ValueError si # à partir de start
lst.index(5) # ValueError
s.index(item, start)
item not in s.
Parcours d’un itérable for ind in range(len(iter)): lst = [1,2,5]
indexé #opérations manipulant for i in range(len(lst)):
iter[ind]
print(lst[i])

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 7

VII.2.2 La classe str

Une chaîne est une séquence non modifiable et ordonnée de caractères. Le tableau suivant résume les
principales opérations applicables aux chaînes.

Description Syntaxe Exemples / Remarques

Création d’une chaîne de #chaîne simple: s = "bonsoir" # ou encore
caractères ("…" ,'…') s = 'bonsoir'
#chaîne multilignes: s1="""chaîne
(""" … """ ,''' …''') multi-
lignes"""
#équivalente à
s1 = 'chaîne\nmulti-\nlignes'
Retour d’une chaîne en Ch.lower ( ) Ch='fG15Z'
minuscule identique à Ch Ch.lower( ) # donne 'fg15z'

Retour d’une chaîne en Ch.upper ( ) Ch='fG15Z'

majuscule identique à Ch Ch.upper ( ) # 'FG15Z'

Retour d’une liste des sous- Ch.split(sep) Ch='Epsilon 2018/2019'

chaînes en utilisant un séparateur Ch.split( ) # donne
sep ['Epsilon', '2018/2019']
Ch.split('0') # donne [Epsilon
Par défaut, le séparateur est le 2', '18/2', '19']
caractère espace
Retour d’une chaîne identique à Ch.strip(sep) Ch="*la chaîne*"
Ch en supprimant les Ch.strip('*')
occurrences d’un séparateur sep # donne 'la chaîne'
du début et de la fin si elles
existent. Par défaut sep est
l'espace.
Retour d’une chaîne de Sep.join(itérable) L=['abc','12','azer']
caractères résultante de la '/'.join(L)
concaténation par sep des # donne 'abc/12/azer'
chaînes de l’itérable ' '.join(L)
TypeError est généré si l’itérable # donne 'abc 12 azer'
contient un objet qui n'est pas de
type str.
Retour d’une chaîne de Ch.format(paramètres) Ch = 'Epsilon {}/{}'
caractères en remplaçant chaque Ch.format(2019,2020)
‘{}’ par les paramètres passés à # donne 'Epsilon 2019/2020'
la méthode (objets de classes
quelconques).
Retour de l’Unicode (entier) du ord(caractère) ord ('A') # 65
caractère passé en paramètre ord('a') # 97

Retour du caractère associé à la chr(entier) chr(65) # donne 'A'

valeur UNICODE passée chr(10) # donne '\n'
paramètre.

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 8

VII.2.3 La classe list

Une liste est une séquence, ordonnée et modifiable, d’éléments éventuellement hétérogènes séparés par une
virgule et délimitée par une paire de crochets.
Le tableau suivant résume les principales fonctions/méthodes applicables aux listes.

Description Syntaxe Exemples

Création d’une liste vide L=[ ] #ou L=[1, 'python', True, 1+1j]
L=list( )

Création d’une liste à L=list(itérable) list('ABCA') # donne ['A','B','C','A']

partir d’un itérable list({3, 'A',4}) # donne [3,4,'A']
list((2,2,(1,2)))# donne [ 2,2,(1,2)]
list({2 :45, 'x':[1,2]}# donne [2,'x']
list(145)# TypeError
Ajout d’un objet à la fin L.append (objet) L.append(2020) ; L
d’une liste #donne [1, 'python', True, (1+1j), 2020]
#remplissage d'une liste par n chaînes
lst = list()
for i in range(n):
x = input("donner l[{}]:".format(i))
lst.append(x)
Ajout d’un objet x dans L L.insert(i,x) L.insert(-1 ,'concours') ; L # donne
à l’indice i [1,'python',True,(1+1j),'concours',2020]

Suppression de la première L.remove(x) L.remove(1+1j) ; L # donne

occurrence d’un l'objet x [1, 'python', True, 'concours', 2020]
dans L
ValueError si x not in L.
Ajout d’éléments de L.extend(t) L.extend({-1,2}) ; L # donne
l’itérable t à la fin de L [1,'python',True,'concours',2020,2,-1]
Suppression et retour du L.pop() L.pop() # donne -1
dernier élément de L L # donne
[1,'python',True,'concours',2020,2]
Suppression et retour de L.pop(i) L.pop(2) # donne True
l’élément d’indice i de la L # donne
liste L [1, 'python', 'concours', 2020, 2]

VII.2.4 La classe tuple

Un tuple est une séquence, ordonnée et non modifiable, d’éléments éventuellement hétérogènes séparés par
une virgule. Le tableau suivant résume les principales fonctions/méthodes applicables aux tuples :

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 9

Description Syntaxe Exemples

Création d’un tuple vide t=( ) #t=tuple( )

Création d’un tuple d’un t=objet , T=255,

seul objet (singleton) T # donne (255,)
T1=[12,5],1
T1 #donne ([12,5], 1)
Création d’un tuple à L=tuple(itérable) tuple({3,'A',4}) # donne (3,'A',4)
partir d’un itérable tuple((2,2,(1,2))) # donne (2,2,(1,2))

VII.3 Les itérables non ordonnés

VII.3.1 La classe set

Un ensemble est une collection d'éléments distincts non ordonnés et encadrés par des accolades. La classe
set représente la notion d’ensemble en mathématique. Un ensemble doit impérativement comporter des
éléments non modifiables. La création d'ensembles de listes, de dictionnaires ou d'ensembles déclenche une
erreur. Le tableau suivant résume les principales fonctions/méthodes applicables aux ensembles.

Description Syntaxe Exemples/ Remarques

Création d’un s = set()
ensemble vide NB : s={} ne crée pas un
ensemble
Création d’ensemble à s = set(iter) s = set("010101")
partir d’un itérable iter s={e0, …,en} s # donne {'0','1'}
ou avec les délimiteurs s = set(3.25) # TypeError
Ajout d’un objet s.add(obj) s = set()
s.add(5) ; s # donne {5}
s.add("eps"); s #donne{5,“eps”}
s.add([1,2,3]) #TypeError

Suppression d’un objet s.discard(x) s = {1,7,2} ; s.remove(1)

s.remove(x) s # donne {2,7}
s-= {obj} s.remove(5) # KeyError
s -= {2} ; s # donne {7}
Union : s1 U s2 s1 | s2 s = {1,2} | {2,3}
s1.union(s2) s # donne {1,2,3}
Intersection : s1 ∩ s2 s1 & s2 s = {1,2} & {2,3}
s1.intersection(s2) s # donne {2}
Différence : s1 \ s2 s1 – s2 s = {1,2} – {2,3}
s1.difference(s2) s # donne {1}
Différence Symétrique s1 ^ s2 s = {1,2}^{2,3}
s1 ∆ s2 s1.symmetric_difference(s2) s # donne {1,3}

Inclusion : s1 ⊂ s2 s1 <= s2 {1,2} <= {1,2,5}# donne True

{1,2} <= {1,2} # donne True
Inclusion stricte : s1 < s2 {1,2} < {1,2,5} # donne True
s1 ⊊ s2 s1.issuperset(s2) {1,2} < {1,2} # donne False

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 10

VII.3.2 La classe dict

Un dictionnaire est une structure modifiable et non ordonnée d'associations (clé : valeur). Les clés sont
impérativement des objets non modifiables. L'utilisation de listes, de dictionnaires ou d'ensembles comme
clé déclenche une erreur. Les valeurs sont des objets de classes quelconques.

Description Syntaxe Exemples / Remarques

Création d’un d = dict()
dictionnaire vide d = {}

Création d’un d= dict(iter) t = [(5,2), "ab", [1,2] ]

dictionnaire à partir d’un d={c1:v1 , …, cn:vn} dict(t) #donne {1:2, 5:2, 'a':'b'}
itérable de couples ou d = {'a': 3, 'b': 5, 4j: 33}
directement
Test d’appartenance k in d 33 in d # donne False
d’une clé k à un k not in d 'a' in d # donne True
dictionnaire d
Accès à une entrée du d[k] d = {'a': 3, 'b': 5, 4j: 33}
dictionnaire d d.get(k) d['a'] # donne 3
d.get(k, vdef) d['c'] # donne KeyError
d.get('c') # None
d.get('c', 0) #0
Mise à jour / insertion d[k] = val d = {}
d’une entrée dans le d.update({k :val}) d['a'] = 33 # insertion
dictionnaire d d # donne {'a' :33}
d['a'] = 22 # mise à jour
d # donne {'a':22}
Copie de dictionnaire d.copy() d = {1:2}
d1 = d.copy()
d[1] = {2} ; d1 # donne {1:{2}}
d # donne {1:2}
Suppression d’une d.pop(k) d = {1:2, 'a':10}
entrée de à partir de sa del d[k] del d[1]; d # donne {'a':10}
clé d.pop('a') # donne la valeur 10
d # donne {}
Parcours des clés d’un for k in d: d = {1:2, 'a':10}
dictionnaire traitements for k in d:
#ou encore print(k)
for k in d.keys()
traitements
Parcours des valeurs for v in d.values(): for v in d.values():
d’un dictionnaire traitements print(v)

Parcours des couples for k, v in d.items(): for k, v in d.items():

clé, valeur d’un traitement print(k,v)
dictionnaire

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 11

VIII Construction des itérables en compréhension

La construction des itérables en compréhension permet de générer des conteneurs de façon concise et élégante. On
peut créer des listes en compréhension, des tuples en compréhension, des ensembles en compréhension et des
dictionnaires en compréhension à l'aide du constructeur de la classe ou les délimiteurs des itérables mutables.

VIII.1 Listes en compréhension

[expression for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n ]
ou encore
list(expression for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n )

- Les conditions if sont facultatives (conditions de filtrage).

- L’ordre d’imbrication des boucles est de la gauche vers la droite.
- On peut utiliser le constructeur list à la place des délimiteurs.
- expression peut elle même être un itérable en compréhension.
Exemples
>>> L= [ i for i in range(1, 21, 2) ] ; L
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> L=[ (i,j) for i in range(1,3) for j in range(1,4) ] ; L
[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3)]
>>> L=[i*j for i in range(1,5) for j in range(1,5) ] ; L
[1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16]
>>> L=[(i,j) for i in range(1,5) if i%2 for j in range(1,5) if (i+j)%2==0]; L
[(1, 1), (1, 3), (3, 1), (3, 3)]
>>>[[(100*i+j)//2 if j%2==0 else 100*i+j for j in range(1,i+1)] for i in
range(1,5)]
[[101], [201, 101], [301, 151, 303], [401, 201, 403, 202]]

VIII.2 Tuples en compréhension

tuple( expression for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n )
Attention : sans le constructeur tuple, la construction en compréhension produit un générateur et non pas
un tuple.

Exemple

tuple((i,j) for i in range(1,5) if i%2 for j in range(1,5) if (i+j)%2==0 )

((1, 1), (1, 3), (3, 1), (3, 3))

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 12

VIII.3 Ensembles en compréhension

set(expression for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n )
ou encore

{ expression for indice_1 in iterable_1 if condition_1 …

for indice_n in iterable_n if condition_n}

Exemple

>>> e={(x,y) for x in range(5) if x%2 for y in range(5) if y%2==0 }

# ou bien e=set((x,y) for x in range(5) if x%2 for y in range(5) if y%2==0)
>>> e
{(1, 2), (3, 2), (3, 0), (1, 4), (1, 0), (3, 4)}

VIII.4 Dictionnaires en compréhension

{cle: valeur for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n }
ou encore

dict((cle,valeur) for indice_1 in iterable_1 if condition_1 …

for indice_n in iterable_n if condition_n)
Exemple:

>>>d={ x:y for x in range(10) if x%2 for y in range(10) if y%2==0}

#ou bien d=dict((x,y) for x in range(10) if x%2 for y in range(10) if y%2==0)
>>>d
{1: 8, 3: 8, 9: 8, 5: 8, 7: 8}

IX Import de bibliothèques ou modules

Il y a trois manières d’import de modules :

 1ère manière d’import :

 Import du module désigné par nom_module mais pas les fonctions qui y sont contenues :
import nom_module

Exemples : import math # import du module math

import random # import du module random

 L’appel de chaque fonction du module se fait par :

nom_module.fonction(…)

Exemples : math.ceil(7.8989) # partie entière supérieure qui est 8

random.randint(0,10) # retourne un entier aléatoire entre 0 et 10

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 13

 2ème manière d’import :

 Utilisation d’un alias :
import nom_module as alias

Exemple : import math as m

 L’appel de chaque fonction du module se fait par :
alias.fonction(…)

Exemple : m.sqrt(4)# retourne la racine carrée de 4 : 2.0

 3ème manière :
 Accès direct à toutes les fonctions du module par :
from nom_module import *
Exemple : from math import *
 Accès direct à une ou quelques fonctions du module par :
from nom_module import nom_fonc1,…,nom_foncp

Exemple : from math import pi,sqrt,ceil

Dans les deux cas, l’appel de chaque fonction du module se fait directement par son nom : nom_fonction(…)
Exemple : sqrt(5) #donne 2.23606797749979

X Les sous-programmes

Une fonction est un bloc d’instructions indentées (corps de la fonction) destiné à réaliser une opération. Elle peut
recevoir des paramètres et renvoie éventuellement un résultat. L’appel d’une fonction Python retourne toujours un
objet, par défaut None. Dans le corps de la fonction ce retour est spécifié à l’aide de l’instruction return.

Le tableau suivant résume les concepts de base associés aux fonctions Python.

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 14

Description Syntaxe Exemples(s) / Remarques

Définition d’une fonction où les def nom_f(paramètres) : #fonction avec paramètres
paramètres sont optionnels corps de nom_f def f(x,y) :
import math
return x**2 + math.sin(y)
#fonction sans paramètres
def g():
whileTrue:
s = input("donner une
chaîne alphabétique : ")
if s.isalpha():
return s
Appel d’une fonction : #arguments positionnels
nom_f(arguments) print(f(3,2))
- Arguments positionnels
nom_f(n_arg1=v1 , …,
- Arguments nommés (ordre
arguments n'a plus d'importance) n_argp=vp) #arguments nommés
r = f(y = 2, x = 3)
Les paramètres nommés doivent
apparaître à la fin
Retour d’une fonction return expression #Définition
L’instruction return permet de #Une fonction sans def f(x) :
retourner un résultat à l’appelant return retourne l’objet if x >0 :
None
d’une fonction. return x**0.5
Cette instruction engendre la #Appel
sortie immédiate du code de la print(f(4)) # affiche 2.0
fonction et le retour vers print(f(-4)) # affiche None
l'appelant.
Paramètres optionnels def f(x,y,z=val_def) : # cette déclaration génère
corps de f SyntaxError
Les paramètres optionnels sont
associés à une valeur par défaut def h(x, y = 5, t) :
(évaluée une seule fois au moment corps
de la définition de la fonction).
Si l’argument associé au # déclaration de f
paramètre n’est pas indiqué lors de def f(x, y = 6) :
l’appel, Python utilise la valeur return x + y
par défaut pour substituer le
paramètre optionnel. #Appel de f
Les paramètres optionnels doivent print(f(1,3)) # affiche 4
apparaître à la fin de la séquence print(f(3)) # affiche 9
des paramètres.

Fonctions lambda lambda paramètres : f = lambda x : x**2

résultat #équivalente à
Elle permet de créer une
def f(x) :
expression de type fonction.
return x**2

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 15

XI Gestion des exceptions

Les exceptions sont des objets spéciaux permettant de représenter une erreur d’exécution dans un script Python. Il
existe plusieurs types d’erreurs : TypeError, ValueError, IndexError. Ces derniers sont des classes Python
héritant toutes de la classe de base Exception permettant de représenter une Erreur quelconque. La table suivante
résume les opérations de gestion d’erreur.

Description Syntaxe Exemple(s) / Remarque(s)

Déclencher une raise Exception(" message ") raise Exception()
exception
Prévoir une if cond_erreur :
exception raise Exception("message" )
ou bien
assert not cond_erreur,
"message"

Intercepter une try : #saisie d’un entier positif (avec

bloc gestion d’erreur)
exception
except : def f():
bloc_cas_erreur while True:
else : try:
bloc_cas_pas_erreur x=int(input('x'))
finally : except:
bloc_tous_les_cas print ('erreur')
else:
if x>0:
return x

XII Gestion des fichiers

Un fichier est une collection d’informations, généralement structurées d’une manière ou d’une autre, placées sur
une mémoire de masse.

XII.1 Fichiers textes

Un fichier texte contient une succession de caractères séquentiels. Lors de l’ouverture d’un fichier texte, un
encodeur assure la conversion des octets lus/écris en lettres UNICODE. Voici les principales fonctions/méthodes
pour le traitement des fichiers.

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 16

Fonctions /Méthodes Description/Exemples

f=open(nom_du_fichier,'r') Ouvre le fichier nom_de_fichier (donné sous la forme d’une
chaîne de caractères indiquant son emplacement) en lecture ( r
comme read). Le fichier doit exister et seule la lecture est
autorisée. L'ouverture d'un fichier inexistant génère une erreur.
L'utilisation de la clause try … except est indiquée pour gérer cette
situation.
f=open(nom_du_fichier,'w') Ouvre le fichier nom_de_fichier en écriture (w comme write). Si
le fichier n’existe pas, il est créé, sinon il est écrasé. f est le fichier
logique associé au fichier physique donné par nom_du_fichier.
f=open(nom_du_fichier,'a') Ouvre le fichier nom_de_fichier en ajout (a comme append).
Identique au mode 'w', sauf que si le fichier existe, il n’est pas
écrasé et l'ajout se fait en fin du fichier.
f.close() Ferme un fichier ouvert par la fonction open.
f.read() Fournit l'intégralité du contenu du fichier sous forme de chaîne de
caractères (à ne réserver qu’aux fichiers de taille raisonnable).
f.readlines() Fournit la totalité du contenu du fichier sous forme d’une liste de
chaînes de caractères.
Le caractère de saut de ligne '\n' présent à la fin de chaque chaîne
indique la fin de chaque ligne.
f.readline() Fournit la ligne courante sous forme d’une chaîne de caractères et
place le curseur sur la ligne suivante. Elle renvoie la chaîne vide
si fin du fichier.
f.write(s) Écrit la chaîne s à partir de la position courante du fichier.
f.writelines(T) Écrit l’ensemble des éléments de T dans le fichier f comme des
T doit être une chaîne de sous chaînes ou lignes successives. Le caractère de saut de ligne '\n' présent à la
un itérable de chaînes fin de chaque chaîne indique la fin de chaque ligne.
Parcours d'un fichier
Parcourir un fichier ouvert en lecture se try:
fait comme le parcours d'un itérable : f = open("nomf.txt","r")
parcourir ses lignes avec une boucle for except:
sans passer par readlines.
print(" fichier introuvable !")
for ligne in f :
else:
[instructions]
for ligne in f:
print(ligne)
f.close()

On n'est jamais à l'abri d'une erreur quand on manipule des fichiers et qu'on oublie de les fermer. Le mot réservé
with du langage python, permet d'éviter cette situation et dont voici sa syntaxe générale :
with open (mon_fichier, mode) as variable :
# Opérations de manipulation du fichier

L'exemple précédent s'écrit alors :

try:
with open ('fp.txt','r') as f :
for ligne in f:
print(ligne)
except:
print(" fichier introuvable !")

Notions de base : Rappel

 Révision Informatique, Concours MP-PC-T 2020 17

XII.2 Fichiers binaires

Dans un fichier binaire les informations sont transférées de la RAM vers le support de stockage sans aucun
formatage (aucun encodeur n’est utilisé). Pour les fichiers binaires, le mode d’ouverture est suffixé par 'b' :
'wb', 'rb' et 'ab'. La manipulation d'un fichier binaire n'est pas une fin en soi et cela ne présente aucun
intérêt pour l'utilisateur. L'intérêt à ce niveau est de pouvoir utiliser le module pickle permettant de
sérialiser/désérialiser des objets (entier, réel, chaîne, liste, dictionnaire, etc.) dans leur format et non pas sous
forme de suite de caractères.
Sérialiser un objet, à l'aide de la méthode dump, consiste à le transformer en une suite d’octets afin de pouvoir
le stocker dans un fichier binaire. Désérialiser, à l'aide de la méthode load, consiste à récupérer les objets dans
leur format initial.
>>>import pickle
>>>pickle.dump(objet, fichier_binaire)
>>>objet = pickle.load(fichier_binaire)
Remarque : load génère une erreur si plus d'objets à lire, l'utilisation du try … except s'impose.

XIII La récursivité
Une fonction récursive est une fonction dont le corps contient un ou plusieurs appels à elle-même.
Un traitement récursif nécessite de déterminer :
 le cas trivial ou encore le cas d'arrêt
 le traitement récurrent et de s'assurer que ce dernier atteindra le cas d'arrêt (terminaison).
Dans le tableau suivant, on donne deux exemples de problèmes résolus de façon récursive.
Problème Démarche Solution récursive
def factorielle(n):
Calcul de la On raisonne par récurrence sur n if n<=1:
factorielle de n  Cas trivial : 0 ! = 1 return 1 #cas trivial
𝒏 else:
𝒏! = 𝒊  𝑛! = 𝑛 × (𝑛 − 1)! return n*factorielle(n-1)
𝒊 𝟏

Tri Fusion Le tri fusion est un tri récursif qui def fusion_Rec(L1,L2):
applique le principe "diviser pour if L1==[]:
régner". return L2
Pour une liste L, le principe du tri fusion if L2==[]:
est le suivant : return L1
 si L est de taille 1, elle est triée et on if L1[0]<L2[0]:
la retourne (cas trivial) ; return [L1[0]]+fusion_Rec(L1[1:],L2)
 sinon on divise L en deux sous-listes else:
L1 et L2 presque égales ( return [L2[0]]+fusion_Rec(L1,L2[1:])
L1[0:len(L)//2] et L2[len(L)//2:
len(L)] ) : def tri_fusion_Rec(L):
 on applique récursivement if len(L)<=1:
l’algorithme de tri par fusion à L1 return L
puis à L2 L1=[L[x] for x in range (len(L)//2)]
 on fusionne les L1 et L2 triées. (La L2=[L[x] for x in range (len(L)//2,
fusion est également effectuée de len(L))]
manière récursive où le cas trivial Return fusion_Rec(tri_fusion_Rec(L1,
est l'épuisement de l'une des 2 listes tri_fusion_Rec(L2))
et on retourne l'autre).

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 18

XIV Complexité algorithmique

XIV.1 Calcul du coût

Le temps d’exécution d’un programme dépend fortement de la machine qui l’exécute, du langage dans lequel il
est écrit et de l’algorithme sous-jacent. Pour des données de grandes tailles, l’algorithme est la cause
déterminante du temps d’exécution d’un programme. Des méthodes rationnelles permettent de calculer le coût
d’un programme exprimé en nombre d’opérations élémentaires exécutées par la machine afin d’obtenir le
résultat final. Généralement, ce nombre est fonction de la taille n des données à traiter.
Le coût se calcule comme suit :
 Coût d’une opération élémentaire op = 1.
 Coût d'une séquence de k instructions p_1 ; p_2 ; … p_k = ∑𝒌𝒊 𝟏 𝒄𝒐û𝒕(𝒑𝒊 ) .
 Coût d'une structure conditionnelle simple if c: p else : q <= coût(c) + max(coût(q),coût(p)).
 Coût d'une structure conditionnelle complète if c_1: p_1 elif c_2 : p_2 … elif c_i : p_i … else : p_k+1
= (∑𝒌𝒊 𝟏 𝒄𝒐û𝒕(𝒄𝒊 )) + 𝐦𝐚𝐱 𝒄𝒐û𝒕(𝒑𝒊 ).
𝟏 𝒊 𝒌 𝟏
 Coût d'une boucle for i in iterable : p_i = ∑ ∈ é 𝑐𝑜û𝑡(𝑝𝑖)
 Coût d'une boucle while c : p est le plus difficile à exprimer (nombre d'itérations non connu à priori)
majorer le nombre de répétitions => NombreRépétitions*( 𝑐𝑜û𝑡(𝑐)+ 𝑐𝑜û𝑡(𝑝))+1* 𝑐𝑜û𝑡(𝑐)

Exemple : Calcul xn
- Approche naïve :
def puiss1(x,n):
r = 1 #1 affectation
for i in range(n): # n affectations
r*= x # 1 affectation + 1 multiplication
return r # 1 retour

Le Coût total = f(n) = 2n + 2.

- Exponentiation rapide :
def puiss2(x,n):
r= 1 # 1 affectation
u= x # 1 affectation
while n != 0: # (int(log2(n)) + 1) comparaisons
if n % 2 == 1: #2 = modulo + comparaison
r*= u #2 = multiplication + affectation
u*= u #2 = multiplication + affectation
n//= 2 #2 = division + affectation
return r #1 retour

Le Coût total = f(n) = 9 E[log2(n)]+ 3.

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 19

XIV.2 Complexité asymptotique

La complexité asymptotique consiste à estimer l’ordre de grandeur du nombre d’opérations effectuées par un
programme sans effectuer un décomptage minutieux. Cette complexité est exprimée en Grand-O (notation de
Landau).
Soit f, g : ℕ → ℝ∗ deux fonctions. 𝑓(𝑛) est dite 𝑂(𝑔(𝑛)) ⇔ 𝑓 est dominée par 𝑔 quand 𝑛 → +∞.

• 𝑓(𝑛) est 𝑂(𝑔(𝑛)) et 𝑐 une constante, alors :

 𝑐 + 𝑓(𝑛) est aussi 𝑂(𝑔(𝑛)).
 𝑐 𝑓(𝑛) est aussi 𝑂(𝑔(𝑛)).
 Les facteurs constants sont ignorés dans le calcul de la complexité asymptotique.
• 𝑓 (𝑛) est 𝑂(𝑔 (𝑛)) est 𝑓 (𝑛) est 𝑂(𝑔 (𝑛)), alors :
 𝑓 (𝑛) + 𝑓 (𝑛) est 𝑂 𝑔 (𝑛) + 𝑔 (𝑛) .
 𝑓 (𝑛)𝑓 (𝑛) est 𝑂(𝑔 (𝑛)𝑔 (𝑛)).
• 𝑓 (𝑛) est 𝑂(𝑓 (𝑛)) et 𝑓 (𝑛) est 𝑂 𝑓 (𝑛) , alors :
 𝑓 (𝑛) est 𝑂(𝑓 (𝑛)).

XIV.3 Classes de complexité asymptotique

Nom de la classe Complexité Exemples

Constante 𝑂(1)  Accès à un élément d’une liste l[i].
 Additionner multiplier un nombre constant d’objets.
Logarithmique 𝑂(log(𝑛))  Recherche dichotomique 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Méthode de bissectrices pour trouver le zéro d’une fonction
𝑛= .
 Exponentiation rapide.
 Trouver l’écriture d’un entier n dans une base b.
Linéaire 𝑂(𝑛)  Trouver le maximum/minimum d’une liste 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Tester l’appartenance d’un élément dans une liste 𝑛 =
𝑙𝑒𝑛(𝑙𝑠𝑡).
 Produit scalaire de deux vecteurs.
Quasilinéaire 𝑂(𝑛 log (𝑛))  Trier une liste lst.sort() : 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Tri fusion / Tri rapide
Quadratique 𝑂(𝑛 )  Tri par sélection/insertion/bulles 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Remplissage d’une matrice carrée.
 Somme de deux matrices carrées
Polynomiale 𝑂(𝑛 ) 𝑜ù 𝑝 ≥ 2  Multiplication de deux matrices 𝑂(𝑛 ).
 Réduction de Gauss.
 Inversion d’une matrice.
Exponentielle 𝑂(𝑐 ) 𝑜ù 𝑐 > 1  Trouver tous les sous-ensembles d’un ensemble de taille n.
 Trouver un mot de basse de taille n par brute force.
 Afficher toutes les valeurs binaires qui s’écrivent sur n bits.
Factorielle 𝑂(𝑛!)  Résoudre le problème du voyageur du commerce (avec n =
nombre de villes) par brute force.
 Trier une liste de taille n par brute force.
Exemples :
 4 𝑛 + 100000000 est 𝑂(𝑛).  2 +𝑛 est 𝑂(2 ).
 100 𝑛 + 𝑛 + 300000 𝑛 est 𝑂(𝑛 ).  2 + 𝑛! est 𝑂(𝑛!).

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 20

Bibliographie et Netographie

Ouvrages

Learning Python, Mark Lutz, Edition O’Reilly, Juin 2013, ISBN: 9781449355722.

Informatique pour tous en classes préparatoires aux grandes écoles, Benjamin Wack & al., Edition Eyrolles,
Août 2013, ISBN: 978-2-212-13700-2.

Supports de Cours

Support de Cours de H.Filali et H.Bouzidi, Rappel, pour 2ème année préparatoire sections MP-PC-T, IPEIM,
Année universitaire 2019-2020.

Support de Cours de Laila Hammami pour 1ère année préparatoire sections MP-PC-T, IPEIN, Année
universitaire 2019-2020.

Support de Cours de W.Meftah, Rappel, pour 2ème année préparatoire sections MP-PC-T, IPEIS, Année
universitaire 2019-2020.

Sites Web :

https://www.python-course.eu/

https://www.ics.uci.edu/~brgallar/index.html

Notions de base : Rappel

Programmation Orientée
Objet
Aide-Mémoire pour la préparation de l’épreuve
d’Informatique du Concours National d’Entrée aux
Ecoles d’Ingénieurs MP-PC-T 2020

Elaboré par :

Hayet Latrach (IPEIT)

Houcemeddine Filali (IPEIM)
Laila Hammami (IPEIN)
Wafa Meftah (IPEIS)
Mohamed Hammami (IPEIEM)
Besma Fayech (ENSIT)

-- Mai 2020 --
[Tapez ici]

Préambule

Ce document est destiné aux étudiants de deuxième année MP-PC-T des Instituts
Préparatoires aux Etudes d’Ingénieurs.

Dans les circonstances exceptionnelles liées à la crise sanitaire mondiale et nationale du

Covid19, un ensemble de supports de révision pour le programme d’informatique du
concours national d’entrée aux écoles d’ingénieurs ont été élaborés essentiellement par les
membres de la commission informatique du concours, suite à une action bénévole.

Le but de ces supports est d’accompagner les étudiants de tout le territoire Tunisien dans
leur révision en leur fournissant à tous les mêmes documents, afin d’assurer une équité
entre eux, qu’ils bénéficient ou non d’un enseignement ou tutorat à distance.

Toutefois, ces documents sont considérés comme des aide-mémoires et ne remplacent pas
les cours assurés en présentiel.

Le document présent comporte les concepts de base associés à la programmation orientée

objet en python. Il expose ainsi la représentation et la manipulation des classes, des objets,
des méthodes, de l’héritage, du polymorphisme et de la surcharge. Une application
intéressante aux piles et files est ensuite présentée. Des exercices d’application avec leurs
corrigés sont également intégrés à la fin.

Programmation Orientée Objet

[Tapez ici]

Table des matières

I Introduction ........................................................................................................................................................................ 3
II Classe et Objet .................................................................................................................................................................... 3
II.1 Définitions................................................................................................................................................................... 3
II.2 Création de classe en Python ...................................................................................................................................... 4
II.3 Création d'objets en Python ........................................................................................................................................ 5
III Héritage / Dérivation .......................................................................................................................................................... 6
III.1 Définition .................................................................................................................................................................... 6
III.2 Exemple 1.................................................................................................................................................................... 6
III.3 Exemple 2.................................................................................................................................................................... 7
IV Polymorphisme et surcharge .............................................................................................................................................. 8
IV.1 Définitions et exemples............................................................................................................................................... 8
IV.2 Exemples de surcharge de méthodes spéciales ......................................................................................................... 10
IV.2.1 Représentation formelle d’un objet ................................................................................................................ 10
IV.2.2 Représentation informelle d’un objet ............................................................................................................. 10
IV.2.3 Surcharge des opérateurs ................................................................................................................................ 11
V Application : Création des classes Pile et File..................................................................................................................... 12
V.1 La classe Pile ............................................................................................................................................................. 12
V.1.1 Définition d’une pile ........................................................................................................................................ 12
V.1.2 Implémentation d’une classe Pile .................................................................................................................... 12
V.2 La classe File .............................................................................................................................................................. 12
V.2.1 Définition d’une File ........................................................................................................................................ 12
V.2.2 Implémentation d’une classe File .................................................................................................................... 13
V.3 Exemple d’inversion d’une pile ................................................................................................................................. 13
VI Exercices d’application...................................................................................................................................................... 14
VI.1 Exercice 1 .................................................................................................................................................................. 14
VI.2 Exercice 2 : Extrait de l’examen SM-SP-IPEIT- Décembre 2018 .................................................................................. 14
VII Alternatives de correction pour les exercices ................................................................................................................ 16
VII.1 Corrigé Exercice 1 ...................................................................................................................................................... 16
VII.2 Corrigé Exercice 2 ...................................................................................................................................................... 17
VIII Bibliographie et Netographie ........................................................................................................................................ 20

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
3

I I NTRODUCTION
En programmation procédurale, on s'intéresse aux étapes nécessaires pour résoudre un problème donné. Ces étapes
sont modélisées par des tâches plus ou moins complexes, appelées procédures/fonctions qui manipulent les données
du problème sans beaucoup de contrôle pour aboutir au résultat final. Le programme est donc un enchainement de
ces tâches.

En programmation OO, on modélise le problème par un ensemble d'objets du monde réel qui interagissent entre eux
à travers des messages. L'objet est donc l'entité principale.

L'objet encapsule ses propres données et les traitements relatifs à ses données dans une même entité. Le programme
est un ensemble d'objets et des interactions entre ces objets.

II C LASSE ET O BJET

II.1 Définitions
Concrètement un objet est une entité du monde réel. Une personne, une voiture, une forme géométrique, une
image, une feuille, etc.

En python, toutes les entités manipulées sont des objets (entier, fichier, module, etc)

La définition d'un objet (structure de l'objet) consiste à décrire ses propriétés :

- Statiques, appelées attributs ;

- Comportementales ou dynamiques, appelées méthodes :

Une feuille de papier par exemple, possède une couleur, une longueur et une largeur et on peut la plier, la
déchirer, la couper, etc.

Un exemplaire d'un objet s'appelle une instance. Une feuille de papier de couleur rouge de longueur 21 cm et de
largeur 17 cm est une instance de l'objet.

Deux instances possèdent chacune des valeurs d'attributs différentes mais se partagent les mêmes méthodes de
l'objet. Il n'y a aucune interférence entre les objets d'une même classe.

Une classe est une entité qui permet la création des objets (instances) ayant les mêmes propriétés.

Pour pouvoir manipuler un objet (accéder à ses propriétés ou invoquer l'une de ses méthodes), on utilise
l’opérateur point.

L'interaction entre les objets se fait par invocation des méthodes.

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
4

II.2 Création de classe en Python

Une classe permet de définir (déclarer) l’ensemble attributs et méthodes relatives à une catégorie d’objets.
 Attributs de classe :
Un attribut de classe est défini au niveau de la classe et sa valeur est partagée par tous les objets
instanciés de cette classe. L’accès à l’attribut est donné par : nom_Classe.nom_attribut
 Attributs d’objets

Un attribut d’objet est défini au niveau de la méthode constructeur. La valeur d’un attribut d’objet est
propre à chaque objet. L’accès à l’attribut est donné par : nom_Objet.nom_attribut
 Le constructeur d’objet

Le constructeur est une méthode particulière appelée lors de la création d'un nouvel objet permettant
d’initialiser ses attributs.
Le constructeur se définit dans une classe comme une fonction avec deux particularités :
o le nom de la méthode doit être __init__ ;

o la méthode doit accepter au moins un paramètre de nom self qui apparaît en premier.
 Le paramètre self
Le paramètre self représente en fait l'objet cible, c'est-à-dire que c'est une variable qui référence l'objet
en cours de création et permettant d’accéder à ses attributs et fonctionnalités.
 Les méthodes
Une méthode est une fonction qui agit principalement sur une instance de la classe. Elle doit accepter au
moins le paramètre self figurant en première position.
L’appel d’une méthode se fait par : nom_Objet.nom_méthode (autres paramètres)

Syntaxe de la création :
class nom_classe:
#définition des attributs de classe
(attribut de valeur commune pour toutes les instances)
nom_attr = valeur

#définition des attributs d’objet (chaque instance a sa propre valeur)

def __init__(self, liste_paramètres): # le constructeur de l’objet
self.nomattr1= v1
self.nomattr2= v2
…

#définition des méthodes

def nom_meth (self, autres_paramètres):
#corps de la méthode

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
5

Exemple
Soit la classe Compte_bancaire définie par:
◦ Les attributs:
◦ Attributs de classe : nombank
◦ Attributs d’objet : NumeroCompte, NomProprietaire, solde
◦ Les méthodes: AfficherSolde, Retrait, Dépôt
Elle est créée ainsi :
# création de la classe Compte_Bancaire CompteBc
class compteBc:
nombank= 'amenbank '
def __init__(self, N, A, S) #le paramètre self désigne l’objet lui-même
self.num=N
self.nom=A
self.sold=S
def retrait(self,x):
if self.sold>=x:
self.sold= self.sold-x
else:
raise Exception('retrait impossible')
def depot(self,x):
self.sold+=x
def AfficherSolde (self):
print('compte au nom de ', self.nom, 'a pour solde',self.sold)

II.3 Création d'objets en Python

La création d’une instance (objet) d’une classe donnée se fait par un appel au nom de la classe avec les
paramètres effectifs du constructeur, selon la syntaxe suivante :
>>> nom_obj=nom_classe(paramètres effectifs du constructeur )

Exemple
Soit compte1 une instance de la classe Compte_bancaire dont les données sont les suivantes :
◦ NumeroCompte : 512017
◦ NomProprietaire : mohamed
◦ solde : 1500

L’objet compte1 est créé ainsi :

>>> compte1= compteBc(512017, mohamed, 1500)
>>> compte1.depot(500) # appel de la méthode depot
>>> compte1.AfficherSolde()
compte au nom de mohamed a pour solde 2000

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
6

III H ERITAGE / D ERIVATION

III.1 Définition
C’est le mécanisme qui permet de construire une classe « fille », ou sous-classe, à partir d’une classe « mère ». La
classe fille ainsi obtenue hérite toutes les propriétés et toutes les fonctionnalités de son ancêtre. La classe « fille »
peut éventuellement ajouter des méthodes/attributs propres à elle et redéfinir les méthodes qui ont été héritées de
sa classe mère. La classe fille est une spécialisation de la classe mère.
L’héritage se fait ainsi selon la syntaxe suivante :

class nom_sous_classe(nom_classe_mère):
#définir les attributs et les méthodes de la sous_classe

III.2 Exemple 1
Nous proposons ci-après un exemple d’héritage entre la classe mère Point et la classe fille PointColoré :

class Point:
def __init__(self,a,b):
self.x=a
self.y=b
def Affiche(self):
print('Point',(self.x, self.y))
def deplacer(self, dx, dy) :
self.x += dx
self.y += dy
class PointColoré(Point):
def __init__(self,a,b,col):
Point.__init__(self,a,b) # ou bien super().__init__(a,b)
self.couleur = col
def Affiche(self):
print('PointColoré',(self.x, self.y,self.couleur))

>>> p2=PointColoré(2,3,'rouge'); p2.Affiche()

PointColoré (2, 3, 'rouge')
>>> p2.deplacer(1,1) #méthode héritée
>>> p2.Affiche()
PointColoré (3, 4, 'rouge')

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
7

III.3 Exemple 2
Comme exemple d’héritage à partir d’une classe native Python, nous proposons de définir une classe nommée
ListOfStr permettant de stocker dans une liste uniquement des valeurs de type str. La classe doit déclencher
une exception pour toute tentative d’insertion/substitution d'un élément par une valeur qui n’est pas un str.

class ListOfStr(list):

def __init__(self, source=()):

"""
Construit une instance initialement vide
"""
for item in source:
if not isinstance(item, str):
raise TypeError("type invalide !")
super().__init__(source)

def __repr__(self):
return "ListOfStr(({}))".format(super().__repr__())

def append(self, other):

if not isinstance(other, str):
raise TypeError(" type invalide !")
super().append(other)

def extend(self, other):

for item in other:
if not isinstance(item, str):
raise TypeError("type invalide !")
super().extend(other)

def __setitem__(self, index, item):

if not isinstance(item, str):
raise TypeError(" type invalide ! ")
super().__setitem__(index, item)

>>> l = ListOfStr(("ali", "med", "zied"))

>>> l.append("zeineb")
>>> l
ListOfStr((['ali', 'med', 'zied', 'zeineb']))
>>> l[0] = "salah"
>>> l.extend(("hedi", "salah"))
>>> l.sort() ; l
ListOfStr((['hedi', 'med', 'salah', 'salah', 'zeineb', 'zied']))

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
8

IV P OLYMORPHISME ET SURCHARGE

IV.1 Définitions et exemples

Le polymorphisme est le concept qui permet d’avoir différentes formes d’une méthode. Entre autres, il permet de
redéfinir des méthodes avec des fonctionnalités similaires.

Quand ce concept est appliqué aux méthodes spéciales, on l’appelle surcharge. Une méthode spéciale est en fait
une méthode dont le nom est donné par __nom__, exécutée sans appel explicite. Elle a un comportement par
défaut. On peut citer comme exemples :
__init__ : appelée lors de la création d’une instance de classe par nom_obj=nomClasse(paramètres)
__str__ : appelée par print(obj)
__add__ : appelée par obj1 + obj2

Exemple 1
La classe Etudiant hérite de la classe Personne.
class Personne:
def __init__ (self,nom):
self.nom=nom
def affiche(self):
print("je suis une personne")
class Etudiant(Personne):
def __init__(self,nom,cne):
super().__init__(nom)
self.cne=cne
def affiche(self):
print("je suis un étudiant")

>>> pr=Personne('Ali'); pr.affiche()

je suis une personne
>>> etd=Etudiant('Mohammed',123444); etd.affiche()
je suis un étudiant

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
9

Exemple 2 :
Il s’agit des méthodes calcul du périmètre et de l’aire dans les classes Carré et Disque.
class Carre :
” ” ” Un carré est modélisé par son coin supérieur gauche et une arête ” ” ”
def __init__ ( self, P, a ) :
self. coin = P
self.arete=a
def perimetre ( self ) :
return 4 * self.arete
def aire ( self ) :
return self.arete** 2

class Disque :
” ” ” Un disque est modélisé par son centre et son rayon ” ” ”
def __init__(self, c, r ) :
self.centre = c
self.rayon = r
def perimetre ( self ) :
return 2 * pi * self.rayon
def aire ( self ) :
return pi * self.rayon **2

>>> from math import pi

>>> p=Point(2,3); p1=Point(0,0);d=Disque(p,5);c=Carre(p1,2)
>>> d.perimetre(); c.perimetre()
31.41592653589793
8
>>> d.aire(); c.aire()
78.53981633974483
4

Exemple 3
La méthode spéciale __add__ (l’opérateur +) est surchargée dans des différentes classes (float, complex, str,..) :
>>> x1 = 3 ; x2 = 5.1 ; x2 + x1 #float.__add__(x2, x1)
8.1
>>>z1 = 3+4j; z2 = 2-3j; z2 + z1 #complex.__add__(z2,z1)
5+1j
>>> s1 = « ali » ; s2 = « med » ; s2 + s1 #str.__add__(s2, s1)
“medali”
>>> t1 = (5,2); t2 = (3,); t2 +t1 #tuple.__add__(t2, t1)
(3, 5, 2)

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
10

IV.2 Exemples de surcharge de méthodes spéciales

IV.2.1 Représentation formelle d’un objet

Pour afficher les informations relatives à un objet, en utilisant le nom de l’objet (représentation sur le shell) ou
en utilisant la commande print(), il faut surcharger la méthode spéciale __repr__ :

def __repr__(self):
return #la chaine qu’on veut afficher

Exemple
class point:
def __init__(self,a,b):
self.x=a
self.y=b
def __repr__(self):
return (str((self.x , self.y)))

>>>p=point(2,3)
>>>p # l’exécution de l’évaluation de p fait appel à __repr__
(2,3)
>>>print(p) # l’exécution de print fait appel à la méthode __repr__
(2,3)

IV.2.2 Représentation informelle d’un objet

Pour donner une représentation textuelle informelle à un objet, il suffit de surcharger la méthode spéciale
__str__ :

def __str__(self):
return #la chaine qu’on veut afficher

Exemple1 :

class point:
def __init__(self,a,b):
self.x=a
self.y=b
def __str__(self):
return 'point'+str((self.x , self.y))

>>>p=point(2,3)
>>>p #sans redéfinir __repr__ l’exécution renvoie la référence de l’objet
<__main__.point object at 0x033DAB10>
>>>print(p) # l’exécution de print fait appel à la méthode __str__
point(2,3)

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
11

Exemple2 :

class point:
def __init__(self,a,b):
self.x=a
self.y=b
def __repr__(self):
return ( str((self.x , self.y)))
def __str__(self):
return 'point'+str((self.x , self.y))

>>>p=point(2,3)
>>>p # l’exécution de l’évaluation de p fait appel à __repr__
(2,3)
>>>print(p) # l’exécution de print fait appel à la méthode __str__
point(2,3)

IV.2.3 Surcharge des opérateurs

La surcharge d’opérateurs permet la redéfinition et l’utilisation des opérateurs en fonction de la classe. Par
exemple, l’utilisation de l’opérateur + pour additionner deux objets de même type.

Python associe à chaque opérateur une méthode spéciale qu’on peut surcharger, on cite dans la suite quelques
exemples :

 Exemples des méthodes spéciales permettant la surcharge des opérateurs arithmétiques :

o opérateurs unaires :
 + : __pos__(self)
 - : __neg__(self)
o opérateurs binaires :
 + : __add__(self,other)
 * : __mul__(self, other)
 - : __sub__(self,other)
 …
 Exemples des méthodes spéciales permettant la surcharge des opérateurs de comparaison :
 == : __eq__(self,other)
 != : __ne__(self, other)
 > : __gt__(self,other)
 …
 Exemples des méthodes spéciales permettant la surcharge des opérateurs d’indexation :
 objet[i]: __getitem__(self,indice)
 objet[i]= v : __setitem__(self,indice,valeur)

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
12

V A PPLICATION : C REATION DES CLASSES P ILE ET F ILE

V.1 La classe Pile

V.1.1 Définition d’une pile

On rappelle qu’une pile est une structure de données qui suit le principe d’une pile d’assiettes, ˝ le dernier
arrivé est le premier servi˝, on parle du mode LIFO (Last In First Out). L’insertion ou la suppression d’un
élément ne peut se faire qu’à une seule extrémité, appelée sommet de la pile.
Une pile est définie par les opérations suivantes :
 Empiler: permet l’ajout d’un élément au sommet de la pile ;
 Dépiler: permet la suppression de l’élément au sommet de la pile si elle n’est pas vide ;
 Vérifier si une pile est vide ou non.
V.1.2 Implémentation d’une classe Pile

La classe Pile est définie par :

- L’attribut :
 liste : initialisé par une liste vide
- Les méthodes :
 empiler : permet l’ajout d’un élément donné à la fin de l’attribut liste
 depiler : permet de supprimer et retourner le dernier élément de l’attribut liste s’il existe
 est_vide : permet de vérifier si l’attribut liste est vide ou non
class Pile :
def __init__(self) :
self.liste=[ ]
def empiler (self, v) :
self.liste.append(v)
def depiler(self) :
if self.est_vide( )== False:
return self.liste.pop( )
def est_vide( self) :
return self.liste ==[ ]

V.2 La classe File

V.2.1 Définition d’une File

On rappelle qu’une file est une structure de données qui suit le principe d’une file d’attente, ˝ le premier arrivé
est le premier servi˝, on parle du mode FIFO (First In First Out).

Une file est définie par les opérations suivantes :

 enfiler : permet l’ajout d’un élément la fin de la file ;
 défiler : permet la suppression de l’élément au début de la file si elle n’est pas vide
 vérifier si une file est vide ou non
Programmation Orientée Objet
Révision Informatique, Concours MP-PC-T 2020
13

V.2.2 Implémentation d’une classe File

La classe File est définie par :

- L’attribut :
 liste : initialisé par une liste vide
- Les méthodes :
 enfiler : permet l’ajout d’un élément donné à la fin de l’attribut liste
 defiler : permet de supprimer et retourner le premier élément de l’attribut liste s’il existe
 est_vide : permet de vérifier si l’attribut liste est vide ou non

class File :
def __init__(self) :
self.liste=[ ]
def enfiler (self, v) :
self.liste.append(v)
def defiler(self) :
if not self.est_vide( ):
return self.liste.pop(0 )
def est_vide( self) :
return self.liste ==[ ]

V.3 Exemple d’inversion d’une pile

Il s’agit d’écrire une fonction Inverser (p) qui permet d’inverser une pile p :
- avec utilisation d’une file intermédiaire ;
- sans utilisation d’une file intermédiaire

#en utilisant une file intermédiaire #sans utiliser une file intermédiaire
def Inverser(p) : def Inverser(p) :
f1=file() p1=pile( )
while not p.est_vide( ): p2=pile( )
f1.enfier (p.depiler( )) while not p.est_vide( ):
while not f1.est_vide( ) : p1.empiler (p.depiler( ))
p.empiler( f1.defiler()) while not p1.est_vide( ) :
p2.empiler(p1.depiler())
while not p2.est_vide( ) :
p.empiler(p2.depiler())

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
14

VI E XERCICES D ’ APPLICATION

VI.1 Exercice 1
On s’intéresse à ordonner les éléments d’une file d’entiers dans l’ordre croissant. On suppose définie la classe
file, définir les méthodes suivantes :

1. taille_file(F) : qui permet de retourner la taille de la file F.

2. Permutation_Circulaire(F,n) : qui permet de réaliser n permutations circulaires à gauche.
3. Inserer_Elt (F,elt) qui permet d’insérer un élément dans une file F ordonnée selon l’ordre croissant .
4. Ordonner_file(F) qui permet, à partir d’une file F, de retourner une file FO ordonnée selon l’ordre
croissant.

VI.2 Exercice 2 : Extrait de l’examen SM-SP-IPEIT- Décembre 2018

Dans ce problème, on s’intéresse à une application de gestion de stocks des différents magasins d’une enseigne.
Un stock est composé par une collection d’articles. Un article admet une référence qui l’identifie, une
désignation, et un prix d’achat. Un article est vendu avec un taux de bénéfice qui peut être modifié lors des
promotions.
Afin de réaliser cette application, nous définissons une classe Article, une sous-classe ArticleEnPromo et une
classe Stock.
A- Classe Article :
Définir la classe Article en écrivant :
1. Une méthode constructeur __init__ qui permet d’initialiser les attributs ref, dsg, et prix_a de types
respectivement entier, chaine de caractères et réel. Ces attributs représentent les informations relatives à un
article, à savoir, la référence, la désignation et le prix d’achat.
2. Une méthode de représentation __repr__ qui permet d’afficher les différentes informations d’un article sous
forme d’un tuple comprenant la référence, la désignation et le prix d’achat.
3. Une méthode set_article qui permet de modifier une des informations relatives à un article. Elle prend en
paramètres :
 Self.
 type_modif de type entier pour identifier la modification: (1 : Modification de la référence, 2 :
Modification de la désignation, 3 : Modification du prix d’achat).
 modif qui représente l’information à modifier.
La méthode déclenche une exception intitulée TypeError si le type du paramètre modif ne coïncide pas
avec le type de l’attribut concerné par la modification.
Indication: L’instruction : raise nom_exception(msg)déclenche l’exception nom_exception en
affichant le message msg.

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
15

4. Une méthode prix_vente qui permet de calculer et retourner le prix de vente d’un article. Ce prix est calculé
à partir du prix d’achat de l’article et d’un pourcentage P en appliquant la formule suivante :
prix de vente= prix d’achat + prix d’achat × P.
Le pourcentage P est un paramètre de la méthode et admet par défaut la valeur 20%.

B- Classe ArticleEnPromo :
Définir la classe ArticleEnPromo qui hérite de la classe Article en écrivant :
1. Une méthode constructeur __init__ qui permet de définir les mêmes attributs de la classe Article et
d’initialiser l’attribut remise qui représente le taux de la remise accordée. Cette méthode prend en paramètre
self, un article et le taux de remise.

2. Une méthode prix_ventePromo qui permet de retourner le prix de vente après la promotion.

C- Classe Stock :
Définir la classe Stock sachant que cette classe admet un attribut LS de type liste. Chaque élément de LS est une
sous-liste qui comprend un article et la quantité en stock correspondante.
Pour cela, écrire:
1. Une méthode constructeur __init__ qui permet d’initialiser l’attribut LS par une liste vide.
2. Une méthode de représentation __repr__ qui permet d’afficher le contenu du stock. L’affichage sera fait
ligne par ligne où chaque ligne est de la forme suivante :
(référence,désignation,prix_achat) : quantité en stock.
3. Une méthode rechercher_article qui permet, à partir de la référence, de chercher un article dans le stock.
Elle retourne la désignation, le prix de vente et la quantité en stock de cet article s’il existe et None sinon.
4. Une méthode ajouter_article qui permet d’ajouter un nouvel article en stock.
5. Une méthode maj_qtstock qui permet, à partir de la référence d’un article et d’une quantité qt, de mettre à
jour la quantité en stock d’un article existant. Cette méthode prend de plus un paramètre type_maj de type
entier, il est égal à 1 dans le cas d’un ajout et -1 dans le cas d’une réduction.
6. Une méthode supprimer_article qui, à partir de la référence d’un article, permet de le supprimer.
7. Une méthode articles_prix qui permet de retourner la liste des articles dont le prix de vente est compris
entre prix1 et prix2.
8. Une méthode articles_promo_qt qui permet de créer et retourner une liste de tuples où chaque tuple
comprend l’article qui sera en promotion ainsi que son prix de vente initial et son prix de vente après
promotion.
Les articles qui seront en promotion sont ceux dont la quantité en stock est inférieure à une valeur qt_min.
Le taux de remise et la valeur qt_min sont donnés en paramètres.
9. Soit StockE un dictionnaire qui contient les stocks de n magasins d’une enseigne. Les clés de StockE sont
représentées par des entiers identifiant les différents magasins et les valeurs sont les stocks correspondants.
10.Ecrire un programme python qui permet de :
 saisir une référence ref d’un article.
 pour chaque magasin, afficher la quantité en stock de l’article identifié par la référence ref.
 déterminer et afficher la quantité totale en stock de cet article.

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
16

VII A LTERNATIVES DE CORRECTION POUR LES EXERCICES

VII.1 Corrigé Exercice 1

class file:
def __init__(self):
self.l=[]
def enfiler (self,v):
self.l.append(v)
def defiler(self):
if not self.est_vide():
return self.l.pop(0)
def est_vide(self):
return self.l==[]
# Question 1
def Taille(F):
f1=file()
n=0
while not F.est_vide():
f1.enfiler(F.defiler())
n+=1
while not f1.est_vide():
F.enfiler(f1.defiler())
return n

# Question 2
def permutation_circulaire(f,n):
if not f.est_vide():
for i in range(n):
f.enfiler(f.defiler())
# Question 3
def Inserer_Elt(F,elt):
if F.est_vide():
F.enfiler(elt)

else:
n=Taille(F)
ne=0
for i in range(n):
x=F.defiler()
ne+=1
if x<elt:

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
17

F.enfiler(x)
else:
break
F.enfiler(elt)
if x>elt:
F.enfiler(x)
if n-ne>0:
permutation_circulaire(F,n-ne)
# Question 4
def Ordonner_file(F):
FO=file()
while not F.est_vide():
e=F.defiler()
Inserer_Elt(FO,e)
return FO

VII.2 Corrigé Exercice 2

class Article:
def __init__(self,ref,dsg,prix_a):
self.ref=ref
self.dsg=dsg
self.prix_a=prix_a
def __repr__(self):
return'('+str(self.ref)+','+self.dsg+','+str(self.prix_a)+')'
def set_article(self,type_modif,modif,):
if type_modif==1:
if type(modif)!=int:
raise ValueError('erreur de type')
self.ref=modif
elif type_modif==2:
if type(modif)!=str:
raise ValueError('erreur de type')
self.dsg=modif
elif type_modif==3:
if type(modif)!=float:
raise ValueError('erreur de type')
self.prix_a=modif
def prix_vente(self,pourcentage=20):
return self.prix_a*(1+pourcentage/100)

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
18

class ArticleEnPromo(Article):
def __init__(self,A,remise):
Article.__init__(self,A.ref,A.dsg,A.prix_a)
self.remise=remise
def prix_ventePromo(self):
return self.prix_vente()*(1-self.remise/100)

class Stock:
def __init__(self):
self.LS=[]
def __repr__(self):
ch=''
for i in self.LS:
ch=ch+str(i[0])+':'+str(i[1])+'\n'
return ch
def recherche_article(self,ref):
for i in self.LS:
if i[0].ref==ref:
return i[0].dsg,i[0].prix_vente(),i[1]
return None

def ajouter_article(self,A,qt):
self.LS.append([A,qt])

def maj_qtstock(self,ref,qt,type_maj):
for i in self.LS:
if i[0].ref==ref:
if type_maj==1:
i[1]+=qt
else:
i[1]-=qt
break

def supprimer_Articles(self,ref):
for i in range(len(self.LS)):
if self.LS[i][0].ref==ref:
self.LS.pop(i)

def articles_prix(self,p1,p2):
L=[]
for i in self.LS:
pv=i[0].prix_vente()

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
19

if pv>=p1 and pv<=p2:

L.append(i[0])
return L
def articles_promo_qt(self,qt_min,remise):
L=[]
for i in self.LS:
if i[1]<qt_min:
x=ArticleSolde(i[0],remise)
L.append((x,x.prix_vente(),x.prix_venteSolde()))
return L
#main
while True :
try:
ref=int(input("donner le numéro du magasin: "))
break
except : continue
qt_T=0
for m in StockE:
for i in StockE[m].LS:
if i[0].ref==ref:
print(m,':',i[1])
qt_T+=i[1]

Programmation Orientée Objet

Révision Informatique, Concours MP-PC-T 2020
20

VIII B IBLIOGRAPHIE ET N ETOGRAPHIE

Ouvrages :

INFORMATIQUE Programmation et calcul scientifique en Python et Scilab, Thierry,Audibert & Amar Oussalah,
Edition ellipses,2014, ISBN:978-2-7298-84710

Apprendre à programmer avec Python , Gérard Swinnen, Edition Eyrolles, ISBN :978-2-212-13434-6

Supports de Cours

Support de Cours de H.Latrach POO, pour 2ème année préparatoire MP-PC, IPEIT, Année universitaire 2019-
2020.

Sites Web :

https://courspython.com/classes-et-objets.html

https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python

https://developpement-informatique.com/article/152/polymorphisme-en-python

Programmation Orientée Objet

Notions de Base : Rappel
Aide-Mémoire pour la préparation de l’épreuve
d’Informatique du Concours National d’Entrée aux
Ecoles d’Ingénieurs MP-PC-T 2020

Elaboré par :

Houcemeddine Filali (IPEIM)

Laila Hammami (IPEIN)
Houssemeddine Bouzidi (IPEIM)
Wafa Meftah (IPEIS)
Hayet Latrach (IPEIT)
Mohamed Hammami (IPEIEM)
Besma Fayech (ENSIT)

-- Avril 2020 --
[Tapez ici]

Préambule

Ce document est destiné aux étudiants de deuxième année MP-PC-T des Instituts
Préparatoires aux Etudes d’Ingénieurs.

Dans les circonstances exceptionnelles liées à la crise sanitaire mondiale et nationale du

Covid19, un ensemble de supports de révision pour le programme d’informatique du
concours national d’entrée aux écoles d’ingénieurs ont été élaborés essentiellement par les
membres de la commission informatique du concours, suite à une action bénévole.

Le but de ces supports est d’accompagner les étudiants de tout le territoire Tunisien dans
leur révision en leur fournissant à tous les mêmes documents, afin d’assurer une équité
entre eux, qu’ils bénéficient ou non d’un enseignement ou tutorat à distance.

Toutefois, ces documents sont considérés comme des aide-mémoires et ne remplacent pas
les cours assurés en présentiel.

Le document présent comporte un rappel sur les notions de base associées à Python comme
la manipulation des itérables, les structures de contrôle, les fichiers mais également sur la
récursivité et la complexité algorithmique.

Notions de base : Rappel

[Tapez ici]

Table des matières

I Introduction ........................................................................................................................................................................ 1
II Variable et affectation ........................................................................................................................................................ 1
III Opérateurs .......................................................................................................................................................................... 2
IV Classes élémentaires........................................................................................................................................................... 2
V Opérations d'entrée/sortie ................................................................................................................................................. 3
VI Structures de contrôle ........................................................................................................................................................ 4
VII Classes itérables .............................................................................................................................................................. 5
VII.1 Opérations communes aux itérables ........................................................................................................................... 5
VII.2 Les séquences ............................................................................................................................................................. 6
VII.2.1 Opérations communes aux séquences .............................................................................................................. 6
VII.2.2 La classe str ....................................................................................................................................................... 7
VII.2.3 La classe list ....................................................................................................................................................... 8
VII.2.4 La classe tuple ................................................................................................................................................... 8
VII.3 Les itérables non ordonnés ......................................................................................................................................... 9
VII.3.1 La classe set ....................................................................................................................................................... 9
VII.3.2 La classe dict.................................................................................................................................................... 10
VIII Construction des itérables en compréhension .............................................................................................................. 11
VIII.1 Listes en compréhension ........................................................................................................................................... 11
VIII.2 Tuples en compréhension ......................................................................................................................................... 11
VIII.3 Ensembles en compréhension ................................................................................................................................... 12
VIII.4 Dictionnaires en compréhension ............................................................................................................................... 12
IX Import de bibliothèques ou modules ................................................................................................................................ 12
X Les sous-programmes ........................................................................................................................................................ 13
XI Gestion des exceptions ..................................................................................................................................................... 15
XII Gestion des fichiers ....................................................................................................................................................... 15
XII.1 Fichiers textes ........................................................................................................................................................... 15
XII.2 Fichiers binaires ........................................................................................................................................................ 17
XIII La récursivité................................................................................................................................................................. 17
XIV Complexité algorithmique............................................................................................................................................. 18
XIV.1 Calcul du coût ............................................................................................................................................................ 18
XIV.2 Complexité asymptotique ......................................................................................................................................... 19
XIV.3 Classes de complexité asymptotique ......................................................................................................................... 19
Bibliographie et Netographie ................................................................................................................................................... 20

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 1

I Introduction
Python est un langage de programmation multi-paradigmes (procédural, orienté objet et fonctionnel) et
dynamiquement typé. Sa version standard est libre et est disponible sur le site officiel de Python « python.org ».
La version Pyton3.X est adoptée par le programme officiel du cycle préparatoire. Cette version inclut un grand
nombre de modules pré-programmés fournis d’office, tels que math, cmath, random, etc., mais n'inclut pas les
modules tels que numpy, scipy et matplotlib qu'il faut importer explicitement au besoin. Un module regroupe des
ensembles de variables et de fonctions apparentées, que l’on appelle également bibliothèque.
Anaconda est une solution comportant l’interpréteur Python livré avec plusieurs environnements de développement
intégrés (IDLE, spyder, Jupyter) et inclut une panoplie de modules (numpy, scipy et matplotlib) mais qui nécessite
beaucoup de ressources.

II Variable et affectation
Une variable est une référence associée à un objet déjà créé en mémoire. Elle n'a pas de type et n'est pas déclarée.
Toute variable doit être affectée avant son utilisation. L'identificateur (nom) de la variable ne peut contenir que des
caractères alphanumériques et le caractère '_' et ne débutant pas par un chiffre.

L’affectation permet d’associer un nom à un objet (instance d'une classe) en mémoire :

>>> nom = objet nom id(nom)== id(nom1)

Objet
ou bien
Ainsi une affectation de la forme : nom is nom1
nom1 Classe de l’objet
>>> nom1 = nom
référence le même objet avec autre nom (nom1). type(nom)

On obtient le type d'un objet à l'aide de la fonction type(objet) et son adresse mémoire désignant son identité à
l'aide de id(objet).

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 2

III Opérateurs

Description Opérateurs Exemples/Remarques

Affectation v = valeur x = 5
v1=v2=v3= valeur x = y= z = t = 5
v1,v2,v3=valeur1,valeur2,valeur3 x, y, z = 1, '2', 5
Parenthèses () (x+y)*2 #donne 6

Opérations arithmétiques
Puissance x**y # ou pow(x,y) 1j**2 #donne -1+0j
Signes +;-

Opérateurs multiplicatifs x*y ;x / y # produit et 4/2 #donne

division réelle de x par y 2.0(float)
x//y ; x%y #quotient et 4//2# donne 2 (int)
reste de division entière de x 4%2 # donne 0
par y
Opérateurs additifs x+y ; x -y

Opérateurs relationnels

Comparaison d’identité is
is not

Comparaison de valeur x==y ; x!=y 2!=5 # donne True

2==5 # donne False
Comparaison riche < ; > ; <= ; >=

Opérateurs logiques
Produisent un booléen and ; or ; not
(bool)
Opérateurs avec assignation

Produisent le même x += y # x = x + y
résultat que l'affectation x -= y # x = x  y
du résultat de l'opération x *= y # x = x * y
effectuée
x /= y # x = x / y
x //= y # x = x // y
x %= y # x = x % y
x **= y # x = x ** y

IV Classes élémentaires
Les classes élémentaires sont immuables (non modifiables). Les opérations appliquées aux instances de ces classes
génèrent de nouvelles instances comme le montre l'exemple suivant :

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 3

>>> x=5
>>> id(x)
2053437424
>>> x+=1 # x référence une nouvelle instance
>>> id(x)
2053437440

Classes élémentaires Description Exemples / Remarques

NoneType Classe de l’objet None (objet type(None) # donne NoneType
n'ayant pas de valeur)
Bool Booléens type(True) # donne bool
bool(20) # donne True
True et False sont les seules
bool(0) # donne False
instances de cette classe.
x=y=2; x==y # donne True
x,y=1,2; x==y # donne False
Int Entiers relatifs (Z) y=2 ; type(y) # donne Int
x = int('52') # x prend 52
int(22.5) # donne 22
Float Nombres flottants (IR ) y=3.5 ; type(y) #donne Float
x = float('22.2')#x prend 22.2
x = -1e33 #x prend -1e+33
Complex Nombres complexes (C) z = 3+1j #ou z = complex(3,1)
type(z) # donne Complex
complex(5) # donne(5+0j)
z.real # donne 3.0 (float)
z.imag # donne 1.0 (float)
z.conjugate() # donne 3-1j
Remarque
bool (x) # retourne False si l'évaluation de x est nulle et True autrement
int(x) # retourne un entier si x est un nombre ou une chaine de caractère contenant
un nombre entier.
float(x) # retourne un réel si x est un nombre ou une chaine de caractère contenant
un nombre réel.

complex(x,y) # retourne un nombre complex formé par la partie réelle x et la partie

imaginaire y.

V Opérations d'entrée/sortie

Description Syntaxe Exemples

Sortie print(expr1, … , exprn) print('bienvenue à la formation')

Entrée nom = input() >>> nom= input('votre nom svp: ')

nom = input("message") votre nom svp: Foulen
Input prend (optionnel) et
>>> print('Bonjour',nom)
retourne une chaîne de
caractères Bonjour Foulen

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 4

VI Structures de contrôle
Un bloc de code est un groupe d’instructions Python indentées précédées par ":". Un bloc peut en inclure d'autres.

Description Syntaxe Exemples

Structure conditionnelle
Permet de conditionner if cond : #maximum de 3 entiers x, y, z
l'exécution d'un ou plusieurs bloc1 if x > y and x >z :
blocs d’instructions, mais un elif cond2 : print(x)
seul est exécuté. bloc2 elif y > z:
… print(y)
else : else :
blocn print(z)
Boucle conditionnelle

Permet d’exécuter un bloc while cond_exécution : #pgcd de x et y

tant que la condition bloc while x % y != 0 :
d'exécution de la boucle est x, y = y, x % y
à True. print(y)
La condition est toujours
testée avant l’exécution du
bloc de la boucle.
Permet d’exécuter un bloc while True : #saisie d’une voyelle
jusqu’à ce que la condition bloc while True:
d’arrêt devienne True. La if cond_arrêt : v=input('saisir une voyelle:')
condition d’arrêt est break if v in ['a','e','i','o','u','y']:
toujours testée après break
l’exécution du bloc de la
boucle.
Boucle NON conditionnelle
Permet d’exécuter le bloc for v in itérable: #calcul du produit des éléments d’une
bloc liste
pour chaque élément v de
l’itérable. Un itérable est une p = 1
collection d’objets (voir for v in [1,8,7]:
section VII sur les itérables). p*=v

Expression conditionnelle
Python offre la possibilité de expr1 if cond1 else #maximum de 2 valeurs x ,y
former des expressions dont expr2 m = x if x > y else y
l’évaluation est soumise à
une condition. Le résultat #les éléments négatifs de L1 sont
est l’évaluation de remplacés par 0 dans L2 (voir
expression1 si la condition l’itérable liste dans la section VII)
est True, et celle de L1=[-1,0,5,3]
expression2 sinon. expr1 if cond1 else L2=[0 if x<0 else x for x in L]
Cette construction ne permet expr2 if cond2 else
pas l’utilisation du mot expr3 x=int(input("?"))
réservé elif mais on peut ">0" if x>0 else "<0" if x<0 else "=0"
emboîter deux expressions
conditionnelles.

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 5

VII Classes itérables

Les classes itérables ou conteneurs permettent de conserver une collection d’objets. Ces classes peuvent se ramifier
selon deux critères :
 La mutabilité : classes modifiables (list, set, dict) et classes non modifiables (range, str et tuple).
 L’ordre : classes ordonnées appelées encore séquences (str, tuple, list, range) et classes non ordonnées (set
et dict).

VII.1 Opérations communes aux itérables

Le tableau suivant présente quelques opérations communes applicables aux instances des itérables.

Description Syntaxe Exemples / Remarques

Taille d’un itérable len(iter) lst = [1,2,5]
len(lst) #donne 3
Test d’appartenance d’un x in iter 5 in (1,5,[1,3]) # donne True
élément x à un itérable x not in iter 3 not in (1,5,[1,3]) # donne True
"li b" in "ali baba" # donne True
"Ali" in "ali baba" # donne False
Somme des éléments d’un sum(iter) sum([1,5,2,10]) # donne 18
itérable (itérable de valeurs
numériques uniquement).
Valeur maximale/ minimale max(iter) max([1,5,2,10]) # donne 10
min(iter) l = (1+3j,2+5j,11j); max(l)# Error
TypeError pour un itérable
comportant des objets non min(1,5,2,10) # donne 1
comparables
Tri d’un itérable d’objets sorted(iter) d = {'med':10, 'ali':20, 'lilia':5}
comparables (TypeError si sorted(d) # donne ['ali', 'lilia',
l’itérable comporte un objet 'med']
non comparable) sorted(d, reverse = True) # donne
Renvoie une liste contenant l'ordre inverse['med', 'lilia', 'ali']
les éléments dans l’ordre.
Parcours d’un itérable for item in iter : lst = [1,2,5]
#opérations for e in lst:
manipulant item print(e)
Énumération des éléments enumerate(iter) ch = "cem"
d’un itérable enumerate(iter, for i, v in enumerate(ch):
start_index)
print(i, v)
# donne en sortie
0 c
1 e
2 m

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 6

VII.2 Les séquences

Les itérables ordonnés, appelés encore séquences (tuple, liste et chaîne), conservent l’ordre dans lequel les
éléments ont été créés. Ainsi, chaque élément d’une séquence possède un indice indiquant sa position relative
par rapport aux autres éléments. Les indices commencent à partir de 0 pour un parcours de la gauche vers la
droite.

Un intervalle défini par range, également considéré comme une séquence, est un itérable ou conteneur formé
par une succession d’entiers.

range(debut, fin, pas) génère l’intervalle [debut, fin [ par pas entier relatif égal à pas.

VII.2.1 Opérations communes aux séquences

Le tableau suivant liste quelques opérations communes à toutes les séquences.

Description Syntaxe Exemples / Remarques

Indexage simple s[i] s = 'python'
avec 0 ≤ 𝑖 ≤ 𝑙𝑒𝑛(𝑠) − 1 ou s[0] #donne 'p'
−𝑙𝑒𝑛(𝑠) ≤ 𝑖 ≤ −1 s[len(s)-1] #ou s[-1] donne'n'
s[len(s)] # IndexError
Morcelage (Slicing) # fin non inclus s = 'python'
s[dep:fin:pas]
s[ ::-1] # donne 'nohtyp'
#pas par défaut égal à 1 s[ :2] # donne 'py'
s[dep:fin]
s[2:] # donne 'thon'
#du début avec pas=1
s[ :fin] s[::2] # donne 'pto'
#jusqu'à la fin avec pas=1
s[dep :]
Concaténation s1 + s2 [1,2] + [3] # donne [1,2,3]
(1,2) + (3,) # donne (1,2,3)
'med' + 'ali'# donne 'medali'

Répétition n * s # ou bien s * n [0] * 3 # donne [0,0,0]

avec n entier Naturel (1,2) * 2 # donne (1,2,1,2)
'bon' * 2 # donne 'bonbon'

Comptage du nombre s.count(item) lst = [0,1,0,1,1,1]

d’occurrences lst.count(1) # donne 4
ch ="ali baba"
ch.count("a") # donne 3
Retour de l’index d’un # première occurrence lst.index(0) # donne 0
item s.index(item)
lst.index(0,1)# donne 2
Déclenche ValueError si # à partir de start
lst.index(5) # ValueError
s.index(item, start)
item not in s.
Parcours d’un itérable for ind in range(len(iter)): lst = [1,2,5]
indexé #opérations manipulant for i in range(len(lst)):
iter[ind]
print(lst[i])

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 7

VII.2.2 La classe str

Une chaîne est une séquence non modifiable et ordonnée de caractères. Le tableau suivant résume les
principales opérations applicables aux chaînes.

Description Syntaxe Exemples / Remarques

Création d’une chaîne de #chaîne simple: s = "bonsoir" # ou encore
caractères ("…" ,'…') s = 'bonsoir'
#chaîne multilignes: s1="""chaîne
(""" … """ ,''' …''') multi-
lignes"""
#équivalente à
s1 = 'chaîne\nmulti-\nlignes'
Retour d’une chaîne en Ch.lower ( ) Ch='fG15Z'
minuscule identique à Ch Ch.lower( ) # donne 'fg15z'

Retour d’une chaîne en Ch.upper ( ) Ch='fG15Z'

majuscule identique à Ch Ch.upper ( ) # 'FG15Z'

Retour d’une liste des sous- Ch.split(sep) Ch='Epsilon 2018/2019'

chaînes en utilisant un séparateur Ch.split( ) # donne
sep ['Epsilon', '2018/2019']
Ch.split('0') # donne [Epsilon
Par défaut, le séparateur est le 2', '18/2', '19']
caractère espace
Retour d’une chaîne identique à Ch.strip(sep) Ch="*la chaîne*"
Ch en supprimant les Ch.strip('*')
occurrences d’un séparateur sep # donne 'la chaîne'
du début et de la fin si elles
existent. Par défaut sep est
l'espace.
Retour d’une chaîne de Sep.join(itérable) L=['abc','12','azer']
caractères résultante de la '/'.join(L)
concaténation par sep des # donne 'abc/12/azer'
chaînes de l’itérable ' '.join(L)
TypeError est généré si l’itérable # donne 'abc 12 azer'
contient un objet qui n'est pas de
type str.
Retour d’une chaîne de Ch.format(paramètres) Ch = 'Epsilon {}/{}'
caractères en remplaçant chaque Ch.format(2019,2020)
‘{}’ par les paramètres passés à # donne 'Epsilon 2019/2020'
la méthode (objets de classes
quelconques).
Retour de l’Unicode (entier) du ord(caractère) ord ('A') # 65
caractère passé en paramètre ord('a') # 97

Retour du caractère associé à la chr(entier) chr(65) # donne 'A'

valeur UNICODE passée chr(10) # donne '\n'
paramètre.

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 8

VII.2.3 La classe list

Une liste est une séquence, ordonnée et modifiable, d’éléments éventuellement hétérogènes séparés par une
virgule et délimitée par une paire de crochets.
Le tableau suivant résume les principales fonctions/méthodes applicables aux listes.

Description Syntaxe Exemples

Création d’une liste vide L=[ ] #ou L=[1, 'python', True, 1+1j]
L=list( )

Création d’une liste à L=list(itérable) list('ABCA') # donne ['A','B','C','A']

partir d’un itérable list({3, 'A',4}) # donne [3,4,'A']
list((2,2,(1,2)))# donne [ 2,2,(1,2)]
list({2 :45, 'x':[1,2]}# donne [2,'x']
list(145)# TypeError
Ajout d’un objet à la fin L.append (objet) L.append(2020) ; L
d’une liste #donne [1, 'python', True, (1+1j), 2020]
#remplissage d'une liste par n chaînes
lst = list()
for i in range(n):
x = input("donner l[{}]:".format(i))
lst.append(x)
Ajout d’un objet x dans L L.insert(i,x) L.insert(-1 ,'concours') ; L # donne
à l’indice i [1,'python',True,(1+1j),'concours',2020]

Suppression de la première L.remove(x) L.remove(1+1j) ; L # donne

occurrence d’un l'objet x [1, 'python', True, 'concours', 2020]
dans L
ValueError si x not in L.
Ajout d’éléments de L.extend(t) L.extend({-1,2}) ; L # donne
l’itérable t à la fin de L [1,'python',True,'concours',2020,2,-1]
Suppression et retour du L.pop() L.pop() # donne -1
dernier élément de L L # donne
[1,'python',True,'concours',2020,2]
Suppression et retour de L.pop(i) L.pop(2) # donne True
l’élément d’indice i de la L # donne
liste L [1, 'python', 'concours', 2020, 2]

VII.2.4 La classe tuple

Un tuple est une séquence, ordonnée et non modifiable, d’éléments éventuellement hétérogènes séparés par
une virgule. Le tableau suivant résume les principales fonctions/méthodes applicables aux tuples :

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 9

Description Syntaxe Exemples

Création d’un tuple vide t=( ) #t=tuple( )

Création d’un tuple d’un t=objet , T=255,

seul objet (singleton) T # donne (255,)
T1=[12,5],1
T1 #donne ([12,5], 1)
Création d’un tuple à L=tuple(itérable) tuple({3,'A',4}) # donne (3,'A',4)
partir d’un itérable tuple((2,2,(1,2))) # donne (2,2,(1,2))

VII.3 Les itérables non ordonnés

VII.3.1 La classe set

Un ensemble est une collection d'éléments distincts non ordonnés et encadrés par des accolades. La classe
set représente la notion d’ensemble en mathématique. Un ensemble doit impérativement comporter des
éléments non modifiables. La création d'ensembles de listes, de dictionnaires ou d'ensembles déclenche une
erreur. Le tableau suivant résume les principales fonctions/méthodes applicables aux ensembles.

Description Syntaxe Exemples/ Remarques

Création d’un s = set()
ensemble vide NB : s={} ne crée pas un
ensemble
Création d’ensemble à s = set(iter) s = set("010101")
partir d’un itérable iter s={e0, …,en} s # donne {'0','1'}
ou avec les délimiteurs s = set(3.25) # TypeError
Ajout d’un objet s.add(obj) s = set()
s.add(5) ; s # donne {5}
s.add("eps"); s #donne{5,“eps”}
s.add([1,2,3]) #TypeError

Suppression d’un objet s.discard(x) s = {1,7,2} ; s.remove(1)

s.remove(x) s # donne {2,7}
s-= {obj} s.remove(5) # KeyError
s -= {2} ; s # donne {7}
Union : s1 U s2 s1 | s2 s = {1,2} | {2,3}
s1.union(s2) s # donne {1,2,3}
Intersection : s1 ∩ s2 s1 & s2 s = {1,2} & {2,3}
s1.intersection(s2) s # donne {2}
Différence : s1 \ s2 s1 – s2 s = {1,2} – {2,3}
s1.difference(s2) s # donne {1}
Différence Symétrique s1 ^ s2 s = {1,2}^{2,3}
s1 ∆ s2 s1.symmetric_difference(s2) s # donne {1,3}

Inclusion : s1 ⊂ s2 s1 <= s2 {1,2} <= {1,2,5}# donne True

{1,2} <= {1,2} # donne True
Inclusion stricte : s1 < s2 {1,2} < {1,2,5} # donne True
s1 ⊊ s2 s1.issuperset(s2) {1,2} < {1,2} # donne False

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 10

VII.3.2 La classe dict

Un dictionnaire est une structure modifiable et non ordonnée d'associations (clé : valeur). Les clés sont
impérativement des objets non modifiables. L'utilisation de listes, de dictionnaires ou d'ensembles comme
clé déclenche une erreur. Les valeurs sont des objets de classes quelconques.

Description Syntaxe Exemples / Remarques

Création d’un d = dict()
dictionnaire vide d = {}

Création d’un d= dict(iter) t = [(5,2), "ab", [1,2] ]

dictionnaire à partir d’un d={c1:v1 , …, cn:vn} dict(t) #donne {1:2, 5:2, 'a':'b'}
itérable de couples ou d = {'a': 3, 'b': 5, 4j: 33}
directement
Test d’appartenance k in d 33 in d # donne False
d’une clé k à un k not in d 'a' in d # donne True
dictionnaire d
Accès à une entrée du d[k] d = {'a': 3, 'b': 5, 4j: 33}
dictionnaire d d.get(k) d['a'] # donne 3
d.get(k, vdef) d['c'] # donne KeyError
d.get('c') # None
d.get('c', 0) #0
Mise à jour / insertion d[k] = val d = {}
d’une entrée dans le d.update({k :val}) d['a'] = 33 # insertion
dictionnaire d d # donne {'a' :33}
d['a'] = 22 # mise à jour
d # donne {'a':22}
Copie de dictionnaire d.copy() d = {1:2}
d1 = d.copy()
d[1] = {2} ; d1 # donne {1:{2}}
d # donne {1:2}
Suppression d’une d.pop(k) d = {1:2, 'a':10}
entrée de à partir de sa del d[k] del d[1]; d # donne {'a':10}
clé d.pop('a') # donne la valeur 10
d # donne {}
Parcours des clés d’un for k in d: d = {1:2, 'a':10}
dictionnaire traitements for k in d:
#ou encore print(k)
for k in d.keys()
traitements
Parcours des valeurs for v in d.values(): for v in d.values():
d’un dictionnaire traitements print(v)

Parcours des couples for k, v in d.items(): for k, v in d.items():

clé, valeur d’un traitement print(k,v)
dictionnaire

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 11

VIII Construction des itérables en compréhension

La construction des itérables en compréhension permet de générer des conteneurs de façon concise et élégante. On
peut créer des listes en compréhension, des tuples en compréhension, des ensembles en compréhension et des
dictionnaires en compréhension à l'aide du constructeur de la classe ou les délimiteurs des itérables mutables.

VIII.1 Listes en compréhension

[expression for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n ]
ou encore
list(expression for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n )

- Les conditions if sont facultatives (conditions de filtrage).

- L’ordre d’imbrication des boucles est de la gauche vers la droite.
- On peut utiliser le constructeur list à la place des délimiteurs.
- expression peut elle même être un itérable en compréhension.
Exemples
>>> L= [ i for i in range(1, 21, 2) ] ; L
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> L=[ (i,j) for i in range(1,3) for j in range(1,4) ] ; L
[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3)]
>>> L=[i*j for i in range(1,5) for j in range(1,5) ] ; L
[1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16]
>>> L=[(i,j) for i in range(1,5) if i%2 for j in range(1,5) if (i+j)%2==0]; L
[(1, 1), (1, 3), (3, 1), (3, 3)]
>>>[[(100*i+j)//2 if j%2==0 else 100*i+j for j in range(1,i+1)] for i in
range(1,5)]
[[101], [201, 101], [301, 151, 303], [401, 201, 403, 202]]

VIII.2 Tuples en compréhension

tuple( expression for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n )
Attention : sans le constructeur tuple, la construction en compréhension produit un générateur et non pas
un tuple.

Exemple

tuple((i,j) for i in range(1,5) if i%2 for j in range(1,5) if (i+j)%2==0 )

((1, 1), (1, 3), (3, 1), (3, 3))

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 12

VIII.3 Ensembles en compréhension

set(expression for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n )
ou encore

{ expression for indice_1 in iterable_1 if condition_1 …

for indice_n in iterable_n if condition_n}

Exemple

>>> e={(x,y) for x in range(5) if x%2 for y in range(5) if y%2==0 }

# ou bien e=set((x,y) for x in range(5) if x%2 for y in range(5) if y%2==0)
>>> e
{(1, 2), (3, 2), (3, 0), (1, 4), (1, 0), (3, 4)}

VIII.4 Dictionnaires en compréhension

{cle: valeur for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n }
ou encore

dict((cle,valeur) for indice_1 in iterable_1 if condition_1 …

for indice_n in iterable_n if condition_n)
Exemple:

>>>d={ x:y for x in range(10) if x%2 for y in range(10) if y%2==0}

#ou bien d=dict((x,y) for x in range(10) if x%2 for y in range(10) if y%2==0)
>>>d
{1: 8, 3: 8, 9: 8, 5: 8, 7: 8}

IX Import de bibliothèques ou modules

Il y a trois manières d’import de modules :

 1ère manière d’import :

 Import du module désigné par nom_module mais pas les fonctions qui y sont contenues :
import nom_module

Exemples : import math # import du module math

import random # import du module random

 L’appel de chaque fonction du module se fait par :

nom_module.fonction(…)

Exemples : math.ceil(7.8989) # partie entière supérieure qui est 8

random.randint(0,10) # retourne un entier aléatoire entre 0 et 10

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 13

 2ème manière d’import :

 Utilisation d’un alias :
import nom_module as alias

Exemple : import math as m

 L’appel de chaque fonction du module se fait par :
alias.fonction(…)

Exemple : m.sqrt(4)# retourne la racine carrée de 4 : 2.0

 3ème manière :
 Accès direct à toutes les fonctions du module par :
from nom_module import *
Exemple : from math import *
 Accès direct à une ou quelques fonctions du module par :
from nom_module import nom_fonc1,…,nom_foncp

Exemple : from math import pi,sqrt,ceil

Dans les deux cas, l’appel de chaque fonction du module se fait directement par son nom : nom_fonction(…)
Exemple : sqrt(5) #donne 2.23606797749979

X Les sous-programmes

Une fonction est un bloc d’instructions indentées (corps de la fonction) destiné à réaliser une opération. Elle peut
recevoir des paramètres et renvoie éventuellement un résultat. L’appel d’une fonction Python retourne toujours un
objet, par défaut None. Dans le corps de la fonction ce retour est spécifié à l’aide de l’instruction return.

Le tableau suivant résume les concepts de base associés aux fonctions Python.

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 14

Description Syntaxe Exemples(s) / Remarques

Définition d’une fonction où les def nom_f(paramètres) : #fonction avec paramètres
paramètres sont optionnels corps de nom_f def f(x,y) :
import math
return x**2 + math.sin(y)
#fonction sans paramètres
def g():
whileTrue:
s = input("donner une
chaîne alphabétique : ")
if s.isalpha():
return s
Appel d’une fonction : #arguments positionnels
nom_f(arguments) print(f(3,2))
- Arguments positionnels
nom_f(n_arg1=v1 , …,
- Arguments nommés (ordre
arguments n'a plus d'importance) n_argp=vp) #arguments nommés
r = f(y = 2, x = 3)
Les paramètres nommés doivent
apparaître à la fin
Retour d’une fonction return expression #Définition
L’instruction return permet de #Une fonction sans def f(x) :
retourner un résultat à l’appelant return retourne l’objet if x >0 :
None
d’une fonction. return x**0.5
Cette instruction engendre la #Appel
sortie immédiate du code de la print(f(4)) # affiche 2.0
fonction et le retour vers print(f(-4)) # affiche None
l'appelant.
Paramètres optionnels def f(x,y,z=val_def) : # cette déclaration génère
corps de f SyntaxError
Les paramètres optionnels sont
associés à une valeur par défaut def h(x, y = 5, t) :
(évaluée une seule fois au moment corps
de la définition de la fonction).
Si l’argument associé au # déclaration de f
paramètre n’est pas indiqué lors de def f(x, y = 6) :
l’appel, Python utilise la valeur return x + y
par défaut pour substituer le
paramètre optionnel. #Appel de f
Les paramètres optionnels doivent print(f(1,3)) # affiche 4
apparaître à la fin de la séquence print(f(3)) # affiche 9
des paramètres.

Fonctions lambda lambda paramètres : f = lambda x : x**2

résultat #équivalente à
Elle permet de créer une
def f(x) :
expression de type fonction.
return x**2

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 15

XI Gestion des exceptions

Les exceptions sont des objets spéciaux permettant de représenter une erreur d’exécution dans un script Python. Il
existe plusieurs types d’erreurs : TypeError, ValueError, IndexError. Ces derniers sont des classes Python
héritant toutes de la classe de base Exception permettant de représenter une Erreur quelconque. La table suivante
résume les opérations de gestion d’erreur.

Description Syntaxe Exemple(s) / Remarque(s)

Déclencher une raise Exception(" message ") raise Exception()
exception
Prévoir une if cond_erreur :
exception raise Exception("message" )
ou bien
assert not cond_erreur,
"message"

Intercepter une try : #saisie d’un entier positif (avec

bloc gestion d’erreur)
exception
except : def f():
bloc_cas_erreur while True:
else : try:
bloc_cas_pas_erreur x=int(input('x'))
finally : except:
bloc_tous_les_cas print ('erreur')
else:
if x>0:
return x

XII Gestion des fichiers

Un fichier est une collection d’informations, généralement structurées d’une manière ou d’une autre, placées sur
une mémoire de masse.

XII.1 Fichiers textes

Un fichier texte contient une succession de caractères séquentiels. Lors de l’ouverture d’un fichier texte, un
encodeur assure la conversion des octets lus/écris en lettres UNICODE. Voici les principales fonctions/méthodes
pour le traitement des fichiers.

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 16

Fonctions /Méthodes Description/Exemples

f=open(nom_du_fichier,'r') Ouvre le fichier nom_de_fichier (donné sous la forme d’une
chaîne de caractères indiquant son emplacement) en lecture ( r
comme read). Le fichier doit exister et seule la lecture est
autorisée. L'ouverture d'un fichier inexistant génère une erreur.
L'utilisation de la clause try … except est indiquée pour gérer cette
situation.
f=open(nom_du_fichier,'w') Ouvre le fichier nom_de_fichier en écriture (w comme write). Si
le fichier n’existe pas, il est créé, sinon il est écrasé. f est le fichier
logique associé au fichier physique donné par nom_du_fichier.
f=open(nom_du_fichier,'a') Ouvre le fichier nom_de_fichier en ajout (a comme append).
Identique au mode 'w', sauf que si le fichier existe, il n’est pas
écrasé et l'ajout se fait en fin du fichier.
f.close() Ferme un fichier ouvert par la fonction open.
f.read() Fournit l'intégralité du contenu du fichier sous forme de chaîne de
caractères (à ne réserver qu’aux fichiers de taille raisonnable).
f.readlines() Fournit la totalité du contenu du fichier sous forme d’une liste de
chaînes de caractères.
Le caractère de saut de ligne '\n' présent à la fin de chaque chaîne
indique la fin de chaque ligne.
f.readline() Fournit la ligne courante sous forme d’une chaîne de caractères et
place le curseur sur la ligne suivante. Elle renvoie la chaîne vide
si fin du fichier.
f.write(s) Écrit la chaîne s à partir de la position courante du fichier.
f.writelines(T) Écrit l’ensemble des éléments de T dans le fichier f comme des
T doit être une chaîne de sous chaînes ou lignes successives. Le caractère de saut de ligne '\n' présent à la
un itérable de chaînes fin de chaque chaîne indique la fin de chaque ligne.
Parcours d'un fichier
Parcourir un fichier ouvert en lecture se try:
fait comme le parcours d'un itérable : f = open("nomf.txt","r")
parcourir ses lignes avec une boucle for except:
sans passer par readlines.
print(" fichier introuvable !")
for ligne in f :
else:
[instructions]
for ligne in f:
print(ligne)
f.close()

On n'est jamais à l'abri d'une erreur quand on manipule des fichiers et qu'on oublie de les fermer. Le mot réservé
with du langage python, permet d'éviter cette situation et dont voici sa syntaxe générale :
with open (mon_fichier, mode) as variable :
# Opérations de manipulation du fichier

L'exemple précédent s'écrit alors :

try:
with open ('fp.txt','r') as f :
for ligne in f:
print(ligne)
except:
print(" fichier introuvable !")

Notions de base : Rappel

 Révision Informatique, Concours MP-PC-T 2020 17

XII.2 Fichiers binaires

Dans un fichier binaire les informations sont transférées de la RAM vers le support de stockage sans aucun
formatage (aucun encodeur n’est utilisé). Pour les fichiers binaires, le mode d’ouverture est suffixé par 'b' :
'wb', 'rb' et 'ab'. La manipulation d'un fichier binaire n'est pas une fin en soi et cela ne présente aucun
intérêt pour l'utilisateur. L'intérêt à ce niveau est de pouvoir utiliser le module pickle permettant de
sérialiser/désérialiser des objets (entier, réel, chaîne, liste, dictionnaire, etc.) dans leur format et non pas sous
forme de suite de caractères.
Sérialiser un objet, à l'aide de la méthode dump, consiste à le transformer en une suite d’octets afin de pouvoir
le stocker dans un fichier binaire. Désérialiser, à l'aide de la méthode load, consiste à récupérer les objets dans
leur format initial.
>>>import pickle
>>>pickle.dump(objet, fichier_binaire)
>>>objet = pickle.load(fichier_binaire)
Remarque : load génère une erreur si plus d'objets à lire, l'utilisation du try … except s'impose.

XIII La récursivité
Une fonction récursive est une fonction dont le corps contient un ou plusieurs appels à elle-même.
Un traitement récursif nécessite de déterminer :
 le cas trivial ou encore le cas d'arrêt
 le traitement récurrent et de s'assurer que ce dernier atteindra le cas d'arrêt (terminaison).
Dans le tableau suivant, on donne deux exemples de problèmes résolus de façon récursive.
Problème Démarche Solution récursive
def factorielle(n):
Calcul de la On raisonne par récurrence sur n if n<=1:
factorielle de n  Cas trivial : 0 ! = 1 return 1 #cas trivial
𝒏 else:
𝒏! = 𝒊  𝑛! = 𝑛 × (𝑛 − 1)! return n*factorielle(n-1)
𝒊 𝟏

Tri Fusion Le tri fusion est un tri récursif qui def fusion_Rec(L1,L2):
applique le principe "diviser pour if L1==[]:
régner". return L2
Pour une liste L, le principe du tri fusion if L2==[]:
est le suivant : return L1
 si L est de taille 1, elle est triée et on if L1[0]<L2[0]:
la retourne (cas trivial) ; return [L1[0]]+fusion_Rec(L1[1:],L2)
 sinon on divise L en deux sous-listes else:
L1 et L2 presque égales ( return [L2[0]]+fusion_Rec(L1,L2[1:])
L1[0:len(L)//2] et L2[len(L)//2:
len(L)] ) : def tri_fusion_Rec(L):
 on applique récursivement if len(L)<=1:
l’algorithme de tri par fusion à L1 return L
puis à L2 L1=[L[x] for x in range (len(L)//2)]
 on fusionne les L1 et L2 triées. (La L2=[L[x] for x in range (len(L)//2,
fusion est également effectuée de len(L))]
manière récursive où le cas trivial Return fusion_Rec(tri_fusion_Rec(L1,
est l'épuisement de l'une des 2 listes tri_fusion_Rec(L2))
et on retourne l'autre).

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 18

XIV Complexité algorithmique

XIV.1 Calcul du coût

Le temps d’exécution d’un programme dépend fortement de la machine qui l’exécute, du langage dans lequel il
est écrit et de l’algorithme sous-jacent. Pour des données de grandes tailles, l’algorithme est la cause
déterminante du temps d’exécution d’un programme. Des méthodes rationnelles permettent de calculer le coût
d’un programme exprimé en nombre d’opérations élémentaires exécutées par la machine afin d’obtenir le
résultat final. Généralement, ce nombre est fonction de la taille n des données à traiter.
Le coût se calcule comme suit :
 Coût d’une opération élémentaire op = 1.
 Coût d'une séquence de k instructions p_1 ; p_2 ; … p_k = ∑𝒌𝒊 𝟏 𝒄𝒐û𝒕(𝒑𝒊 ) .
 Coût d'une structure conditionnelle simple if c: p else : q <= coût(c) + max(coût(q),coût(p)).
 Coût d'une structure conditionnelle complète if c_1: p_1 elif c_2 : p_2 … elif c_i : p_i … else : p_k+1
= (∑𝒌𝒊 𝟏 𝒄𝒐û𝒕(𝒄𝒊 )) + 𝐦𝐚𝐱 𝒄𝒐û𝒕(𝒑𝒊 ).
𝟏 𝒊 𝒌 𝟏
 Coût d'une boucle for i in iterable : p_i = ∑ ∈ é 𝑐𝑜û𝑡(𝑝𝑖)
 Coût d'une boucle while c : p est le plus difficile à exprimer (nombre d'itérations non connu à priori)
majorer le nombre de répétitions => NombreRépétitions*( 𝑐𝑜û𝑡(𝑐)+ 𝑐𝑜û𝑡(𝑝))+1* 𝑐𝑜û𝑡(𝑐)

Exemple : Calcul xn
- Approche naïve :
def puiss1(x,n):
r = 1 #1 affectation
for i in range(n): # n affectations
r*= x # 1 affectation + 1 multiplication
return r # 1 retour

Le Coût total = f(n) = 2n + 2.

- Exponentiation rapide :
def puiss2(x,n):
r= 1 # 1 affectation
u= x # 1 affectation
while n != 0: # (int(log2(n)) + 1) comparaisons
if n % 2 == 1: #2 = modulo + comparaison
r*= u #2 = multiplication + affectation
u*= u #2 = multiplication + affectation
n//= 2 #2 = division + affectation
return r #1 retour

Le Coût total = f(n) = 9 E[log2(n)]+ 3.

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 19

XIV.2 Complexité asymptotique

La complexité asymptotique consiste à estimer l’ordre de grandeur du nombre d’opérations effectuées par un
programme sans effectuer un décomptage minutieux. Cette complexité est exprimée en Grand-O (notation de
Landau).
Soit f, g : ℕ → ℝ∗ deux fonctions. 𝑓(𝑛) est dite 𝑂(𝑔(𝑛)) ⇔ 𝑓 est dominée par 𝑔 quand 𝑛 → +∞.

• 𝑓(𝑛) est 𝑂(𝑔(𝑛)) et 𝑐 une constante, alors :

 𝑐 + 𝑓(𝑛) est aussi 𝑂(𝑔(𝑛)).
 𝑐 𝑓(𝑛) est aussi 𝑂(𝑔(𝑛)).
 Les facteurs constants sont ignorés dans le calcul de la complexité asymptotique.
• 𝑓 (𝑛) est 𝑂(𝑔 (𝑛)) est 𝑓 (𝑛) est 𝑂(𝑔 (𝑛)), alors :
 𝑓 (𝑛) + 𝑓 (𝑛) est 𝑂 𝑔 (𝑛) + 𝑔 (𝑛) .
 𝑓 (𝑛)𝑓 (𝑛) est 𝑂(𝑔 (𝑛)𝑔 (𝑛)).
• 𝑓 (𝑛) est 𝑂(𝑓 (𝑛)) et 𝑓 (𝑛) est 𝑂 𝑓 (𝑛) , alors :
 𝑓 (𝑛) est 𝑂(𝑓 (𝑛)).

XIV.3 Classes de complexité asymptotique

Nom de la classe Complexité Exemples

Constante 𝑂(1)  Accès à un élément d’une liste l[i].
 Additionner multiplier un nombre constant d’objets.
Logarithmique 𝑂(log(𝑛))  Recherche dichotomique 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Méthode de bissectrices pour trouver le zéro d’une fonction
𝑛= .
 Exponentiation rapide.
 Trouver l’écriture d’un entier n dans une base b.
Linéaire 𝑂(𝑛)  Trouver le maximum/minimum d’une liste 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Tester l’appartenance d’un élément dans une liste 𝑛 =
𝑙𝑒𝑛(𝑙𝑠𝑡).
 Produit scalaire de deux vecteurs.
Quasilinéaire 𝑂(𝑛 log (𝑛))  Trier une liste lst.sort() : 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Tri fusion / Tri rapide
Quadratique 𝑂(𝑛 )  Tri par sélection/insertion/bulles 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Remplissage d’une matrice carrée.
 Somme de deux matrices carrées
Polynomiale 𝑂(𝑛 ) 𝑜ù 𝑝 ≥ 2  Multiplication de deux matrices 𝑂(𝑛 ).
 Réduction de Gauss.
 Inversion d’une matrice.
Exponentielle 𝑂(𝑐 ) 𝑜ù 𝑐 > 1  Trouver tous les sous-ensembles d’un ensemble de taille n.
 Trouver un mot de basse de taille n par brute force.
 Afficher toutes les valeurs binaires qui s’écrivent sur n bits.
Factorielle 𝑂(𝑛!)  Résoudre le problème du voyageur du commerce (avec n =
nombre de villes) par brute force.
 Trier une liste de taille n par brute force.
Exemples :
 4 𝑛 + 100000000 est 𝑂(𝑛).  2 +𝑛 est 𝑂(2 ).
 100 𝑛 + 𝑛 + 300000 𝑛 est 𝑂(𝑛 ).  2 + 𝑛! est 𝑂(𝑛!).

Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 20

Bibliographie et Netographie

Ouvrages

Learning Python, Mark Lutz, Edition O’Reilly, Juin 2013, ISBN: 9781449355722.

Informatique pour tous en classes préparatoires aux grandes écoles, Benjamin Wack & al., Edition Eyrolles,
Août 2013, ISBN: 978-2-212-13700-2.

Supports de Cours

Support de Cours de H.Filali et H.Bouzidi, Rappel, pour 2ème année préparatoire sections MP-PC-T, IPEIM,
Année universitaire 2019-2020.

Support de Cours de Laila Hammami pour 1ère année préparatoire sections MP-PC-T, IPEIN, Année
universitaire 2019-2020.

Support de Cours de W.Meftah, Rappel, pour 2ème année préparatoire sections MP-PC-T, IPEIS, Année
universitaire 2019-2020.

Sites Web :

https://www.python-course.eu/

https://www.ics.uci.edu/~brgallar/index.html

Notions de base : Rappel

Simulation Numérique et
Applications
Aide-Mémoire pour la préparation de l’épreuve
d’Informatique du Concours National d’Entrée aux
Ecoles d’Ingénieurs MP-PC-T 2020

Elaboré par :

Mohamed Hammami (IPEIEM)

Houcemeddine Filali (IPEIM)
Laila Hammami (IPEIN)
Wafa Meftah (IPEIS)
Hayet Latrach (IPEIT)
Besma Fayech (ENSIT)

-- Avril 2020 --
[Tapez ici]

Préambule

Ce document est destiné aux étudiants de deuxième année MP-PC-T des Instituts
Préparatoires aux Etudes d’Ingénieurs.

Dans les circonstances exceptionnelles liées à la crise sanitaire mondiale et nationale du

Covid19, un ensemble de supports de révision pour le programme d’informatique du
concours national d’entrée aux écoles d’ingénieurs ont été élaborés essentiellement par les
membres de la commission informatique du concours, suite à une action bénévole.

Le but de ces supports est d’accompagner les étudiants de tout le territoire Tunisien dans
leur révision en leur fournissant à tous les mêmes documents, afin d’assurer une équité
entre eux, qu’ils bénéficient ou non d’un enseignement ou tutorat à distance.

Toutefois, ces documents sont considérés comme des aide-mémoires et ne remplacent pas
les cours assurés en présentiel.

Le document présent comporte une description de quelques bibliothèques utiles à

importer, comme numpy, scipy ou matplotlib, pour la résolution, entre autres, de
problèmes mathématiques, simulation numérique ou traitement d’images. Des
applications associées à des algorithmes de cryptage sont aussi exposées. Plusieurs
exercices et leurs corrigés sont intégrés dans ce document.

Pour les différentes bibliothèques, quelques fonctions seulement parmi les plus utilisées
sont décrites. Aussi, toutes les applications présentées sont données juste à titre d’exemple
et ne constituent en aucun cas un ensemble complet.

Simulation numérique et Applications

[Tapez ici]

Table des matières

I Introduction ........................................................................................................................................................................ 3
II Les bibliothèques numpy, matplotlib et scipy ..................................................................................................................... 3
II.1 La bibliothèque numpy ............................................................................................................................................... 3
II.1.1 Vecteurs ............................................................................................................................................................ 4
II.1.2 Matrices ............................................................................................................................................................ 5
II.2 La bibliothèque matplotlib .......................................................................................................................................... 8
II.2.1 Utilisation de la fonction plot ............................................................................................................................ 9
II.2.2 Subdivision régulière d’un intervalle ............................................................................................................... 11
II.3 La bibliothèque scipy................................................................................................................................................. 12
II.3.1 Présentation .................................................................................................................................................... 12
II.3.2 Le module optimize ......................................................................................................................................... 12
II.3.3 Le module integrate ........................................................................................................................................ 13
III Application au Traitement d’images .................................................................................................................................. 15
III.1 Présentation et définitions ........................................................................................................................................ 15
III.2 Traitement des images sous Python .......................................................................................................................... 16
III.3 Exercice pour quelques traitements d’image ............................................................................................................ 17
IV Application à la cryptographie .......................................................................................................................................... 19
IV.1 Définition .................................................................................................................................................................. 19
IV.2 Le chiffrement de César............................................................................................................................................. 19
IV.2.1 Principe ........................................................................................................................................................... 19
IV.2.2 Exercice : Chiffrement César ............................................................................................................................ 20
IV.3 Le chiffrement de Vigenère ....................................................................................................................................... 20
IV.3.1 Principe ........................................................................................................................................................... 20
IV.3.2 Exercice : Chiffrement de Vigenère.................................................................................................................. 21
IV.4 Le chiffrement RSA .................................................................................................................................................... 21
IV.4.1 Principe ........................................................................................................................................................... 21
IV.4.2 Exercice : Chiffrement RSA .............................................................................................................................. 21
V Autres Exercices d’application ........................................................................................................................................... 22
V.1 Méthodes de résolution d’un système linéaire ......................................................................................................... 22
V.2 Méthodes de recherche de zéros d’une fonction....................................................................................................... 26
VI Alternatives de corrections pour les exercices .................................................................................................................. 29
VI.1 Corrigé des exercices de traitement d’image ............................................................................................................. 29
VI.2 Corrigés des exercices sur les algorithmes de cryptage ............................................................................................. 32
VI.3 Corrigé des méthodes de résolution d’un système linéaire ....................................................................................... 36
VI.4 Corrigé des méthodes de recherche de zéros d’une fonction .................................................................................... 38
Bibliographie et Netographie ................................................................................................................................................... 42

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
3

I Introduction

Python offre une panoplie de bibliothèques intéressantes pour, entre autres, la simulation numérique et le calcul
scientifique. Dans ce but, nous exposerons dans ce qui suit les principales fonctionnalités de Numpy, Matplotlib
et Scipy. Nous présenterons ensuite des applications liées au traitement d’image et à la cryptographie, en plus de
plusieurs exercices d’application avec leurs corrigés.

II Les bibliothèques numpy, matplotlib et scipy

II.1 La bibliothèque numpy

numpy est une bibliothèque numérique apportant le support efficace de manipulation des tableaux (uni, bi et
multi-dimensionnel) ainsi que les opérations mathématiques de haut niveau (fonctions spéciales, algèbre
linéaire, statistiques, etc.). La bibliothèque numpy doit être importée avant toute utilisation.
Le module numpy contient entre autres la classe numpy.ndarray, proposant des outils similaires à la classe
list, toutefois les tableaux modélisés sont de taille fixe et ayant des éléments de même type (entiers, flottants,
booléens).

>>>import numpy as np
>>>a=np.array([1,4,5,8])
>>>b=np.array([[1,2],[3,4],[5,6]],dtype=float)
>>>c=np.array([[[1,2],[1,2]],[[1,2],[1,2]]])
>>>print(a)
[1 4 5 8]
>>>print(b)
[[ 1. 2.]
[ 3. 4.]
[ 5. 6.]]
>>>print(c)
[[[1 2]
[1 2]]
[[1 2]
[1 2]]]
>>>c[1,1,1]
2
Nous limiterons notre propos aux tableaux uni et bi-dimensionnel appelés aussi vecteurs et matrices.

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
4

II.1.1 Vecteurs

En Python la fonction numpy.array permet de créer un vecteur qui est un tableau à une dimension. Pour
créer un vecteur il suffit de passer l'itérable contenant les éléments comme argument.

>>>v=np.array([-1,3.,0,-2,5,8,0,22,0,-5]) #l'itérable est une liste

>>>print(v)
[ -1. 3. 0. -2. 5. 8. 0. 22. 0. -5.]

Les fonctions size retourne le nombre d’éléments d’un vecteur et la fonction ndim retourne la dimension
qui est 1 dans le cas d’un vecteur (2 pour une matrice).

>>>np.size(v); v.size #de façon équivalente

10
10
>>>np.ndim(v); v.ndim #de façon équivalente
1
1
L’accès à un élément ou une tranche d’éléments (slicing) se fait comme pour les listes.
>>>v[0]
-1.0
>>>v[len(v)-1]
-5.0
>>>v[2:];v[:3];v[4:8]
array([ 0., -2., 5., 8., 0., 22., 0., -5.])
array([-1., 3., 0.])
array([ 5., 8., 0., 22.])
>>>v[-1]
-5.0

Les fonctions empty, zeros, ones, arange, linspace permettent aussi la création de vecteurs
particuliers.

Fonctions Description Syntaxe

Empty Construit un vecteur non initialisé (le contenu est totalement np.empty(taille)
imprédictible ou aléatoire).

Zeros Construit un vecteur dont les éléments sont nuls np.zeros(taille)

Ones Construit un vecteur dont les éléments sont tous 1 np.ones(taille)

Arange Construit un vecteur à partir d’un intervalle d’entiers np.arange(d,f,p)

Linspace Construit un vecteur de points équidistant dans un intervalle np.linspace(a,b,n)

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
5

Exemple

>>>v1=np.linspace(-1,1,10)
>>>print(v1)
[-1. -0.77777778 -0.55555556 -0.33333333 -0.11111111 0.11111111
0.33333333 0.55555556 0.77777778 1. ]
>>>v2=np.arange(10)
>>>print(v2)
[0 1 2 3 4 5 6 7 8 9]
>>>type(v2)
<type 'numpy.ndarray'>
>>>v3=np.arange(2,10,2)
>>>print(v3)
[2 4 6 8]
>>>v4=np.zeros(8);v5=np.ones(6,dtype=int)
>>>print(v4);print(v5)
[ 0. 0. 0. 0. 0. 0. 0. 0.]
[1 1 1 1 1 1]
1

Les opérations sur les vecteurs sont possibles avec les opérateurs classiques de Python, tels que décrit ci-
dessous.

>>>u=np.array([1,2,3,4]);v=np.array([5,6,7,8])
>>>u+v
>>>v-u
>>>u*2
>>>v**3
>>>u*v
>>>v/u

II.1.2 Matrices

Pour créer une matrice en Python, qui est un tableau à deux dimensions, il suffit de passer un itérable
d'itérables (liste de listes, liste de tuples, tuple de tuples, etc.) comme argument à la fonction array.

>>>m=np.array([[1.2,2.5],[3.2,1.8],[1.1,4.3]]) # une liste de listes

>>>print(m)
[[ 1.2 2.5]
[ 3.2 1.8]
[ 1.1 4.3]]

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
6

Les fonctions size, shape et ndim retournent respectivement le nombre d’élément, nombre de
lignes/colonnes et la dimension. Par exemple :

>>>np.size(m);np.shape(m);np.ndim(m) #ou bien les attributs m.size;

m.shape ; m.ndim
6
(3, 2)
2
1

La fonction reshape permet de redimensionner un vecteur ou une matrice, comme décrit ci-après :

>>>m1=np.reshape(np.arange(10),(2,5))
#ou bien m1 = np.arange(10).reshape((2,5))
>>>print(m1)
[[0 1 2 3 4]
[5 6 7 8 9]]
>>>m.reshape(2,3)
array([[ 1.2, 2.5, 3.2],
[ 1.8, 1.1, 4.3]])

Les fonctions empty, zeros, ones, eye et diag permettent de créer des matrices particulières.

Fonctions Description Syntaxe

empty Construit une matrice non initialisée (l lignes et c colonnes) np.empty((l,c))

zeros Construit une matrice nulle np.zeros((l,c))

ones Construit une matrice dont les éléments sont tous 1 np.ones((l,c))

eye Construit une matrice identité d’ordre n np.eye(n)

diag Construit une matrice diagonale np.diag(L)

Exemple

>>>m2=np.zeros((2,4));m3=np.ones((3,3),dtype=int);
>>>m4=np.eye(4); m5=np.diag([1,2,3])
>>> print('m2=',m2);print('m3=',m3);print('m4=',m4);print('m5=',m5)
m2= [[0. 0. 0. 0.]
[0. 0. 0. 0.]]
m3= [[1 1 1]
[1 1 1]
[1 1 1]]
m4= [[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
7

[0. 0. 0. 1.]]
m5= [[1 0 0]
[0 2 0]
[0 0 3]]

L’accès à un élément d’une matrice se fait à l’aide d’indexage 𝐴[𝑖, 𝑗] où 𝑖 désigne la ligne et 𝑗 la colonne. On
peut également récupérer une partie d’une matrice : ligne, colonne et sous-matrice. Par exemple :

>>>A=np.array([[1,2,3],[4,5,6],[7,8,9]],dtype=int)
>>>A[1,0];A[2,2]
4
9
>>>A[0,:];A[:,1]
array([1, 2, 3])
array([2, 5, 8])
>>>A[0:1,:];A[:,1:2]
array([[1, 2, 3]])
array([[2],
[5],
[8]])

Les opérations algébriques sur les matrices sont possibles avec les opérateurs classiques de Python.

>>>A+A
array([[ 2, 4, 6],
[ 8, 10, 12],
[14, 16, 18]])
>>>A-A
array([[0, 0, 0],
[0, 0, 0],
[0, 0, 0]])
>>>A*2
array([[ 2, 4, 6],
[ 8, 10, 12],
[14, 16, 18]])

Pour le produit matriciel, il faut utiliser la fonction dot, comme l’exemple suivant :

>>>np.dot(A,A)# ou bien A.dot(A)

array([[ 30, 36, 42],
[ 66, 81, 96],
[102, 126, 150]])

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
8

La trace et la transposé s’obtiennent avec les fonctions trace et transpose. Par exemple :

>>>np.trace(A) # ou bien A.trace()

15
>>> A.transpose() # ou bien A.T
array([[1, 4, 7],
[2, 5, 8],
[3, 6, 9]])

Le déterminant, le rang, l’inverse, les valeurs propres et les vecteurs propres s’obtiennent respectivement par
les fonctions det, matrix_rank, inv, eigvals et eig du module numpy.linalg. Par exemple :

>>>np.linalg.det(A)
6.66133814775e-16
>>>np.linalg.matrix_rank(A)
2
>>>np.linalg.inv(A)
[[ -4.50359963e+15 9.00719925e+15 -4.50359963e+15]
[ 9.00719925e+15 -1.80143985e+16 9.00719925e+15]
[ -4.50359963e+15 9.00719925e+15 -4.50359963e+15]]
>>>np.linalg.eigvals(A)
[ 1.61168440e+01 -1.11684397e+00 -1.30367773e-15]
>>>np.linalg.eig(A)
(array([ 1.61168440e+01, -1.11684397e+00, -1.30367773e-15]),
array([[-0.23197069, -0.78583024, 0.40824829],
[-0.52532209, -0.08675134, -0.81649658],
[-0.8186735 , 0.61232756, 0.40824829]]))

Pour finir, la fonction solve du module numpy.linalg permet de résoudre le système linéaire 𝐴 ⋅ 𝑥 = 𝑏

>>>print(np.linalg.solve(A,np.array([1,0,1])))
[ -9.00719925e+15 1.80143985e+16 -9.00719925e+15]

II.2 La bibliothèque matplotlib

Le module matplotlib.pyplot est un sous module de la bibiliothèque matplotlib qui fournit des outils
de traçages graphiques qu'on peut paramétrer, semblables à ceux du logiciel Matlab.
Pour l’utiliser, on procédera toujours de la manière suivante :
- Appeler la fonction clf() (clean figure) pour effacer la figure précédente et en commencer une nouvelle.
- Tracer des courbes, nuages de points, en appelant (éventuellement plusieurs fois) la fonction plot().
- On remarquera que rien n’est affiché, seul un objet est créé par Python, d'où l'intérêt du paramétrage.
- Paramétrer le graphique (axes, titre, légendes etc.) en utilisant les fonctions adéquates.
- Afficher le graphique avec la fonction show() ou le sauvegarder avec la fonction savefig(). On dispose
alors d’une image (différents formats possibles).

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
9

II.2.1 Utilisation de la fonction plot

Cette fonction peut être utilisée de nombreuses manières différentes, pour obtenir des résultats assez fins.
L’idée générale est de lui donner en argument deux tableaux de nombres, décrivant respectivement les
abscisses et les ordonnées des points à tracer. Sans autre option, ces points sont reliés par des segments
bleus, en traits pleins.
Exemple 1

import matplotlib.pyplot as plt

x = [1, 3, 4, 2]
y = [2, 1, 4, 2]
plt.clf()
plt.plot(x,y)
plt.show()
plt.savefig("ex_base_01.png")

Les options graphiques permettent notamment de modifier le type de segment (pointillés, sans segment),
d’afficher ou non un marqueur au niveau de chaque point et de changer la couleur de ces objets.
Exemple 2

import matplotlib.pyplot as plt

x = [1, 3, 4, 2]
y = [2, 1, 4, 2]
plt.clf()
plt.plot(x,y,marker='o',color='r',linestyle='--')
plt.show()
plt.savefig("ex_base_02.png")

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
10

On peut enfin appeler plusieurs fois la fonction plot successivement. Les tracés sont alors superposés.
Exemple 3

import matplotlib.pyplot as plt

x = [1.5, 3, 3.5, 2]
y = [3, 2, 4, 2]
plt.clf()
plt.plot(x,y,marker='x',color='y',linestyle='-.')
plt.plot([1,4],[1,4])
plt.show()
plt.savefig("ex_base_03.png")

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
11

II.2.2 Subdivision régulière d’un intervalle

Pour tracer une fonction, on trace en fait des cordes de cette fonction, à partir d’une subdivision de
l’intervalle considéré. La fonction linespace() de la bibliothèque numpy permet de créer automatiquement
de telles subdivisions, avec un nombre de points à régler manuellement.
Exemple
Pour tracer le graphe de la fonction 𝑥 ↦ 𝑥 sur [0,1] avec une subdivision en 100 segments, donc en utilisant
101 points, on peut utiliser le code suivant :

import matplotlib.pyplot as plt

from numpy import linspace
x = linspace(0,1,100)
y = [t**3 for t in x]
plt.clf()
plt.plot(x,y)
plt.xlabel("t")
plt.ylabel(" t^3 ")
plt.title("courbe de la fonction puissance")
plt.show()
plt.savefig('ex_numpy_01.png')

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
12

II.3 La bibliothèque scipy

II.3.1 Présentation

Scipy est une bibliothèque numérique d’algorithmes et de fonctions mathématiques, basée sur les tableaux,
complétant ou améliorant (en termes de performance) les fonctionnalités de la bibliothèque numpy.
La librairie Scipy contient de nombreuses boîtes à outils consacrées aux méthodes de calcul scientifique :
- Fonctions spéciales : scipy.special (fonctions de Bessel, erf, gamma, etc.)
- Intégration numérique : scipy.integrate (intégration numérique ou d’équations différentielles)
- Méthodes d’optimisation : scipy.optimize (minimisation, moindres-carrées, zéros d’une fonction)
- Interpolation : scipy.interpolate
- Transformées de Fourier : scipy.fftpack
- Traitement de signal : scipy.signal (convolution, corrélation, filtrage, ondelettes, etc.)
- Algèbre linéaire : scipy.linalg
- Statistiques : scipy.stats (fonctions et distribution statistiques)
- Traitement d’images multidimensionnelles : scipy.ndimage
- Entrées/Sorties : scipy.io

II.3.2 Le module optimize

Ce module propose des fonctions qui permettent de déterminer des valeurs approchées des zéros d’une
fonction :
- fsolve : déterminer la racine d’une équation scalaire ou vectorielle.
- bisect : permet d’implémenter la méthode de recherche par dichotomie.
- newton : permet d’implémenter la méthode de recherche newton.

Exemple

import scipy.optimize as spo

f = lambda x : x**2-2
a,b=1,2
x1=spo.fsolve(f,a)
x2=spo.bisect(f,a,b)
x3=spo.newton(f,a)
>>>x1
array([ 1.41421356])
>>>x2
1.4142135623724243
>>>x3
1.4142135623730947

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
13

II.3.3 Le module integrate

L’extension scipy.integrate propose des fonctions pour calculer des intégrales simples, doubles ou
même triples et aussi de résoudre des équations différentielles de premier ou second ordre.

- quad : permet de calculer la valeur d’une intégrale simple.

- trapz : implémente la méthode des trapèzes.
- simps : implémente la méthode de simpson.
- odeint : résout numériquement des équations différentielles.

Exemple
import math
import scipy.integrate as spi
h = lambda x:math.cos(x)
y=spi.quad(h,0.0,math.pi/2.0)
>>>y
(0.9999999999999999, 1.1102230246251564e-14)
La fonction odeint résout numériquement des équations différentielles avec des conditions initiales de la
forme : = 𝑓(𝑦(𝑡), 𝑡)

Exemple : on souhaite résoudre l’équation = 2𝑡𝑦 avec 𝑡 ∈ [0,2] et 𝑦(0) = 0,2

from numpy import linspace

import scipy.integrate as spi
k = lambda y,t:2*t*y**2
t = linspace(0,2,10)
y0 = 0.2
y = spi.odeint(k,y0,t)
>>>y
array([[ 0.2 ],
[ 0.20199509],
[ 0.20822631],
[ 0.2195123 ],
[ 0.23753682],
[ 0.26557403],
[ 0.31034526],
[ 0.38756059],
[ 0.5436259 ],
[ 1.00000647]])

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
14

La représentation graphique des solutions de cette résolution peut être donnée par :

import matplotlib.pyplot as plt

plt.plot(t,y)
plt.show()

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
15

III Application au Traitement d’images

III.1 Présentation et définitions

Les appareils photographiques numériques sont actuellement omniprésents via des supports variés comme les
téléphones portables ou les tablettes numériques. Ils permettent le stockage d’un grand nombre d’images et ils
proposent également des options de retouches.
La suite présente quelques aspects du traitement mathématique et informatique des images numériques.
 Pixel :
Le terme pixel provient de l’abréviation anglaise « PiCture ELement » qui signifie élément d’image. Un
pixel est l’unité de base qui permet de mesurer la définition d’une image numérique.
 Image numérique :
Une image numérique est une matrice de n lignes et p colonnes dont les coefficients sont les valeurs des
pixels. Donc, il est possible d’avoir facilement accès à la grille des pixels et de faire des traitements
matriciels directs sur les images.
 Image en niveau de gris :
Dans le cas des images numériques en niveaux de gris, la valeur du pixel est généralement enregistrée dans
l’ordinateur ou l’appareil photo numérique sous forme de nombres entiers entre 0 et 255 soit 256 valeurs
possibles pour chaque pixel. La valeur 0 est attribué au noir, 255 correspond au blanc et les pixels entre 0 et
255 représentent les niveaux de gris (ou nuances de gris).
 Image couleur :
Une image couleur est en fait la réunion de trois images : une rouge, une verte et une bleue.
Chaque pixel est alors représenté par un triplet (Red, Green, Blue), chacun étant un entier codé sur 8 bits.
Exemple :(255,0,0) correspond à un pixel rouge, (0,255,0) représente un pixel vert, (0,0,255) est le pixel
bleu. Par additivité (255,0,255) devient le pixel magenta.

Remarque : Sur une image en niveaux de gris, chaque pixel est ou bien noir (0) ou bien blanc (255) ou bien
possède un niveau de gris entre les deux. Cela signifie que les trois composantes R, G, B ont la même valeur.

Si R = G = B = 0, le pixel est noir.

Si R = G = B = 255 (valeur maximale), le pixel est blanc.

Dans la suite de cette partie, les traitements ne s’appliquent qu’à des images en niveaux de gris, il est possible
d’opérer sur des images couleurs en appliquant les traitements proposés sur chacune des trois couleurs du
triplet.

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
16

III.2 Traitement des images sous Python

Python propose plusieurs modules qui permettent de faire des traitements sur des images de différents
formats (.jpg, .jpeg, .png, bmp …) comme le module PIL ou les module ndimage et misc de la
bibliothèque scipy ou le module pyplot de la bibliothèque matplotlib.
Dans la suite, on propose l’utilisation du module pyplot de la bibliothèque matplotlib qui permet de
charger une image directement sous forme d’un tableau numpy (de type ndarray).
 Lecture d’une image :
La fonction imread permet d’interpréter un fichier image comme un tableau numpy.
>>>import numpy as np
>>>import matplotlib.pyplot as plt
>>>M=plt.imread("mon_image.png")

 Affichage d’une image :

La fonction imshow permet d’afficher une image (si c’est un tableau numpy).
>>>M1=M[50:101 , 50:101]
>>>plt.imshow(M1)
>>>plt.show()

 Sauvegarde des images :

La fonction imsave permet de sauvegarder une image.
>>>plt.imsave("sous_image.png")
 Création d’une image :
Créer une image revient à construire un tableau numpy puis le représenter sous forme d’image à l’aide du
module pyplot de matplotlib.
>>>import numpy as np
>>>import matplotlib.pyplot as plt
>>>check=np.zeros((8,8)) #exemple pour image en niveau de gris
>>>check[::2,1::2]=255
>>>check[1::2,::2]=255
>>>plt.imshow(check)
>>>plt.show()
>>>plt.imsave("echequier.png")

>>>import numpy as np
>>>import matplotlib.pyplot as plt
>>>check=np.zeros((8,8,3),dtype='uint8') #exemple pour image couleur
>>>check[:,1:,::2]=255
>>>plt.imshow(check)
>>>plt.show()

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
17

III.3 Exercice pour quelques traitements d’image

 Binarisation :
Binariser une image consiste à la partitionner en deux parties : une partie sombre et une partie claire selon un
seuil s de niveau de gris.
1. Ecrire le script de la fonction Python permettant la binarisation d’une image donnée.

 Contraste :
Le contraste peut être modifié par l’application de fonctions mathématiques. Par exemple, en remplaçant la
valeur de chaque pixel par sa racine carrée, l’image assombrie alors qu’elle s’éclaircit si la valeur du pixel
est remplacée par son carré. Ces fonctions ont pour effet de diminuer le contraste.
Une autre idée consiste à faire un réajustement linéaire des valeurs des pixels selon :
𝑓: [0,256[ → [0,256[
𝑦 = 𝑥 + 0,4. (𝑥 − 127) 𝑠𝑖 𝑦 ∈ [0,255]
𝑥 ↦ 0 𝑠𝑖 𝑦 < 0
255 𝑠𝑖 𝑦 > 255

Il s’agit d’augmenter l’écart entre la valeur du pixel et la valeur moyenne (127) pour une image dont les
valeurs sont comprises entre 0 et 255. Cette fonction permet d’augmenter le contraste, les "noirs" sont plus
noirs et les "blancs" plus blancs.
2. Ecrire le script de la fonction Python permettant de modifier le contraste d’une image donnée.

 Négatif d’une image :

Une image négative est une image dont les niveaux de gris sont inversés par rapport à l’originale. La valeur x
de chaque pixel est remplacée par 255 – x.
3. Ecrire le script de la fonction Python permettant de déterminer le négatif d’une image donnée.
 Transformer une image couleur en une image en niveau de gris :
Dans les images en niveaux de gris, les trois niveaux de couleur sont égaux. On remplace donc Rouge, Vert
et Bleu par la moyenne pondérée des trois couleurs donnée par : 0,21 × 𝑅 + 0,71 × 𝑉 + 0,07 × 𝐵
4. Ecrire le script de la fonction Python permettant de transformer une image couleur donnée en une image
en niveau de gris.

 Filtrage (enlever le bruit)

Les images sont parfois de mauvaise qualité. Un exemple typique de défaut est le bruit qui apparait quand
une photo est sous-exposée, c’est-à-dire qu’il n’y a pas assez de luminosité. Ce bruit se manifeste par de
petites fluctuations aléatoires des niveaux de gris.
Afin d’enlever le bruit dans les images, il convient de faire une modification aux valeurs de pixels.
L’opération la plus simple consiste à remplacer la valeur a de chaque pixel par la moyenne de a et des 8
valeurs b, c, d, e, f, g, h, i des 8 pixels qui entourent a.
ℎ
On obtient ainsi une image modifiée en remplaçant a par :

5. Ecrire le script de la fonction Python permettant de filtrer une image donnée en utilisant la méthode de
moyennage.

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
18

En effectuant cette opération pour chaque pixel, on supprime une partie du bruit, car ce bruit est constitué de
fluctuations aléatoires, qui sont diminuées par un calcul de moyennes.

Le moyennage des pixels est très efficace pour enlever le bruit dans les images, malheureusement il détruit
également une grande partie de l’information de l’image. On peut en effet s’apercevoir que les images
obtenues par moyennage sont floues. Ceci est en particulier visible près des contours, qui ne sont pas nets.
Afin de réduire ce flou, il faut remplacer le moyennage par une opération un peu plus complexe, que l’on
nomme médiane. Etant donné la valeur a d’un pixel, et les valeurs b, c, d, e, f, g, h, i, on commence par les
classer par ordre croissant.

La médiane des neuf valeurs a, b, c, d, e, f, g, h, i est la 5ème valeur de ce classement (c’est-à-dire la valeur
centrale de ce classement).
6. Ecrire le script de la fonction Python permettant de filtrer une image donnée en utilisant la méthode de
médiane.

 Détection de contours :
Pour localiser des objets dans les images, il est nécessaire de détecter les bords de ces objets. Ces bords
correspondent à des zones de l’image où les valeurs des pixels changent rapidement.
Afin de savoir si un pixel avec une valeur a est le long d’un bord d’un objet, on prend en compte les valeurs
b, c, d, e de ses quatre voisins (deux horizontalement et deux verticalement), qui sont disposés par rapport à
a. Notons que l’on utilise ici seulement les 4 voisins qui ont un coté commun avec le pixel considéré, ce qui
est différent du calcul de moyennes et de médianes où l’on utilisait 8 voisins. Ceci est important afin de
détecter aussi précisément que possible les bords des objets.

On calcule une valeur l suivant la formule : 𝑙 = (𝑏 − 𝑑) + (𝑐 − 𝑒)

On peut remarquer que si l = 0, alors on a : b = d et c = e. Au contraire, si l est grand, ceci signifie que les
pixels voisins ont des valeurs très différentes, le pixel considéré est donc probablement sur le bord d’un
objet.
On affiche ainsi ces valeurs avec du noir quand l = 0, du blanc quand l est grand, et on utilise des niveaux de
gris pour les valeurs intermédiaires.
7. Ecrire le script de la fonction Python permettant de détecter les contours des objets d’une image donnée.

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
19

IV Application à la cryptographie

IV.1 Définition
La cryptographie est une des disciplines de la cryptologie s'attachant à protéger des messages (assurant
confidentialité, authenticité et intégrité) en s'aidant souvent de secrets ou clés. Elle se distingue de la
stéganographie qui fait passer inaperçu un message dans un autre message alors que la cryptographie rend un
message inintelligible à autre que qui-de-droit. Elle est utilisée depuis l'Antiquité, mais certaines de ses
méthodes les plus importantes, comme la cryptographie asymétrique, datent de la fin du XXe siècle.
Le chiffrement est la conversion des données d’un format lisible à un format codé qui peut uniquement être
lu ou traité qu’après déchiffrement.
Les principes du chiffrement se basent sur la notion d’algorithmes de chiffrement et de « clés ». Lorsque
l’information est envoyée, elle est chiffrée à l’aide d’un algorithme et peut être décodée uniquement à l’aide
de la clé appropriée.
Quelques méthodes qui sont utilisées pour coder et décoder les informations sont présentées dans la suite.

IV.2 Le chiffrement de César

IV.2.1 Principe

Jules César a-t-il vraiment prononcé la célèbre phrase :

DOHD MDFWD HVW

ou bien comme le disent deux célèbres Gaulois : « Ils sont fous ces romains ! ».

En fait César, pour ses communications importantes à son armée, cryptait ses messages (ce que l’on appelle
le chiffrement de César). Le chiffrement de César est un décalage des lettres : pour crypter un message, A
devient D, B devient E, C devient F,...

𝐴 ↔ 𝐷 𝐵 ↔ 𝐸 𝐶 ↔ 𝐹…𝑊 ↔ 𝑍 𝑋 ↔ 𝐴 𝑌 ↔ 𝐵 𝑍 ↔ 𝐶

Pour déchiffrer le message de César, il suffit de décaler les lettres dans l’autre sens, D se déchiffre en A, E en
B,...

Pour ce faire, nous associons à chacune des 26 lettres majuscules (ou minuscules) de A à Z (de a à z) un
entier de 0 à 25.

Le chiffrement de César est simplement une addition dans ℤ/26ℤ. Fixons un entier k qui est le décalage (par
exemple k = 3 dans l’exemple de César ci-dessus) et définissons la fonction de chiffrement de César de
décalage k qui va de l’ensemble ℤ/26ℤ dans lui-même :

ℤ/26ℤ → ℤ/26ℤ
𝐶 :
𝑥 ↦𝑥+𝑘

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
20

Pour déchiffrer, il suffit d’aller dans l’autre sens, c’est-à-dire ici de soustraire. La fonction de déchiffrement
de César de décalage k est :

ℤ/26ℤ → ℤ/26ℤ
𝐷 :
𝑥 ↦ 𝑥−𝑘

Exemple
FLEN veut envoyer des messages secrets à FELTEN. Ils se sont d’abord mis d’accord sur une clé secrète k,
par exemple k = 11. Alice veut envoyer le message "COUCOU" (ou "coucou") à Bruno. Elle transforme
"COUCOU" (ou "coucou") en "2 14 20 2 14 20". Elle applique la fonction de chiffrement 𝐶 (𝑥) = 𝑥 +
11 à chacun des nombres qui donne "13 25 5 13 25 5" ce qui correspond au mot crypté "NZFNZF" (ou
"nzfnzf"). Elle transmet le mot crypté à Bruno, qui selon le même principe applique la fonction de
déchiffrement 𝐷 (𝑥) = 𝑥 − 11 affin de récupérer le message de départ.

IV.2.2 Exercice : Chiffrement César

1. Ecrire une fonction nommée Cqui définit la fonction de chiffrement de César.

2. Ecrire une fonction nommée Dqui définit la fonction de déchiffrement de César.
3. Ecrire une fonction nommée chiffreCesar permettant de chiffrer un message clair donné avec une clé
clef donnée.
4. Ecrire une fonction nommée dechiffreCesar permettant de déchiffrer un message crypté donné avec
une clé clef donnée.
5. Ecrire une fonction nommée attaqueCesar permettant d’attaquer un message chiffré donné en
affichant toutes les possibilités de déchiffrement.

IV.3 Le chiffrement de Vigenère

IV.3.1 Principe

Le chiffrement de Vigenère est un système de chiffrement poly-alphabétique, c’est un chiffrement par

substitution, mais une même lettre du message clair peut, suivant sa position dans celui-ci, être remplacée
par des lettres différentes.
On dispose d’une clé qui est une chaîne de caractère (en général un mot), et on décale la première lettre du
texte à crypter d’un rang correspondant à celui de la première lettre de la clé dans l’alphabet, on décale la
deuxième lettre du texte à crypter d’un rang correspondant à celui de la deuxième lettre de la clé dans
l’alphabet et ainsi de suite jusqu’à la dernière lettre du texte. On revient au début de la clé si le texte à crypter
est plus long que la clé.
Exemple
Soit à crypter le texte : J’adore ecouter la radio toute la journee, avec la clé suivante : MUSIQUE
Texte en clair : J’adore ecouter la radio toute la journee
Clé répétée : M USIQU EMUSIQU EM USIQU EMUSI QU EMUSIQU
Rang : 12 20 18 8 16 20 4 12 20 18 8 16 20 4 12 20 18 8 16 20 4 12 20 18 8 16 20 4 12 20 18 8 16 20
La lettre J est décalée de 12 ce qui donne V
La lettre a est décalée de 20 ce qui donne u Etc.
Texte chiffré : V’uvwhy ioimbul pm lslyi xaolm bu naojvuy

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
21

IV.3.2 Exercice : Chiffrement de Vigenère

Ecrire une fonction nommée chiffreVigenere permettant de chiffrer un message clair donné avec une clé
clef donnée en utilisant le chiffrement de Vigenère.

IV.4 Le chiffrement RSA

IV.4.1 Principe

Le chiffrement RSA (nommé par les initiales de ses trois inventeurs) est un algorithme de cryptographie
asymétrique, très utilisé dans le commerce électronique et plus généralement pour échanger des données
confidentielles sur Internet. Cet algorithme a été décrit en 1977 par Rivest, Shamir et Adelman.
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.

Chaque clé est un couple d’entiers déterminé comme suit :

 choisir deux grands nombres premiers p et q puis on pose 𝑛 = 𝑝 ∗ 𝑞 ;

La création des clés s’effectue de la manière suivante. Soient p et q deux grands nombres premiers.
 calculer l’indicatrice 𝑧 = (𝑝 − 1) ∗ (𝑞 − 1) ;
 calculer 𝑛 = 𝑝 ∗ 𝑞 ;
 choisir un grand entier c, premier avec z ;
 calculer l’entier 𝑑 = 𝑐 ( )
𝑚𝑜𝑑 𝑧. (notons que l’inverse modulaire est calculé par l’algorithme
d’Euclide étendu)
La clé publique est le tuple (𝑛, 𝑐) et la clé privée est le tuple (𝑛, 𝑑)

L’entier crypté y associé à un entier x est donné par : 𝑦 = 𝑥 𝑚𝑜𝑑 𝑛.

L’entier x est retrouvé en décryptant l’entier y par : 𝑥 = 𝑦 𝑚𝑜𝑑 𝑛.

IV.4.2 Exercice : Chiffrement RSA

On suppose avoir déjà défini la fonction python invmod qui calcule l’inverse modulaire de deux entiers
premiers entre eux avec l’algorithme d’Euclide étendu.

def invmod(n,p):
n1,p1,u1,u2)=(n,p,1,0)
while p1>0:
q=n1/p1
(n1,p1,u1,u2)=(p1,n1-q*p1,u2,u1-q*u2)
return u1%p

>>> invmod(39,53)
34

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
22

PARTIE A : cryptage et décryptage d’entier(s)

1. Ecrire une fonction python, nommée clefRSA, qui prend en entrée deux grands nombres p et q
(supposés premiers) et retourne les deux clés (publique et privée).

2. Ecrire une fonction python, nommée cryptDecryptE, qui prend un entier a et une clé CL et retourne
l’entier crypté (ou décrypté) associé à a.
3. Ecrire une fonction python, nommée cryptDecryptList, qui prend une liste d’entiers L et une clé
CL et retourne la liste image 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.
4. Ecrire une fonction python, nommée codage, qui prend une chaîne CH et retourne la liste des codes
ASCII correspondants.
5. Ecrire une fonction python, nommée decodage, qui prend une liste d’entiers L (codes ASCII) et
retourne la chaîne de caractères correspondante.
6. Ecrire une fonction python, nommée cryptageC, 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. Ecrire une fonction python, nommée decryptageC, qui prend une liste d’entiers cryptés L et une clé
CL et retourne la chaîne claire.

V Autres Exercices d’application

V.1 Méthodes de résolution d’un système linéaire

On se propose de programmer quelques méthodes permettant de résoudre les systèmes de n équations à n
inconnues de la forme :

𝑎 , 𝑥 + 𝑎 , 𝑥 + ⋯……+𝑎 , 𝑥 =𝑏
⎧
𝑎 , 𝑥 + 𝑎 , 𝑥 + ⋯……+ 𝑎 , 𝑥 =𝑏
⎨⋮
⎩𝑎 , 𝑥 +𝑎 , 𝑥 + ⋯……+ 𝑎 , 𝑥 =𝑏

Nous noterons ce système sous la forme matricielle : 𝐴. 𝑥 = 𝑏

Où A désigne la matrice des éléments 𝑎 avec 0 ≤ 𝑖 ≤ 𝑛 − 1, 0 ≤ 𝑗 ≤ 𝑛 − 1 ; b étant le vecteur des

composantes (𝑏 , 𝑏 , … … … , 𝑏 ) et x le vecteur des composantes(𝑥 , 𝑥 , … … … , 𝑥 ).

Partie I : Utilisation de la formule de CRAMER pour la résolution du système

Dans cette méthode, et pour chaque composante 𝑥 du vecteur x, on construit une nouvelle matrice que l’on
obtient en remplaçant les composantes de la colonne i de la matrice A par les composantes du vecteur b. la
composante 𝑥 est calculée par division du déterminant de cette nouvelle matrice par celui de A. (Il est
nécessaire que le déterminant de A ne soit pas nul)

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
23

𝑎 , ……𝑎 , 𝑏 𝑎 , ………𝑎 ,
⋮⋮⋮
⋮⋮⋮
𝑎 , ……𝑎 , 𝑏 𝑎 , ……𝑎 ,
𝑥 =
𝑑𝑒𝑡( 𝐴)
1) Ecrire une fonction python, nommée METHODE1, qui permet de résoudre le système d’équations
(𝐴𝑥 = 𝑏) par l’utilisation de la formule de CRAMER.

Partie II : Résolution du système par calcul de l’inverse

A partir de l’équation 𝐴𝑥 = 𝑏 et en supposant que la matrice A est inversible, on peut calculer le vecteur
résultat x par la relation :
𝑥 = 𝐴 .𝑏
On rappelle que chaque coefficient 𝑥 du vecteur résultat x est obtenu par la relation :

𝑥 = 𝑎 𝑏

avec 𝑎 le coefficient de 𝐴 d’indices i j et 𝑏 le coefficient d’indices j du vecteur b.

2) Ecrire une fonction python, nommée METHODE2, qui permet de résoudre le système d’équations
(𝐴𝑥 = 𝑏) par calcul de l’inverse.

Partie III : Résolution du système par la méthode dite directe

Nous pouvons remarquer que si le système se présente sous la forme suivante :

𝑎 , 𝑥 + 𝑎 , 𝑥 + ⋯……+ 𝑎 , 𝑥 =𝑏
⎧
𝑎 , 𝑥 + ⋯………+ 𝑎 , 𝑥 =𝑏
⎨⋮
⎩𝑎 , 𝑥 =𝑏

et en supposant qu’aucun des termes 𝑎 , 0 ≤ 𝑖 ≤ 𝑛 − 1, n’est nul, on peut résoudre le système comme suit :

𝑏
⎧𝑥 =
⎪ 𝑎 ,

⎨ 𝑏 −∑ 𝑎 𝑥
⎪𝑥 = 𝑖 = 𝑛 − 2, 𝑛 − 1, … … ,0
⎩ 𝑎

Pour pouvoir utiliser cette méthode, il faut rendre le système triangulaire supérieur. Pour cela, on procède
comme suit :

Etape1

- On vérifie que l’élément 𝑎 , est non nul sinon on permute la ligne d’indice 0 avec la première ligne du
système à premier coefficient non nul.
- On applique la relation 𝐿 ← 𝐿 − , 𝐿 sur les coefficients des lignes d’indices 1 à 𝑛 − 1 ( 𝐿
,
représente les coefficients de la ligne i de A).

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
24

Etape k

- On vérifie que l’élément 𝑎 est non nul sinon on permute la ligne d’indice k avec la première ligne
(parmi les lignes de k+1 à n du système) qui présente un coefficient d’indice colonne k non nul.
- On applique la relation 𝐿 ← 𝐿 − 𝐿 sur les coefficients des lignes de k+1 à 𝑛 − 1 (𝐿 représente les
coefficients de la ligne i de A).
L’étape 1 permet de rendre nul les coefficients de 𝑎 , à 𝑎 , de la première colonne de la matrice. Il faut
donc ré-appliquer cette démarche, au reste de la matrice, étape par étape, jusqu’à obtenir une matrice
triangulaire supérieure.
3) En supposant qu’aucun des termes 𝑎 , 0 ≤ 𝑖 ≤ 𝑛 − 1, n’est nul, Ecrire une fonction python, nommée
TRIANGLE, qui permet de rendre le système triangulaire supérieure.
4) Ecrire une fonction python, nommée METHODE3, qui permet de résoudre le système d’équations
(𝐴𝑥 = 𝑏) par utilisation de la méthode dite directe.

Partie IV : Résolution du système par la décomposition LU

La factorisation LU d'une matrice 𝐴 × est une méthode de décomposition très importante dans le domaine
de l'analyse numérique. Sa définition est simple, mais ses applications sont très nombreuses et très utiles.
La factorisation LU consiste à écrire une matrice inversibleA comme le produit de deux autres matrices L et
U:𝐴=𝐿×𝑈
L est une matrice triangulaire inférieure ayant des 1 sur la diagonale et U une matrice triangulaire
supérieure.

1 0 0 … 0 𝑢 , 𝑢 , … 𝑢 , 𝑢 ,
𝑙 , 1 0 … 0 0 𝑢 , … 𝑢 , 𝑢 ,
⎛ ⎞ ⎛ ⎞
𝐿=⎜ 𝑙 , 𝑙 , 1 … 0⎟ 𝑈 = ⎜ 0 0 … 𝑢 , 𝑢 , ⎟
⋮ ⋮ ⋱ ⋮ ⋮ ⋮ ⋮ ⋱ ⋮ ⋮
⎝𝑙 , 𝑙 , 𝑙 , … 1⎠ ⎝ 0 0 0 … 𝑢 , ⎠

Les déterminations des coefficients de L et de U sont liées et sont donnés par l’algorithme suivant :
- Le coefficient 𝑢 , =𝑎 , ;
- La première ligne de U est la première ligne de A et la première colonne de L est formée par les pivots
𝑙, = , .
,

- Les coefficients de la diagonale de U sauf 𝑢 , sont calculés par : 𝑢 , = 𝑎 , − ∑ 𝑙, 𝑢 , ;

- Les coefficients de U et L en dehors de la diagonale sont calculés par : 𝑢 , = 𝑎 , − ∑ 𝑙, 𝑢 ,
𝑙, = 𝑎, −∑ 𝑙, 𝑢 , ;
,

Le coefficient 𝑢 , =𝑎 , −∑ 𝑙 , 𝑢 , .
5) En supposant que la matrice A du système est inversible, écrire une fonction python, nommée
decomp_LU, qui permet de décomposer une matrice A en deux matrices L et U.

Supposons maintenant que nous connaissons la factorisation LU de la matrice A. Alors, le système 𝐴. 𝑥 = 𝑏

peut se réécrire 𝐿. 𝑈. 𝑥 = 𝑏.
Si l’on pose 𝑧 = 𝑈. 𝑥, on doit résoudre les équations 𝐿. 𝑧 = 𝑏 où l’inconnue est z puis 𝑈. 𝑥 = 𝑧 où l’inconnue
est x.
Simulation numérique et Applications
Révision Informatique, Concours MP-PC-T 2020
25

Deux équations au lieu d’une, cela paraît plus compliqué mais ici, les matrices L et U sont triangulaires et
dans ce cas la résolution est rapide.
𝑧 =𝑏
L’algorithme de détermination de z est :
𝑧 = 𝑏 −∑ 𝐿, 𝑧1≤𝑖 ≤𝑛−1

Pour 𝑈. 𝑥 = 𝑧, on retrouve l’algorithme de Gauss puisque U est triangulaire supérieure.

𝑥 =𝑧
𝑧 −∑ 𝑈, 𝑥
𝑥 = 𝑛−2≤𝑖 ≤0
𝑈,
6) Ecrire une fonction python, nommée METHODE4, qui permet de résoudre le système d’équations
(𝐴𝑥 = 𝑏) par utilisation de la décomposition LU.

Partie V : Résolution en PYTHON et comparaison des différentes méthodes

Nous voulons comparer les différentes méthodes de résolution du système présentées dans les parties I, II,
III, IV et celle de Python et cela par calcul du temps d'exécution de chacune des méthodes. Le temps
d'exécution en Python pourrait être obtenu en faisant appel à la fonction time() de la bibliothèque time
avant et après l'appel de la fonction dont on désire calculer le temps d'exécution. La commande time()
retourne en effet, une valeur représentant le temps CPU. Il suffit donc de calculer la différence entre les deux
valeurs retournées par time() pour connaître la durée d'exécution d'une fonction.
7) Ecrire une fonction python, nommée METHODE5, qui permet de résoudre le système d’équations
(𝐴𝑥 = 𝑏) par utilisation de la fonction prédéfinie de Python.

Soit le système S défini par :

 2.x0  1.x1  1

S  1.x0  2.x1  1.x2  2
 1.x1  2.x2  3

8) Définir la matrice A du système S.
9) Définir le vecteur b du système S.
10) Ecrire les instructions Python permettant la résolution du système S par les différentes méthodes de
résolutions présentées en I, II, et III, IV et celle de Python et d'indiquer la méthode la plus rapide pour
la résolution de ce système.

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
26

V.2 Méthodes de recherche de zéros d’une fonction

PARTIE A
On désire implémenter un module de fonctions python permettant la recherche approchée d'un zéro d'une
fonction dans un intervalle fixé, par plusieurs méthodes avec une précision de calcul 𝜀.

Description des méthodes

 Méthode des dichotomies

Soit une fonction f donnée. En supposant que l'on connaisse un intervalle [𝑎, 𝑏] sur lequel la fonction
change de signe, c'est à dire que 𝑓(𝑎)𝑓(𝑏) < 0. Si la fonction 𝑓 est continue et strictement monotone, nous
savons que cet intervalle contient alors une racine 𝛼 de 𝑓.
( )
Découpons cet intervalle en deux en posant :𝑐 = . Trois cas sont possibles :

- Si 𝑓(𝑐) est du signe de 𝑓(𝑎), la racine appartient à l'intervalle [𝑐, 𝑏],

- Si 𝑓(𝑐) est du signe opposé à 𝑓(𝑎), la racine appartient à l'intervalle [𝑎, 𝑐],

- Si 𝑓(𝑐) = 0, la racine de𝑓 est c.

Il suffit de répéter le processus jusqu'à ce que la précision 𝜀 demandée soit atteinte. Cette précision est
atteinte lorsque f  c    .

 Méthode de Newton
La méthode de Newton consiste à calculer une suite de valeurs (𝑥 )convergeant vers la racine 𝛼 de
l'équation 𝑓(𝑥) = 0. Cette méthode est applicable à la double condition : la fonction doit être dérivable et
la dérivée ne doit pas s'annuler au voisinage de 𝛼.

Partant d'un point 𝑥 , on calcule successivement :

𝑓(𝑥 )
𝑥 =𝑥 −
𝑓′(𝑥 )
𝑓(𝑥 )
𝑥 =𝑥 −
𝑓′(𝑥 )
.
.
𝑓(𝑥 )
𝑥 =𝑥 −
𝑓′(𝑥 )

Le processus s'arrête lorsque la différence |𝑥 − 𝑥 | ≤ 𝜀, 𝑥 est alors une valeur approchée de 𝛼.

 Méthode d'approximation successive

En posant par exemple 𝑔(𝑥) = 𝑥 + 𝑓(𝑥), l'équation 𝑓(𝑥) = 0 peut s'écrire sous la forme 𝑥 = 𝑔(𝑥).

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
27

En supposant que la solution appartienne à un intervalle [𝑎, 𝑏] fixé et que < 1∀𝑥 ∈ [𝑎, 𝑏], alors la suite
définie par 𝑥 = 𝑔(𝑥 ) ∀𝑥 ∈ [𝑎, 𝑏] converge vers la racine 𝛼 quand 𝑛 tend vers l'infini.
Le processus s'arrête lorsque la différence |𝑥 − 𝑥 | ≤ 𝜀, 𝑥 est alors une valeur approchée de 𝛼.

 Méthode de Regula Falsi

On peut améliorer la convergence de la méthode des dichotomies.

On définit l'abscisse 𝑐comme intersection de l'axe des 𝑥 et de la corde joignant les points 𝑀 𝑒𝑡 𝑀 tels que
𝑀 = 𝑎, 𝑓(𝑎) et 𝑀 = 𝑏, 𝑓(𝑏)

𝑎𝑓(𝑏) − 𝑏𝑓(𝑎)
𝑐=
𝑓(𝑏) − 𝑓(𝑎)

- Si 𝑓(𝑐) = 0, on a évidemment trouvé une racine de𝑓 ;

- Si 𝑓(𝑐)est du signe de 𝑓(𝑎), la racine appartient à l'intervalle [𝑐, 𝑏] ;

- Si 𝑓(𝑐) est du signe opposé à 𝑓(𝑎), la racine appartient à l'intervalle [𝑎, 𝑐].
Il suffit de répéter le processus jusqu'à ce que la précision 𝜀 demandée soit atteinte. Cette précision est
atteinte lorsque f  c    .

Travail demandé

NB : Pour toutes les questions, les vérifications de continuité, de dérivabilité et de monotonie des fonctions
ne sont pas demandées.

1. On souhaite chercher une racine de l’équation f définie par : 𝑓(𝑥) = 𝑡𝑔(𝑥) − 𝑥.

Ecrire une fonction f définissant la fonction f.

2. L’utilisation de certaines méthodes nécessite le calcul de la fonction dérivée.

Une approximation numérique de la dérivée d’une fonction f en un point 𝑥 est donnée par : 𝑓′(𝑥) =
( ℎ) ( ℎ)
ℎ
, avec h constante égale à 0.001.
Ecrire une fonction fprime permettant de calculer puis retourner la dérivée de f en un point 𝑥 donné.

Dans la suite, a, b, eps, xn , kmax, nb et ibf désignent :

a et b : les extrémités de l’intervalle où se trouve la racine de 𝑓que l’on cherche,
eps : la précision 𝜀 voulue,
xn : approximation de la racine recherchée,
kmax : le nombre maximum d’itérations que l’on accepte d’effectuer,
nb : nombre d’itérations réellement effectuées,
ibf : indicateur de bonne fin. Si le résultat de recherche de la racine est obtenu avec la précision voulue
avant que l’on ait effectué les kmax itérations, ibf=0 et xn contient l’approximation de la racine
recherchée ; sinon ibf=1.
Chacune des fonctions de calcul de zéro d’une fonction f prend a, b, eps et kmax comme données
(paramètres en entrée) et retourne xn, nb et ibf.

3. Ecrire une fonction nommée dicho qui permet de calculer, par la méthode des dichotomies, une valeur
Simulation numérique et Applications
Révision Informatique, Concours MP-PC-T 2020
28

approximative xn de la racine 𝛼 pour laquelle la fonction 𝑓 s’annule.

4. Ecrire une fonction nommée newton qui permet de calculer, par la méthode de Newton, une valeur
approximative xn de la racine 𝛼. On prendra comme point de départ la valeur 𝑥 = .
5. L’utilisation de la méthode d’approximations successives nécessite la réécriture de l'équation 𝑓(𝑥) = 0
sous la forme 𝑥 = 𝑔(𝑥).
5.1. Ecrire une fonction g définissant la fonction 𝑔(𝑥) = 𝑥 + 𝑓(𝑥)
5.2. Ecrire une fonction nommée success qui permet de calculer, par la méthode d’approximations
successives, une valeur approximative xn de la racine 𝛼 pour laquelle la fonction 𝑓 s’annule en
utilisant la fonction 𝑔 définie en 5.1. On prendra comme point de départ la valeur 𝑥 = .
6. Ecrire une fonction nommée falsi qui permet de calculer, par la méthode de Regula Falsi, une valeur
approximative xn de la racine 𝛼 pour laquelle la fonction 𝑓 s’annule.
PARTIE B
On veut conserver les résultats d’exécution de ces fonctions dans une matrice. Pour cela, on associe à
chacune des méthodes un numéro tel que :
1 : pour la méthode des dichotomies,

2 : pour la méthode de Newton,

3 : pour la méthode d’approximations successives,

4 : pour la méthode de Regula Falsi.

7. Ecrire une fonction nommée creer qui retourne une matrice M contenant un nombre de lignes égal au
nombre de méthodes de recherche. Chacune de ces lignes contient dans l’ordre : le numéro de la
méthode et les valeurs nb, xn et ibf. Ces valeurs seront extraites à partir du résultat obtenu par appel des
fonctions associées à chacune des méthodes.
On désire réorganiser le contenu de la matrice M obtenu par l’appel de la fonction creer de la question 7 de
telle sorte que les lignes dont ibf vaut 0 (c'est-à-dire recherche fructueuse) seront placées au début de la
matrice. Ces lignes seront par la suite triées selon la valeur associée à nb dans M, de la plus petite vers la
plus grande.

8. Ecrire une fonction nommée organiser qui permet de retourner une matrice M quelconque réorganisée
selon le principe présenté ci-dessus.
On demande d’utiliser, pour la programmation du tri, la méthode dite par sélection et qui consiste dans une
première étape à chercher la valeur la plus petite associée à nb dans la partie de M à trier et à permuter la
ligne correspondante avec la première ligne. L’étape suivante consiste à trier la matrice M diminuée de sa
première ligne c'est-à-dire de chercher dans la matrice diminuée la valeur associée à nb la plus petite puis
de permuter la ligne correspondante avec la première ligne de la matrice diminuée. Cette même opération
sera répétée pour le reste de la matrice jusqu’à ce que le tri souhaité soit effectué.

9. En supposant que les valeurs de a, b, eps et kmax sont déjà saisies, écrire le script python permettant
d’afficher le nom de la méthode (si elle existe) ayant effectué le minimum d’itérations pour le calcul du
zéro de 𝑓 ainsi que le résultat de la recherche.

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
29

VI Alternatives de corrections pour les exercices

VI.1 Corrigé des exercices de traitement d’image

1. Binarisation

import numpy as np

import matplotlib.pyplot as plt

def Binariser(M,s):

n,p=np.shape(M)

M1=np.zeros((n,p))

for i in range(n):

for j in range(p):

if M[i,j]>s:

M1[i,j]=255

return M1

A=plt.imread("source.png")

B=Binariser(A,127)

plt.imshow(B)

plt.show()

plt.imsave("cible.png")

2. Contraste

f=lambda x:x-0.4*(x-127)

def Contraste(M):

n,p=np.shape(M)

M1=np.empty((n,p))

for i in range(n):

for j in range(p):

y=f(M[i,j])

if y>255:

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
30

M1[i,j]=255

elif y<0:

M1[i,j]=0

else:

M1[i,j]=y

return M1

3. Négatif d'une image

def Negatif(M):

n,p=np.shape(M)

M1=np.empty((n,p))

for i in range(n):

for j in range(p):

M1[i,j]=255-M[i,j]

return M1

4. Transformation d’une image couleur en une image en niveau de gris

def Transformer(M):
R,V,B=M[:,:,0], M[:,:,1], M[:,:,2]
M1=0.21*R + 0,71*V + 0.07*B
return M1

5. Filtrage avec moyennage

def Filtrer_moy(M):

n,p=np.shape(M)

M1=M[:,:]

for i in range(1,n-1):

for j in range(1,p-1):

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
31

I=M[i-1:i+2,j-1,j+2]

M1[i,j]=sum(I[x,y] for y in range(3) for x in range(3))/9

return M1

6. Filtrage avec médiane

def Filtrer_mediane(M):

n,p=np.shape(M)

M1=M[:,:]

for i in range(1,n-1):

for j in range(1,p-1):

I=M[i-1:i+2,j-1,j+2]

L=[I[x,y] for y in range(3) for x in range(3)]

L.sort()

M1[i,j]=L[4]

return M1

7. Détection de contours

def Detecter_contours(M):

n,p=np.shape(M)

M1=M[:,:]

for i in range(1,n-1):

for j in range(1,p-1):

I=M[i-1:i+2,j-1,j+2]

l=int(np.sqrt((I[1,0]-I[0,1])**2+(I[1,2]-I[2,1])**2))

if l==0:

M1[i,j]=0

elif l>200:

M1[i,j]=255

return M1

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
32

VI.2 Corrigés des exercices sur les algorithmes de cryptage

#Chiffrement Cesar

Lmajus=['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
Lminus=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
def C(x,k):
y=x+k
if y>26:
y-=26
return y
def D(x,k):
y=x-k
if y<0:
y+=26
return y
def Chiffre_cesar(msg,clef):
msg1=""
for c in msg:
if c in Lmajus:
e=Lmajus.index(c)
e1=C(e,clef)
msg1+=Lmajus[e1]
elif c in Lminus:
e=Lminus.index(c)
e1=C(e,clef)
msg1+=Lminus[e1]
else:
msg1+=c
return msg1
def Dechiffre_cesar(msg,clef):
msg1=""
for c in msg:
if c in Lmajus:
e=Lmajus.index(c)
e1=D(e,clef)
msg1+=Lmajus[e1]
elif c in Lminus:
e=Lminus.index(c)
Simulation numérique et Applications
Révision Informatique, Concours MP-PC-T 2020
33

e1=D(e,clef)
msg1+=Lminus[e1]
else:
msg1+=c
return msg1

>>> Chiffre_cesar("COUCOU",11)
'NZFNZF'
>>> Dechiffre_cesar("NZFNZF",11)
'COUCOU'
>>> Chiffre_cesar("J'aime ecouter la radio toute la journee",20)
"D'ucgy ywionyl fu luxci niony fu diolhyy"
>>> Dechiffre_cesar("D'ucgy ywionyl fu luxci niony fu diolhyy",20)
"J'aime ecouter la radio toute la journee"

def Attaque_cesar(msg):
for k in range(1,26):
print(Dechiffre_cesar(msg,k))

>>> Attaque_cesar("NZFNZF")
MYEMYE
LXDLXD
KWCKWC
JVBJVB
IUAIUA
HTZHTZ
GSYGSY
FRXFRX
EQWEQW
DPVDPV
COUCOU
BNTBNT
AMSAMS
ZLRZLR
YKQYKQ
XJPXJP
WIOWIO
VHNVHN
UGMUGM
TFLTFL
SEKSEK
RDJRDJ

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
34

QCIQCI
PBHPBH
OAGOAG

#Chiffrement Vigenère

def Chiffre_vigenere(msg,mot):

msg1=""

mot=mot.upper()

i=0

for c in msg:

if c in Lmajus:

e=Lmajus.index(c)

e1=C(e,Lmajus.index(mot[i]))

msg1+=Lmajus[e1]

elif c in Lminus:

e=Lminus.index(c)

e1=C(e,Lmajus.index(mot[i]))

msg1+=Lminus[e1]

else:

msg1+=c

i+=1

if i>len(mot)-1:

i=0

return msg1

def Dechiffre_vigenere(msg,mot):

msg1=""

mot=mot.upper()

i=0

for c in msg:

if c in Lmajus:

e=Lmajus.index(c)

e1=D(e,Lmajus.index(mot[i]))

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
35

msg1+=Lmajus[e1]

elif c in Lminus:

e=Lminus.index(c)

e1=D(e,Lmajus.index(mot[i]))

msg1+=Lminus[e1]

else:

msg1+=c

i+=1

if i>len(mot)-1:

i=0

return msg1

>>> Chiffre_vigenere("J'aime ecouter la radio toute la journee","MUSIQUE")

"V'sqcy qwgcjyv fs huhui beoxq di dsglfmu"

>>> Dechiffre_vigenere("V'sqcy qwgcjyv fs huhui beoxq di dsglfmu","MUSIQUE")

"J'aime ecouter la radio toute la journee"

#Chiffrement RSA

def invmod(n,p):

(n1,p1,u1,u2)=(n,p,1,0)

while p1>0:

q=n1/p1

(n1,p1,u1,u2)=(p1,n1-q*p1,u2,u1-q*u2)

return u1%p

def clef_RSA(p,q):

z=(p-1)*(q-1)

n=p*q

c=z+1

d=invmod(c,z)

return (n,c),(n,d)

def CryptDecryptE(e,CL):

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
36

return (e**CL[1])%CL[0]

def CryptDecryptList(L,CL):

return [CryptDecryptE(e,CL) for e in L]

def Codage(ch):

return [ord(c) for c in ch]

def Decodage(L):

ch=""

for e in L:

ch+=chr(e)

return ch

def CryptageC(ch,CL):

return CryptDecryprtList(Codage(ch),CL)

def DecryptageC(L,CL):

return Decodage(CryptDecryptList(L,CL))

VI.3 Corrigé des méthodes de résolution d’un système linéaire

import numpy as np
def METHODE1(A,b):
n=len(b)
x=np.empty(n)
for i in range(n):
A1=A[:,:]
for k in range(n):
A1[k,i]=b[k]
x[i]=np.linalg.det(A1)/ np.linalg.det(A)
return x
def METHODE2(A,b):
n=len(b)
x=np.empty(n)
IA=np.linalg.inv(A)
for i in range(n):
x[i]=sum(IA[i,j]*b[j] for j in range(n))
return x
def TRIANGLE(A):
n=len(A)
for k in range(1,n):

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
37

for i in range(k,n):
pivot=A[i,k-1]/ A[k-1,k-1]
for j in range(k-1,n)
A[i,j]=A[i,j] - pivot*A[k-1,j]
return A
def METHODE3(A,b):
n=len(b)
x=np.empty(n)
x[n-1]=b[n-1]/A[n-1,n-1]
for i in range(n-2,-1,-1):
x[i]=(b[i]-sum(A[i,j]*x[j] for j in range(i+1,n)))/A[i,i]
return x
def decomp_LU(A):
n=len(b)
L=np.eye(n)
U=np.zeros((n,n))
U[0,0]=A[0,0]
for i in range(1,n):
U[0,i]=A[0,i]
L[i,0]=A[i,0]/ A[0,0]
U[i,i]= A[i,i]-sum(L[i,k]*U[k,i] for k in range(i))
for j in range(i+1,n):
U[i,j]= A[i,j]-sum(L[i,k]*U[k,j] for k in range(i))
L[j,i]= (A[j,i]-sum(L[k,i]*U[j,k] for k in range(i)))/U[i,i]
U[n-1,n-1]= A[n-1,n-1]-sum(L[n-1,k]*U[k,n-1] for k in range(n-1))
return L,U
def METHODE4(A,b):
n=len(b)
x=np.empty(n)
L,U=decomp_LU(A)
z=np.empty(n)
z[0]=b[0]
for i in range(1,n):
z[i]=b[i]-sum(L[i,j]*z[j] for j in range(i))
x[n-1]=z[n-1]
for i in range(n-2,-1,-1):
x[i]=(z[i]-sum(U[i,j]*x[j] for j in range(i+1,n)))/U[i,i]
return x
def METHODE5(A,b):
return np.linalg.solve(A,b)
A=np.array([[2,-1,0],[-1,2,-1],[0,-1,2]])
b=np.array([1,2,3])

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
38

from time import time

t=time()
x=METHODE1(A,b)
tm1=time()-t
t=time()
x=METHODE2(A,b)
tm2=time()-t
t=time()
x=METHODE3(A,b)
tm3=time()-t
t=time()
x=METHODE4(A,b)
tm4=time()-t
t=time()
x=METHODE5(A,b)
tm5=time()-t
L=[tm1,tm2,tm3,tm4,tm5]
Tmin=min(L)
print(“la methode{} est la méthode la plus rapide“.format(L.index(Tmin)+1))

VI.4 Corrigé des méthodes de recherche de zéros d’une fonction

from math import tan

f=lambda x:tan(x)-x
def fprime(x):
h=0.001
return (f(x+h)-f(x-h))/(2*h)
def dicho(a,b,eps,kmax):
nb=0
while 1:
nb+=1
xn=(a+b)/2
if f(a)*f(xn)<0:
b=xn
elif f(a)*f(xn):
a=xn
if abs(f(xn))<=eps:
break
if nb<kmax:
ibf=0
else:

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
39

ibf=1
return nb,xn,ibf
def newton(a,b,eps,kmax):
nb=0
x0=(a+b)/2
while 1:
nb+=1
xn=x0-f(x0)/fprime(x0)
if abs(xn-x0)<=eps:
break
else:
x0=xn
if nb<kmax:
ibf=0
else:
ibf=1
return nb,xn,ibf
g=lambda x:f(x)-x
def success(a,b,eps,kmax):
nb=0
x0=(a+b)/2
while 1:
nb+=1
xn=g(x0)
if abs(xn-x0)<=eps:
break
else:
x0=xn
if nb<kmax:
ibf=0
else:
ibf=1
return nb,xn,ibf
def falsi(a,b,eps,kmax):
nb=0
while 1:
nb+=1
xn=(a*f(b)-b*f(a))/(f(b)-f(a))
if f(a)*f(xn)<0:
b=xn
elif f(a)*f(xn):
a=xn

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
40

if abs(f(xn))<=eps:
break
if nb<kmax:
ibf=0
else:
ibf=1
return nb,xn,ibf
import numpy as np
def creer(a,b,eps,kmax):
M=np.empty((4,4))
t1=dicho(a,b,eps,kmax)
t2=newton(a,b,eps,kmax)
t3=success(a,b,eps,kmax)
t4=falsi(a,b,eps,kmax)
for i in range(4):
M[i,0]=i+1
for j in range(1,4):
M[0,j]=t1[j-1]
M[1,j]=t2[j-1]
M[2,j]=t3[j-1]
M[3,j]=t4[j-1]
return M
def organiser(M):
nl=np.shape(M)[0]
i,j=0,nl-1
while 1:
while M[i,3]==0 and i<=nl-1:
i+=1
while M[j,3]==1 and j>=0:
j-=1
if i<j:
M[i,:],M[j,:]= M[j,:],M[i,:]
i+=1
j-=1
else:
break
nlz=i-1
for i in range(nlz-1):
im=i
for j in range(i+1,nlz):
if M[j,1]<M[im,1]:
im=j

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
41

M[i,:],M[im,:]= M[im,:],M[i,:]
return M
M=creer(a,b,eps,kmax)
M=organiser(M)
d={1:”dichotomie”, 2:”newton”, 3:”approximation successive”, 4:”regula falsi”}
if M[0,3]==1:
print(“aucune méthode”)
else :
print(“la méthode{} a effectué le minimum d’itérations avec un nombre
d’itéartions égal à {}”.format(d[M[0,0]],M[0,1]))

Simulation numérique et Applications

Révision Informatique, Concours MP-PC-T 2020
42

Bibliographie et Netographie

Ouvrages :

Learning Python, Mark Lutz, Edition O’Reilly, Juin 2013, ISBN: 9781449355722.

Informatique pour tous en classes préparatoires aux grandes écoles, Benjamin Wack& al., Edition Eyrolles,
Août 2013, ISBN: 978-2-212-13700-2.

Supports de Cours

Support de Cours de M.Hammami, Simulation numérique, pour 2ème année préparatoire des sections MP-PC-
T, IPEIEM, Année universitaire 2019-2020.

Sites Web :

https://www.python-course.eu/

https://www.ics.uci.edu/~brgallar/index.html

https://www.scipy.org/

https://numpy.org/

https://matplotlib.org/

Simulation numérique et Applications

Bases de Données
Aide-Mémoire pour la préparation de l’épreuve
d’Informatique du Concours National d’Entrée aux
Ecoles d’Ingénieurs MP-PC-T 2020

Elaboré par :

Wafa Meftah (IPEIS)

Hayet Latrach (IPEIT)
Houcemeddine Filali (IPEIM)
Laila Hammami (IPEIN)
Mohamed Hammami (IPEIEM)
Besma Fayech (ENSIT)

-- Mai 2020 --
[Tapez ici]

Préambule

Ce document est destiné aux étudiants de deuxième année MP-PC-T des Instituts
Préparatoires aux Etudes d’Ingénieurs.

Dans les circonstances exceptionnelles liées à la crise sanitaire mondiale et nationale du

Covid19, un ensemble de supports de révision pour le programme d’informatique du
concours national d’entrée aux écoles d’ingénieurs ont été élaborés essentiellement par les
membres de la commission informatique du concours, suite à une action bénévole.

Le but de ces supports est d’accompagner les étudiants de tout le territoire Tunisien dans
leur révision en leur fournissant à tous les mêmes documents, afin d’assurer une équité
entre eux, qu’ils bénéficient ou non d’un enseignement ou tutorat à distance.

Toutefois, ces documents sont considérés comme des aide-mémoires et ne remplacent pas
les cours assurés en présentiel.

Le document présent comporte les concepts de base associés aux bases de données
relationnelles. Il expose ainsi la représentation et la manipulation des tables et relations,
ainsi que l’accès à la base à travers les requêtes exprimées en algèbre relationnelle ou en
SQL. L’utilisation de la bibliothèque Python SQLite3 est également présentée. Des exercices
d’application avec leurs corrigés sont intégrés à la fin.

Bases de données
[Tapez ici]

Table des matières

I Introduction ........................................................................................................................................................................ 4
II Base de données : concepts................................................................................................................................................. 4
II.1 Eléments du Modèle Relationnel ................................................................................................................................ 4
II.2 Modèle relationnel : Clé primaire ................................................................................................................................ 4
II.3 Modèle relationnel : Clé étrangère .............................................................................................................................. 5
II.4 Exemple : Modèle relationnel de la base de données Magasin ................................................................................... 5
III Algèbre relationnelle ...................................................................................................................................................... 6
III.1 Projection.................................................................................................................................................................... 6
III.2 Restriction (sélection) ................................................................................................................................................. 7
III.3 Jointure ....................................................................................................................................................................... 7
III.4 Union .......................................................................................................................................................................... 8
III.5 Intersection ................................................................................................................................................................. 9
III.6 Différence ................................................................................................................................................................... 9
IV SQL ( Structured Query Language) ................................................................................................................................ 10
IV.1 Introduction .............................................................................................................................................................. 10
IV.2 Définition des données : LDD .................................................................................................................................... 10
IV.2.1 Création de table : ........................................................................................................................................... 10
IV.2.2 Suppression / Modification de Table ............................................................................................................... 11
IV.3 Manipulation des données : LMD .............................................................................................................................. 12
IV.3.1 Insertion des lignes ......................................................................................................................................... 12
IV.3.2 Modification des données ............................................................................................................................... 13
IV.3.3 Suppression des données ................................................................................................................................ 13
IV.3.4 Extraction des données ................................................................................................................................... 13
IV.3.5 Extraction de données avec condition ............................................................................................................. 14
IV.3.6 Expression des jointures .................................................................................................................................. 16
IV.3.7 Les sous-requêtes ............................................................................................................................................ 17
IV.3.8 Les opérations ensemblistes............................................................................................................................ 18
IV.3.9 Fonctions de calcul .......................................................................................................................................... 18
IV.3.10 La clause Group By … Having .......................................................................................................................... 19
IV.3.11 La clause Limit ................................................................................................................................................. 20
IV.3.12 Forme générale de SELECT............................................................................................................................... 20
V SQLITE ............................................................................................................................................................................... 20
V.1 Instructions de base sous python .............................................................................................................................. 20

Bases de données
[Tapez ici]

V.2 Les fonctions execute() et executemany() ................................................................................................................. 21

V.3 Les fonctions fetchone() et fetchall() ......................................................................................................................... 22
VI Exercices d’Application ................................................................................................................................................. 23
VI.1 Exercice 1 .................................................................................................................................................................. 23
VI.2 Exercice 2 .................................................................................................................................................................. 24
VII Corrigé des exercices..................................................................................................................................................... 25
VII.1 Corrigé de l’exercice 1 ............................................................................................................................................... 25
VII.2 Corrigé de l’exercice 2 ............................................................................................................................................... 27
VIII Bibliographie et Netographie ........................................................................................................................................ 29

Bases de données
 4
Révision Informatique, Concours MP-PC-T 2020

I I NTRODUCTION
Une base de données relationnelle (BDR) est une base de données où l'information est organisée selon le modèle
relationnel. Les données sont organisées en tables et manipulées par des opérateurs algébriques. Dans ce qui suit,
les notions de base associées aux BDR sont présentées afin de pouvoir créer et alimenter une base de données avec
Python et écrire des requêtes en langage algébrique ou langage SQL.

II B ASE DE DONNEES : CONCEPTS

II.1 Eléments du Modèle Relationnel

De façon informelle, on peut définir le modèle relationnel de la manière suivante :

○ Il est composé de trois briques de base : relation, attribut, domaine.

○ Les données sont organisées sous forme de tables à deux dimensions, encore appelées relations,
dont les lignes sont appelées n-uplet ou tuple en anglais ;
○ Les données sont manipulées par des opérateurs de l’algèbre relationnelle ;
○ L’état cohérent de la base est défini par un ensemble de contraintes d’intégrité.

Exemple

Modèle Relationnel : Exemple

● La relation Etudiant ayant pour attributs Numéro, Nom, prénom, adresse, âge, département.
● Chaque attribut possède un domaine.

II.2 Modèle relationnel : Clé primaire

Une clé primaire d’une relation est l’ensemble minimal des attributs de la relation dont les valeurs identifient
un tuple unique, selon les propriétés suivantes :

● Une relation a au moins une clé et peut en avoir plusieurs clés : ce sont les clés candidates.
● Parmi les clés candidates, le concepteur choisit une et une seule clé primaire.
● Par convention, on représente la clé primaire en la soulignant dans l’énoncé de la relation

Bases de données
 5
Révision Informatique, Concours MP-PC-T 2020

Exemple

Voici les clés primaires (attributs soulignés) de quelques relations :

○ Etudiant ( numero , nom , prénom , adresse, âge, département )
○ Département ( nom , chef )
○ Enseignant ( nom , prénom , CIN )
○ Module ( réf_module, responsable , département )

II.3 Modèle relationnel : Clé étrangère

Une clé étrangère ou une clé secondaire est un ensemble d’attributs qui fait référence à la clé primaire d’une
autre relation, selon les propriétés suivantes :

● Une clé étrangère exprime un lien obligatoire entre deux relations.

● Une relation possède une clé primaire, peut spécifier plusieurs clés étrangères.
● Convention d’écriture : italique
Exemple

Voici des exemples de clés étrangères (en italique) de quelques relations :

- Etudiant ( numero , nom , prénom , adresse, âge, département ) :

L’attribut département est une clé étrangère qui fait référence à la clé primaire de la relation Département.
- Département ( nom , chef )
L’attribut chef est une clé étrangère qui fait référence à la clé primaire de la relation Enseignant.
- Enseignant ( nom , prénom , CIN )
La relation enseignant ne possède pas de clé étrangère.
- Module ( réf_module, responsable , département )
L’attribut responsable est une clé étrangère qui fait référence à la clé primaire de la relation Enseignant.
L’attribut département est une clé étrangère qui fait référence à la clé primaire de la relation Département.

II.4 Exemple : Modèle relationnel de la base de données Magasin

Dans la suite, nous nous basons sur un exemple d’application d’une base de données fournie pour les magasins.
La conception de la BD magasin a donné trois relations principales : Client, Produit et Vente.

Ces relations sont modélisées par le schéma relationnel suivant :

• Client( IdCli, nom, ville )

• Produit( IdPro, nom, marque, prix, qstock )
• Vente (IdCli,IdPro, date,qte)

Bases de données
 6
Révision Informatique, Concours MP-PC-T 2020

Une représentation graphique du Schéma Relationnel de la BD ‘Magasin’

III A LGEBRE RELATIONNELLE

L’algèbre relationnelle (AR) est un langage procédural qui permet d’indiquer comment construire une nouvelle
relation à partir d’une ou plusieurs relations existantes.

C’est un langage abstrait, avec des opérations qui travaillent sur une (ou plusieurs) relation(s) pour définir une
nouvelle relation sans changer la (ou les) relation(s) originale(s).

Le résultat de toute opération est une relation.

Il y a deux types d’opérations :

● Opérations spécifiques : Projection, restriction, jointure.

● Opérations ensemblistes : Union, intersection, différence ;

III.1 Projection
La projection d'une relation R1 est la relation R2 obtenue en supprimant les attributs de R1 non mentionnés.

On notera : R2 = πR1 (Ai, Aj, ... , Am)

La projection permet d’éliminer des attributs d’une relation. Elle correspond à un découpage vertical :

Exemple :

Requête : Lister les références et les prix des produits :

Réponse en AR : πPRODUIT (IdPro, Prix)

Bases de données
 7
Révision Informatique, Concours MP-PC-T 2020

III.2 Restriction (sélection)

La restriction d'une relation R1 est une relation R2 de même schéma n'ayant que les n-uplets de R1 répondant à
la condition énoncée.
On notera : R2 = σR1 (condition)
La restriction permet d'extraire les n-uplets qui satisfont une condition.

Exemple :

Requête : Lister les produits de marque ‘IBM’

Réponse en AR : σPRODUIT (Marque = ’IBM’)

III.3 Jointure
La jointure de deux relations R1 et R2 est une relation R3 dont les n-uplets sont obtenus en concaténant les n-
uplets de R1 avec ceux de R2 et en ne gardant que ceux qui vérifient la condition de liaison
On notera : R3 = R1 ⋈ R2 (condition).
Remarques
Le schéma de la relation résultante de la jointure est la concaténation des schémas des opérandes (s'il y a des
attributs de même nom, il faut les renommer).
Les n-uplets de R1 ⋈ R2 (condition) sont tous les couples (u1,u2) d'un n-uplet de R1 avec un n-uplet de R2 qui
satisfont "condition".
La jointure de deux relations R1 et R2 est le produit cartésien des deux relations, suivi d'une restriction.

Bases de données
 8
Révision Informatique, Concours MP-PC-T 2020

Exemple :

Requête : Donner les identifiants des clients ayant acheté un produit de marque Apple.
Réponse en AR : R1 = σPRODUIT (marque = 'Apple')
R2 = R1 ⋈ VENTE (R1.IdPro = VENTE.IdPro)
RESUL = πR2 (IdCli)

III.4 Union
L'union de deux relations R1 et R2 de même schéma est une relation R3 de schéma identique qui a pour n-uplets
les n-uplets de R1 et/ou R2.

On notera : R3 = R1 ∪ R2

Requête : Donner les identifiants des clients de Nice et les clients de Paris.
Réponse en AR : R1 = σClient (ville= 'Nice')
R2 = σClient (ville='paris')
R3 = R1 ∪ R2
RESUL = πR3 (IdPro)

Bases de données
 9
Révision Informatique, Concours MP-PC-T 2020

III.5 Intersection
L’intersection entre deux relations R1 et R2 de même schéma est une relation R3 de schéma identique ayant
pour n-uplets les n-uplets communs à R1 et R2. On notera : R3 = R1 ∩ R2.

Exemple :
Requête : Donner les identifiants des produits de marque Apple et de prix < 2000
Réponse en AR : R1 = σPRODUIT (marque = Apple')
R2 = σPRODUIT (prix < 2000)
R3 = R1∩R2
RESUL = πR3 (IdPro)

III.6 Différence
La différence entre deux relations R1 et R2 de même schéma est une relation R3 de schéma identique ayant
pour n-uplets les n-uplets de R1 n'appartenant pas à R2. On notera : R3 = R1 − R2.

Exemple :
Requête : Donner les identifiants des clients n'ayant acheté que des produits de marque Apple
Réponse en AR : R1 = VENTE ⋈ PRODUIT (VENTE.IdPro = PRODUIT.IdPro)
R2 = σR1 (marque = 'Apple')
R3 = πR2 (IdCli)
R4 = σR1 (marque ≠ 'Apple')
R5 = πR4 (IdCli)
RESUL = R3 − R5
Bases de données
 10
Révision Informatique, Concours MP-PC-T 2020

IV SQL ( S TRUCTURED Q UERY L ANGUAGE )

IV.1 Introduction
SQL est un langage standard pour accéder aux bases de données. Il est composé de plusieurs sous-langages,
dont :
○ Le Langage de Définition des données (LDD) pour la création et la suppression d’objets dans la base de
données. Il comporte les commandes SQL : CREATE, DROP, ALTER.
○ Le Langage de Manipulation des données (LMD) pour la recherche, l'insertion, la mise à jour et la
suppression de données. Il comporte les commandes SQL : SELECT, INSERT, UPDATE, DELETE.

IV.2 Définition des données : LDD

IV.2.1 Création de table :

La commande CREATE TABLE crée la définition d'une table selon la syntaxe suivante :
CREATE TABLE table (
-- définition des colonnes
colonne type [ NOT NULL [UNIQUE] ]
[ DEFAULT valeur ]
[ PRIMARY KEY ]
[ REFERENCES table ]
[ CHECK condition ] ,
... ,
-- contraintes de table
[ PRIMARY KEY (liste de colonnes) ],
[ UNIQUE (liste de colonnes) ] ,
[ FOREIGN KEY (liste de colonnes) REFERENCES table )

Types des colonnes Contraintes d'intégrité

CHAR(n) NOT NULL

TEXT UNIQUE
SMALLINT PRIMARY KEY
INTEGER FOREIGN KEY
DECIMAL(n,m) : CHECK
DATE
BOOLEAN

Bases de données
 11
Révision Informatique, Concours MP-PC-T 2020

Exemple
Pour l’exemple associé au magasin (section II.4) :
● CREATE TABLE client (
IdCli CHAR(4) PRIMARY KEY ,
nom CHAR(20) ,
ville CHAR(30) ,
CHECK (ville IN ('Nice', 'Paris', 'Rome', 'Tunis') ) )
● CREATE TABLE produit (
IdPro CHAR(6) PRIMARY KEY ,
nom CHAR(30) NOT NULL UNIQUE ,
marque CHAR(30) ,
prix DEC(6,2) ,
qstock SMALLINT CHECK (qstock BETWEEN 0 AND 100)
)
● CREATE TABLE vente (
IdCli CHAR(4) NOT NULL REFERENCES client ,
IdPro CHAR(6) NOT NULL ,
date DATE NOT NULL ,
qte SMALLINT CHECK (qte BETWEEN 1 AND 10) ,
-- contrainte de table
PRIMARY KEY (IdCli, IdPro, date) ,
FOREIGN KEY (IdPro) REFERENCES produit
)
IV.2.2 Suppression / Modification de Table

 Suppression d’une table : Toute table peut être supprimée à l’aide de DROP. Par exemple :
DROP TABLE Vente

 Ajout d’une colonne : Pour ajouter une colonne à une table, on utilise ALTER. Par exemple :
ALTER TABLE client ADD COLUMN tel CHAR(16)

A l’exécution de cette commande, la table possède une nouvelle colonne qui ne contient que des
valeurs NULL pour toutes les lignes.
On ne peut ajouter une colonne obligatoire (NOT NULL) que si la table est vide ou si cette colonne
possède une valeur par défaut (DEFAULT).

Bases de données
 12
Révision Informatique, Concours MP-PC-T 2020

IV.3 Manipulation des données : LMD

Le sous-langage LMD de SQL permet de consulter le contenu des tables et de les modifier. Il comporte 4
commandes :
 La requête INSERT insère de nouvelles lignes dans une table.
 La requête DELETE supprime des lignes d'une table.
 La requête UPDATE modifie les valeurs de colonnes de lignes existantes.
 La requête SELECT extrait des données des tables.
IV.3.1 Insertion des lignes

La commande INSERT permet d'ajouter de nouvelles lignes à une table selon la syntaxe suivante :
INSERT
INTO table [ (liste de colonnes) ]
{VALUES (liste de valeurs) | requête}
Remarques :
● Dans le cas où la liste de colonnes n'est pas spécifiée tous les attributs de la table cible doivent être
fournis dans l'ordre de déclaration.
● Si seulement certaines colonnes sont spécifiées, les autres sont insérées avec la valeur NULL.
● Une insertion à partir d'une requête permet d'insérer plusieurs lignes dans la table cible à partir
d'une autre table.
Exemples
- Insertion d'une seule ligne
Pour ajouter le client ('TN100', 'Ali', Tunis') dans la table client :
INSERT
INTO client (IdCli, nom, ville)
VALUES ('TN100', 'Ali', 'Tunis')
- Insertion de plusieurs lignes
Pour ajouter dans une table « temp » de même schéma que la table Vente avec toutes les ventes qui sont
antérieures au 01-Jan-2019 :
INSERT
INTO temp (IdCli, IdPro, date, qte)
SELECT V.no_cli, V.IdPro, V.date, V.qte
FROM vente V
WHERE V.date < '01-jan-2019'

Bases de données
 13
Révision Informatique, Concours MP-PC-T 2020

IV.3.2 Modification des données

La commande UPDATE permet de changer des valeurs d'attributs des lignes existantes, selon la syntaxe
suivante :
UPDATE table
SET liste d'affectations
[ WHERE qualification ]

Remarque : L'absence de clause WHERE signifie que les changements doivent être appliqués à toutes les
lignes de la table cible.
Exemple

● Augmenter de 20% les prix de tous les produits :

UPDATE produit
SET prix = prix * 1.2
● Augmenter de 50% les prix des produits de marque hp :
UPDATE produit
SET prix = prix * 1.5
WHERE marque = 'hp'

IV.3.3 Suppression des données

La commande DELETE permet d'enlever des lignes dans une table, selon la syntaxe suivante :
DELETE
FROM table
[ WHERE qualification ]
Remarque : L'absence de clause WHERE signifie que toutes les lignes de la table cible sont enlevées.
Exemple
Pour supprimer les ventes antérieures au 01-jan-2019 :
DELETE
FROM vente
WHERE date < '01-jan-2019'

IV.3.4 Extraction des données

La commande SELECT (projection en AR) permet de rechercher des données à partir de plusieurs tables ; le
résultat est présenté sous forme d'une table réponse.

Exemples

● Q1 : Donner les noms, marques et prix des produits.

SELECT nom, marque, prix
FROM produit

Bases de données
 14
Révision Informatique, Concours MP-PC-T 2020

On peut introduire dans la clause FROM un synonyme (alias) à un nom de table, en le plaçant
immédiatement après le nom de la table.

Les noms de table ou les synonymes peuvent être utilisés pour préfixer les noms de colonnes dans le
SELECT.
SELECT P.nom, P.marque, P.prix
FROM produit P
● Q2 : Donner les différentes marques de produit :
SELECT P.marque
FROM produit P
Pour éliminer les doublons, il faut spécifier DISTINCT.

SELECT DISTINCT P.marque

FROM produit P
● Q3 : Donner les références des produits et leurs prix majorés de 20%.
SELECT P.IdPro, P.prix * 1.20
FROM produit P
Il est possible d'effectuer des opérations arithmétiques (+, -, *, /) sur les colonnes extraites.

● Q4 : Donner tous les renseignements sur les clients.

SELECT *
FROM client
Une étoile (*) permet de lister tous les attributs.

IV.3.5 Extraction de données avec condition

La condition de recherche (restriction en AR) est spécifiée après la clause WHERE par un prédicat. Un prédicat
simple peut-être :
– un prédicat d’égalité ou d’inégalité (=, <>, <, >, <=, >=)
– un prédicat LIKE
– un prédicat BETWEEN
– un prédicat IN
– un test de valeur NULL
– un prédicat EXISTS

Un prédicat composé est construit à l’aide des connecteurs AND, OR et NOT.

● Q5 : Donner les noms des produits de marque IBM.

SELECT P.nom
FROM produit P
WHERE P.marque = 'IBM'

Bases de données
 15
Révision Informatique, Concours MP-PC-T 2020

● Q6 : Lister les clients dont le nom comporte la lettre A en 2ème position.

SELECT *
FROM client C
WHERE C.nom LIKE '_A%'
Le prédicat LIKE compare une chaîne avec un modèle :
– (_) remplace n'importe quel caractère
– (%) remplace n'importe quelle suite de caractères.

● Q7 : Lister les produits dont le prix est compris entre 50 dinars et 120 dinars
SELECT *
FROM produit P
WHERE P.prix BETWEEN 50 AND 120
Le prédicat BETWEEN teste l'appartenance à un intervalle.

● Q8 : Lister les produits de marque IBM, Apple ou hp.

SELECT *
FROM produit P
WHERE P.marque IN ('IBM', 'Apple', ‘hp')
Le prédicat IN teste l'appartenance à une liste de valeurs.

● Q9 : Lister les produits dont le prix est inconnu.

SELECT *
FROM produit P
WHERE P.prix IS NULL
La valeur NULL signifie qu'une donnée est inconnue.
● Q10 : Lister les produits de marque IBM dont le prix est inférieur à 120 dinars
SELECT *
FROM produit P
WHERE P.marque = 'IBM' AND P.prix < 120
Le connecteur AND relie les 2 prédicats de comparaison.
● Q11 : Lister tous les produits en les triant par marques.
SELECT *
FROM produit P
ORDER BY P.marque
La clause ORDER BY permet de spécifier les colonnes définissant les critères de tri
L'ordre de tri est précisé par ASC (croissant) ou DESC (décroissant) ; par défaut ASC.
● Q12 : Lister tous les produits en les triant par marques et à l'intérieur d'une marque par prix
décroissants.
SELECT *
FROM produit P
ORDER BY P.marque, P.prix DESC
Le tri se fera d'abord selon la première colonne spécifiée, puis selon la deuxième colonne, etc.

Bases de données
 16
Révision Informatique, Concours MP-PC-T 2020

IV.3.6 Expression des jointures

La jointure (jointure en AR) permet de produire une table constituée de données extraites de plusieurs
tables. La condition de jointure est exprimée après WHERE. On peut utiliser aussi JOIN … ON.

● Q13 : Donner les références et les noms des produits vendus.

SELECT P.IdPro, P.nom
FROM produit P , vente V
WHERE P.IdPro = V.IdPro
ou bien :
SELECT P.IdPro, P.nom
FROM produit P JOIN vente V
ON P.IdPro = V.IdPro

 Q14 : Donner les noms des clients qui ont acheté le produit de nom 'PS1'.
SELECT C.nom
FROM client C , produit P, vente V
WHERE V.IdCli = C.IdCli
AND V.IdPro = P.IdPro
AND P.nom = 'PS1‘
ou bien :
SELECT C.nom
FROM VENTE V join produit P
ON V.IdPro = P.IdPro
join Client C
ON V.IdCli = C.IdCli
WHERE P.nom = 'PS1‘
 Q15 : Donner les noms des clients de la même ville que Ali.
SELECT C2.nom
FROM client C1 JOIN client C2
ON C1.ville = C2.ville
WHERE C1.nom = ‘Ali'
AND C2.nom <> ‘Ali‘
Cet exemple utilise, pour le couplage des villes, la jointure de la table Client avec elle-même (auto-
jointure).
Pour pouvoir distinguer les références ville dans les 2 copies, il faut introduire 2 alias différents C1 et C2
de la table client.

Bases de données
 17
Révision Informatique, Concours MP-PC-T 2020

IV.3.7 Les sous-requêtes

SQL permet l'imbrication de sous-requêtes au niveau de la clause WHERE.

Les sous-requêtes sont utilisées :

– dans des prédicats de comparaison (=, <>, <, <=, >, >=)
– dans des prédicats IN
– dans des prédicats EXISTS

Une sous-requête dans un prédicat de comparaison doit se réduire à une seule valeur ("singleton select").

Une sous-requête dans un prédicat IN doit représenter une table à colonne unique.

L'utilisation de constructions du type "IN sous-requête" permet d'exprimer des jointures.

 Q16 : Donner les noms des clients qui ont acheté le produit d'identifiant 'SHP1'

❏ Avec sous-requête
SELECT C.nom
FROM client C
WHERE IdCli IN
(
SELECT V.IdCli
FROM vente V
WHERE V.IdPro = 'SHP1'
)
❏ Avec jointure
SELECT C.nom
FROM client C , vente V
WHERE C.IdCli = V.IdCli
AND V.IdPro = 'SHP1'
 Q17 : Donner les noms des produits qui n'ont pas été acheté
SELECT P.nom
FROM produit P
WHERE NOT EXISTS
( SELECT *
FROM vente V
WHERE V.IdPro = P.IdPro )
Le prédicat EXISTS permet de tester si le résultat d'une sous-requête est vide ou non.

Bases de données
 18
Révision Informatique, Concours MP-PC-T 2020

IV.3.8 Les opérations ensemblistes

Les opérations ensemblistes d’union, intersection ou différence peuvent être exprimées en SQL, en
connectant SELECT avec UNION, INTERSECT ou EXCEPT.

Exemple pour les opérateurs ensemblistes entre deux tables

 Q18 : Donner les numéros des produits de marque IBM ou ceux achetés par le client d'identifiant
'100'.
SELECT P.IdPro
FROM produit P
WHERE P.marque = 'IBM'
UNION
SELECT V.IdPro
FROM vente V
WHERE V.IdCli = ‘100'

L'union élimine les doublons.

IV.3.9 Fonctions de calcul

SQL fournit des fonctions de calcul opérant sur l'ensemble des valeurs d'une colonne de table :
– COUNT : nombre de valeurs
– SUM : somme des valeurs
– AVG : moyenne des valeurs
– MAX : plus grande valeur
– MIN : plus petite valeur
 Q19 : Donner le nombre total de clients.
SELECT COUNT ( IdCli )
FROM client

Bases de données
 19
Révision Informatique, Concours MP-PC-T 2020

 Q20 : Donner le nombre total de clients ayant acheté des produits.

SELECT COUNT ( DISTINCT IdCli )
FROM vente

On peut faire précéder l'argument du mot clé DISTINCT pour indiquer que les valeurs redondantes
doivent être éliminées avant application de la fonction.
La fonction spéciale COUNT (*) compte toutes les lignes dans une table.

 Q21 : Donner le nombre total de 'PS1' vendus.

SELECT SUM ( V.qte )
FROM vente V , produit P
WHERE P.IdPro = V.IdPro
AND P.nom = 'PS1'

 Q22 : Donner les noms des produits moins chers que la moyenne des prix de tous les produits
SELECT P1.nom
FROM produit P1
WHERE P1.prix <
(
SELECT AVG ( P2.prix )
FROM produit P2
)
Cet exemple montre un "singleton select " pour calculer la moyenne des prix.

IV.3.10 La clause Group By … Having

La clause GROUP BY permet de partitionner une table en plusieurs groupes.

Toutes les lignes d'un même groupe ont la même valeur pour la liste des attributs de partitionnement spécifiés
après GROUP BY.
Les fonctions de calcul opèrent sur chaque groupe de valeurs.
La clause HAVING permet de spécifier une condition de restriction des groupes. Elle sert à éliminer certains
groupes, comme WHERE sert à éliminer des lignes.

 Q23 : Donner pour chaque référence de produit la quantité totale vendue.

SELECT V.IdPro, SUM ( V.qte )
FROM vente V
GROUP BY V.IdPro
 Q24 : Donner les noms des marques dont le prix moyen des produits est < 50 dinars
SELECT P.marque, AVG ( P.prix )
FROM produit P
GROUP BY P.marque
HAVING AVG ( P.prix ) < 50

Bases de données
 20
Révision Informatique, Concours MP-PC-T 2020

IV.3.11 La clause Limit

La clause LIMIT est à utiliser dans une requête SQL pour spécifier le nombre maximum de résultats que
l’on souhaite obtenir.
 Q25 : Donner le nom et la marque des deux plus chers produits.
SELECT P.nom, P.marque
FROM produit P
Order by P.prix DESC
Limit 2

IV.3.12 Forme générale de SELECT

SELECT [DISTINCT] liste d'attributs, expressions

FROM liste de tables

WHERE qualification

GROUP BY attributs de partitionnement

HAVING qualification de groupe

ORDER BY liste de colonnes [ ASC | DESC ]

Limit nombre d’enregistrements souhaités

V SQLITE
SQLite est un système de gestion de base de données (SGBD) qui sauvegarde la base sous forme d'un fichier multi-
plateforme. C’est une bibliothèque qui fournit une base de données légère sur disque ne nécessitant pas de processus
serveur distinct et permet d’accéder à la base de données à l’aide d’une variante du langage de requête SQL Il
permet ainsi une gestion simple et rapide des bases de données.

V.1 Instructions de base sous python

La librairie qu'il faut utiliser est sqlite3 :
import sqlite3

Les bases créées avec cette librairie sont enregistrées sous forme de fichier .db, .sq3.
Un fichier .db/.sq3 s'ouvre en créant un objet de type Connection :
conn = sqlite3.connect('magasin.sq3')

Un curseur est ensuite créé à partir de l'objet Connection. Ce curseur représente un canal entre la base de données
et le script Python :
cur = conn.cursor()

Bases de données
 21
Révision Informatique, Concours MP-PC-T 2020

Pour exécuter des commandes dans la base, on crée des requêtes SQL sous forme de chaînes de caractères.
Ensuite, on l’exécute à partir de la fonction execute() :
requete = 'SELECT * FROM vente'
cur.execute(requete)

Lorsque le travail prévu est terminé, il est nécessaire d’enregistrer les modifications faites sur la base :
conn.commit()

Enfin, il faut fermer la connexion vers la base :

conn.close()

V.2 Les fonctions execute() et executemany()

La fonction execute() permet d'exécuter des requêtes SQL dans la base soit pour :

– Créer / modifier des tables (CREATE, DROP, ALTER)

– Modifier des données (INSERT, DELETE, UPDATE),
– Extraire des données (SELECT)

Il existe plusieurs manières d'insérer des données :

▪ La plus simple étant celle-ci :
c = (136 , 'Yassine' , 'Tunis' )
cur.execute(""" insert into client(idcli,Nom,Ville) VALUES (? ,? , ?) """, c)

▪ En insérant des champs précis :

cur.execute("""INSERT INTO client(nom, ville) VALUES ("Aloui" , "Tunis")""")

▪ Ou encore, en insérant tous les champs :

cur.execute("""INSERT INTO client VALUES (3,"Hamed", "Gabes")""")

▪ En passant un dictionnaire :
data = {"name" : "ramzi", "city" : "Tunis"}
cur.execute("""INSERT INTO client(nom,ville) VALUES(:name, :city)""", data)

▪ En réalisant plusieurs insertions en une seule fois avec la fonction executemany() :

cli= []
cli.append(("ali","Gabes"))
cli.append(("lara","Sfax"))
cli.append(("lamia" , "Mahdia"))
cur.executemany(
"""INSERT INTO client(nom, ville) VALUES(?,?)""", cli
)

Bases de données
 22
Révision Informatique, Concours MP-PC-T 2020

V.3 Les fonctions fetchone() et fetchall()

La requête SQL SELECT demande l'extraction d’un ensemble particulier d’enregistrements, qui devront être
transférés de la base de données au curseur.
On peut récupérer la première ligne correspondant à une recherche à l'aide de la fonction fetchone() :
cur.execute("""SELECT nom , ville FROM client""")
client1 = cur.fetchone()
print(client1 ) # Le résultat est un tuple: ('Yassine' , 'Tunis')

On peut récupérer toutes les lignes de la même recherche en utilisant la fonction fetchall() :
lignes = cur.fetchall() # Le résultat est une liste de tuples

L'objet curseur fonctionne comme un itérateur, invoquant la méthode fetchall() automatiquement :

for ligne in cur :
print(ligne)

Bases de données
 23
Révision Informatique, Concours MP-PC-T 2020

VI E XERCICES D ’A PPLICATION

VI.1 Exercice 1
Soit les relations suivantes de la société Gavasoft :

Emp(NumE, NomE, Fonction, NumS, Embauche, Salaire, Comm, NumD )

Dept(NumD, NomD, Lieu)

Exemple

NumD NomD Lieu

1 Droit Créteil
2 Commerce Laval

Num NomE Fonction NumSup Embauche Salaire Comm NumD

1 Gava Doyen NULL 1979 10000 NULL NULL
2 Guimezanes Président 1 2006 5000 NULL 1
3 Toto Stagiaire 1 2006 0 NULL 1
4 Al-Capone Commercial 2 2006 5000 100 2
Partie Algèbre Relationnelle :

1. Donner les noms des personnes embauchées depuis 2006.

2. Donner la liste des employés travaillant à Créteil .
3. Donner les noms des doyens travaillant dans le département de Commerce.
Partie SQL :

4. Créer la table Dept (NumD s’incrémente automatiquement).

5. Ajouter le département ‘RH’ situé à Paris.
6. Attacher tous les doyens à ce nouveau département ‘RH’.
7. Donner la liste des employés ayant une commission (non NULL) classés par commission décroissante.
8. Donner la moyenne des salaires des employés travaillant à Laval.
9. Donner la liste des employés gagnant plus que la moyenne des salaires de l’entreprise.
10. Donner le nombre d’employés par département.
11. Donner le lieu de département dont le nombre d’employés dépasse 100.
Partie SQLITE :

Soit le script python suivant :

import sqlite3
conn = sqlite3.connect(‘Gavasoft.db’)
cur = conn.cursor()
nouveau={‘nom’ :’Martin’, ‘fonction’ : stagiaire’, ‘embauche’ : 2010}

12. Ecrire le/les instructions permettant d’ajouter ce nouvel employé dans la base de données.

Bases de données
 24
Révision Informatique, Concours MP-PC-T 2020

13. Ecrire une fonction Employes(ville) qui prend en paramètre le lieu ville d’un département et qui retourne
la liste des employés de la ville donnée.
14. Ecrire une fonction getVilles ( ) qui retourne la liste des villes de tous les départements.
15. Ecrire les instructions nécessaires permettant de sauvegarder les renseignements des employés de
chaque ville dans des fichiers. Chaque fichier sera nommé par le nom de la ville. Par exemple
‘Creteil.txt’ comporte dans chaque ligne les données d’un employé séparées par un point-virgule.

VI.2 Exercice 2
On considère le schéma relationnel suivant qui modélise une application sur la gestion de livres et de disques
dans une médiathèque.

Disque(CodeOuv, Titre, Style, Pays, Année, Producteur)

E_Disque(NumEx, CodeOuv, DateAchat, Etat, CodeA)
Livre(CodeOuv, Titre, Editeur, Genre, Collection, CodeA)
Auteurs(CodeA,Nom, Prenom)
Abonne(NumAbo, Nom, Prénom, Rue, Ville, CodeP, Téléphone)
Prêt(CodeOuv, NumEx, DisqueOuLivre, NumAbo, DatePret)
Personnel(NumEmp, Nom, Prénom, Adresse, Fonction, Salaire)

Ecrire les requêtes SQL permettant de répondre aux questions suivantes :

1. Quel est le contenu de la relation Livre ?
2. Quels sont les titres des romans édités par Gava-Editor ?
3. Quelle est la liste des titres que l’on retrouve à la fois comme titre de disque et titre de livre ?
4. Quelle est l’identité des auteurs qui ont fait des disques et écrit des livres ?
5. Quels sont les différents styles de disques proposés ?
6. Quel est le salaire annuel des membres du personnel gagnant plus de 20000 euros en ordonnant le résultat
par salaire descendant et nom croissant ?
7. Donnez le nombre de prêts en cours pour chaque famille en considérant qu’une famille regroupe des
personnes de même nom et possédant le même numéro de téléphone ?
8. Quel est le code du disque dont la médiathèque possède le plus grand nombre d’exemplaire ?
9. Quels sont les éditeurs pour lesquels l’attribut Collection n’a pas été renseigné ?
10. Quels sont les abonnés dont le nom contient la chaîne « ALDO » ?
11. Quel est le nombre de prêts en cours ?
12. Quels sont les salaires minimum, maximum et moyen des employés exerçant une fonction de
bibliothécaire?
13. Quel est le nombre de genres de livres différents ?
14. Quel est le nombre de disque acheté en 1998 ?
15. Quel est le salaire annuel des membres du personnel gagnant plus de 20000 euros ?
16. Quel est le nom, prénom et l’adresse des abonnés ayant emprunté un disque le ’12/01/2006’ ?
17. Quels sont les titres des livres et des disques actuellement empruntés par Frédéric Gava ?
18. Quels sont les titres des ouvrages livres policiers ou disques de Jazz empruntés par Frédéric Gava ?
19. Quel est l’identité des auteurs qui n’ont écrit que des romans policiers (genre=policier) ?
20. Quels sont les codes des ouvrages des livres pour lesquels il y a au moins un exemplaire emprunté et au
moins un exemplaire disponible ?

Bases de données
 25
Révision Informatique, Concours MP-PC-T 2020

VII C ORRIGE DES EXERCICES

VII.1 Corrigé de l’exercice 1

Partie Algèbre Relationnelle:
1. Donner les noms des personnes embauchées depuis 2006
R1 = σEmp (Embauche>=2006)
R2= πR1 (NomE)
2. Donner la liste des employés travaillant à Créteil
R1 = Emp ⋈ Dept (Emp.NumD=Dept.NumD)
R2 = σR1 (Lieu = ‘Créteil’)
R3= πR2 (NomE)
3. Donner les noms des doyens travaillant dans le département de Commerce.
R1 = Emp ⋈ Dept (Emp.NumD=Dept.NumD)
R2 = σR1 (NomD = ‘Commerce’)
R3 = σR2 (Fonction = ‘Doyen’)
R4= πR3 (NomE)

Partie SQL:
4. Créer la table Dept (NumD s’incrémente automatiquement)
CREATE TABLE `Dept` (
`NumD` INTEGER PRIMARY KEY AUTOINCREMENT,
`NomD` TEXT,
`Lieu` TEXT
);
5. Ajouter le département ‘RH’ situé à Paris
Insert into Dept(nomD , Lieu ) values(‘RH , ‘Paris’)
6. Attacher tous les doyens à ce nouveau département ‘RH’
Update Emp set numD = 3 where fonction = ‘Doyen’
7. Donner la liste des employés ayant une commission (non NULL) classé par commission décroissante
Select nomE
From Emp
Where Comm is not NULL
Order by comm desc
8. Donner la moyenne des salaires des employés travaillant à laval
Select avg(salaire)
From emp
Bases de données
 26
Révision Informatique, Concours MP-PC-T 2020

Where numD = (select numD

From dept
Where lieu = ‘laval’
)

Ou bien :

Select avg(salaire)
From emp
Join dept
ON emp.numD = dept.numD
Where lieu = ‘laval’

9. Donner la liste des employés gagnant plus que la moyenne des salaires de l’entreprise
Select *
From emp
Where salaire > (select avg(salaire)
From emp
)
10.Donnez le nombre d’employés par département
Select count(*)
From Emp
Group by numD
11.Donnez le lieu de département dont le nombre d’employés dépasse 100
Select lieu
From Dept
Join Emp
On Dept.NumD = Emp.NumD
Group by Dept.NumD
Having count(*) > 100

Partie SQLITE :
Soit le script python suivant :
import sqlite3
conn = sqlite3.connect(‘Gavasoft.db’)
cur = conn.cursor()
nouveau={‘nom’ :’Martin’, ‘fonction’ : stagiaire’, ‘embauche’ : 2010}

Bases de données
 27
Révision Informatique, Concours MP-PC-T 2020

12.Ecrire le/les instructions permettant d’ajouter ce nouveau employé dans la base de donnée
cur.execute ( ‘insert into emp values( :nom, :fonction, :embauche) ,nouveau )

13.Ecrire une fonction Employes(ville) qui prend en paramètre le lieu ville d’un département et qui retourne
la liste des employés de la ville donnée.
def getEmployes(ville) :
req = ‘select * from emp where numD = (select numD from dept where lieu
={}’.format(ville)
cur.execute(req)
employes = cur.fetchall()
return employes

14.Ecrire une fonction getVilles ( ) qui retourne la liste des villes de tous les départements.
def getVilles ( ) :
req = ‘select distinct lieu from dept’
cur.execute(req)
return cur.fetchall()
15.Ecrire les instructions nécessaires permettant de sauvegarder les renseignements des employés de chaque
ville dans des fichiers. Chaque fichier sera nommé par le nom de la ville par exemple ‘Creiteil.txt’et comporte
dans chaque ligne les données d’un employé séparées par un point-virgule
villes = getVilles ( )
for ville in villes :
f = open(ville+’txt’ , ‘w’)
Lemp = getEmployes(ville)
for emp in Lemp :
emp = [str(x) for x in emp ]
ligne =’ ;’.join( emp) +’\n’
f.write(ligne)
f.close()

VII.2 Corrigé de l’exercice 2

1) SELECT * FROM Livre

2) SELECT Titre FROM Livre WHERE Editeur="Droit-Edition" AND Genre="Roman"

3) SELECT D.Titre FROM Disque D, Livre L WHERE D.Titre=L.Titre

Bases de données
 28
Révision Informatique, Concours MP-PC-T 2020

4)SELECT Nom, Prenom FROM Disque D, Auteur A WHERE D.CodeA=A.CodeA INTERSECT SELECT
Nom, Prenom FROM Livre L, Auteur A WHERE D.CodeA=L.CodeA

5) SELECT DISTINCT Style FROM Disque

6)SELECT Nom, Prénom, Salaire*12 AS Salaire_Annuel FROM Personnel WHERE Salaire_Annuel>20000

ORDER BY Salaire DESC, Nom ASC

7) SELECT Nom, Téléphone, COUNT(*) FROM Abonne A, Prêt P WHERE A.NumAbo=P.NimAbo GROUP
BY Nom, Téléphone

8) SELECT CodeOuv FROM E_Disque GROUP BY CodeOuv HAVING COUNT(*)=(SELECT MAX

(COUNT(*)) FROM E_Disque GROUP BY CodeOuv)

9) SELECT Editeur FROM Livre WHERE Collection IS NULL

10) SELECT * FROM Abonne WHERE Nom=‘%ALDO%’

11) SELECT COUNT(*) FROM Prêt

12) SELECT MIN(Salaire), MAX(Salaire), AVG(Salaire) FROM Personnel WHERE Fonction=«

bibliothécaire »

13) SELECT COUNT(DISTINCT Genre) FROM Livre

14) SELECT COUNT(*) FROM E_Disque WHERE DateAchat BETWEEN ’01-Jan-2006’ AND ’10-Dec-
2007’

15) SELECT Nom, Prénom, Salaire*12 AS Salaire_Annuel FROM Personnel WHERE

Salaire_Annuel>20000

16) SELECT Nom, Prénom, Rue, Ville, CodeP FROM Abonne A, Prêt P, Disque D WHERE
A.NumAbo=P.NumAbo AND P.CodeOuv=D.CodeOuv AND DatePret=’12-Jan-2006’

17) SELECT Titre FROM Abonne A, Prêt P, Disque D WHERE A.NumAbo=P.NumAbo AND
P.CodeOuv=D.CodeOuv AND NOM="Gava" AND Prénom="Frédéric" UNION SELECT Titre FROM
Abonne A, Prêt P, Livre L WHERE A.NumAbo=P.NumAbo AND P.CodeOuv=L.CodeOuv AND
NOM="Gava" AND Prénom="Frédéric"

18) SELECT CodeOuv FROM Prêt P, Abonne A WHERE P.NumAbo=A.NumAbo AND Prénom="Frédéric"
AND Nom="Gava" AND CodeOuv IN (SELECT CodeOuv FROM Livre WHERE Genre="Policier")
OR CodeOuv IN (SELECT CodeOuv FROM Disque WHERE Style="Jazz")

19) SELECT Identité FROM Auteur A, Livre L WHERE A.CodeOuv=L.CodeOuv AND Genre="Policier"
AND NOT ALL(SELECT Identité FROM Auteur A, Livre L WHERE A.CodeOuv=L.CodeOuv AND
Genre<>"Policier")

20) (SELECT P.CodeOuv FROM E_Livre E, Prêt P WHERE E.CodeOuv=P.CodeOuv) INTERSECT

(SELECT CodeOuv FROM E_Livre E WHERE NOT EXISTS(SELECT * FROM Prêt P WHERE
E.CodeOuv=P.CodeOuv AND E.NumEx=P.NumEx))

Bases de données
 29
Révision Informatique, Concours MP-PC-T 2020

VIII B IBLIOGRAPHIE ET N ETOGRAPHIE

Ouvrages :

Toute l’informatique en CPGE scientifique, Etienne Cochard, Sophie Rainero, Marielle Roussange, Emanuelle
Sebert-Cuvillier

Apprendre à programmer avec Python 3, G. Swinnen

Informatique pour tous en classes préparatoires aux grandes écoles, Benjamin Wack& al., Edition Eyrolles,
Août 2013, ISBN: 978-2-212-13700-2.

Supports de Cours

Support de Cours de W.Meftah, Les bases de données relationnelles, pour 2ème année préparatoire MP-PC-T et
BG, IPEIS, Année universitaire 2019-2020.

Sites Web :

https://docs.python.org/3/library/sqlite3.html

https://python.doctor/page-cours-python-debutant-documentation

Cours SGBD 1 Concepts et langages des Bases de Données Relationnelles :

https://www.i3s.unice.fr/~nlt/cours/licence/sgbd1/sgbd1_cours.pdf

Cours de Base de Données, Cours n.3 Algèbre relationnelle : http://www.i3s.unice.fr/~edemaria/cours/c3.pdf

https://www.cours-gratuit.com/langage-sql/

Bases de données