Vous êtes sur la page 1sur 26

Impossible d’afficher l’image.

Impossible d’afficher l’image.

CAHIER
D’ LGORITHMIQUE
ET DE PROGRAMMATION
Date de mise à jour : 13/09/2021
Chapitre 0 : Pensée computationnelle et programmation.................................................................... 1
I- Définition de la pensée computationnelle (CT) : .................................................................................................. 2
II- Résolution d’un problème informatique : ........................................................................................................... 2

Chapitre 1 : Les structures de données .......................................................................................................... 5


1) Le type entier : ..................................................................................................................................................... 5
2) Le type réel : ......................................................................................................................................................... 6
3) Les nombres aléatoires : ...................................................................................................................................... 6
4) Le type logique : ................................................................................................................................................... 7
5) Le type caractère :…………………………………………………………………………………………………………………………………..….… 8

6) Le type chaîne de caractères :.............................................................................................................................. 8


7) Les tableaux :........................................................................................................................................................ 9

Chapitre 2 : Les actions élémentaires simples .......................................................................................... 12


I- Introduction : ..................................................................................................................................................... 12
II- Les actions d’entrées :........................................................................................................................................ 12
III- L’affectation : ..................................................................................................................................................... 12
IV- Les actions de sortie : ......................................................................................................................................... 12

Chapitre 3 : Les structures de contrôle conditionnelles ....................................................................... 15


I- Introduction : ..................................................................................................................................................... 15
II- Les structures conditionnelles : la forme simple : ............................................................................................. 15
III- Les structures conditionnelles : la forme complète : ......................................................................................... 15
IV- Les structures conditionnelles : la forme généralisée : ..................................................................................... 16
V- Structure conditionnelle à choix multiple : ........................................................................................................ 16

Chapitre 4 : La saisie contrôlée ........................................................................................................................ 18


Chapitre 5 : Les structures de contrôle itératives.................................................................................... 20
I- Structure de contrôle itérative complète : la boucle « pour » .......................................................................... 20
II- Structure de contrôle itérative à condition d’arrêt :.......................................................................................... 21

Annexe…………………………………………………………………………………………………………………..……………………………………………..22
Avant-propos

Tout le monde utilise un ordinateur, mais c’est une autre chose de le piloter ! Tu vas apprendre ici les
bases de la programmation.

À qui s’adresse ce cours ?


Ce cours prend la suite des « Notes de cours d’algorithmique » destiné aux élèves 2ème année
scientifiques. Bien qu’à ce jour il n’existe pas de manuel scolaire, il semble utile de disposer d’un cours
généraliste en français consacré à l’algorithmique et à la programmation en Python.
Des erreurs peuvent subsister dans ce document, le lecteur voudra bien m’en excuser et me les
signaler le cas échéant (j.marwane2@gmail.com).

Pourquoi Python ?
Choisir un langage de programmation pour débuter est délicat. Il faut un langage avec une prise en
main facile, bien documenté, avec une grande communauté d’utilisateurs. Python possède toutes ces
qualités et davantage encore. Il est moderne, puissant et très utilisé, y compris par les programmeurs
professionnels. Malgré toutes ces qualités, débuter la programmation (avec Python ou un autre
langage) est difficile. Le mieux est d’avoir déjà une expérience du code, à l’aide de Scratch par
exemple.

Bien maîtriser Python te permettra d’apprendre facilement les autres langages. Surtout le langage
n’est pas le plus important, l’essentiel ce sont les algorithmes. Les algorithmes sont comme des
recettes de cuisine, il faut suivre pas à pas les instructions et ce qui compte, c’est le résultat final et
non le langage avec lequel a été écrite la recette.

Caractéristiques de Python
• langage de haut niveau
• portable sur tous les systèmes d’exploitation
• typage dynamique : pas besoin de déclarer le type des variables !
• extensible (interfaçable avec d’autres bibliothèques et modules)
• sous licence libre
• syntaxe « très simple »
• multiparadigme : impératif et orienté-objet
• interprété et/ou pré-compilé puis interprété
Chapitre 0

Chapitre 0
Pensée
computationnelle

1
Pensée
computationnelle

11 Pensée computationnelle et programmation


I-Définition de la pensée computationnelle (CT) :
C’est un ensemble de compétences et procédures qui facilitent la résolution des problèmes en s’appuyant sur des
principes tirés des sciences informatiques (algorithmes et dispositifs informatiques).
Les éléments de la pensée conceptuelle :
 Décomposition : Diviser un problème complexe en petites parties simple à gérer
 Identification de modèles : identifier des similarités entre problèmes ou à l’intérieur du même problème
