Livre1 Cours

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 BG 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 BG 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 et les fichiers.
Notions de base : Rappel

[Tapez ici]
Table des matières

I Introduction ........................................................................................................................................................................ 1
II Variable et affectation ........................................................................................................................................................ 1
III Opérateurs .......................................................................................................................................................................... 2
IV Types élémentaires ............................................................................................................................................................. 2
V Opérations d'entrée/sortie ................................................................................................................................................. 3
VI Structures de contrôle ........................................................................................................................................................ 4
VII Les 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 Chaines de caractère (str) .................................................................................................................................. 7
VII.2.3 Les listes (list) .................................................................................................................................................... 8
VII.2.4 Les tuples (tuple) ............................................................................................................................................... 8
VII.3 Les itérables non ordonnés ......................................................................................................................................... 9
VII.3.1 Les ensembles (set) ........................................................................................................................................... 9
VII.3.2 Les dictionnaires (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
Bibliographie et Netographie ................................................................................................................................................... 18

Révision Informatique, Concours BG 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 en mémoire :
>>> nom = objet
Ainsi une affectation de la forme :

>>> nom1 = nom
référence le même objet avec autre nom (nom1).
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).

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 Types élémentaires
Les types élémentaires sont immuables (non modifiables). Les opérations appliquées aux objets de ces types
génèrent de nouveaux objets comme le montre l'exemple suivant :

>>> x=5
>>> id(x)
2053437424
>>> x+=1 # x référence un nouvel objet
>>> id(x)
2053437440
Types é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

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

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 elif cond2 : print(x)
un 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, par p = 1
exemple une liste, est une for v in [1,8,7]:
collection d’objets (voir p*=v
section VII sur les
itérables).

VII Les itérables

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

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.

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])

VII.2.2 Chaines de caractère (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.

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 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.

VII.2.3 Les listes (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 applicables aux listes.

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 Les tuples (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 applicables aux tuples :


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 Les ensembles (set)
Un ensemble est une collection d'éléments distincts non ordonnés et encadrés par des accolades. Le type 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 False
Inclusion stricte : s1 < s2 {1,2} <= {1,2,5}# donne True
s1 ⊊ s2 s1.issuperset(s2) {1,2} <= {1,2} # donne True

VII.3.2 Les dictionnaires (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 quelconques.

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

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 …
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))

VIII.3 Ensembles en compréhension

set(expression for indice_1 in iterable_1 if condition_1 …
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
 2ème manière :
 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.

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

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. 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 (avec gestion
bloc d’erreur)
exception
except : def f():
bloc_cas_erreur while True:
try:
x=int(input('x'))
return x
except:
print ('erreur')
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.

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 sans
except:
passer par readlines.
for ligne in f : print(" fichier introuvable !")
else:
[instructions]
for ligne in f:
print(ligne)
f.close()

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.

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 des sections MP-PC-T, IPEIM,
Année universitaire 2019-2020.
Support de Cours de Laila Hammami pour 1ère année préparatoire des sections MP-PC-T, IPEIN, Année
universitaire 2019-2020.
Support de Cours de W.Meftah, pour 1ère année préparatoire de la section BG, IPEIS, Année universitaire 2019-
2020.
Sites Web :
https://www.python-course.eu/
https://www.ics.uci.edu/~brgallar/index.html

Programmation Orientée
Objet
Ecoles d’Ingénieurs MP-PC-T 2020
Elaboré par :

Wafa Meftah (IPEIS)
-- 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.

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

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.

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

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

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')

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:
raise TypeError("type invalide !")
super().extend(other)
def __setitem__(self, index, item):

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']))

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

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)

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:
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:
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)

11
Exemple2 :
class point:
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)

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
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())

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.

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.

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:

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:
self.dsg=modif
elif type_modif==3:
if type(modif)!=float:
self.prix_a=modif
def prix_vente(self,pourcentage=20):
return self.prix_a*(1+pourcentage/100)

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()

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]

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

