Nous ne pouv ons pas afficher l’image.

Nous ne pouv ons pas afficher l’image.

CAHIER
D’ LGORITHMIQUE
ET DE PROGRAMMATION
Date de mise à jour : 04/10/2022
Chapitre 1 : 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 2 : Les structures de données .......................................................................................................... 4

1) Le type entier : ..................................................................................................................................................... 5
2) Le type réel : ......................................................................................................................................................... 7
3) Les nombres aléatoires : ...................................................................................................................................... 7
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 3 : 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 : ......................................................................................................................................... 13

Chapitre 4 : 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 5 : Les structures de contrôle itératives.................................................................................... 17

I- Structure de contrôle itérative complète : la boucle « pour » .......................................................................... 18
II- Structure de contrôle itérative à condition d’arrêt :.......................................................................................... 19

Chapitre 6 : Les sous programmes .................................................................................................................. 20

I- Introduction : ..................................................................................................................................................... 21
II- Fonction :............................................................................................................................................................ 21
III- Procédures : ....................................................................................................................................................... 21

Annexe…………………………………………………………………………………………………………………..……………………………………………..24
 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
technologies de l’informatique. 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 1

Chapitre 1
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) Ecrire (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- Ecrire : 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
…………………. : ……………………………………. ……………….………………………

Algobox utilise l’instruction "Afficher" au lieu de l’instruction "Ecrire" pour réaliser la même chose.
ar
M
ZI
JA

3
Chapitre 2

e
Chapitre 2

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

Retourne la racine carrée de x si x est Entier

Racine_carré(x) sqrt (x) * Réel
positif sinon il provoque une erreur. ou Réel
Entier

Retourne un entier, en ignorant la partie

Réel

Ent(x) int (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

Même
Abs (x) abs (x) Retourne la valeur absolue de x. Entier ou Réel
type que x

e
Retourne l’entier le plus proche de
Arrondi(x) round (x) Réel Entier
x.

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

Retourne un entier, en ignorant la

Ent(x) int (x) Réel Entier
partie décimale de x.

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

Fonction Rôle Exemple

ar
aussi en Permet d’arrondir x à n chiffres après la virgule.
Python round(x[, n])
Si n est omis, la valeur par défaut à 0.

fabs Retourne la valeur absolue de x en float

M

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

booléenne Y doit être égale à :

Y← 7 > ………….. Vrai
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]

e
s[:-4]
s[-5:]
s[0:7:2]

an
s[2:8:3]
s[::-1]
s*2
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
ar
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.
En Python on utilise la bibliothèque numpy pour implémenter un tableau.
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
T[i]=int(input())  Importation du module
Permet de remplir la case d’indice i
Lire(T[i]) T[i]=float(input())
du tableau T par la valeur.
T[i]=input()
 déclaration d’un tableau
JA

Permet d’afficher l’élément d’indice i de 10 entiers

Ecrire(T[i]) print(T[i])
du tableau T.

* Pour utiliser les tableaux en Python, il faut importer la bibliothèque numpy :

9
Les structures de
données

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
On souhaite écrire une marche à suivre permettant d'assurer respectivement les actions suivantes :
o Saisir les noms d'un groupe de 5 élèves
o Saisir les notes de ces élèves (DC et DS)
o Calculer leurs moyennes
o Afficher les noms des élèves suivies de leurs moyennes
Des indices (ou des rangs)
ZI

0 1 2 3 4
ELEVE Lamia Mounir Samir Ali Sonia

ELEVE [0] ELEVE [4] = 'Ali'

JA

0
='Lamia' 1 2 3 4
MOY 11 9.75 14 1 7.66

MOY [2] = 14

10
Chapitre 3

Chapitre 3

e
an
w
Les actions
ar
M

élémentaires
ZI

simples
JA

11
Chapitre 4

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) ECRIRE(″Donner A″); LIRE (A)
Lire une moyenne MOY LIRE (MOY)
Lire 3 entiers N1, N2 et N3 ECRIRE(″Donner 3 valeurs″);
LIRE (N1, N2, N3)
Lire un nom LIRE (NOM)
M

III- L’affectation :
L'affectation consiste à ranger une valeur ou expression ou valeur d’une autre variable dans la case mémoire
d'une variable.
Cette action permet de modifier la valeur de la variable d'une manière interne
ZI

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

Identificateur_d’une_autre_variable Identificateur_d’une_autre_variable
Exemples :
Coef  3 Coef = 3
Moy  (Moy1 + Moy2) / 2 Moy = (Moy1 + Moy2) / 2

En Python, on peut affecter plusieurs variables en même temps