donné.

e
 Abstraction : focaliser sur les parties importantes du problème pour les résoudre
 Algorithme : Trouver une solution à traves

an
1- Décomposition :
Un problème complexe est divisé en plusieurs problèmes partiels compréhensibles.

2- Identification de modèles :
On recherche des modèles identifiables au cœur des problèmes partiels. Ce faisant on s’appuie sur des valeurs
empiriques : souvent, les processus identifiés sont déjà connus en totalité ou en partie, dans le cadre d’autres
processus de résolution de problèmes.

3- Abstraction :

w
Les aspects insignifiants du problème sont mis de côté. L’accent est mis sur les détails pertinents. On veille à fortement
simplifier le problème initial.
ar
4- Algorithme :
Grâce aux étapes de réflexion précédentes, on sait désormais selon quels modèles opère la problématique rencontrée
et comment nous pouvons les influencer. Il est maintenant possible de définir des règles menant à la résolution de
problèmes.
M

II-Résolution d’un problème informatique :


Pour résoudre un problème informatique on doit écrire un algorithme puis le traduire en langage de programmation
compris par l’ordinateur.

 L’algorithme a la structure suivante :


ZI

0- début nom programme


1- action 1
2- action 2
……
……
JA

(N-1)……
N- Fin nom programme

Application :
1- Ecrire un algorithme qui permet de saisir deux nombres a et b, calculer leur somme en la stockant dans une
variable s puis l’afficher.
2- Utiliser le logiciel Algobox pour écrire cet algorithme sur la machine.
0) Début somme
1) Lire (a)
2) Lire (b)
3) s a+b
4) Afficher (s)
5) Fin somme

2
Pensée
computationnelle
Remarques :
1- lire : est un mot clé traduire l’action de saisie à partir du clavier. Les informations saisies
(clavier) sont rangées en mémoire centrale
2- s a + b : il s’agit d’une opération d’affectation
Attribuer à une case mémoire(Variable) une valeur
3- Afficher : est un mot clé traduire l’action d’affichage sur l’écran.

Passage de l’algorithme au programme :


Utilisation du logiciel AlgoBox
Programme en Python :
a=int(input("donner un entier: "))

e
b=int(input("donner un entier: "))
s=a+b

an
print("la somme = ",s)

Dégager les mots clés d’un algorithme :


Mot clé Rôle
traduction Python
…………………. : .…………………………………… ……………………………………….

w
…………………. : ……………………………………. ……………….………………………
…………………. : ……………………………………. ……………….………………………
ar
M
ZI
JA

3
Chapitre 1

e
Chapitre 1

an
w
Les structures de
ar
données
M
ZI
JA

4
Les structures de
données

12 Les structures de données


1) Le type entier :
En informatique, un entier est un type de donnée qui représente un sous-ensemble fini de nombres entiers relatifs.
Type en T.D.O Type en Python
Entier int

Opérateur
Opération Exemple
En Algo En Python
13 - (2 + 5) * 6 = - 29
() () Parenthèse
13 – 2 + 5 * 6 = 41

e
* * Multiplication 3 * 9 = 27
/ / Division 15 / 9 = 1.6666666666666667
DIV // Division entière 15 / 9 = 1

an
MOD % Reste de la division entière 15 % 9 = 6
+ + Addition 5+2=7
- - Soustraction 5–2=3

Il existe aussi les opérateurs augmentés :


a += b équivaut à a = a+b

w
a -= b équivaut à a = a-b
a *= b équivaut à a = a*b
a /= b équivaut à a = a/b
a %= b équivaut à a = a%b
ar
Existe Opérateur / Fonction Rôle Exemple
aussi en ** Puissance 5**2=25
Python
pow(x,y) Retourne x à la puissance y (même chose que x**y).
M

Les fonctions standards des variables du type entier


Type de x

Type du
résultat

Syntaxe en Syntaxe en
Rôle de la fonction Exemples
algo Python
ZI

Même
Entier

que x
type
Réel
ou

Abs (x) abs (x) Retourne la valeur absolue de x.


Entier
Réel

Arrondi (x) round(x) Retourne x arrondi


JA

Entier

Retourne un entier, en ignorant la partie


Réel

Ent(x) trunc (x) *


