Université des Sciences et de la Technologie

Houari Boumédiene

Faculté de Génie Electrique - Département de Télécommunication

Licence de Télécommunications

Matière

Informatique 3

TP #3

Transcription des algorithmes en Python

Année universitaire 2023/2024

Page 1
1. Objectif du TP
L'objectif de ce TP est d'apprendre à transcrire un algorithme en code Python. Dans un
premier temps, nous rappellons les bases de l'algorithme à travers un exemple. Puis,
nous donnons les principales instructions à utiliser pour écrire un algorithme via un
pseudo-code et un organigramme.

2. Etapes d'écriture d'un algorithme

Un algorithme est composé d'une suite d'opérations de calcul pour résoudre un
problème. Il permet à partir des données en entrée de fournir un résultat en sortie. On
peut représenter un algorithme par le schéma suivant :

Entrée Algorithme Sortie

L'écriture d'un algorithme se déroule selon les étapes suivantes :

1. Décrire le problème à traiter.
2. Proposer une solution pour traiter le problème.
3. Transformer la solution en une suite d'étapes.
4. Décrire la solution par un pseudo-code ou un organigramme (Flowchart).

Exemple 1 :
1. Problème à traiter : Calcul des racines de l'équation du second degré de la forme :

2. Solution proposée : Il s'agit de résoudre l'équation de second degré pour trouver ses
racines. Pour cela, il faut donner les paramètres a, b et c pour calculer les racines en
utilisant le déterminant selon la formule suivante :

Trois cas sont possibles :

 si alors et
 si alors
 si alors et

3. Transformation de la solution en étapes selon la séquence suivante :

Etape 1 : Donner les valeurs de a, b, c

Etape 2 : Calculer
Etape 3 : Calculer les racines , selon le signe de
 si alors et
Page 2
  si alors
 si alors et
Afficher ,

4. Description de la solution par un pseudo-code ou un organigramme.

Après avoir défini les étapes pour le calcul des racines, il faut à présenter écrire
l'algorithme. Dans la section suivante, nous présentons les différentes instructions qui
permettent l'écriture d'un algorithme.

3. Représentation d'un algorithme

Dans un algorithme, chaque opération de calcul est traduite en une instruction. La
représentation d'un algorithme peut se faire à l'aide d'un pseudo-code ou d'un
organigramme.
 Un pseudo-code est composé d'un ensemble d'instructions proche du code
informatique.
 Un organigramme est un schéma qui permet de décrire les étapes d'un algorithme
depuis l'entrée jusqu'à la sortie.

Le choix de l'écriture de l'algorithme dépend de l'application.

3.1. Représentation de l'algorithme par un pseudo-code