Bases de Données
Ecoles d’Ingénieurs MP-PC-T 2020
Elaboré par :
Wafa Meftah (IPEIS)

-- 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.

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
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
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
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
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
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
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
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
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
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
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
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
● 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
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
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
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
 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
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
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
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
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
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
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
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
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
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
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
Simulation Numérique et
Applications
Ecoles d’Ingénieurs BG 2020
Elaboré par :

Wafa Meftah (IPEIS)
Samir Elloumi (FST)
-- Avril 2020 --
[Tapez ici]
Préambule
Ce document est destiné aux étudiants de deuxième année BG des Instituts Préparatoires
aux Etudes d’Ingénieurs.

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 à la bio-informatique 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 Bio-Informatique ..................................................................................................................................... 19
IV.1 Concepts liés à la biologie ......................................................................................................................................... 19
IV.1.1 De L’ADN aux protéines................................................................................................................................... 19
IV.1.2 Traduction et transcription.............................................................................................................................. 19
IV.2 Représentation en Python......................................................................................................................................... 20
IV.3 Exercice d’application 1 ............................................................................................................................................. 21
IV.4 Exercice d’application 2 ............................................................................................................................................. 21
V Alternatives de corrections pour les exercices................................................................................................................... 22
V.1 Corrigé des exercices de traitement d’image ............................................................................................................. 22
V.2 Corrigé des exercices de bio-informatique ................................................................................................................ 25
V.2.1 Corrigé de l’Exercice1 ...................................................................................................................................... 25
V.2.2 Corrigé de l’Exercice2 ...................................................................................................................................... 27
Bibliographie et Netographie ................................................................................................................................................... 30

Révision Informatique, Concours BG 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 bio-informatique, 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.

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)

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]]

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.]

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]])

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).

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

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

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

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()

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 :

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')

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

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]])

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

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

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.

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 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.
>>>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")
>>>check=np.zeros((8,8,3),dtype='uint8') #exemple pour image couleur
>>>check[:,1:,::2]=255
>>>plt.imshow(check)
>>>plt.show()

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 :

18
5. Ecrire le script de la fonction Python permettant de filtrer une image donnée en utilisant la méthode de
moyennage.
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.

19
IV Application à la Bio-Informatique
IV.1 Concepts liés à la biologie
IV.1.1 De L’ADN aux protéines
L'ADN, pour Acide DésoxyriboNucléique, est une macromolécule constituée de deux brins qui forme une
double hélice maintenue par des liaisons hydrogène. Ces brins sont formés par un enchainement de maillons
appelés, nucléotides qui contiennent les bases de l'ADN :
A pour Adénine
T pour Thymine
G pour Guanine
C pour Cytosine
Les bases de l'ADN fonctionnent par paire, une sur chaque brin : adénine avec thymine et guanine avec
cytosine.
IV.1.2 Traduction et transcription
La transcription est un mécanisme qui permet de "recopier" l'ADN dans le noyau de la cellule pour former un
ARN (acide ribonucléique) qui sera utilisé dans la cellule notamment lors de la traduction. L'ARN présente la
même structure que l'ADN mais lors de la transcription, la thymine (T) est remplacée par l'uracile (U).
La traduction de l'ADN consiste à lire l'ARN issue de la transcription pour synthétiser une protéine avec l'aide
de la machinerie cellulaire. L'ARN est découpé en codons qui sont constitués de 3 bases et correspondent à un
acide aminé, c'est le code génétique. Les codons sont lus les uns à la suite des autres et les protéines sont
assemblées comme une chaîne (peptidique) d’acides aminés.

20
Correspondance codons - acides aminés
Le tableau ci-dessous vous donne la correspondance entre un codon, composé de trois bases de l'ARN et un
acide aminé.
IV.2 Représentation en Python