fractionnaire décimale de X.

* Pour utiliser cette fonction en Python, il faut importer la bibliothèque math :

5
Les structures de
données

2) Le type réel :
Les valeurs de type réel (float) ou nombre à virgule flottante, forment un sous ensemble des nombres réels R.
Type en T.D.O Type en Python
Réel float

Les fonctions arithmétiques standards du type réel


Syntaxe en Syntaxe en Type de
Rôle de la fonction Type de x Exemples
algo python résultat

Retourne l’entier le plus proche de


Arrondi(x) round (x) Réel Entier
x.

e
Retourne la racine carrée de x si x
Racine_carré(x) sqrt (x) est positif sinon il provoque une Entier ou Réel Réel
erreur.

an
Retourne un entier, en ignorant la
Ent(x) trunc (x) * Réel Entier
partie décimale de x.

* Pour utiliser ces fonctions en Python, il faut importer la bibliothèque math :

Existe
aussi en
Opérateur /
Fonction

round(x[, n])
Rôle

w
x arrondi à n chiffres, arrondissant la moitié au pair.
Si n est omis, la valeur par défaut à 0.
Exemple
ar
Python

abs (x) Retourne la valeur absolue de x.


M
fabs Retourne la valeur absolue de x en float

Activité :
Quel sera le résultat donné par la console après saisie des suites d ́instructions suivantes ?
Instructions Résultats
ZI
JA

6
Les structures de
données

3) Les nombres aléatoires :