Un pseudo-code est composé de trois parties : Titre de l'algorithme, Déclarations des
variables (variables d'entrée et de sortie) et le bloc d'instructions appelé Corps.
Généralement, l'écriture d'un algorithme en pseudo-code se fait en anglais car elle
permet de se rapprocher le plus possible du code informatique.

Algorithm : Titre de l'algorithme

Variables
Input : liste des variables en précisant le type (réel, entier, etc).
Output : liste des variables avec le type
Start
Instruction 1
Instruction 2
....
End

Exemple 2
Algorithm : Calcul des racines d'une équation de second degré
Variables
Input : (real), (real), (real)

Page 3
 Output : (real or complex), (real or complex)
Start
Instruction 1 Bloc
Instruction 2 d'instructions
....
End

3.2. Représentation d'un algorithme par un schéma

La représentation d'un algorithme par un schéma se fait au moyen de blocs dans chacun
décrit une instruction particulière. Chaque bloc est relié à un autre bloc par des flèches
pour montrer le sens d'exécution de l'algorithme.
D'une manière générale, l'organigramme se présente de la manière suivante :

Start

Input

Bloc
d'instructions

End

Titre de l'algorithme

4. Instructions d'un algorithme

4.1. Instructions d'affectation et de calcul

L'affectation d'une valeur à une variable a = valeur est représentée par le symbole
suivant :

Pseudo-code :
a  valeur

Organigramme :
Page 4
 a  valeur

où la flèche  signifie que la variable "a" reçoit la valeur qui peut être un nombre
entier, réel ou complexe.

Exemple 3

Pseudo-code :
a  14.5 # a reçoit la valeur 14.5
aa+2 # a reçoit la valeur 14.5 + 2
b2*a # b reçoit la valeur 2 * 16.5=37
ba*b # b reçoit la valeur de a * b = 16.5 * 16.

Le symbole # est utilisé pour indiquer qu'il s'agit d'un commentaire pour expliquer le
rôle de l'instruction.

Organigramme :
a  14.5

a  a+2

a2*a

aa*b

Si valeur est une donnée saisie par le clavier, on utilise l'instruction input :

Pseudo-code :
a  input("Donner la valeur de a : ")

Organigramme :
Input a

Page 5
4.2. Instructions conditionnels
Une instruction conditionnelle est une instruction qui permet d'exécuter un bloc de
codes si elle vérifie une certaines condition. On distingue l'instruction if.

4.2.1. Instruction if ... then

L'instruction if permet d'exécuter un bloc de codes en vérifiant si la condition est
vérifiée désignée par Oui dans l'organigramme.

Pseudo-code :
if condition then
bloc_de_codes

Organigramme :
Condition

Oui
Bloc
d'instructions

condition peut être l'un des opérateurs mathématiques reportés dans le tableau suivant :

Nom de Opérateur
l'opérateur mathématique
Egalité
Différent
Supérieur
Inférieur
Supérieur ou égal
Inférieur ou égal

4.2.2. L'instruction if .... then ... else

L'instruction if ... then ... else permet d'exécuter le premier bloc de codes si la
condition est vérifiée. Dans le cas contraire, ce sera le deuxième bloc de codes qui sera
exécuté. La syntaxe de l'instruction est la suivante:

Pseudo-code :

if condition then
bloc_de_codes_1
else:
Page 6
 bloc_de_codes_2
end if

Organigramme :
Condition Non Bloc 2
d'instructions

Oui
Bloc 1
d'instructions

4.2.3. Instructions logiques

Dans certaines applications, on souhaite vérifier deux conditions simultanées (en même
temps). Pour cela, deux opérateurs logiques sont utilisés and et or.

Pseudo-code :

if (condition_1 and condition_2) then

bloc_de_codes_1
else:
bloc_de_codes_2
end if

Organigramme :
Condition_1
and Condition_2 Non
Bloc 2
d'instructions

Oui
Bloc 1
d'instructions

4.3. Instructions répétitives

Une instruction répétitive est une instruction qui permet d'exécuter un bloc de codes en
boucle tant que la condition est vérifiée. On distingue l'instruction while et l'instruction
for.

4.3.1. Instruction while

Page 7
L'instruction while permet d'exécuter tant que la condition est vérifiée.

Pseudo-code :

while condition then

bloc_de_codes
end while

Organigramme :

Condition Non

Oui
Bloc
d'instructions

End

4.3.2. Instruction for

L'instruction for permet de faire une itération (répétition ou balayage) sur une séquence
d'une variable.

Pseudo-code :

for var=vi to vf step st do

bloc d'instructions

vi, vf et st définissent les valeurs initiale, finale et du pas qui doit prendre la variable
var.

Organigramme :

varvi

var vf Oui
Page 8

Non
var  var + st
Bloc
4.4. Application à la résolution de l'équation de second degré

Dans l'exemple 1, nous avons donné la solution de la résolution de l'équation du second

degré. Nous proposons maintenant le pseudo-code et l'organigramme pour déterminer
ses racines.

Pseudo-code :

Algorithm: Calcul des racines d'une équation de second degré

Variables
Input : (real), (real), (real)
Output : (real or complex), (real or complex)
Start

if then and
else:
if then
else: et
end if
end if
Print
End

Organigramme :

Start

Input a, b, c

Page 9
 No

Yes

Print

End

5. Transcription de l'algorithme en Python

La transcription de l'algorithme en code Python consiste à remplacer chaque instruction

de l'algorithme en une instruction reconnue par Python.

La figure suivante montre la transcription de l'algorithme de calcul des racines de

l'équation de second en code Python.

RacineEquation.py
"""

Python code Python for computing the equation roots of the second order

"""

# Import the functions sqrt and abs

Page 10
 from numpy import sqrt, abs

# Input a, b, c
a = float(input("Give a : "))
b = float(input("Give b : "))
c = float(input("Give c : "))

# Compute the determinant Delta

delta = b * b - 4 * a * c

# Compute the roots according to the sign of the determinant Delta

if delta > 0:
x1 = (- b - sqrt(delta))/(2 * a)
x2 = (- b + sqrt(delta))/(2 * a)
elif delta == 0:
x1 = x2 = - b / (2 * a)
else:
x1 = complex(- b/(2*a), - sqrt(abs(delta))/(2 * a))
x2 = complex(- b/(2*a), sqrt(abs(delta))/(2 * a))

# Print the roots x1 and x2

print("Root x1 = ", x1)
print("Root x2 = ", x2)

Application 1 :

Application 2 :

Page 11