Exemple :
a3

a8

12
Chapitre 4

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)
Syntaxe :
En algorithme En Python
ECRIRE ("Message", objet) print ("Message", objet, end="")

e
ECRIRE ("Message", expression) print ("Message", expression, end="")
ECRIRE_NL ("Message", objet) print ("Message", objet)
ECRIRE_NL ("Message", expression) print ("Message", expression)

an
Exemple :
En Algorithme En Python Affichage
A  12 A=12 12
ECRIRE (A) print (A)
ECRIRE ("Donner un entier:") print ("Donner un entier: ") Donner un entier:
ECRIRE_NL ("A =", A) print ("A =", A) A=12
ECRIRE ("A+1 =", A+1)

w
print (("A+1 =", A+1, end="")
 L’instruction "print" fait un retour à la ligne automatique
A+1=13

 Le retour à la ligne peut être forcé par le caractère \n, la tabulation par le caractère \t :
 Pour écrire un commentaire en Python, il doit suivre le modèle suivant : """ commentaire """
ar
On peut fixer le formatage d'affichage des variables comme suit :
 Ancienne méthode :
Syntaxe :
M
print(“%[largeur][.précision]type“%(valeur(s)))
Exemples :
ZI

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

13
Chapitre 4

e
Chapitre 4

an
w
Les structures de
ar
contrôle
M

conditionnelles
ZI
JA

14
La saisie contrôlée

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

2) Syntaxe :

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
La saisie contrôlée

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.
ar
2) Syntaxe :
En algorithme En Python version ≥ 3.10 En Python version < 3.10
SELON Selecteur match Selecteur :
Valeur1, Valeur2,… : case Valeur1 : instruction(s) Puisque la structure conditionnelle à
instruction(s) case Valeur2 : instruction(s) choix multiple n’a pas d’équivalent en
M
Valeur3 : Instruction(s) case Valeur3 : Instruction(s) Python, on pourra la remplacer par la
……………….. ……………….. structure conditionnelle forme
[Sinon : instruction(s)] case _ : Instruction(s) généralisée
FIN SELON
N.B. : Le sélecteur doit être de type scalaire.
ZI

Activité :
Écrire un algorithme puis la traduction en Python d’un programme intitulé JOURS qui affichera le nombre
de jours d’un mois, en fonction du numéro d’un mois (M) et une année (A) donnés.
JA

16
Chapitre 5

Chapitre 5

e
an
Les structures
w
ar
M

de contrôle
ZI
JA

itératives
17
 Les structures de
contrôle itératives

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) Ecrire(“Saisir la moyenne de l’élève N° 1 :”) , Lire (............)

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

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

I- Structure de contrôle itérative complète : la boucle « pour »

Syntaxe
En algorithme w
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
connu à l’avance.

En Python
ar
Pour compteur de Vi à Vf [Pas=valeur_Pas] faire For compteur in range (Vi, Vf+1[, Pas]):
Instruction 1 Instruction 1
Instruction 2 Instruction 2
….. …..
Instruction N Instruction N
M
FinPour

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

• Le traitement de la boucle « Pour » s’arrête lorsque le compteur atteint la valeur finale (Vf).
• Les instructions entre « Pour » et « FinPour » constituent le corps du traitement à répéter.
• La valeur du Pas peut être positive ou négative. Par défaut, elle est égale à 1.
ZI

• Éviter de modifier la valeur du compteur de la structure itérative complète au niveau du

traitement.
Exemples :
JA

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.

18
 Les structures de
contrôle itératives
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’à » :
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.

b) Syntaxe :
Instruction

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

an
True
Activité :
Ecrire un algorithme puis la traduction en Python d’un programme intitulé PALINDROME permettant de
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

Activité :
w
On souhaite réaliser la saisie du numéro d’un mois (compris entre 1 et 12) avec vérification.
ar
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 :
En algorithme En Python
False
TantQue Condition Faire While Condition : Condition
Instruction 1 Instruction 1
JA

Instruction 2 Instruction 2 True

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

19
Chapitre 6

Chapitre 6

e
an
Les sous
w
ar
programmes
M
ZI
JA

20
 Les sous-
programmes

15 Les sous-programmes
I- Introduction
Certains problèmes conduisent à des programmes longs, difficiles à écrire et à comprendre. On les découpe en des
parties appelées sous-programmes (fonctions /procédure) ou modules.
Les modules sont des groupes d'instructions indépendants désignés par un nom.

LES AVANTAGES DE LA Modularité

Elles ont plusieurs intérêts :
• Permettent de "factoriser" les programmes, càd mettre en commun les parties qui se répètent.