La base de l’ADN est représentée par : BASES_ADN=['A','T','C','G']
La base de l’ARN est représentée par : BASES_ARN=['A','U','C','G']
Le codon STOP est représenté par la liste suivante : STOP=['TAA','TAG','TGA']
Un ADN valide est formé par nombre de bases nbases multiple de 3 et sa taille doit être supérieure à 9.
Le code génétique est représenté par le dictionnaire geneticCode. La clé représente l’acide aminé et la valeur
représente la liste des codons possibles.
geneticCode = {"Leu": ["UUA", "UUG", "CUU", "CUC", "CUA", "CUG"],
"Phe": ["UUU", "UUC"],
"Ile": ["AUU", "AUC", "AUA"],
"Met": ["AUG"],
"Val": ["GUU", "GUC", "GUA", "GUG"],
21
"Ser": ["UCU", "UCC", "UCA", "UCG", "AGU", "AGC"],

"Pro": ["CCU", "CCC", "CCA", "CCG"],
"Thr": ["ACU", "ACC", "ACA", "ACG"],
"Ala": ["GCU", "GCC", "GCA", "GCG"],
"Tyr": ["UAU", "UAC"],
"STOP": ["UAA", "UAG", "UGA"],
"His": ["CAU", "CAC"],
"Gln": ["CAA", "CAG"],
"Asn": ["AAU", "AAC"],
"Lys": ["AAA", "AAG"],
"Asp": ["GAU", "GAC"],
"Glu": ["GAA", "GAG"],
"Cys": ["UGU", "UGC"],
"Trp": ["UGG"],
"Arg": ["CGU", "CGC", "CGA", "CGG", "AGA", "AGG"],
"Gly": ["GGU", "GGC", "GGA", "GGG"]}
IV.3 Exercice d’application 1

1. Écrire une fonction qui prend en paramètre la taille nbases de l’ADN et génère aléatoirement un brin
d'ADN. On pourra choisir aléatoirement un codon STOP pour terminer le brin ou la partie codante.
2. Écrire une fonction qui prend en paramètre le brin ADN et l’écrire dans un fichier donné.
3. Écrire une fonction qui lit un brin d'ADN dans un fichier et retourne le brin déjà lu.
4. Ecrire une fonction qui vérifie s'il s'agit d'un brin d'ADN ou d'ARN et si ce brin est valide
5. Ecrire un script python qui permet d’extraire les informations suivantes d'un brin d'ADN :
1. Nombre total de bases
2. Nombre de codons
3. Pourcentage de chaque base dans le brin
IV.4 Exercice d’application 2
1. Écrire une fonction prend en paramètre un brin ADN et réalise la transcription de l'ADN en ARN
2. Écrire une fonction qui traduit l'ARN et renvoie la chaîne d'acides aminés correspondante en se basant sur
le code génétique. Attention, elle doit s'arrêter au codon STOP.
3. Ecrire un script python qui permet de calculer le nombre d'acides aminés

22
V Alternatives de corrections pour les exercices
V.1 Corrigé des exercices de traitement d’image
1. Binarisation
import numpy as np
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:

23
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):
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

24
6. Filtrage avec médiane
def Filtrer_mediane(M):
n,p=np.shape(M)
M1=M[:,:]
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[:,:]
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

25
V.2 Corrigé des exercices de bio-informatique
V.2.1 Corrigé de l’Exercice1
1. Construire aléatoirement un brin d'ADN
import numpy as np
BASES_ADN=['A','T','C','G']
BASES_ARN=['A','U','C','G']
STOP=['TAA','TAG','TGA']
def gen_brins(nbases):
if nbases%3!=0 or nbases<9:
return('brin invalide')
else:
brin='AUG'
for i in range(nbases-6):
brin=brin+BASES_ADN[np.random.randint(0,4)]
brin=brin+STOP[np.random.randint(0,3)]
return(brin)
brin = gen_brins(18)
print(brin)
print(len(brin))
2. Écrire une fonction qui écrit le brin d'ADN dans un fichier
def write_file(fragment, fichier):