En Python, le module random permet de générer des nombres aléatoires. Pour utiliser les fonctions de ce module
taper :
En Algo En Python Rôle
Aléa (a,b) randint(a,b) Choisit un entier (int) aléatoirement dans [a, b]
Opérateur / Fonction Rôle
Existe randrange(a,b,k) Choisit un entier (int) aléatoirement dans range(a,b,k)
aussi en choice(List) Choisit un entier (int) aléatoirement dans la liste List
Python random() Choisit un réel (float) aléatoirement dans [0, 1[
uniform(a,b) Choisit un réel (float) aléatoirement dans [a, b[

e
4) Le type logique :
Le type logique ou booléen comme dans tout langage peut prendre deux valeurs uniquement. En Python, ces valeurs

an
sont True et False.
Soit B1 et B2 deux objets de type Booléen, les principales opérations définies sur ce type sont :
Opération En Algo En Python B1 B2 not B1 B1 and B2 B1 or B2 B1 ^ B2
Négation Non(a) not(a) True True False True True False
Conjonction a ET b a and b True False False False True True
Disjonction a OU b a or b False True True False True True
Disjonction a OUEX b a ^ b False False True False False False

w
Tous les opérateurs relationnels retournent une valeur de type logique, quel que soit le type des objets
comparés.
ar
Soit x et y deux objets d'un type supportant les opérateurs relationnels, la liste de ces opérateurs est :
Syntaxe en Algo Syntaxe en Python Description
x<y x<y Inférieur
x≤y x <= y Inférieur ou égal
x>y x>y Supérieur
x≥y x >= y Supérieur ou égal
M
x=y x == y Égal (attention !)
x <> y x != y Différent
x≠y x != y Différent
xЄy x in y Appartient

Activité :
ZI

Compléter les expressions booléennes manquantes dans la liste des affectations suivantes en respectant la
valeur imposée de la variable booléenne Y :
La valeur de la variable
Affectations
booléenne Y doit être égale à :
Y← 7 > ………….. Vrai
JA

Y← (6=6) et ( ……………………….) Vrai


Y← (6>6) ou ( ……………………….) Faux
Y← 5 Mod 10 = …………… Vrai
Y← 18 Div 3 ………………………… Faux
Y← (18 Mod 19 ≠ …………. ) Vrai
Y← ( (10 Div 2) x 2 ) Mod 10 …….…………….. Vrai
Y← Non(………………………….) Faux
Y← Non( (7 mod 3 …………..) et ( 19 Div 4 …………………) ) Faux
Y← Non( (7 mod 14 …………) ou ( 8 Div 10 ………………) ) Vrai

7
Les structures de
données

5) Le type caractère :
Une variable de type caractère contient un caractère et un seul. Un caractère est représenté par le caractère lui-
même placé entre apostrophes. Puisque le type caractère n’existe pas en Python, on peut le remplacer par le type
chaine de caractères.
En Algo En Python
Caractère str
Les fonctions standards relatives aux chaînes de caractères
Syntaxe en Algo Syntaxe en Python Description Exemple
chr(x) chr(x) Renvoie le caractère dont le code est le nombre entier x.

e
ord(c) ord(c) Renvoie le code ASCII du caractère c. Il s'agit de l'inverse de chr().

6) Le type chaîne de caractères :


Une chaîne de caractère est un objet qui peut contenir n caractères où 0≤n≤255. Si n=0, la chaîne est dite vide.

an
• Le caractère de position i dans une chaîne de caractères ch est symbolisé par ch[i].
• En algorithme, le premier caractère de la chaine est de position 0 (et en Python de position 0).
• En Python, une chaîne de caractères est un objet immutable, c’est-à-dire que ses caractères ne peuvent
pas être modifiés par une affectation séparée et sa longueur est fixe.
• Si on essaye de modifier un caractère d’une chaîne de caractères, Python renvoie une erreur.
En Algo En Python

Syntaxe en Algo Syntaxe en Python w


Chaine de caractères

Description
str

Les fonctions standards relatives aux chaînes de caractères


Exemple
ar
Permet la concaténation de deux ou plusieurs
+ +
chaines de caractères
Permet d’extraire une partie de la chaîne
construite par les caractères qui se trouvent
M
Sous-chaine(ch,d,f) ch[d:f] entre la position d et f (f exclu). Cette
opération renvoie le morceau de la chaîne
sélectionné, sans modifier la chaîne d'origine.
Retourne le nombre de caractères d’une
Long(ch) len(ch)
chaine
Permet de transformer la plupart des
Convch(n) str(n) variables d'un autre type en chaînes de
ZI

caractère
Construit un nombre entier ou réel à
int(ch) / float(ch) / partir d’un entier, d’un réel ou d’une
Valeur (ch)
eval(ch) chaîne (à condition que la chaîne
représente un nombre entier)
JA

Mettre tous les caractères d’une chaîne ch en


Majus(ch) ch.upper()
majuscules

Retourne la position d’une sous chaîne ch2


Pos(ch2,ch1) ch1.find(ch2)
dans une chaine ch1
Retourne True, si tous les caractères de la
chaîne sont des caractères numériques ou
EstNum(ch) ch.isnumeric() False, si au moins un caractère n’est pas un
caractère numérique.
Il existe aussi : isdigit(), isalpha(), isalnum()
Sch1=ch[:d+1] Permet de supprimer une sous chaine depuis ch←"Python c’est facile"
Effacer(ch,d,f) Sch2=ch[f:] de la chaine ch en commençant du caractère Effacer(ch,7,9)
Ch= Sch1+ Sch2 de position d jusqu’au caractère de position f. ch devient " Python est facile "

8
Les structures de
données

Activité :
On considère la chaîne de caractères s="Bonjour le monde !". Déterminer les sous-chaînes suivantes :
Instruction Résultat
s[:4]
s[6:]
s[1:3]
s[-3:-1]
s[:-4]
s[-5:]
s[0:7:2]

e
s[2:8:3]
s[::-1]
s*2

an
s+" ça va ?"
len(s*3)
s.find("on")
s.isnumeric()
s.upper()
s[:7]+chr(32)+ "tout"+chr(32)+s[8:-1]+":)"

7) Les tableaux :

w
Un tableau est une variable indicée permettant de stocker n valeurs de même type. Le nombre n d'éléments, qui est
précisé à la déclaration, s'appelle la taille (ou capacité) du tableau. Les éléments d’un tableau ont généralement le
même type de données. La position d'un élément s'appelle indice ou rang de l'élément.
ar
On peut traduire le tableau en Python en une liste. Une liste est une collection ordonnée d’éléments éventuellement
hétérogène. Ces éléments sont séparés par des virgules et entourés de crochets et accessibles à l’aide des indices
associés (maliste[indice]).
M
Déclaration d’un tableau en Algo
Objet Type/Nature
T Tableau de N Type_élément

Les fonctions standards relatives aux listes


ZI

Syntaxe en
Syntaxe en Python Description Exemple
Algorithme
Permet d’ajouter un élément v
Lire(T[i]) T.append(v)
à la fin d'une liste.
Permet d’afficher les éléments
Ecrire(T[i]) print(T[i])
JA

d’un tableau T.
Pour changer la valeur d’un élément d’une liste on utilise l’expression suivante : liste[indice]←NouvelleValeur

9
Les structures de
données

