Algorithmique & Programmation Python (MPSI/PCSI)

12. Traduction en Python
Algorithmique & Programmation (MPSI & PCSI)
Prof. El Kourchi Khalid
Types en Python
En python, on manipule deux catégories de types :
Types simples
Type
Description
Champ de valeurs
acceptables
int
Integer(Entier)
Z
float
Réel
IR
complex
Nombres Complexes
C = {a+bj, a et b
appartiennent à IR}.
Le coefficient « b » doit
être toujours présent
même si c’est 0 ou 1.
bool
Type Logique
True, False
Python est sensible à la case : Il fait la différence entre majuscule et
minuscule.
Tous les mots clés réservés du langage python sont en minuscules.
« True » et « False » sont 2 valeurs logiques. Elles commencent par leurs
premières lettres aux majuscules.
Types composés
Type
Description
Str
Type texte ou bien chaines de caractères
List
Pour manipuler une séquence de valeurs
Tuple
Un tuplet de valeurs
Dict
Un dictionnaire d’éléments : clé = valeur
Etant donné une valeur, on peut connaitre facilement son type en
utilisant la fonction « type » :
Exemples fonction « type »
type (1)
Int
type (1.0)
Float
type (1+1j)
complex
type (True)
Bool
type (« Hello »)
Str
Operations & Expressions
Une expression est un calcul qui donne une valeur (un résultat).
Une expression peut contenir des variables, constantes, appels de
fonctions combinés entre eux par des opérateurs :
Exemple : e = x*sin ((PI/2)*x) + 1
Operateurs arithmétiques (a=10, b=2)
Operateur
Description
Exemple
+
Addition
a + b donne 12
-
Soustraction
a – b donne 8
*
Multiplication
a * b donne 20
**
Puissance
a ** b donne 100
/
Division réelle
b / a donne 5.0
//
Division Euclidienne
b // a donne 5
%
Modulo
b % a donne 0
Operateurs arithmétiques (a=10, b=2)
Operateur
Description
Exemple
+
Addition
a + b donne 12
-
Soustraction
a – b donne 8
*
Multiplication
a * b donne 20
**
Puissance
a ** b donne 100
/
Division réelle
b / a donne 5.0
//
Division Euclidienne
b // a donne 5
%
Modulo
b % a donne 0
Operateurs logiques (a=True, b=False)
Opérateur
Description
Exemple
and
Le ET logique
(a and b) donne False
or
Le OU logique
(a or b) donne True
not
(non) La négation
not(a or b) donne False
Operateurs de comparaison (a=15, b=13)
Opérateur
Description
Exemple
==
Test d’égalité
a == b (False)
!=
Test de Différence
a != b (True)
<
Inferieur
a < b (False)
>
Supérieur
b > a (False)
<=
Inférieur ou Egal
b <= a (True)
>=
Supérieur ou Egal
a >= b (True)
N.B
Tous les opérateurs de comparaison composés de 2 caractères se
terminent par « = ».
Typage des variables
Avant de commencer la traduction des instructions de base, il faut faire
bien la différence entre :
Typage statique
Lors de la déclaration d’une variable on doit préciser son type.
Une fois déclarée, la variable ne peut pas changer de type.
Exemples de langages à typage statique
Langages compilés (C, C++, Java, C#...)
N.B : En algorithmique, on utilise aussi le typage statique.
Typage dynamique
La variable peut changer de type à n’importe quel moment.
Donc, ce n’est pas la peine de préciser le type de la variable au départ.
Exemples de langages à typage dynamique
Langages interprétés (Python, Php, Javascript…)
N.B : Python c’est un langage à typage dynamique.
Instructions de base
On va passer maintenant à faire la traduction des instructions de base vu
en algorithmique en langage Python.
Déclaration d’une variable
Se passe par affectation d’une valeur initiale à la variable.
a = v0
Déclaration ou définition d’une variable de nom « a » en lui
affectant la valeur initiale « v0 »
type de a = type de v0

12. Traduction en Python
Algorithmique & Programmation (MPSI & PCSI)
Prof. El Kourchi Khalid
N.B :
• Pour déclarer une variable, on doit avoir une valeur initiale « v0 ».
• Si on n’a pas cette valeur initiale et on veut comme même déclarer la
variable, on peut utiliser la valeur spéciale « None ».
• « None » c’est une valeur spéciale qui veut dire absence de valeur.
Déclaration de constante
Une constante c’est variable qui ne change pas de valeur, donc sa valeur
initiale est elle-même sa valeur finale.
Affectation
Opération de changement de la valeur d’une variable déjà définie.
En Algorithmique
En Python
a  v1
a = v1
N.B :
• La première affectation c’est la déclaration ou bien la définition de la
variable.
• Les autres affectations après sont des opérations de changement de
valeur.
Lecture « input »
Lire(a)
(a  vs) Affecter à « a » la valeur saisie par l’utilisateur
a=input()
En python, la valeur saisie par l’utilisateur est retournée
par la fonction « input »
Fonction « input »
C’est une primitive bloquante qui va attendre l’utilisateur jusqu’à ce
qu’il saisit une valeur et valide par « Entrée », et en fin retourne cette
valeur.
La valeur retournée par « input » est toujours de type « str ».
Accepte le message de la saisie comme seul paramètre si présent.
Exemple de la fonction « input »
a = input (« Entrer la valeur de a : »)
Conversion de type
Les valeurs saisies par utilisateurs doivent être manipulées dans leurs
propres types, pas entant que « str ».
Le retour de « input » doit être converti vers le type adéquat selon la
valeur saisie par l’utilisateur.
Fonction de conversion vers le type « int »
Type de valeur
Valeur de retour
Exemple
str
Retourne l’entier
contenu dans la
chaine de
caractères. N.B : la
chaine de caractères
passée en
paramètre doit
contenir
exactement un
entier
int(« 123 ») ==
123
Int
Retourne l’entier
passé en paramètre
Int(123)
== 123
float
Retourne la partie
entière du réel
passé en paramètre
Int(12.3654)
== 12
bool
Retourne 1 si True 0
si False
int(True)
== 1
int(False)
== 0
complex
Génère une
TypeError, On ne
peut pas convertir
un complexe vers
un entier.
Fonction de conversion vers le type « float »
Type de valeur
Valeur de retour
Exemple
str
Retourne l’entier
contenu dans la
chaine de
caractères.
float(« 0.123 ») ==
0.123
Int
Retourne le réel qui
correspond à cet
entier
float(14)
== 14.0
float
Retourne le réel
passé en paramètre
float(0.213)
== 0.213
bool
Retourne 1.0 si
True 0.0 si False
float(True)
== 1.0
float(False)
== 0.0
complex
Génère une
TypeError, ne peut
pas convertir un
complexe vers un
réel.
Fonction de conversion vers le type « complex »
Type de
valeur
Valeur de retour
Exemple
str
Retourne le complexe
contenu dans la chaine
de caractères.
complex(« 1+1j ») == 1+1j
Int
Retourne valeur + 0j
complex(14) == 14+0j
float
Retourne valeur + 0j
complex(0.213) == 0.213
+ 0j
bool
complex(True) == 1 + 0j
complex(False) == 0j
complex
Retourne le complexe
passé en paramètre
complex(1+2j) == 1+2j
Fonction de conversion vers le type « bool »
Type de valeur
Evaluées à « True
»
Evaluées à « False »
Bool
True
False
Int
V !=0
V==0
Float
V !=0.0
V==0.0
Complex
V !=0j
V==0j
Str
V != « » chaine vide
V== « » chaine vide
Conversion vers le type « str »
La fonction « str(v) » peut convertir n’importe quelle valeur de n’importe
quel type vers le type « str ».
Ecriture « output » = « print »
La fonction primitive d’édition des résultats en Python c’est « print ».
Ecrire(a,b,c) est traduit simplement par print(a,b,c)
a=None
Déclaration d’une variable sans valeur et sans type.

12. Traduction en Python
Algorithmique & Programmation (MPSI & PCSI)
Prof. El Kourchi Khalid
Déclaration d’une variable par une valeur saisie de type « int »
a = input(“Entrer la valeur entiere:”)
a = int(a)
Par loi de composition, cela est équivalent à :
a = int(input(“Entrer la valeur entiere:”))
Traduction d’un algorithme
1ère méthode (Traduction directe du corps de l’algorithme)
Algorithme
Python
Algorithme calcul_ttc
Constante tva : Réel
Variables npc : Entier
Pu, ttc : Réel
Debut
Tva «- 0.2
Ecrire(« Entrer le npc : »)
Lire(npc)
Ecrire(« Entrer le pu: »)
Lire(pu)
ttc «- npc*pu*(1+tva)
Ecrire (« ttc(dh) : », ttc)
Fin
tva = 0.2
npc = int(input(« Entrer npc : »))
pu = float(input(« Entrer pu: »))
ttc = npc*pu*(1+tva)
print(« ttc(dh) : », ttc)
2ème méthode (Traduction par fonction principale)
Algorithme
Python
Algorithme calcul_ttc
Constante tva : Réel
Variables npc : Entier
Pu, ttc : Réel
Debut
Tva  0.2
Ecrire(« Entrer le npc : »)
Lire(npc)
Ecrire(« Entrer le pu: »)
Lire(pu)
ttc  npc*pu*(1+tva)
Ecrire (« ttc(dh) : », ttc)
Fin
def calcul_ttc() :
tva = 0.2
npc = int(input(« Entrer npc : »))
pu = float(input(« Entrer pu: »))
ttc=npc*pu*(1+tva)
print(« ttc(dh) : », ttc)
Organisation du code en Python « Indentation »
Un bloc est une suite d’instructions qui s’exécutent les uns après les
autres.
En algorithmique et dans autres langages on utilise des délimiteurs pour
borner les instructions qui font partie d’un même bloc de code.
Exemples de délimiteurs en algorithmique
Structure d’algorithme
Structure conditionnelle « SI »
Début
Corps de l’algorithme
Fin
SI cond ALORS
Bloc de la condition « si »
FINSI
Structure « TANTQUE »
Structure « POUR »
TANTQUE cond FAIRE
Corps de la boucle
FINTANTQUE
POUR i allant de v0 à vn FAIRE
Corps de la boucle
FINPOUR
En Python, on utilise l’indentation comme technique pour identifier les
instructions appartenant à un même bloc de code.
Indenter signifie ajouter le même nombre d’espaces devant chacune des
lignes définissant les instructions d’un même bloc de code.
# cette ligne a un niveau d’indentation de 0
# cette ligne a un niveau d’indentation de 1
# cette ligne a un niveau d’indentation de 2
Ainsi, dans le code de notre programme on peut avoir les différentes
structures (SI, TANTQUE, POUR…) imbriquées les unes dans les autres et
par la suite avoir plusieurs niveaux d’indentations.
Chaque nouvelle structure (SI, TANTQUE, POUR) va définir un nouveau
niveau pour son corps.
Traduction des structures algorithmiques
Structure conditionnelle « SI » = « if »
Algorithmique
Python
SI C1 ALORS
Bloc de la condition C1
SINON SI C2 ALORS
Bloc de la condition C2
.
.
.
SINON SI Ci ALORS
Bloc de la condition Ci
SINON
Bloc Alternatif
FINSI
if C1 :
Bloc de la condition C1
elif C2 :
Bloc de la condition C2
.
.
.
elif Ci :
Bloc de la condition Ci
else :
Bloc alternatif
Exemple (Résolution d’équation de 2 dégrée)
def eq2d() :
a = float(input("Entrer le a:"))
b = float(input("Entrer le b:"))
c = float(input("Entrer le c:"))
if a!=0 :
d=b*b-4*a*c
if d>0 :
x1=(-b+d**0.5)/(2*a)
x2=(-b-d**0.5)/(2*a)
print(x1, x2)
elif d==0 :
print(x1)
else :
print ("Pas de solution dans IR")
else :
print("Equation de 1 degree")
Boucle conditionnelle « TANTQUE » = « while »
Algorithmique
Python
TANTQUE Condition FAIRE
Bloc de la boucle
FINTANTQUE
while Condition :
Bloc de la boucle
Boucle inconditionnelle « POUR » = « for »
Algorithmique
Python
POUR i ALLANT DE vi à vf PAR
PAS DE pas FAIRE
Bloc de la boucle
FINPOUR
for e in sequence :
Bloc de la boucle
En python, la « sequence » à parcourir en générale est une suite de
valeurs.
La traduction de la structure « POUR » se fait par une suite arithmétique
créée par la fonction « range » à base de 3 valeurs : vi, vf, p (pas).
La variable du parcours « e » est définie à l’intérieur de la boucle par la
valeur initiale « VI ».

12. Traduction en Python
Algorithmique & Programmation (MPSI & PCSI)
Prof. El Kourchi Khalid
Sequence = range (vi, vf, pas)
La fonction « range » n’accepte que des valeurs entières pour vi, vf et le
pas. Et donc la suite générée est une suite arithmétique entière.
Exemple
Sequence = range(1,11,2)  [1,3,5,7,9]
N.B : La valeur finale est toujours exclue
Formes d’appels à la fonction « range »
range(VI,VF,PAS)
range(VI,VF)
PAS = 1
range(VF)
VI=0, PAS=1
N.B
SI VI »= VF : range génère une séquence vide dans ce cas, la variable du
parcours « e » ne vas pas être définie.
Instructions de contrôle des boucles
Parfois on veut contrôler l’exécution d’une boucle, arrêter la boucle ou
bien sauter quelques itérations. Ce mécanisme existe dans tous les
langages de programmations à travers les 2 instructions suivantes :
Instructions de contrôle des boucles
Instruction « break »
Force l’arrêt de l’exécution d’une boucle et va exécuter la suite du
programme.
Instruction « continue »
Ignore le code qui se situe après l’instruction « continue » et passe
directement à l’itération suivante.
N.B
Les 2 instructions « break » et « continue » il faut les exécuter sous une ou
plusieurs conditions. 10. Else du « while » et « for »
Else du « while » et « for »
Else du « while »
La boucle « while » peut avoir un bloc « else » qui va être exécuté
seulement si on vient de quitter la boucle lorsque la condition devient
fausse.
Exemple
p=int(input(« entrer un entier > 2 »))
d=3
while d <= p**0.5 :
if p%d == 0:
print(p, ’pas premier’)
break
d=d+2
else :
print(p, ‘est premier’)
def premier():
p=int(input(« entrer un entier > 2 »))
d=3
while d <= p**0.5 :
if p%d == 0:
print(p, ’pas premier’)
break
d=d+2
else :
print(p, ‘est premier’)
Else du « for »
La boucle « for » peut avoir un bloc « else » qui va être exécuté seulement
si on vient de parcourir tous les éléments de la suite de la boucle.
for e in sequence :
# bloc de la boucle « for »
else :
# Bloc lorsqu’on vient de parcourir toute la séquence.
Exemple
p=int(input(« entrer un entier »))
for d in range(3, p**0.5+1, 2) :
if p%d == 0 :
print(p, ’pas premier’)
break
else :
print(p, ‘est premier’)
def premier():
p=int(input(« entrer un entier > 2 »))
for d in range(3, int(p**.5)+1, 2):
if p%d == 0:
print(p, ’pas premier’)
break
else :
print(p, ‘est premier’)