""" Écrit le fragment dans un fichier """
f=open(fichier, "w")
f.write(fragment)
f.close()
3. Lire le brin dans un fichier

def read_adn(fichier):
""" lit un brin d'ADN sur un fichier """
f=open(fichier, "r")
fragment = f.readline()
f.close()
return fragment
fragment = gen_brins(99)
print(fragment)
write_file(fragment, ‘adn.dat’)

26
read_adn(‘adn.dat’)
4. Identifier s'il s'agit d'un brin d'ADN ou d'ARN et si ce brin est valide
def is_valid(fragment, typ):
# type ADN ou ARN
if typ == "ADN":
bases = BASES_ADN
elif typ == "ARN":
bases = BASES_ARN
else:
print("typ doit être 'ARN' ou 'ADN', typ = %s" % typ)
valid=False
return valid
# valeur retournée
valid = True
# test multiple de 3
if len(fragment) % 3 != 0:
valid = False
print("Error number of bases")
return valid
# test des bases :
else:
for base in fragment:
if base not in bases:
valid = False
print("Error : ", base, " is not valid.")
break
return valid
# pour tester:
adn_ok = "TAATCCTAAAACCCT"
adn_bad = "TAATCCTAAAACCT" # erreur nbre de bases
arn_ok = "UAAUCCUAAAACCCU"
arn_bad = "UAAUYCUAAXACCCU" # erreur nom des bases
print("adn_ok : ", is_valid(adn_ok, "ADN"))
print("adn_bad : ", is_valid(adn_bad, "ADN"))
print("arn_ok : ", is_valid(arn_ok, "ARN"))
print("arn_bad : ", is_valid(arn_bad, "ARN"))

27
5. Statistiques sur le brin