Opérateur / Fonction Rôle Exemple


len(T) Retourne la longueur de la liste T

Retourne le nombre d’élèments


T.count(v) avec la valeur spécifée v de la liste
T

Insère l’élément v à la position p


T.insert(p,v)
de la liste T

Permet de supprimer une valeur v


T.remove(v)
de la liste T.
Existe

e
aussi en Permet de supprimer l’élément
del(T[i])
Python d’indice i de la liste T.
Permet de supprimer l’élément

an
T.pop(p)
d’indice p de la liste T.

T.sort() Trie la liste

Permet de trouver la première


T.index(v[,start] [,end]) position de l’élément v de la liste
T entre start et end s’ils existent.
separateur.join(Liste)

min(T) / max(T)
une chaine de caractère
Renvoi le plus petit / grand
élément de la liste T
w
Permet de convertir une liste en
ar
Permet de copier liste L1 dans une
L2=L1.copy()
nouvelle liste L2

Activité :
M
Soit la variable msg="Python:c’est:facile",
Exécuter les instructions ci-dessous en Python et compléter le tableau suivant :

Instruction Résultat Observation


A=msg.split(":") A=
B=[1,12,5,6,3,19] B=
ZI

B.append(len(A[0])) B=
B.insert(3,len(A[1])) B=
B.append(max(B)) B=
B.append(len(A[0])*2) B=
print(B.count(19))
JA

print(B.index(5))
B.pop(2) B=
B.remove(19) B=
del(B[len(B)-1]) B=
B.sort() B=

10
Chapitre 2

Chapitre 2

e
an
w
Les actions
ar
M

élémentaires
ZI

simples
JA

11
Les actions
élémentaires simples

13 Les actions élémentaires simples


I- Introduction :
On sait bien qu'un programme comporte un ensemble d'actions exécutées par l'ordinateur, suivant un ordre bien
déterminé, pour assurer une tâche bien précise.
L'ensemble de ces actions peut se présenter sous forme de structures :
 Simples
 Conditionnelles
 Répétitives
Dans ce chapitre nous allons nous intéresser des structures simples.
Une structure est dite simple si elle est réduite à :

e
 Une action d'entrée ou lecture (saisie) de données.
 Une action d'affectation d'une valeur à une variable.
 Une action de sortie ou écriture (affichage) de données, de résultats ou de messages.

an
II- Les actions d’entrées :
Une action d'entrée consiste à saisir une ou plusieurs données à partir du clavier (ou autres sources d'entrées) pour
les ranger dans les cases mémoires correspondantes.
Syntaxe :
En algorithme En Python
LIRE (Identificateur_objet) Identificateur_objet =input (ˮMessageˮ)

Exemples :
Tâche
Lire un entier A LIRE (A)
En Algo
w En Python
ar
Lire un entier A (version 2) AFFICHER(″Donner A″); LIRE (A)
Lire une moyenne MOY LIRE (MOY)
Lire 3 entiers N1, N2 et N3 AFFICHER(″Donner 3 valeurs″);
LIRE (N1, N2, N3)
M
Lire un nom LIRE (NOM)

III- L’affectation :
L'affectation consiste à ranger une valeur dans la case mémoire d'une variable.

Cette action permet de modifier la valeur de la variable d'une manière interne (c'est à dire sans faire
appel à l'intervention de l'utilisateur)
ZI

Syntaxe :
En algorithme En Python
Identificateur_variable  Valeur Identificateur_variable = Valeur
Exemples :
JA

Coef  Coef1 + Coef2 Coef = Coef1 + Coef2


Moy  (Moy1 + Moy2) / 2 Moy = (Moy1 + Moy2) / 2
Ancienne valeur Nouvelle valeur
6 X
3
X X X *2

IV- Les actions de sortie :


Une action de sortie sert à afficher une information sur l’écran (ou autres organe de sortie).
Cette information peut être :
Le contenu (valeur) d'un objet (constante ou variable)
La valeur d'une expression arithmétique (déjà évaluée par l'ordinateur)
La valeur d'une expression logique (expression booléenne)
Un message (commentaire)

12
Les actions
élémentaires simples

Syntaxe : Afficher un message


En algorithme En Python avec retour du
AFFICHER (Identificateur_objet) print (Identificateur_objet) curseur à la ligne.
AFFICHER ("Message") print (ˮMessageˮ)
Ou bien
print (ˮMessage\nˮ)
Exemple :
En Algorithme En Python
AFFICHER (A) print (A)
AFFICHER ("Donner un entier:") print ("Donner un entier: ")
AFFICHER ("A =") print ("A =")

