Simulation Numérique et

Applications
Aide-Mémoire pour la préparation de l’épreuve
d’Informatique du Concours National d’Entrée aux
Ecoles d’Ingénieurs BG 2020

Elaboré par :

Mohamed Hammami (IPEIEM)

Wafa Meftah (IPEIS)
Samir Elloumi (FST)
Houcemeddine Filali (IPEIM)
Laila Hammami (IPEIN)
Hayet Latrach (IPEIT)
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 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

Simulation numérique et Applications

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.

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
4

II.1.1 Vecteurs

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

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

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

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

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

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

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

Fonctions Description Syntaxe

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

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

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

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

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
5

Exemple

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

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

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

II.1.2 Matrices

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

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

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
6

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

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

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

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

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

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

Fonctions Description Syntaxe

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

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

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

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

diag Construit une matrice diagonale np.diag(L)

Exemple

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
7

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

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

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

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

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

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

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

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
8

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

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

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

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

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

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

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

II.2 La bibliothèque matplotlib

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
9

II.2.1 Utilisation de la fonction plot

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

import matplotlib.pyplot as plt

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

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

import matplotlib.pyplot as plt

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
10

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

import matplotlib.pyplot as plt

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
11

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

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

import matplotlib.pyplot as plt

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
12

II.3 La bibliothèque scipy

II.3.1 Présentation

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

II.3.2 Le module optimize

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

Exemple

import scipy.optimize as spo

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
13

II.3.3 Le module integrate

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

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

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

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

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

from numpy import linspace

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
14

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

import matplotlib.pyplot as plt

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
15

III Application au Traitement d’images

III.1 Présentation et définitions

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

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

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

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

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
16

III.2 Traitement des images sous Python

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

 Affichage d’une image :

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

 Sauvegarde des images :

La fonction imsave permet de sauvegarder une image.
>>>plt.imsave("sous_image.png")

 Création d’une image :

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

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
17

III.3 Exercice pour quelques traitements d’image

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

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

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

 Négatif d’une image :

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

 Filtrage (enlever le bruit)

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

Simulation numérique et Applications

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

Simulation numérique et Applications

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
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"],
Simulation numérique et Applications
Révision Informatique, Concours BG 2020
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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
22

V Alternatives de corrections pour les exercices

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

1. Binarisation

import numpy as np

import matplotlib.pyplot as plt

def Binariser(M,s):

n,p=np.shape(M)

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

for i in range(n):

for j in range(p):

if M[i,j]>s:

M1[i,j]=255

return M1

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

B=Binariser(A,127)

plt.imshow(B)

plt.show()

plt.imsave("cible.png")

2. Contraste

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

def Contraste(M):

n,p=np.shape(M)

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

for i in range(n):

for j in range(p):

y=f(M[i,j])

if y>255:

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
24

6. Filtrage avec médiane

def Filtrer_mediane(M):

n,p=np.shape(M)

M1=M[:,:]

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

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

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

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

L.sort()

M1[i,j]=L[4]

return M1

7. Détection de contours

def Detecter_contours(M):

n,p=np.shape(M)

M1=M[:,:]

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

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

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

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

if l==0:

M1[i,j]=0

elif l>200:

M1[i,j]=255

return M1

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
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’)

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
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"))

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
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"],

Simulation numérique et Applications

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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
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

Simulation numérique et Applications

Révision Informatique, Concours BG 2020
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/

Simulation numérique et Applications