adn = gen_brins(18)
print(adn)
print("nombre de bases : ", len(adn))
print("nombre de codons : ", len(adn) // 3)
print('pourcentage T:',100*adn.count("T")/len(adn))
print('pourcentage A:',100*adn.count("A")/len(adn))
print('pourcentage G:',100*adn.count("G")/len(adn))
print('pourcentage C:',100*adn.count("C")/len(adn))
V.2.2 Corrigé de l’Exercice2
1. La transcription de l'ADN en ARN

def transcription(fragment):
"""
Transcrit un brin d'ADN (base A T C G) en brin d'ARN (base A U C G).
Args:
fragment (str): fragment d'ADN
Return:
arn (str): fragment d'ARN
"""
return fragment.replace("T", "U")
adn = gen_brins(21) #de l’exercice 1
print(adn)
arn = transcription(adn)
print(arn)
2. Traduction de l’ARN
Le code génétique :
geneticCode = {"Leu": ["UUA", "UUG", "CUU", "CUC", "CUA", "CUG"],
"Phe": ["UUU", "UUC"],
"Ile": ["AUU", "AUC", "AUA"],
"Met": ["AUG"],
"Val": ["GUU", "GUC", "GUA", "GUG"],
"Ser": ["UCU", "UCC", "UCA", "UCG", "AGU", "AGC"],
"Pro": ["CCU", "CCC", "CCA", "CCG"],
"Thr": ["ACU", "ACC", "ACA", "ACG"],
"Ala": ["GCU", "GCC", "GCA", "GCG"],
"Tyr": ["UAU", "UAC"],
"STOP": ["UAA", "UAG", "UGA"],
"His": ["CAU", "CAC"],

28
"Gln": ["CAA", "CAG"],

"Asn": ["AAU", "AAC"],
"Lys": ["AAA", "AAG"],
"Asp": ["GAU", "GAC"],
"Glu": ["GAA", "GAG"],
"Cys": ["UGU", "UGC"],
"Trp": ["UGG"],
"Arg": ["CGU", "CGC", "CGA", "CGG", "AGA", "AGG"],
"Gly": ["GGU", "GGC", "GGA", "GGG"]}
Codon vers acide aminé

def codon_to_aa(uncodon):
"""
Renvoie le code à trois lettres d'un acide aminé correspondant au codon donné
en argument.
Args: uncodon (str): codon de l'ARN.
Return: acideAmine (str): code à trois lettres de l'acide aminé
correspondant.
"""
acideAmine = None
identify = False
for aa, codons in geneticCode.items():
if uncodon in codons:
acideAmine = aa
identify = True
break
if not identify:
raise ValueError("ERREUR : codon %s non identifié" % uncodon)
return acideAmine
#pour tester:
print(codon_to_aa("CAA"))
print(codon_to_aa("AZF"))
Traduction de l’ARN
def traduction(fragment):
"""
Traduit le brin d'ARN en séquence peptidique.
Args:
fragment (str): fragment d'ARN à traduire
Returns:
sequence (str): séquence peptidique.

29
"""
#nombre de codons dans le fragment
ncodon = len(fragment) // 3
# traduction
sequence = ""
n = 0
while n < ncodon:
aa = codon_to_aa(fragment[3*n : 3*n+3])
if aa != "STOP":
sequence += aa + "-"
n += 1
else:
sequence += aa
break
return sequence
3. Nombres d’acides aminés
adn = gen_brins(21)
print(adn)
arn = transcription(adn)
print(arn)
sequence = traduction(arn)
print(sequence)
Nbacides= len(sequence.split("-")) # le nombre d’acides aminés
print("la sequence contient ", Nbacides, "acides aminés")
# exemple de résultat
AUGTCGCATTATTTCCTATAA
AUGUCGCAUUAUUUCCUAUAA
Met-Ser-His-Tyr-Phe-Leu-STOP
la sequence contient 7 acides aminés

30
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 MP-PC-T, IPEIEM,
Année universitaire 2019-2020.
Support de Cours de S.Elloumi, Simulation numérique, pour 2ème année préparatoire BG, IPEIEM, Année
universitaire 2017-2018.
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/

Livre1 Cours

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Livre1 Cours

Transféré par

Droits d'auteur :

Formats disponibles

Notions de Base : Rappel

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

Houcemeddine Filali (IPEIM)

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

Notions de base : Rappel

Table des matières

Notions de base : Rappel

Python est un langage de programmation multi-paradigmes (procédural, orienté objet et fonctionnel) et

L’affectation permet d’associer un nom à un objet en mémoire :

>>> nom = objet

Ainsi une affectation de la forme :

Notions de base : Rappel

Description Opérateurs Exemples/Remarques

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

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

Notions de base : Rappel

Types élémentaires Description Exemples / Remarques

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

Description Syntaxe Exemples

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

Notions de base : Rappel

Description Syntaxe Exemples

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

Notions de base : Rappel

VII Les itérables

VII.1 Opérations communes aux itérables

Description Syntaxe Exemples / Remarques

Notions de base : Rappel

VII.2 Les séquences

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

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

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

Notions de base : Rappel

VII.2.2 Chaines de caractère (str)

Description Syntaxe Exemples / Remarques

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

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

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

Notions de base : Rappel

VII.2.3 Les listes (list)

Description Syntaxe Exemples

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

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

VII.2.4 Les tuples (tuple)

Notions de base : Rappel

Description Syntaxe Exemples

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

VII.3 Les itérables non ordonnés

VII.3.1 Les ensembles (set)

Description Syntaxe Exemples/ Remarques

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

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

Notions de base : Rappel

VII.3.2 Les dictionnaires (dict)

Description Syntaxe Exemples / Remarques

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

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

Notions de base : Rappel

VIII Construction des itérables en compréhension

VIII.1 Listes en compréhension

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

VIII.2 Tuples en compréhension

def init(self, source=()):

def setitem(self, index, item):