e
AFFICHER (A) print (A)
AFFICHER ("A =", A) print ("A =", A)

an
On peut fixer le formatage d'affichage des variables comme suit :
 Ancienne méthode :
Syntaxe :
print(“%[largeur][.précision]type“%(valeur(s)))
Exemples :

w
Le retour à la ligne peut être forcé par le caractère \n, la tabulation par le caractère \t :
ar
M

 Nouvelle méthode :
Syntaxe :
print(“{[largeur]:[.précision]type}“.format(valeur(s)))
Exemple :
ZI

Avec :
 Tous ce qui est entre [ ] est optionnel
 largeur : largeur totale (en caractère) sur laquelle on veut afficher la valeur
 précision : nombre de chiffres à afficher de la valeur réel utilisée
JA

 type : peut être :


• d:pour les entiers
• f :pour les réels
• s :pour les chaines de caractères
 Formatage de chaînes manuellement :
En Python Description Exemple
Renvoie une chaîne alignée à
ch.rjust(largeur[, fillchar])
droite et rempli avec fillchar.
Renvoie une chaîne alignée à
ch.ljust(largeur[, fillchar])
gauche et rempli avec fillchar.
Renvoie une chaîne centrée et
ch.center(largeur[, fillchar])
rempli avec fillchar.

13
Chapitre 3

e
Chapitre 3

an
w
Les structures de
ar
contrôle
M

conditionnelles
ZI
JA

14
Les structures de
contrôle condionnelles

14 Les structures de contrôle conditionnelles


I- Introduction :
Nous avons traité dans le chapitre précédent des algorithmes manipulant des structures simples. Mais,
souvent, on est amené à traiter des problèmes ou il est nécessaire de faire des choix et par conséquent prendre des
décisions (traitements) en fonction de ces choix.
Dans ce chapitre nous allons traiter des problèmes manipulant des structures de contrôles conditionnelles qui
peuvent se présenter sous 3 formes :
les structures conditionnelles à forme simple.
les structures conditionnelles à forme complète.

e
les structures conditionnelles généralisée.

II- Les structures conditionnelles : la forme simple :

an
1) Définition :
Une structure conditionnelle simple est dite réduite si son traitement est exécuté quand la condition est
vraie.
2) Syntaxe :
En algorithme En python
SI Condition ALORS if Condition :
Instruction 1 Instruction 1

w Instruction 2
.
Instruction n
FINSI
Instruction 2
.
Instruction n
Identation
ar
 Dans cette forme, en évaluant la condition :
 Si la valeur de la condition est VRAIE les instructions indiquées entre ALORS et FINSi seront exécutées.
 Si la valeur de la condition est FAUX les instructions indiquées entre ALORS et FINSi ne seront pas exécutées.
 Python utilise le symbole de deux points ( : ) et en retrait (identation) pour marquer là où commence et où
se termine le code de la structure.
M

Activité :
Écrire un algorithme puis la traduction en Python d’un programme intitulé SUP qui affichera la plus grande
valeur (MAX) de 2 entiers donnés N1 et N2.

III- Les structures conditionnelles : la forme complète :


ZI

1) Définition :
La structure conditionnelle est une structure dans laquelle on a à choisir entre deux traitements ou plus.
Une structure conditionnelle simple est dite complète si suivant la valeur d'une condition, on exécute soit un
traitement T1 soit un traitement T2.
2) Syntaxe :
JA

En algorithme En python
SI Condition ALORS if Condition :
Traitement 1 Traitement 1
SINON else :
Traitement 2 Traitement 2
FIN SI Identation

Activité :
Écrire un algorithme puis la traduction en Python d’un programme intitulé PARITE qui affiche un message
vérifiant la parité d’un entier E donné.

15
Les structures de
contrôle condionnelles

IV- Les structures conditionnelles : la forme généralisée :


1) Syntaxe :
En algorithme En Python
SI Condition1 ALORS if Condition1 :
traitement1 Traitement 1
SINON SI Condition2 elif Condition2 :
ALORS traitement2 Traitement 2
………….. …………..
SINON SI Condition n-1 elif Condition n-1 :
ALORS Traitement n-1
traitement n-1 else :

e
SINON Traitement n
traitement n
FIN SI