e
• Permettent une structuration et une meilleure lisibilité des programmes
• Facilitent la maintenance du code (il suffit de modifier une seule fois).
• Les modules peuvent éventuellement être réutilisés dans d'autres programmes

an
II- Fonction:
1) Définition:
Une fonction est un sous-programme auquel on fournit certaines données (une ou plusieurs), qui les traite pour
obtenir un seul résultat de type simple (entier, réel, booléen, caractère, chaîne, types énumérés et types intervalles).

Qu’est-ce qu’un paramètre

w
Un paramètre est un objet qui sert à faire passer des informations entre un programme appelant et un
module appelé.
Paramètre formel
ar
C’est un paramètre qui figure dans la définition du module
Paramètre effectif
C’est un paramètre qui figure dans l’appel du module
Remarques :
 Les paramètres effectifs et les paramètres formels doivent s’accorder du point de vue nombre et ordre.
M
 Leurs types doivent être identiques ou compatibles.
Le type tableau fait partie des types structurés et non pas des types simples.

2) Syntaxe :
a) Déclaration :
En Algorithme En Python
ZI

Fonction Nom_Fonction (pf1 :type, pf2 :type,…,pfN :type) :Type résultat def Nom_Fonction(pf1, pf2,…, pfN) :
Début … (traitement)
… (traitement) Identation return valeur_finale
Retourner valeur_finale
Fin
JA

b) L’appel :
En Algorithme En Python
NomVariable Nom_fonction(pef1, pef2, …, pefN) NomVariable= Nom_fonction(pef1, pef2, …, pefN)

Activité :
Ecrire une fonction qui permet de chercher le nombre d’occurrence d’un entier donnée X dans un tableau d’entier T
de n entiers.

III- Procédure:
1) Définition:
Une procédure est un sous-programme qui peut être paramétrée ou non paramétrée et qui peut retourner un ou
plusieurs résultats. A la différence d’une fonction ces résultats peuvent être de types structurés.

21
 Les sous-
programmes

2) Syntaxe :
a) Déclaration :
En Algorithme En Python
Procedure nom_procedure (pf1:type, pf2:type ,…, pfN:type) : def Nom_procedure(pf1, pf2,…, pfN) :
Début … (traitement)
Identation
… (traitement)
Fin

b) L’appel :
En Algorithme En Python
Nom_procedure(pef1, pef2, …, pefN) Nom_ procedure (pef1, pef2, …, pefN)

e
Activité :

an
Écrire un module division(X,Y) qui affiche le quotient et le reste de division de deux nombres réels x et y passés en
paramètres.

3) Mode de passage des paramètres:

 Passage par valeur :
La valeur du paramètre effectif ne sera jamais modifiée après l’exécution d’un sous-programme. En Python, les
types (entier, réel, booléen, chaine de caractères, … passent par valeur)

 Passage par adresse (par référence) :

w
La valeur du paramètre effectif sera modifiée après l’exécution d’un sous-programme. En Python, les types (liste,
dictionnaire, …) passent par adresse.
ar
En algorithme, si le mode de passage est par adresse, on ajoutera le symbole @ avant le nom du
paramètre.
M
4) Les variables locales et globales:
 Variable locale :
Déclarée dans un sous-programme et n’est visible (utilisable) qu’à l’intérieur de de celui-ci.

 Variable globale :
Déclarée hors du sous-programme (c’est-à-dire dans le programme principal) et visible (utilisable) dans tout le
programme.
ZI

Activité :
Soit le programme python suivant :
Questions :
JA

1- Quelles sont le(s) variable(s) globale(s) du programme?

2- Quelles sont le(s) variable(s) locale(s) du module1?
3- Quelles sont le(s) variable(s) locale(s) du module2?
4- Pourquoi le programme affiche le message d’erreur :
NameError : name ‘a’ is not defined
dans la ligne 7

22
 Les sous-
programmes
Activité :
On désire faire un programme nommé « travail » qui permet de faire les tâches suivantes :
1- Saisir un entier n (avec 2<n<10).
2- Remplir un tableau t par n entiers.
3- Afficher le tableau t après le remplissage.
4- Calculer et afficher la moyenne du tableau t.
5- Chercher et afficher le maximum du tableau t.

NB: Il faut décomposer votre programme en modules

Travail demandé :

e
1- Faire l’algorithme du programme principal (n’oublier pas le TDNT et le TDOG).
2- Faire les algorithmes des modules envisagés (n’oublier pas les TDOLs).
3- Donner la traduction Python de votre programme.

an
w
ar
M
ZI
JA

23
 Annexe
V- 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
Dans la même collection