an
Activité :
Écrire un algorithme puis la traduction en Python d’un programme intitulé SAISON qui affichera le nom de
la saison en fonction de sa première lettre (S) donnée.

V- Structure conditionnelle à choix multiple :


1) Définition :

w
Une structure de contrôle conditionnelle est dite à choix lorsque le traitement dépend de la valeur que prendra le sélecteur.

2) Syntaxe :
ar
En algorithme En Python
SELON Selecteur
Valeur1, Valeur2,… : instruction(s) Puisque la structure conditionnelle à choix
Valeur3 : Instruction(s) multiple n’a pas d’équivalent en Python,
……………….. on pourra la remplacer par la structure
M
[Autres : instructions] conditionnelle forme généralisée
FIN SELON

Activité :
Écrire un algorithme puis la traduction en Python d’un programme intitulé JOURS qui affichera le nombre
ZI

de jours d’un mois, en fonction du numéro d’un mois (M) et une année (A) donnés.
JA

16
Chapitre 4

Chapitre 4

e
an
La saisie
w
contrôlée
ar
M
ZI
JA

17
La saisie contrôlée

15 La saisie contrôlée
Activité :
Ecrire un algorithme puis la traduction en Python d’un programme intitulé « Décision_Examen » qui à partir des
deux notes N1 et N2 de coefficients respectifs 3 et 4 obtenues par un élève dans un examen, affiche un message
indiquant si l’élève a réussi ou en revanche a échoué.

Prenons le cas où l’utilisateur se trompe et introduit par exemple les notes suivantes :
N1=35 & N2=16 ce qui donne une moyenne égale à 24,14 autrement dit l’élève sera déclaré comme admis, ce qui
n’est pas acceptable.

e
Questions :
 Comment doit-on modifier la solution pour que l’ordinateur redonne la possibilité à l’utilisateur de saisir

an
une nouvelle note à chaque fois que celle-ci est hors intervalle.
 Combien de fois l’ordinateur va-t-il inviter l’utilisateur à réintroduire la note ? Inconnu
 Combien de fois au minimum l’ordinateur va-t-il redemander la saisie de la note ? 0 fois

Définition :
Prenons le cas d’une saisie au clavier (une lecture), où par exemple, le programme pose une question à laquelle
l’utilisateur doit répondre par O (Oui) ou N (Non). Mais tôt ou tard, l’utilisateur, facétieux ou maladroit, risque de

w
taper autre chose que la réponse attendue. Dès lors, le programme peut planter soit par une erreur d’exécution
(parce que la valeur de la réponse ne correspond pas au type de la variable attendu) soit par une erreur
fonctionnelle (il se déroule normalement jusqu’au bout, mais en produisant des résultats fantaisistes).
Alors, on met en place ce qu’on appelle un contrôle de saisie, afin de vérifier que les données entrées au clavier
ar
correspondent bien à celles attendues par l’algorithme.
Cette structure est utilisée lorsque le nombre de répétition d'exécution du module répétitif est inconnu.

La structure « répéter » :
Cette structure exécute les instructions placées entre (REPETER et JUSQU’A) et évalue à chaque répétition une
M
condition de type booléenne avant de continuer la boucle pour décider l'arrêt ou la continuité de la répétition. Il y a
donc au moins une fois exécution des instructions

Syntaxe
En Algorithme En python Lecture
Répéter n = input("Entrez un nombre: ")
ZI

Lire(n) while not(Condition) : False


Jusqu’à Condition n = input("Entrez un nombre: ") Condition

True
JA

Les instructions sont toujours exécutées au moins une fois. Dans ce cas on utilise la boucle Répéter
…Jusqu’à

Activité :
On souhaite réaliser la saisie du numéro d’un mois (compris entre 1 et 12) avec vérification..

18
Chapitre 5

Chapitre 5

e
Les structures

an
w
ar
de contrôle
M
ZI

itératives
JA

19
Les structures de
contrôle itératives

16 Les structures de contrôle itératives


Activité :
On se propose d’écrire un algorithme intitulé MOYENNE_CLASSE permettant
• De saisir la moyenne de chaque élève (pour un groupe de 3 élèves)
• De calculer et d’afficher la somme de la classe
Solution
0) Début MOYENNE_CLASSE
1) ......................................
2) Afficher(“Saisir la moyenne de l’élève N° 1 :”) , Lire

e
(............)
3) SOM ← .............. Pour éviter toutes ces répétitions, on utilise
4) Afficher (“Saisir la moyenne de l’élève N° 2 :”) , Lire les structures itératives appelées aussi

an
(............) structure répétitives ou boucles.
5) SOM ← ...............
6) Afficher (“Saisir la moyenne de l’élève N° 3 :”) , Lire
(............)
7) SOM ← ...............
8) MOY ← ....................
9) Afficher (“La moyenne de la classe est :”, MOY)
10) FIN MOYENNE_CLASSE

w
I- Structure de contrôle itérative complète : la boucle « pour »
Un résultat à une définition itérative complète s’il est la répétition d’une suite d’instructions un nombre fini de fois
ar
connu à l’avance.
Syntaxe
En algorithme En Python
Pour compteur de Vi à Vf faire For compteur in range (Vi, Vf+1):
Instruction 1 Instruction 1
M
Instruction 2 Instruction 2
….. …..
Instruction N Instruction N
FinPour

• Vi : Valeur initiale du compteur et Vf : Valeur finale du compteur.


ZI

• Le traitement de la boucle « Pour » s’arrête lorsque le compteur atteint la valeur finale (Vf).
• Les instructions entre « Pour » et « FinPour » constitue le corps du traitement à répéter.

Exemples :
JA

20
Les structures de
contrôle itératives
Activité :
Ecrire un algorithme puis la traduction en Python d’un programme intitulé PUISSANCE permettant de
déterminer puis d’afficher la valeur de P qui représente X à la puissance N (P = XN)

N.B. : On suppose que dans tous les cas les valeurs de X et N sont strictement positives.

II- Structures de contrôle itératives à condition d’arrêt :


Cette structure de boucle est utilisée lorsque le nombre de répétition d'exécution du module répétitif est inconnu.

1) La boucle « Répéter…Jusqu’à » :

e
a) Définition :
12 Cette boucle exécute les instructions placées entre (REPETER et JUSQU’A) puis évalue à chaque répétition une condition de type
booléenne avant de continuer la boucle pour décider l'arrêt ou la continuité de la répétition. Il y a donc au moins une fois
exécution des instructions.

an
b) Syntaxe :
Instruction
En Algorithme En python
Répéter Instruction
Instruction while not(Condition) : False
Jusqu’à Condition Instruction Condition

Activité :
w True

Ecrire un algorithme puis la traduction en Python d’un programme intitulé PALINDROME permettant de
ar
saisir un mot puis chercher si ce mot est un palindrome ou non. Un palindrome est un mot qui est
identique si on le lit de gauche à droite ou de droite à gauche.
Exemple : kayak est un palindrome

2) La boucle « tant que » :


M
a) Définition :
Ce type de boucle, contrairement à la précédente, évalue une condition avant d'exécuter des instructions (et non
pas l'inverse), c'est-à-dire qu'on peut ne pas entrer dans la structure de répétition si les conditions ne sont pas
favorables.
De plus, au moins une variable de l'expression d'évaluation doit être modifiée au sein de la structure de répétition
pour qu'on puisse en sortir.
ZI

b) Syntaxe :
False
En algorithme En Python Condition
TantQue Condition Faire While Condition :
Instruction 1 Instruction 1 True
JA

Instruction 2 Instruction 2 Instruction


…… ……
Instruction N Instruction n
Fin TantQue

Dans la boucle « TantQue », on peut tomber dans un cas où le traitement correspondant ne s’exécute aucune fois et
ceci si dès la première évaluation la condition est fausse.

Activité :
Écrire un algorithme puis la traduction en Python d’un programme intitulé TRAITEMENT permettant de
saisir une phrase quelconque ( PH ) puis élimine tous les espaces supplémentaires entre les mots (en
laissant un seul).
N.B. : On suppose qu'il n’existe aucun espace au début et à la fin de la phrase PH.

21
Annexe
IV- Pro cédu re :
Une procéd ure est u n sous-progra mme qui pe ut être paramétrée ou n on para métrée et qui e nglobe un traiteme nt qui ne ret ourne a ucun rés ultat.

Appel d’une pr océ dure


L’appel de la procéd ure se fait en i ndiq uant le nom d e la procédure s uivi de la liste des para mètres e ffectifs entre pare nthèse s.
Exemple : PROC AFFICHAGE (x) au niveau de l’alg orithme
AFFICHAGE (x) #au niveau d’un pro gramme Python

Table ASCII

e
an
w
ar
M
ZI
JA

22

Vous aimerez peut-être aussi