COURS 3SI

PROGRAMMATION
PYTHON
 Niveau : 3SI/4SC

Cours 3SI
ProgrammationPython
Chapitre 1 : Les structures de données et les structures simples
Chapitre 2 : Les structures algorithmiques de contrôle
Chapitre 3 : Les sous programmes
Chapitre 4 : Le vecteur et la matrice
Chapitre 5 : Les algorithmes de tri et de recherche
Chapitre 6 : Les algorithmes récurrents
Chapitre 7 : Les algorithmes arithmétiques
Chapitre 8 : Les enregistrements
Chapitre 9 : Les fichiers

Proposé par : Mr Y.G 1/61 A.S :22/23

 Niveau : 3SI/4SC

Chapitre1 : Les structures simples et les structures de données

I. L’opération d’entrée:
1. Définition :
L’opération d’entrée c’est l’instruction qui permet à l’utilisateur de rentrer ou de saisir des
valeurs au clavier pour qu’elles soient utilisées par le programme. Cette opération est la lecture.

2. Vocabulaire et syntaxe:
Algorithme Python
Lire (variable) variable = type (input( ))

3. Exemple :
Algorithme Python
Lire (n) n = int (input( ))

4. Remarque:
▪ Quand on demande à la machine de lire un variable, cela implique que l’utilisateur va devoir
écrire cettevaleur.
▪ Les données qui sont lues doit être compatibles aux variables réservées enmémoire.

II. L’opération de sortie:

1. Définition :
L’opération de sortie c’est l’instruction qui permet au programme de communiquer des
valeurs à l’utilisateur en les affichant à l’écran. Cette opération est l’écriture.

2. Vocabulaire et syntaxe:
En algorithme En Python
Affichage d’un texte : Affichage d’un texte :

Ecrire ("message") print ("message")

Affichage de contenu d’une variable : Affichage de contenu d’une variable :

Ecrire (variable) print (variable)

Affichage mixte (texte et variable) : Affichage mixte (texte et variable) :

Ecrire ("message", variable) print ("message", variable)

3. Exemple :
En algorithme En Python
Ecrire ("La valeur de n est : ") print ("La valeur de n est : ")
Ecrire (n) print (n)
ou bien ou bien
Ecrire ("La valeur de n est : ", n) print ("La valeur de n est : ", n)

4. Remarque:
▪ Quand on demande à la machine d’écrire une valeur, c’est pour que l’utilisateur puisse lalire.

5. Application:
Ecrire l’algorithme et son implémentation en Python d’un programme qui permet de
calculer puis d’afficher la somme de deux réels a et b.

Proposé par : Mr Y.G 2/61 A.S :22/23

 Niveau : 3SI/4SC

➢ Solution:
En algorithme En Python
Algorithme Somme
Début
Ecrire("a="), Lire (a) a = float(input("a="))
Ecrire("b="), Lire(b) b = float(input("b="))
som  a+b som = a+b
Ecrire (som) print ("som=", som)
Fin
Résultat d’exécution
▪ T.D.O :
O T/N
a,b, som Réels

III. L’opération d’affectation:

1. Définition :
L’opération d’affectation c’est une action qui permet d’affecter une valeur à une variable.
Elle est représentée par une flèche orientée vers la gauche «  ».

2. Vocabulaire et syntaxe:
Algorithme Python
Variable valeur Variable = valeur

3. Exemple :
Algorithme Python Commentaire Résultat
x5 x =5 x reçoit 5 x=5
ax+3 a =x+3 a reçoit la valeur de l’expression x+3 a = 5+3 = 8
xx-2 x =x-2 x reçoit la valeur de l’expression x-2 x = 5-2 = 3

4. Remarque:
▪ Il est évident que la variable située à gauche soit de typenumérique.
▪ Le type des variables situées à droite doit être de même type ou de type compatible que celle
située àgauche.
5. Application 1 :
Soit la séquence d'affectations suivante :
1) x  10
2) y  8
3) z x
4) x y
5) y z
1. Donner le résultat d'exécution de cette séquence sous forme d'untableau.
2. Quelles sont les valeurs finales de x et de y?
3. Quel est le rôle de cette séquence?
4. Quelle est l'utilité de la variable z?

6. Application 2 :
Ecrire l’algorithme et son implémentation en Python d’un programme qui permet de permuter
les contenus de deux réels a et b.

Proposé par : Mr Y.G 3/61 A.S :22/23

 Niveau : 3SI/4SC

IV. Les constantes et les variables:

Application :
On se propose de calculer et d’afficher sur l'écran le périmètre P et la surface S d'un cercle de
rayon R. Pour ce fait, on vous demande de d'écrire un algorithme correspondant et son
implémentation en Python.

V. Les types de données:

1. Le type Entier ( int):
a. Définition:
Le type Entier désigne un sous ensemble des nombres entiers relatifs Z.

b. Les opérations arithmétiques et relationnelles sur les entiers:

Opérations Opérations
Rôles Exemples
(en Algorithme) (enPython)
+ + Adition 5+2=7
- - Soustraction 5–2=3
* * Multiplication 5 * 2 = 10
/ / Division 5 / 2 = 2.5
DIV // Division entière 5 // 2 = 2
= == Egalité 5 = = 5 renvoie vrai
< < Inférieur 2 < 5 renvoievrai
> > Supérieur 5 > 2 renvoievrai
≤ <= Inférieur ou égal 2 <= 5 renvoie vrai
≥ >= Supérieur ou égal 5 >= 2 renvoie vrai
≠ != Différent 5 != 2 renvoie vrai
Xn X ** n Puissance 5 ** 2 = 25
MOD % Modulo 5%2=1

c. Application:
On se propose de saisir l'heure en seconde et de l'affiche en heure, minute et seconde. Pour ce
fait, on vous demande de d'écrire l'algorithme correspondant et le traduire en Python.

2. Le type Réel ( float ):

a. Définition:
Le type Réel désigne un sous ensemble des nombres Réels IR.

b. Les opérations arithmétiques et relationnelles sur les réels:

Les mêmes opérations que les entiers.

c. Les fonctions prédéfinies sur les réels:

Fonctions (en algorithme) Fonctions (en Python) Exemple

Tronc (x) int (x) int (3.51) = 3
Arrondi (x) round (x) round (3.49) = 3 et round (3.5) = 4
Abs (x) abs (x) abs (-3) = 3
RacineCarré (x) sqrt (x) sqrt (25) = 5
Aléa ( ) random ( ) Renvoie un réel aléatoire de [0, 1[
Aléa (a, b) uniform (a, b) Renvoie un réel aléatoire de [a, b]
Aléa (m, n) randint (m, n) Renvoie un entier aléatoire de [m, n]

Proposé par : Mr Y.G 4/61 A.S :22/23

 Niveau : 3SI/4SC

d. Application:
Ecrire un algorithme d’un programme qui permet de saisir un réel R, puis de calculer et
d’afficher sa racine carrée Rc.
3. Le type Booléen ( bool):
a. Définition:
Le type booléen comporte deux valeurs Vrai et Faux (True et False en Python).

b. Opérations logiques sur les Booléens:

En Algorithme En Python Rôle

NON NOT Négation
OU OR Disjonction
ET AND Conjonction
OUex XOR ou exclusif

La table de vérité qui manipule ces opérateurs est :

x y NON(x) x ET y x OU y x OUex y
V V F V V F
V F F F V V
F V V F V V
F F V F F F

4. Le type chaîne de caractère( str):

a. Définition:
C'est une succession de n caractère (lettre, symbole, chiffre) avec n ≥ 0.

Remarque :
▪ Si n = 0 alors la chaîne est dite vide ("" : chaîne vide).
▪ Les valeurs chaîne de caractères sont définies entreguillemets

b. Manipulation de chaîne de caractère:

On peut accéder en lecture et en écriture au ième caractère d'une chaîne Ch en utilisant la notation
CH[i] avec 1 ≤ i ≤ Long (Ch).

 Exemple :Soit Ch"Bonjour papa"

• Ch [0] ="B"
• Ch [1] ="o"
• Ch [:3] = "Bon" renvoie les trois premierscaractères
• Ch [3:] = "jour papa" renvoie Ch on élimine les trois premierscaractères
• Ch [::3] ="Bjra"
• Ch [3:7] = "jour" renvoie une sous chaine de Ch de la position 3 jusqu’à la position7-1=6

Proposé par : Mr Y.G 5/61 A.S :22/23

 Niveau : 3SI/4SC

c. Fonctions prédéfinis sur les chaînes de caractère:

Fonctions Fonctions
Exemples
en algorithme enPython
Concat (ch1, ch2) ch1 +ch2 "Bon" + "jour" renvoie "Bonjour"
Long (ch) len (ch) len ("Bonjour") renvoie 7
Ch = " Bonjour papa "
EffaceEspace(Ch) Ch.Strip()
Ch.Strip() renvoie "Bonjour papa"
Ch = "Bonjour"
Pos (ch1, ch) Ch.find (ch1)
Ch.find ("on") renvoie 1
Ch = "Bonjour papa"
Remplace (Ch1, Ch2, Ch) Ch.replace(Ch1, Ch2) Ch.replace("papa","maman")
renvoie "Bonjour maman"
MAJUS (Ch) Ch.upper() Ch = "Bonjour"
Ch.upper() renvoie "BONJOUR"
MINUS (Ch) Ch.lower() Ch = "Bonjour"
Ch.lower() renvoie "bonjour"
Occurrence (Ch1, Ch) Ch.count(Ch1) Ch = "Bonjour"
Ch.count("on") renvoie 1

VI. Les listes (Les tableaux):

1. Définition :
Une liste est une structure de données permettant de ranger un nombre fini d'éléments de
mêmes types ou de types différents. Elle peut contenir même deslistes

2. Création d'une liste:

Les listes en Python peuvent être créées en plaçant simplement la séquence entre crochets [ ]
 Exemple :
# Liste vide
list = []

# liste avec éléments

list=['lundi','mardi']

# liste avec éléments de types différents

list=['mostafa','essaddouki', 31, 2019]

# liste entiers
list=[1, 2, 3]

# liste avec 10 éléments

list=[0] * 10

# afficher les éléments d'une liste

# tous les éléments

print(list)

# premier élément
print(list[0])

# 2èmeélément
print(list[1])

# dernier élément
print(list[-1])

Proposé par : Mr Y.G 6/61 A.S :22/23

 Niveau : 3SI/4SC

3. Ajouter des éléments:

 Exemples :
# création de la liste
list = []
# ajouter des éléments à la liste
list.append(1)
list.append(2)
list.append(4)

print("\n Liste après ajout de trois éléments ")

print(list)

# ajouter plusieurs éléments (1, 2, 3)

# avec une boucle
for i in range(1, 4):
list.append(i)

# ajouter un élément dans une position spécifique

list.insert(0, 12)
# [12, 1, 2, 4]

# ajouter un élément dans une position spécifique

list.insert(2, 12)
# [1, 2, 12, 4]

# ajouter plusieurs éléments à la fin de la liste

List.extend([13 , 7, 9])

# [1, 2, 4, 13, 7, 9] 6 éléments dans la liste

4. Accéder aux éléments de la liste:

 Exemples :
# création de la liste
List = [9, 5,13]

# afficher les éléments d'une liste

# premierélément
print(list[0])
# ->9

# 2ème élément
print(list[1])
# ->5

# dernier élément
print(list[-1])
# ->13

# avant dernier élément

print(list[-2])
# -> 5

# liste imbriquée (matrice) ou tableau 2D

# 3 lignes et 4 colonnes
# 1 , 2, 5, 7
# 3, 7, 9, 8
# 10, 0, 4, 19

list=[[1, 2, 5, 7],[3, 7, 9, 8],[10, 0, 4, 19]]

# afficher l'élément de la ligne 2, 3ème colonne

print(list[1][2])
# -> 9

Proposé par : Mr Y.G 7/61 A.S :22/23

 Niveau : 3SI/4SC

# afficher l'élément de la ligne 3, 2ème colonne

print(list[2][1])
# -> 0

5. Supprimer des éléments de la liste :

 Exemples :
list = [5, 7, 8, 12]
# Supprimer des éléments de la liste
list.remove(5)
list.remove(8)
print("\nListe après la suppression: ")
print(list)
# -> [7, 12]

# Supprimer plusieurs éléments

for i in range(3):
list.remove(list[i])
print("\nListe après la suppression: ")
print(list)
# -> [12]

# supprimer le dernier élément

list.pop()
print(list)
# [5, 7, 8]

# supprimer l'élément de la position 1

list.pop(1)
print(List)
# [5, 8,12]

6. Accéder à une plage d'éléments (découpage ou slice) :

 Exemples :
list = [5, 7, 8, 12, 25, 18, 30]

# afficher tous les éléments de la liste

print(list)
# -> [5, 7, 8, 12, 25, 18, 30]

# afficher les 3 premiers éléments

print(list[:3])
# -> [5, 7, 8]

# afficher les éléments de la liste sans les 3 éléments derniers

print(list[:-3])
# -> [5, 7, 8, 12]

# afficher les éléments de la position 3 jusqu'à la fin

print(list[2:])
# -> [8, 12, 25, 18, 30]

# afficher les éléments avec un pas de 2

print(list[::2])
# -> [5, 8, 25, 30]

# afficher les éléments dans l'ordre inverse

list[::-1]
# -> [30, 18, 25, 12, 8, 7, 5]

Proposé par : Mr Y.G 8/61 A.S :22/23

 Niveau : 3SI/4SC

7. Méthodes
▪ sum()
Calcule la somme de tous les éléments de la liste.

1 # syntaxe : sum(List)
2 List=[1, 6, 3, 9]
3 print(sum(List))

▪ count()
Calcule le nombre d'occurrence d'un élément donné de la liste.

1 # syntaxe : List.count(valeur)
2 List=[10, 2, 3, 9, 2, 1, 2, 3, 2]
3 print(List.count(3))
4 # -> 2

▪ length()
Calcule la taille de la liste

1 # syntaxe : len(liste)
2 List=[10, 2, 3, 9, 2, 1, 2, 3, 2]
3 print(len(List))
4 # -> 9

▪ index()
Retourne l'index de première occurrence. Les index de début et de fin ne sont pas des paramètres
nécessaires.

1 #syntaxe : List.index(valeur[,debut[,fin]])
2 List=[10, 2, 3, 9, 2, 1, 2, 3, 2]
3 print(List.index(2))
4 # -> 1
5
6 # rechercher a partir de la position 3
7 print(List.index(2,3))
8 # -> 4
9
10 # rechercher dans la plage 3 - 6
11 print(List.index(2,3,7))
12 # -> 4

▪ min()
Calcule le minimum de tous les éléments de la liste.

1 # syntaxe min(List)
2 List=[10, 2, 3, 9, 2, 1, 2, 3, 2]
3 print(min(List))
4 # -> 1

▪ max()
Calcule le maximum de tous les éléments de la liste.

1 # syntaxe max(List)
2 List = [10, 2, 3, 9, 2, 1, 2, 3, 2]
3 print(max(List))
4 # -> 10

▪ reverse()
Inverser l'ordre des éléments dans la liste

Proposé par : Mr Y.G 9/61 A.S :22/23

 Niveau : 3SI/4SC

1 # syntaxe List.reverse()
2 List = [10, 2, 3, 9, 2, 1, 2, 3, 2]
3 List.reverse()
4 print(List)
5 # [2, 3, 2, 1, 2, 9, 3, 2, 10]

▪ sort()
Triez (tuple et liste) par ordre croissant.
Key et reverse_flag ne sont pas des paramètres nécessaires et reverse_flag est défini sur False, si
rien n'est passé par sort().

1 # Syntaxe de sorted : sorted([list[,key[,Reverse_Flag]]])

2 # syntaxe de sort : list.sort([key,[Reverse_flag]])
3 !:
4 List=[10, 2, 3, 9, 2, 1, 2, 3, 2]
5 List.sort(reverse=True) #décroissant
6 # -> [10, 9, 3, 3, 2, 2, 2, 2, 1]
7
8
9 sorted(List)
10 # -> [1, 2, 2, 2, 2, 3, 3, 9, 10]

▪ del()
supprimer un élément mentionné à l'aide du nom de la liste et son indice

1 # syntaxe del list[indice]

2 List=[10, 2, 3, 9, 2, 1, 2, 3, 2]
3 delList[2]
4 # -> List = [10, 2, 9, 2, 1, 2, 3, 2]
5
6 # supprimer une plage
7 delList[1:3]
8 # -> [10, 9, 2, 1, 2, 3, 2]

▪ Opérateur"in"
Cet opérateur est utilisé pour vérifier si un élément est présent ou non dans la liste. Renvoie true si
l'élément est présent dans la liste, sinon renvoie false.

1 List=[10, 2, 3, 9, 2, 1, 2, 3, 2]
2 if9inList:
3 print("élément est présent dans la liste")
4 else:
5 print("l'élément n'est pas présent dans la liste")

▪ Opérateur "notin"
Cet opérateur est utilisé pour vérifier si un élément n'est pas présent dans la liste. Renvoie true si
l'élément n'est pas présent dans la liste, sinon renvoie false.

1 List=[10, 2, 3, 9, 2, 1, 2, 3, 2]
2 if9notinList:
3 print("l'élément n'est pas présent dans la liste")
4 else:
5 print("l'élément est présent dans la liste")

Proposé par : Mr Y.G 10/61 A.S :22/23

 Niveau : 3SI/4SC

▪ Opérateurs "+" et"*"

"+" : Cet opérateur est utilisé pour concaténer deux listes en une seule liste.

"*" : Cet opérateur est utilisé pour multiplier la liste «n» fois et renvoyer une seule liste.

1 L1 = [1, 2,3]
2 L2 = [4, 5,6]
3
4 List1=L1+L2
5 # -> [1,2, 3, 4, 5, 6]
6
7 List2=L1 *3
8 # [1, 2, 3, 1, 2, 3, 1, 2, 3]

▪ clear()
Cette fonction permet d'effacer tous les éléments de la liste. Après cette opération, la liste devient
vide.

1 List=[10, 2, 3, 9, 2, 1, 2, 3, 2]
2 List.clear()
3 print(List)
4 # []

Proposé par : Mr Y.G 11/61 A.S :22/23

 Niveau : 3SI/4SC

Chapitre 2 : Les structures algorithmiques de contrôle

I. La structure de contrôle conditionnelle simple:

1. Activité 1:
Ecrire un programme qui permet de saisir un entier n et d’afficher leur signe (positif ou
négatif).
 Exemples :
▪ 5 estpositif
▪ -9 estnégatif
▪ 0 estpositif
D’après sur ce qu’on a déjà vu, on ne peut pas résoudre ce type de problème car on a amènera
à décider si l’entier n est positif ou négatif, donc on a intérêt de définir une nouvelle structure qui
permet de résoudre ce problème.
2. Définition :
La structure de contrôle conditionnelle simple est une structure algorithmique qui fait appel à
au maximum deux traitements suivant le résultat de l’évaluation d’une seule condition (vrai /
faux).
3. Vocabulaire et syntaxe:
Algorithme Python
Si condition alors if condition :
<traitement 1> <traitement 1>
Si non else :
<traitement 2> <traitement 2>
Fin Si

4. Remarque:
▪ Lorsque l'évaluation de la condition produit la valeur:
- Vrai : les instructions entre Alors et Fin Si sontexécutées.
- Faux : les instructions entre Alors et Fin Si ne sont pasexécutées.
▪ La condition peut être simple oucomposée.
▪ Si traitement 2 est vide, on parle de structure conditionnelle simple réduite qui à la syntaxe
suivante:
Algorithme Python
Si condition alors if condition :
<traitement 1> <traitement 1>
Fin Si

2. Solution de l’activité 1:
Algorithme Implémentation en Python
Algorithme Signe
Début
Ecrire ("Taper n : "), Lire(n) n = int (input ("Taper n : "))
Si n ≥ 0 Alors if n >= 0 :
msg ← "positif " msg = "positif"
Sinon else :
msg ← "négatif " msg = "négatif"
FinSi
Ecrire (n, " est ", msg) print (n, " est ", msg)
Fin
 T.D.O :
Objets Type/ Nature
n Entier
msg Chaine de caractère

Proposé par : Mr Y.G 12/61 A.S :22/23

 Niveau : 3SI/4SC

II. La forme généralisée :

Activité 2:
1.
Ecrire un programme qui permet de saisir un entier n et d’afficher leur signe (strictement
positif, strictement négatif ou nul).
 Exemples :
▪ 5 estpositif
▪ -9 estnégatif
▪ 0 estnul
Remarquez bien qu’on a plus que deux traitements donc on a intérêt de définir une nouvelle
forme de structure de contrôle conditionnelle qui nous permet de résoudre ce type de problème.
2. Définition :
La forme généralisée est utilisée lorsqu'on a le choix entre plus que deux traitements suivant
les résultats des les évaluations des plus que deux conditions.

3. Vocabulaire et syntaxe:

Algorithme Python
Si condition1 alors if condition1 :
<traitement1> <traitement 1>
Sinon Si condition2 alors elif condition2 :
<traitement2> <traitement 2>
… ...
Sinon Si conditionN-1 alors elif condition N-1:
<traitement N-1> <traitementN-1>
Sinon else :
<traitement N> <traitement N>
Fin Si

4. Remarque:
▪ L’exécution d’un traitement entraîne automatiquement le non exécution des autres
traitements.
▪ La condition peut être simple oucomposée.

5. Solution de l’activité 2:
Algorithme Implémentation en Python
Algorithme Signe
Début
Ecrire ("Taper n : "), Lire(n) n = int (input ("Taper n : "))
Si n > 0 Alors if n > 0 :
msg ← "strictement positif " msg = "strictement positif"
Sinon Si n<0 Alors elif n < 0 :
msg ← " strictement négatif " msg = " strictement négatif"
Sinon else :
msg ← "nul " msg = "nul"
Fin Si
Ecrire (n, " est ", msg) print (n, " est ", msg)
Fin
 T.D.O :
Objets Type/ Nature
n Entier
msg Chaine de caractère

Proposé par : Mr Y.G 13/61 A.S :22/23

 Niveau : 3SI/4SC

III. La structure itérative complète : la boucle [Pour … Faire]:

1. Activité 3:
Ecrire un programme qui permet d’afficher le mot « Informatique » 1000 fois.
Lenombrederépétitiondel’instruction[Ecrire("Informatique")]esttrèsgrandcequ’il
esitmpossibled’écrirecesnombresd’instructionsdonconaintérêtdedéfinirunenouvelle
structure appelé la structure de contrôle itérative complète que nous permet de répété
l’exécutiond’uneinstructionunnombreconnudefois.

2. Définition :
La structure itérative complète Pour … Faire est utilisée lorsqu'on a un nombre de répétition
connu à l’avance d’un traitement donné.
3. Vocabulaire et syntaxe:
Algorithme Python
Pour <compteur>de <Vi>à <Vf>Faire for <compteur>in range (Vi, Vf):
<traitement1> <traitement1>
Fin pour else :
<traitement 2>

4. Remarque:
• Le compteur est une variable de type scalaire énuméré (généralement entier ou caractère) et sa
pas d’incrémentation est par défaut de 1.
• Le compteur est initialisé à sa valeur initiale Vi et passe à sa valeur suivante après chaque
répétition jusqu'à attendre la valeur finaleVf.
• Vi et Vf sont de même type ou de type compatible que lecompteur.
• Si on utilise range(Vf) alors la valeur initiale Vi=0
• Si on utilise range(Vi, Vf, P) alors sa pas d’incrémentation devient de valeurP
• Dans toutes les structures, chaque traitement peut comporter une ou plusieursinstructions.
• La clause else est facultatif et elle n’est exécutée que lorsque on a attendre la valeur finale Vf-1
de la bouclefor
• On peut utiliser l’instruction break pour sortir de la boucle et passer à l’instructionsuivante
• On peut utiliser l’instruction contenue pour passer directement à l’itérationsuivante

5. Solution de l’activité 3:
Algorithme Implémentation en Python
Algorithme affichage
Début
Pour i de 0 à 1000 faire for i in range(1000) :
Ecrire ("Informatique") print("Informatique")
Fin Pour
Fin
 T.D.O :
Objets Type/ Nature
i Entier

I. La structure itérative à condition d'arrêt : La boucle [Répéter … Jusqu'à]:

1. Activité 4:
Ecrire un programme qui permet de saisir un mot de passe et confirmer à nouveau jusqu’à
avoir le mot de passe est confirmé correctement.
Sionutiliselesstructuresdecontrôlesconditionnellesl’utilisateurpeutsetromperdans lasaisir
de mot de passe, d’où la nécessité d’une nouvelle structure appelé la structure de
contrôleitérativeàconditiond’arrêtquenouspermetderépétél’exécutiond’uneinstruction un
nombre inconnu defois.
2. Définition :
La structure Répéter … Jusqu’à est utilisée lorsqu'on a dans le cas ou le nombre de répétition
d’un traitement donné est inconnu et que le traitement sera exécuté au moins une fois.

Proposé par : Mr Y.G 14/61 A.S :22/23

 Niveau : 3SI/4SC

3. Vocabulaire et syntaxe:
Algorithme Implémentation en Python
Répéter While True:
<traitement> <traitement>
Jusqu'à <condition de sortie> if <condition de sortie>
break

4. Remarque:
• S’il y a un éventuel compteur, il faut l’initialiser avant la boucle pour assurer son avancement
dans laboucle.
• La condition d‘arrêt est considérée comme une condition de sortie de la boucle car, une fois
elle est vérifier on quitte laboucle.
• La condition de sortie de la boucle peut être simple oucomposée.
• La boucle Répéter … Jusqu’à est une structure adaptée pour le contrôle de la saisie des
données. Elle impose l’utilisateur d’entrer des données qui vérifient certainescontraintes.

5. Solution de l’activité 4:
Algorithme Implémentation en Python
Algorithme Mot_Passe
Début
Répéter While True :
Ecrire (" Mot de passe:"), Lire (mot1) mot1=str(print("Mot de passe:"))
Ecrire ("Confirmation:"), Lire (mot2) mot2=str(print("Confirmation:"))
Jusqu’à (mot1 = mot2) if mot1 = mot2 :
Ecrire (" Mot de passe confirmé") break
Fin print("Mot de passe confirmé")

 T.D.O :
Objets Type ou Nature
mot1, mot2 Chaîne de caractère

IV. La structure itérative à condition d'arrêt : La boucle [Tant que … Faire]:

1. Activité 5:
On se propose de chercher le PGCD (plus grand commun diviseurs) de deux entiers m et n par
la méthode de la différence.
Pour mieux comprendre la méthode, prenons un exemple: si m=10 et n=16
PGCD (10, 16) = PGCD (10, 16-10)
= PGCD (10-6, 6)
= PGCD (4,6-4)
= PGCD (4-2,2)
=2
Lenombrederépétitionestinconnudoncimpossibled’opterpourlabouclePour…Faire
Voyons s’il est possible d’utiliser la boucle Répéter … Jusqu’à.
Algorithme
Algorithme PGCD Danslecasoum=nnoussommesamenésvers
Début uneboucleinfinie.Danscecasilfautquenous
Ecrire ("m= "), Lire (m) n’entrions pas dans la boucle dés que la
Ecrire ("n= "), Lire (n) conditionm=nestvérifiée.Donconaintérêtdes
Répéter définir une nouvelle structure qu’elle peut
Si m>n Alors résoudre ce type deproblème.
Mm-n
Sinon
Nn-m
FinSi
Jusqu’à (m=n)
Ecrire ("PGCD = ", m)
Fin

Proposé par : Mr Y.G 15/61 A.S :22/23

 Niveau : 3SI/4SC

2. Définition :
La structure Tant que … Faire est utilisée lorsqu'on a dans le cas ou le nombre de répétition
d’un traitement donné est inconnu et que le traitement sera exécuté zéro ou un nombre variable de
fois.
3. Vocabulaire et syntaxe:

Algorithme Python
Tant que <condition d’entrée>Faire while <condition d’entrée>:
<traitement 1> <traitement 1>
Fin Tant que else :
<traitement 2>

4. Remarque:
• S’il y a un éventuel compteur, il faut l’initialiser avant la boucle pour assurer son avancement
dans laboucle.
• La condition d‘arrêt est considérée comme une condition d’entrée car, tant que elle est
vérifier on itère encore jusqu’à sa nonvérification.
• La condition d’entrée dans la boucle peut être simple oucomposée.
• La clause else est facultatif et elle n’est exécutée que lorsque la condition d’entrée de laboucle
whiledevientfalse
• On peut utiliser l’instruction break pour sortir de la boucle et passer à l’instructionsuivante
• On peut utiliser l’instruction contenue pour passer directement à l’itérationsuivante

5. Solution de l’activité 5:
Algorithme Implémentation en Python
Algorithme PGCD
Début
Ecrire ("Taper n : "), Lire(n) n = int (input ("Taper n :"))
Ecrire ("Taper m : "), Lire(m) m = int (input ("Taper m :"))
Tant que (m≠n) Faire while(m!=n) :
Si m>n Alors if m>n :
m ← m-n m = m-n
Sinon else :
n ← n-m n = n-m
Fin Si
Fin Tant que
Ecrire ("PGCD=", m) print ("PGCD=", m)
Fin
 T.D.O :
Objets Type/ Nature
m,n Entier

Proposé par : Mr Y.G 16/61 A.S :22/23

 Niveau : 3SI/4SC

Chapitre 3 : Les sous-programmes

I. Introduction:
Afin de faciliter la résolution d’un problème complexe et de grande taille, on a intérêt à le
décomposer en sous problèmes indépendants et de taille réduite. A chaque sous problème on
associe un module assurant sa résolution qui peut être une fonction ou une procédure.
II. Les fonctions:

1. Activité 1:
Ecrire un algorithme et son implémentation en Python d’un programme qui permet de calculer
puis d’afficher le nombre de combinaison de P objets parmi N.
CPN= N! / (P!(N-P)!) ; N, P sont deux entiers strictement positifs avec N>P.
 Remarque:
OnconstatequelecalculdeN!,P!et(N-
P)!sefaitdelamêmemanièreetletraitementquicalculelafactorielleserépètetroisfoisetbiens
urleprogrammedévienttrèslong.

Donc on a besoin de définir un nouvel outil pour éliminer cette redondance.

2. Vocabulaire et syntaxe:

Algorithme
Fonction Nom_fonction (pf1: type1, pf2: type2, … , pfn : typen) : Type_résultat
DEBUT
<Traitement>
Retourner Résultat
FIN

Implémentation en Python
def Nom_fonction (pf1, pf2 , … , pfn ) :
<traitement>
Return Résultat

Proposé par : Mr Y.G 17/61 A.S :22/23

 Niveau : 3SI/4SC

3. Solution de l’activité 1:

➢ Solution:
En algorithme Implémentation en Python
Algorithme NbCombinaison
Début def Fact(M):
Répéter F=1
Ecrire ("N="), Lire (N) foriin range(2,M+1) :
Ecrire ("P="), Lire (P) F=F*i
Jusqu'à ((N>P) et (P>0))
F1Fact (N) return(F)
F2Fact (P)
F3Fact (N-P)
C F1/F2*F3 while (True) :
Ecrire (C) N = int(input("N="))
Fin P = int(input("P="))
▪ T.D.O.Globaux: if(N>=P) and (P>0):
Objets Type/ Nature break
F1,F2,F3,N, P, C Entiers F1=Fact(N)
F2=Fact(P)
Fonction Fact (M : Entier) : Entier F3=Fact(N-P)
Début C=F1/F2*F3
F 1 print("C=" , C)
Pour i de 1 à M+1Faire
F  F*i Résultat d’exécution pour N=9 et P=5
Fin Pour
Retourner (F)
Fin
▪ T.D.O.Locaux:
Objets Type/Nature
i,F Entiers

4. Caractéristiques
▪ Une fonction est un sous-programme qui retourne un type simple (entier,réel,…).
▪ Une fonction comporte des paramètres autres que lerésultat(paramètres formels).
▪ Retenons qu’une fonction est essentiellement un module de calcul et renvoi une seule
valeur d’un typesimple.

5. Remarque:

• Tout nouvel objet utilisé dans une fonction est appelé objetlocal.
• Tout objet déclaré dans le programme principal est appelé objetglobal.
• L’appel d’une fonction peut être effectué au niveau du programme principal ou au niveau d’un
moduleappelant et doit être affectée à une variable ou affichée directement
• Les paramètres formels qui figurent dans l’en tête de la déclaration de la fonction
correspondent à des variables locales utilisées dans soncorps.
• Les paramètres effectifs utilisés dans l’instruction d’appel de la fonction sont substitués aux
paramètres formels au moment de l’appel.

Proposé par : Mr Y.G 18/61 A.S :22/23

 Niveau : 3SI/4SC

III. Les procédures:

1. Activité 2:
Ecrire un algorithme et son implémentation en Python d’un programme qui permet de saisir 3
entiers a, b et c puis les afficher avec a suivi de a étoiles et b suivi de b étoiles et c suivi de c
étoiles.

 Remarque:

Onnepeutpasutiliserdesfonctionscommesolutioncarunefonctionestessentiellement
u
n
moduledecalcul.Donconabesoindedéfiniruneautremanièrededécomposition.

2. Vocabulaire et syntaxe:

Algorithme
Procédure Nom_procédure (pf1: type1, pf2: type2, … , pfn: typen)
DEBUT
<Traitement>
FIN

Python
def Nom_procédure (pf1, pf2, … , pfn) :
<Traitement>

3. Solution de l’activité 2:

➢ Solution:

En algorithme Implémentation en Python

Algorithme Affichage def Etoile(n):
Début print(n, end="")
Lire (a, b, c) for i in range(n) :
Etoile (a) print("*", end="")
Etoile (b)
Etoile (c)
a =int(input("a="))
Fin
b =int(input("b="))
▪ T.D.O.Globaux : c = int(input("c="))
Objets Type/ Nature Etoile(a)
a,b, c Entiers Etoile(b)
Etoile(c)
Procédure Etoile (n : Entier)
Début
Ecrire (n) Résultat d’exécution pour a=2, b=3 et c=5
Pour i de 0 à nFaire
Ecrire ("*")
Fin Pour
Fin
▪ T.D.O.Locaux:
Objets Type/Nature
i Entier

Proposé par : Mr Y.G 19/61 A.S :22/23

 Niveau : 3SI/4SC

4. Remarque:

• Tout nouvel objet utilisé dans une procédure est appelé objetlocal.
• Tout objet déclaré dans le programme principal est appelé objetglobal.
• L’appel d’une procédure peut être effectué au niveau du programme principal ou au
niveau d’un moduleappelant.

5. Les paramètres:

a. Les types de paramètres:

Il existe deux types de paramètres :
▪ Les paramètres formelsqui figurent dans l’en tête de la déclaration de la
procédure et correspondent à des variables locales utilisés dans soncorps.
▪ Les paramètres effectifsutilisés dans l’instruction d’appel de la procédure et sont
substitués aux paramètres formels au moment de l’appel.

b. Les modes de passages des paramètres:

La substitution des paramètres effectifs aux paramètres formels s’appelle mode de
passage de paramètres. Il existe deux modes de passages de paramètres :

▪ Passage par valeur:

Dans ce cas, toute modification des paramètres formels n'a aucun effet
sur les paramètres effectifs.
Le transfert de l'information se fait toujours du programme appelant vers le
programme appelé.

▪ Passage par variable:

Dans ce cas, toute modification portés sur le paramètre formel est la même sur le
paramètre effectif. Le transfert d'information entre le programme appelant et le
programme appelé se fait dans le 2 sens.
c. Remarque:
• Avec les fonctions on utilise toujours le passage de paramètre parvaleur.
• Comment choisir le mode de passage de paramètre?
• Sileparamètreestmodifiéparlaprocédure(lectureouaffectation)alorsonchoisit lepassage parvariable.
• Sileparamètren'estpasmodifiéparlaprocédure(affichageouleparamètreestutilisé
commedonnéepourfaireuntraitementquelconque)alorsonutiliselepassageparvaleur.
• Si le mode de passage est par variable (par référence, par adresse), on ajoutera le symbole@
avant le nom du paramètre (Algorithme)

Proposé par : Mr Y.G 20/61 A.S :22/23

 Niveau : 3SI/4SC

Chapitre 4 : Les tableaux

I. Le tableau à une dimension (Vecteur):
1. Définition :
Un vecteur est une structure de données permettant de ranger un nombre fini d'éléments de
même type.

2. Déclaration d'une variable de type vecteur:

En algorithme En Python
# Avec les listes
▪ TDO T = [TypeElements ( )] * Nombre
O T/N
# Avec la bibliothèque numpy
NomTab tableau de NbMaxTypeElements
from numpy import array
T =array([TypeElements( )] * Nombre)

➢ Exemple:
En algorithme En Python
# Avec les listes
▪ TDO T = [int ( )] * 20
O T/N
# Avec la bibliothèque numpy
T tableau de 20 entiers
from numpy import array
T =array ([int ( )] * 20)

➢ Remarque :
▪ Un vecteur est une suite de cases mémoire qui peut contenir des valeurs de mêmetype.
▪ Un vecteur est caractérisé par son nom, sa taille et les types de ses éléments.

3. Accès aux éléments d'un vecteur:

L'accès à chaque élément ce fait par le biais d'un indice.

➢ Exemple : Soit T un tableau de 10réels

T 10.50 0.25 6.00 -5.00 32.00 569.00 14.00 11.00 43.00 12.00
0 1 2 3 4 5 6 7 8 9
▪ 0, 1,…9: desindices.
▪ T [0] = 10.5
▪ T [1] = 0.25
▪ T [9] = 12.00
4. Modifier les éléments d'un vecteur:
➢ Activité : Soit T un vecteur de 5entiers
Donner le contenu de chaque élément du vecteur T après l’exécution de séquence
d’instructions suivantes:
▪ T [0] 20
▪ T [1] 2
▪ T [2]  T [1] DIV T[2]
▪ T [3]  T [3]*5
▪ T [4]  T [4] + T [3] * T[2]

➢ Solution:
T 20 2 10 50 70
0 1 2 3 4

Proposé par : Mr Y.G 21/61 A.S :22/23

 Niveau : 3SI/4SC

5. Application : (Le plus grand élément d'unvecteur)

Ecrire un algorithme et son implémentation en Python d’un programme qui permet de trouver et
d'afficher le plus grand élément d'un vecteur T de n entiers avec (5≤n≤20).
 Exemple:Ondonnepourn=8,T = 2 | 5 | 8 | 1 | 0 | 9 | 5 | 7 le résultat est " Max = 9 ".
➢ Solution:
En algorithme Implémentation en Python
Fonction saisir( ) : entier # Avec les listes
Début T = [int ( )] * 20
Répéter
Ecrire ("n="), Lire (n) def saisir():
Jusqu’à (5≤n≤20) while (True) :
retourner (n) n = int(input("n="))
Fin if(5<=n<=20) :
▪ TDO.Locaux break
Objet Type/Nature return(n)
n entier
def remplir(n):
Fonction remplir( n : entier ) : Tab for i in range(n) :
Début T[i]=int(input("T["+str(i)+"]="))
Pour i de 0 à n-1 Faire return(T)
Ecrire (" T[ ", i , " ]= "), Lire(T[i]) def affichemax(T,n):
Fin pour m=T[0]
retourner (T) for i in range(1,n):
Fin if T[i]>m:
▪ TDO.Locaux m=T[i]
Objet Type/Nature print("Max =",m)
T tableau de 20 entiers
i entier n=saisir()
T=remplir(n)
Procédure AfficheMax(T :Tab ; n :entier)
affichemax (T,n)
Début
MT[0]
# Avec la bibliothèque numpy
Pour i de 0 à n-1 Faire
from numpy import array
Si T[i]>M Alors
M  T[i] T =array ([int ( )] * 20)
Fin Si
Fin pour def saisir():
Ecrire ("Max = ", M) while (True) :
Fin n = int(input("n="))
▪ TDO.Locaux if(5<=n<=20) :
Objet Type/Nature break
M,i Entiers return(n)
Algorithme MaxTab def remplir(n):
for i in range(n) :
Début
n saisir() T[i]=int(input("T["+str(i)+"]="))
T remplir(n) return(T)
AfficheMax(T,n) def affichemax(T,n):
Fin m=T[0]
▪ TDNT for i in range(1,n):
if T[i]>m:
Type
m=T[i]
Tab= tableau de 20 entiers
print("Max =",m)
▪ TDO.Globaux
n=saisir()
Objet Type/Nature T=remplir(n)
n entier affichemax (T,n)
T Tab

Proposé par : Mr Y.G 22/61 A.S :22/23

 Niveau : 3SI/4SC

I. Le tableau à deux dimensions (Matrice):

1. Définition :
Une matrice est une structure de données permettant de ranger un nombre fini d'éléments de
même type, mais dépendent de deux critèresdifférents.
Chaque élément d’une matrice est identifié par un indice de ligne et un autre de colonne.

2. Déclaration d'une variable de type matrice:

En algorithme En Python

▪ TDO • Avec la bibliothèque numpy

O T/N from numpy importarray
T =array([[type( )]* Nc for i in range (Nl)])
NomTab tableau de Nl lignes *Nc
colonnes de TypeElements NB : L’accès à un élément de T :
T[ligne][colonne]

➢ Exemple:
En algorithme En Python

▪ TDO
O T/N
# Avec la bibliothèque numpy
T tableau de 2 lignes * 3 from numpy import array
colonnes des entiers T =array ([[int( )]*3 for i in range (2)])

3. Application: (La somme des éléments pairs et le produit des éléments impairs d'unematrice)

Ecrire un algorithme et son implémentation en Python d’un programme qui permet de trouver et
d'afficher La somme des éléments pairs et le produit des éléments impairs d'une matrice M des entiers
de L lignes et de C colonnes avec (3≤L≤20) et (3≤C≤20).

 Exemple : On donne pour L = 3, C = 4 et M = 2|2|0|1|

3|4|8|0|
1|5|6|1|

Le résultat est " Somme pairs = 22 et Produit impairs = 15 ".

➢ Solution :
from numpy import array
def saisie(M,l,c):
for i in range (l):
for j in range (c):
M[i][j]=int(input('M['+str(i)+']['+str(j)+']='))
def parité(x):
if x%2==0:
return True
else:
return False
def affichesomprod(M,l,c):
som=0
prod=1
Proposé par : Mr Y.G 23/61 A.S :22/23
 Niveau : 3SI/4SC

for i in range(l):
for j in range(c):
if parité(M[i][j])==True:
som = som + M[i][j]
else :
prod = prod * M[i][j]
print("Somme pairs =", som, " et Produit impairs", prod )
l=int(input('nombre de lignes'))
while not(3<=l<=20):
l=int(input('nombre de lignes'))
c=int(input('nombre de colonnes'))
while not(3<=c<=20):
c=int(input('nombre de colonnes'))
M=array([[int()]*c for i in range (l)])
print(M)
saisie(M,l,c)
print(M)
affichesomprod(M,l,c)

4. APPLICATION 1:
On désire afficher, à partir d’une matrice carréeM rempli par n*n entiers strictement positifs, tous les
élémentsqui sont premiers palindromes (les nombres qui sont à la fois premiers et palindromes)
SOLUTION :
from numpy import array
def palindrome(x):
ch=str(x)
l=len(ch)
pal=True
for i in range (l):
if ch[i]!=ch[l-i-1]:
pal=False
return pal
def premier (y):
prem=True
for i in range (2,(y//2)+1):
if y%i==0:
prem=False
return prem
def premierpalindrome(z):
if palindrome(z) and premier(z):
print(M[i][j],' est premier palidrome')
n=int(input('entrer taille matrice carré'))
while n<=0:
n=int(input('entrer taille matrice carré'))
M=array([[int()]*n for i in range (n)])
for i in range (n):
for j in range (n):
M[i][j]=int(input('M['+str(i)+']['+str(j)+']='))
for i in range (n):
for j in range (n):
premierpalindrome(M[i][j])

11 est un nombre premier palindrome 101 est un nombre premier palindrome 131 est un nombre premier
palindrome 151 est un nombre premier palindrome 181 est un nombre premier palindrome 191 est un

Proposé par : Mr Y.G 24/61 A.S :22/23

 Niveau : 3SI/4SC

nombre premier palindrome 313 est un nombre premier palindrome 353 est un nombre premier
palindrome 373 est un nombre premier palindrome 383 est un nombre premier palindrome 727 est un
nombre premier palindrome 757 est un nombre premier palindrome 787 est un nombre premier
palindrome 797 est un nombre premier palindrome 919 est un nombre premier palindrome 929 est un
nombre premier palindrome 10301 est un nombre premier palindrome 10501 est un nombre premier
palindrome
5. Application 2 :
Ecrire un programme qui permet de saisir une matrice de caractères m de l lignes (2<=l<=10) et c
colonnes (2<=c<=15) par des caractères alphabétiques minuscules puis une chaine de caractères non
vide puis de vérifier si la chaine ch existe dans m en horizontal et en vertical.

Solution :
from numpy import array
def verif(t1,t2,l,c,ch):
for i in range (l):
if ch==t1[i]:
return True

for i in range (c):

if ch==t2[i]:
return True

return False

l=int(input('entrer nbr ligne'))

while not(2<=l<=10):
l=int(input('entrer nbr ligne'))
c=int(input('entrer nbr colonne'))
while not(2<=c<=15):
c=int(input('entrer nbr colonne'))
m=array([[str()]*c for i in range (l)])
t1=array([str]*l)
t2=array([str]*c)

for i in range (l):

ch1=''
for j in range (c):
m[i][j]=input('m['+str(i)+']['+str(j)+'[=')
while not ('a'<=m[i][j]<='z'):
m[i][j]=input('m['+str(i)+']['+str(j)+'[=')
ch1=ch1+m[i][j]
t1[i]=ch1
for i in range (c):
ch2=''
for j in range (l):
ch2=ch2+m[j][i]
t2[i]=ch2
print(t1)
print(t2)
ch=input('entrer une chaine non vide')
l=len(ch)
while not(l!=0):
ch=input('entrer une chaine non vide')
print(ch,'existe dans m?',verif(t1,t2,l,c,ch))

Proposé par : Mr Y.G 25/61 A.S :22/23

 Niveau : 3SI/4SC

Chapitre 5 : Les algorithmes de tri et de recherche

I. Recherche Séquentielle:
Principe :
La méthode de recherche séquentielle consiste à comparer la valeur recherchée à toutes les valeurs
présentes dans le tableau jusqu’à la trouver ou terminer le tableau.
Exemple:
Soit T un tableau contenant les10 éléments suivants:

12 10 0 -5 8 12 -2 2 40 -1
0 1 2 3 4 5 6 7 8 9

Pour x =-2, le programme affichera que ‘’-2 existe’’

Pour x =5, le programme affichera que ‘’5 n’existe pas’’

Algorithme Implémentation en Python

Fonction Sequentielle( x,n :Entier,T:Tab) :Booléen def Sequentielle (x,n,T):
Début i=0
i0
trouvefaux trouve=False
tant que i<n et trouve=faux faire while i<n and trouve==False:
Si T[i]=x alors
if (T[i]==x) :
Trouvevrai
Sinon trouve = True
ii+1 else :
Fin Si
Fin Tq i=i+1
Retourner(trouve) return(trouve)
Fin
T.D.O Locaux:
O T/N
i Entier
trouve Booléen

II. Recherche Dichotomique:

Principe :
On va chercher un élément dans un tableau trié dans le sens croissant. Cette recherche consiste à diviser
l’intervalle de recherche par 2 à chaque itération. Pour cela, on procède de la façon suivante:

Soient premier et dernier les extrémités gauche et droite de l’intervalle dans lequel on cherche la valeur x, on
calcule m, l’indice de l’élément du milieu:
m=(premier + dernier ) div 2
Principe:
Il y a 3 cas possibles:
• x<T[m], l’élément x s’il existe, il se trouve dans l’intervalle [premier... m-1]
• x > T[m], l’élément de valeur x, s’il existe, se trouve dans l’intervalle [m+1... Dernier]
•x=T[m], x est trouvé, la recherche est terminée
La recherche dichotomique consiste à itérer ce processus jusqu’à ce que l’on trouve x ou que l‘intervalle de
recherche soit vide.
Exemple:
Soit T un tableau contenant les10 éléments suivants:

-5 -2 -1 0 2 8 10 12 12 40
0 1 2 3 4 5 6 7 8 9

Proposé par : Mr Y.G 26/61 A.S :22/23

 Niveau : 3SI/4SC

Pour x =-2, le programme affichera que ‘’-2 existe’’

Pour x =5, le programme affichera que ‘’5 n’existe pas’’

Algorithme Implémentation en Python

Fonction Dichotomique(x, n:Entier ,T:Tab) :Booléen
Début
Premier 0
dernier n-1
trouve Faux
Répéter
m (premier+dernier) DIV 2
Si (T[m]=x )Alors
TrouveVrai
Sinon Si (x<T[m]) Alors
Dernierm-1
Sinon
Premierm+1
Fin Si
Jusqu'à ((trouve = Vrai) OU (premier>dernier))
Retourner(trouve)
Fin
T.D.OLocaux:

O T/N
a, b,m Entiers
trouve Booléen

Proposé par : Mr Y.G 27/61 A.S :22/23

 Niveau : 3SI/4SC
III. Tri Par Sélection:
Principe :
Il consiste à chercher l’indice du plus petit nombre du tableau (de 0 à n) et le permuter avec l’élément 0 du tableau,
chercher ensuite le plus petit nombre (de 1 à n) et le permuter avec l’élément 1 du tableau, répéter ce traitement jusqu’à
arriver à l’élément n-1.
Exemple:

Algorithme Implémentation en Python

Procedure TriSélection(n : Entier ,@T : Tab) def TriSelection(n,T) :
Debut for i in range(n-1) :
Pour i de 0 à n-1 Faire posmin=i
posmin  i
for j in range(i+1,n) :
Pour j de i+1 à n Faire if T[posmin]>T[j] :
Si T[posmin] > T[j] Alors posmin=j
posmin  j aux=T[posmin]
Fin Si T[posmin]=T[i]
Fin Pour T[i]=aux
aux=T[posmin]
T[posmin]=T[i]
T[i]=aux

Fin Pour
Fin
T.D.OLocaux:
O T/N
i, j,posmin,aux Entiers

Proposé par : Mr Y.G 28/61 A.S :22/23

 Niveau : 3SI/4SC

IV. Tri à Bulles:

Principe:
1- On suppose que le tableau est ordonné en supposant qu’il n’y a pas d’échange à faire
(échangeFaux)
2- Parcourir la table de son début à n-1
3- Comparer l’élément en cours avec son successeur s’ils ne sont pas dans le bon ordre on les
Permute et on change la variable booléenne à Vrai (échangeVrai)
4- On répète les étapes précédentes jusqu’à avoir un tableau trié et qu’il n’ y a plus d’échanges à
faire(échangeFaux)
➢ Exemple:

Algorithme Implémentation en Python

Procedure TriBulles (n : Entier ; @T : Tab) def TriBulles(n,T) :
Debut echange=True
Répéter while (echange==True) :
echange Faux echange=False
Pour i de 0 à n-1Faire for i in range(n-1) :
Si (T[i] >T[i +1] ) Alors if T[i]>T[i+1] :
aux T[i] echange=True
T[i] T[i+1] aux=T[i]
T[i+1] aux T[i]=T[i+1]
echangeVrai T[i+1]=aux
Fin Si
Fin Pour
Jusqu'à (echange = Faux)
Fin
• T.D.OLocaux:
O T/N
i Entier
echange Booléen

Proposé par : Mr Y.G 29/61 A.S :22/23

 Niveau : 3SI/4SC

V. Application :
Ecrire un algorithme et son implémentation en Python d’un programme qui permet de vérifier
l’existence d’un entier x saisi au clavier dans un vecteur T de n entiers avec (5≤n≤20). On utilisant la
méthode de recherche dichotomique.
 Exemple:Siondonnen=8,T = 2 | 5 | 8 | 1 | 0 | 9 | 5 | 7 etx=1 le résultat est " 1 Existe dans T ".
➢ Solution:
En algorithme Implémentation en Python
Fonction saisir( ) : entier from numpy import array
Début T =array ([int ( )] * 20)
Répéter
Ecrire ("n="), Lire (n) def saisir():
Jusqu’à (5≤n≤20) while (True) :
retourner (n) n = int(input("n="))
Fin if(5<=n<=20) :
▪ TDO.Locaux break
Objet Type/Nature return(n)
n entier
def remplir(n,T):
Fonction remplir( n : entier ;T : Tab) for i in range(n):
Début T[i]=int(input("T["+str(i)+"]="))
Pour i de 0 à n-1 Faire
Ecrire (" T[ ", i , " ]= "), Lire(T[i]) def TriBulles(n,T):
Fin pour while True:
Fin Tri=True
▪ TDO.Locaux for i in range(n-1) :
Objet Type/Nature if T[i]>T[i+1]:
i entier aux =T[i]
T[i]=T[i+1]
T[i+1] =aux
Procedure TriBulles (n : Entier ; @T : Tab)
Tri = False
Debut
if Tri==True :
Répéter
break
Tri  Vrai
Pour i de 0 à n-2 Faire
def Dichotomique(x,n,T) :
Si (T[i] >T[i +1] ) Alors
a = 0
aux T[i]
b = n-1
T[i] T[i+1] Existe =False
T[i+1] aux while True:
Tri  Faux p = (a+b) // 2
Fin Si if ( T[p]==x ):
Fin Pour Existe = True
Jusqu'à (Tri = Vrai) elif (x<T[p]) :
Fin b = p-1
• T.D.OLocaux: else :
O T/N a = p+1
i Entier if (Existe==True) or (a>b) :
Tri Booléen break
return(Existe)
Fonction Dichotomique(x, n:Entier ;
@T:Tab):Booléen def afficher(n,T):
Début x=int(input("x="))
a 1 if Dichotomique(x,n,T)==True:
bn print(x,"Existe dans le tableau")
Existe  Faux else:
Répéter print(x,"N'existe pas dans le tableau")

Proposé par : Mr Y.G 30/61 A.S :22/23

 Niveau : 3SI/4SC

p  (a+b) DIV 2
Si ( T[p]=x )Alors n=saisir()
Existe Vrai remplir(n,T)
Sinon Si (x<T[p]) Alors TriBulles(n,T)
b  p-1 afficher(n,T)
Sinon
a p+1
Fin Si
Jusqu'à ((Existe = Vrai) OU (a>b))
Retourner(Existe)
Fin
• T.D.OLocaux:
O T/N
a,b, p Entiers
Existe Booléen

Procédure afficher (n :entier ; T :Tab )

Début
Ecrire("x="), Lire(x)
Si Dichotomique(x,n,T)=VraiAlors
Ecrire (x,"Existe dans letableau")
Sinon
Ecrire(x,"N'existe pas dans le tableau")
Fin
▪ TDO.Locaux
Objet Type/Nature
M,i Entiers

Algorithme Existence
Début
n saisir()
remplir(n, T)
TriBulles(n,T)
afficher(n,T)
Fin
▪ TDNT
Type
Tab= tableau de 20 entiers
▪ TDO.Globaux
Objet Type/Nature
n entier
T Tab

Proposé par : Mr Y.G 31/61 A.S :22/23

 Niveau : 3SI/4SC

Chapitre 6 : Les algorithmes récurrents

I. Introduction
Les algorithmes récurrents sont des algorithmes qui utilisent un traitement itératif pour produire
un résultat généralement calculé. Donc dans cette famille d’algorithmes, nous nous intéressons
au résultat final de l’itération. Ce résultat peut dépendre des p résultats précédents, on parle dans ce
cas d’un algorithme récurrent d’ordrep.

✓ un algorithme récurrent est dit d’ordre 1 si un résultat dépend durésultat précédent.

Exemple :
Dans le calcul d’une somme de n nombres, la somme des n premiers nombres est égale à la somme
des (n-1) premiers nombres ajoutée au nème nombre.

✓ un algorithme récurrent est dit d’ordre 2 si un résultat dépend des deux résultatsprécédents.
Exemple :
Dans la suite de Fibonacci, Bn = Bn-1 + Bn-2

Dans la suite de ce chapitre, nous allons traiter quelques algorithmes récurrents d’ordre 1 et d’ordre 2.

II. Calcul desomme

1. Présentation
Le calcul de la somme d’une série de nombres est un traitement très utilisé en programmation. Ils’agit
d’un traitement récurrent d’ordre 1 puisqu’à un niveau donné, la somme est égale à la valeur précédente de
la somme incrémentée de la valeur en cours de la variable àcumuler.
Dans ce qui suit, nous allons traiter deux cas de calcul de sommes :
- Cas 1 : calcul de la somme de n entierssaisis
- Cas 2 : calcul de la somme des éléments d’un tableau à deuxdimensions.

2. Applications
a. Application1
Ecrire un algorithme et son implémentation en Python d’une fonction Somme1 qui permet de
calculer la somme de n entiers saisis.

➢ Solution:
En algorithme Implémentation en Python
Fonction Somme1 (n : entier ) : entier def Somme1 (n) :
Début S=0
S0 for i in range(n) :
Pour i de 0 à n-1 Faire m=int(input("m ="))
S=S+m
Ecrire ("m ="), Lire (m)
return(S)
S  S+m
Fin Pour
retourner (S)
Fin
▪ TDO.Locaux
Objet Type/Nature
i,m,S Entiers

b. Application2
Ecrire un algorithme et son implémentation en Python d’une fonction Somme2 qui permet de
calculer la somme des éléments réels d’une matrice carrée comportant n lignes et n colonnes.

Proposé par : Mr Y.G 32/61 A.S :22/23

 Niveau : 3SI/4SC

➢ Solution:
En algorithme Implémentation en Python
Fonction Somme2 (M : Matrice ; n : entier ) : entier def Somme2 (M,n) :
Début S=0
S0 for L in range(n) :
Pour L de 0 à n-1 Faire for C in range(n) :
S=S+M[L,C]
Pour C de 0 à n-1Faire
return(S)
S  S +M[L,C]
Fin Pour
Fin Pour
retourner (S)
Fin
▪ TDO.Locaux
Objet Type/Nature
L,C Entiers
S Réel

III. Recherche du minimum et dumaximum

1. Présentation
La recherche du minimum ou du maximum d’une série de nombres est un traitement très utilisé en
programmation. Il s’agit d’un traitement récurrent d’ordre 1 puisqu’ à un niveau donné, la valeur du
minimum est égale à sa valeur précédente comparée à la valeur en cours.
Dans ce qui suit, nous allons traiter deux cas :
Cas 1 : La recherche du minimum et du maximum de n entiers saisis.
Cas 2 : La recherche du minimum et du maximum des éléments d’un tableau à deux dimensions.

2. Applications
a. Application 1:
Ecrire un algorithme et son implémentation en Python d’une fonction MinMax qui permet de
chercher la plus petite et la plus grande valeur de n entiers saisis.
➢ Solution:
En algorithme Implémentation en Python
Procédure MinMax (n : entier def MinMax (n) :
)Début m=int(input("m ="))
Ecrire ("m ="), Lire (m) mini=m
mini  m maxi=m
for i in range(1,n) :
maxi  m m=int(input("m ="))
Pour i de 1 à n-1 Faire if m<mini :
Ecrire ("m ="), Lire (m) mini=m
Si m < mini alors if m>maxi :
mini  m maxi=m
return(mini,maxi)
Fin Si
Si m > maxi alors
maxi  m
Fin Si
Fin Pour
Retourner (mini, maxi)
Fin
▪ TDO.Locaux
Objet Type/Nature
m, i Entiers

Proposé par : Mr Y.G 33/61 A.S :22/23

 Niveau : 3SI/4SC

b. Application 2:
Ecrire un algorithme et son implémentation en Python d’un programme qui permet de déterminer
puis d’afficherle minimum et le maximum des éléments réels d’une matrice carrée comportant
n lignes et n colonnes avec(3≤n≤20).

➢ Solution:
En algorithme Implémentation en Python
Algorithme RechercheMinMax from numpy import array
Début M =array ([[float ( )] * 20 for i in
nSaisir () range(21)])
Remplir (M, n)
def saisir():
mini,maxiPetitGrand(M,n)
while (True) :
Afficher (M, n, mini, maxi) n = int(input("n="))
Fin if(3<=n<=20):
break
▪ TDNT return(n) #Matrice carrée
Type
Mat=tableau de 20 lignes * 20 def remplir(M,n):
colonnes des entiers for i in range(n) :
for j in range(n) :
▪ TDO.Globaux M[i,j]=int(input("M["+str(i)+
Objet Type/Nature ","+ str(j)+ "]="))
n Entier
M Mat def PetitGrand (M, n) :
Remplir Procédure mini=M[0,0]
Afficher Procédure maxi=M[0,0]
for i in range(n):
Fonction saisir( ) : entier for j in range(n):
Début if M[i,j]<mini:
Répéter mini =M[i,j]
Ecrire ("n="), Lire (n) if M[i,j]>maxi:
Jusqu’à (3≤n≤20) maxi =M[i,j]
retourner (n) return(mini,maxi)
Fin
def afficher(M,n,mini,maxi) :
▪ TDO.Locaux mini, maxi = PetitGrand (M, n)
Objet Type/Nature print ("Minimum=", mini,
n entier "Maximum=", maxi)

n=saisir ()
Fonction remplir( M :Mat ;n:entier)
remplir (M, n)
Début
mini,maxi=PetitGrand(M,n)
Pour i de 0 à n-1 Faire
afficher (M, n, mini, maxi)
Pour j de 0 à n-1 Faire
Ecrire (" M[ ", i , ",", j, " ]= "),
Lire(M[i,j])
Fin pour
Fin pour
Fin

▪ TDO.Locaux
Objet Type/Nature
i, j entiers

Proposé par : Mr Y.G 34/61 A.S :22/23

 Niveau : 3SI/4SC

Procédure Afficher (M:Mat ; n:entier;

@mini,maxi:entier) Résultat d’exécution pour n=3
Début
mini, maxi  PetitGrand (M, n)
Ecrire ("Minimum=", mini,
"Maximum=", maxi)
Fin

▪ TDO.Locaux
Objet Type/Nature
PetitGrand Fonction

Fonction PetitGrand (M:Mat ; n

:entier) : Réel
Début
mini M[1,1]
maxi  M[1,1]
Pour L de 0 à n-1 Faire
Pour C de 0 à n-1 Faire
Si M[L,C] < mini alors
mini M[L,C]
Fin Si
Si M[L,C] > maxi alors
maxi M[L,C]
Fin Si
Fin Pour
Fin Pour
retourner (P)
Fin

▪ TDO.Locaux
Objet Type/Nature
L, C Entiers
p Réel

IV. Calcul sur lessuites

1. Présentation
La manipulation des suites permet de faire beaucoup de calculs récurrents. Avec des suites
arithmétiques, géométriques ou autres, nous pouvons faire des recherches du néme terme, un calcul de la
somme des p premiers termes, ….
On s’intéressera dans la suite aux traitements récurrents d’ordre 1.

2. Applications
a. Application1
Ecrire un algorithme et son implémentation en Python d’une procédure TermeN qui permet de
chercher et d’afficher les n premiers termes de la suite U définie par :
U0 = 5
Un = 2Un-1 +1.5

Proposé par : Mr Y.G 35/61 A.S :22/23

 Niveau : 3SI/4SC

En algorithme Implémentation en Python

Procédure TermeN (n : entier def TermeN (n) :
)Début U=5
U5 for i in range(1,n) :
Pour i de 1 à n-1 Faire U = 2*U + 1.5
U  2*U + 1.5 print (U, "|")
Ecrire (U, "|")
Fin Pour
Fin
▪ TDO.Locaux
Objet Type/Nature
i Entier
U Réel

b. Application2
Ecrire un algorithme et son implémentation en Python d’un programme qui permet :
✓ DedéterminerlederniertermeDtpourlequellasommedesnpremierstermesd’unesuite
W dépasse une limite L (100 ≤ L ≤ 500).
✓ D’afficher la liste des termes qui précèdentDt.

La suite W étant définie par : Wn = Un +2

U étant la suite définie au niveau de l’application 1.
U0 = 5
Un = 2Un-1 +1.5

En algorithme Implémentation en Python

Algorithme SomTermeW from numpy import array
Début W =array ([int ( )] * 20)
L=Saisir ()
Chercher (L, Dt, W, Di) def saisir():
while (True) :
Afficher (W, Di) L = int(input("L="))
Fin if(100<=L<=500) :
▪ TDNT break
Type return(L)
Tab=tableau de 20 Réels
def Chercher (L):
▪ TDO.Globaux W[0] = 7
Objet Type/Nature
Som = 7
Di Entier
L,Dt Réels i = -1
W Tab while Som ≤ L :
Saisir Fonction i = i + 1
Chercher Procédure W[i] = 2 * W[i-1] + 3.5
Afficher Procédure Som = Som + W[i]
Dt = W[i]
Fonction saisir( ) : entier Di = i
Début return(W,Dt,Di)
Répéter
Ecrire ("L="), Lire (L) def afficher(W, Di) :
Jusqu’à (100≤L≤500) for i in range(Di+1) :
retourner (L) print(W[i],"|",end="")
Fin

Proposé par : Mr Y.G 36/61 A.S :22/23

 Niveau : 3SI/4SC

▪ TDO.Locaux
Objet Type/Nature
L entier
Résultat d’exécution pour L=400
Fontion Chercher (L : entier)
Début
W[0]  7
Som  7
i  -1
Tant que Som ≤ L faire
ii+1
W[i]  2 * W[i-1] + 3.5
Som  Som + W[i]
Fin Tant que
Dt W[i]
Di  i
retourner (W, Dt,Di)
Fin

▪ TDO.Locaux
Objet Type/Nature
I,Di Entier
Som,Dt Réel
W Tab

Procédure Afficher (W:Tab ; Di:

entier)
Début
Pour i de 0 à Di Faire
Ecrire (W[i], "|")
Fin Pour
Fin
▪ TDO.Locaux
Objet Type/Nature
i Entier

V. Triangle dePascal
1. Présentation
Le triangle de Pascal fournit les coefficients de (a+b)n. C’est un procédé très utilisé et obtenu de
différentes façons en utilisant les combinaisons, ou un algorithmerécurrent.

2. Application
Ecrire un algorithme et son implémentation en Python d’une procédure PascalN qui permet de
remplir les n premières lignes du triangle de Pascal (n étant une donnée entière vérifant 2 ≤ n ≤ 20).

Proposé par : Mr Y.G 37/61 A.S :22/23

 Niveau : 3SI/4SC

En algorithme Implémentation en Python

Algorithme RechercheMinMax from numpy import array
Début M =array ([[int ( )] * 20 for i in
nsaisir () range(21)])
remplirN (M, n)
def saisir():
afficher (M, n)
while True :
Fin n = int(input("n="))
▪ TDNT if(2<=n<=20):
Type break
Mat=tableau de 20 lignes * 20 return(n) #Matrice carrée
colonnes des entiers
def remplirN(M,n):
▪ TDO.Globaux for i in range(n) :
Objet Type/Nature for j in range(i+1):
n Entier if i==j or j==0:
M Mat M[i,j]=1
saisir Fonction else:
remplir Procédure M[i,j] = M[i-1,j] +
afficher Procédure M[i-1,j-1]

Fonction saisir( ) : entier

Début def afficher (M,n) :
Répéter for i in range(n):
Ecrire ("n="), Lire (n) for j in range(n) :
Jusqu’à (2≤n≤20) if j<=i :
retourner (n) print(M[i,j],"|", end="")
Fin print("")
▪ TDO.Locaux
Objet Type/Nature n=saisir()
n entier remplirN(M,n)
afficher(M, n)
Fonction remplirN( M :Mat ;n:entier)
Début
Pour i de 0 à n-1 Faire
Pour j de 0 à i Faire
Si (i=j ou j=0) alors
M[i,j] 1
Sinon Résultat d’exécution pour n=8
M[i,j] M[i-1,j] + M[i-1,j-1]
Fin Si
Fin Pour
Fin Pour
Fin

▪ TDO.Locaux
Objet Type/Nature
i, j Entiers

Proposé par : Mr Y.G 38/61 A.S :22/23

 Niveau : 3SI/4SC

Procédure afficher (M:Mat ; n:entier)

Début
Pour i de 0 à n-1 Faire
Pour j de 0 à n-1 Faire
Si j≤i Alors
Ecrire (M[i,j], "|",end="")
Fin Pour
Ecrire ("\n")
Fin Pour
Fin

▪ TDO.Locaux
Objet Type/Nature
i, j Entiers

Proposé par : Mr Y.G 39/61 A.S :22/23

 Niveau : 3SI/4SC

Chapitre 7 : Les algorithmes arithmétiques

I. Le calcul duPGCD
1. Présentation
Pour chercher le PGCD de deux entiers a et b, nous pouvons appliquer l’algorithme d’Euclide qui
repose sur le principe suivant :
▪ Si a=b, le PGCD est a (oub)
▪ Sinon, a et b ont le même PGCD que b et le reste r de la division Euclidienne de a parb

2. Définition
Le plus grand commun diviseur de deux entiers a et b appelé aussi PGCD est le plus grand
entier permettant de diviser a et b. On le note PGCD (a,b).

3. Applications :
a.Application1
Ecrire un algorithme et son implémentation en Python d’une fonction qui permet d’utiliser
l’algorithme d’Euclide pour déterminer le PGCD de deux entiers donnés m et n.

➢ Solution:
En algorithme Implémentation en Python
Fonction PGCD_Euclide (m, n : entier ) : entier def PGCD_Euclide (m,n) :
Début while n!=0 :
Tantque (n ≠ 0) Faire R = m % n
R  m Mod n m =n
mn n =R
nR
Fin Tantque return(m)
retourner (m)
Fin
▪ TDO.Locaux
Objet Type/Nature
R Entier

c. Application 2 :
PGCD par différence :
▪ Si a=b alors PGCD(a,b) = a (oub)
▪ Sinon PGCD(a,b) = PGCD(a-b,b) si a >b
▪ Sinon PGCD(a,b) =PGCD(a,b-a)

➢ Solution:
En algorithme Implémentation en Python
Fonction PGCD_Diff (m, n : entier ) : entier def PGCD_Diff (m,n) :
Début while m!=n :
Tantque (m ≠ n) Faire if m>n:
Si m > n alors m=m-n
mm–n else :
Sinon n=n-m
nn–m
Fin Si return(m)
Fin Tantque
retourner (m)
Fin

Proposé par : Mr Y.G 40/61 A.S :22/23

 Niveau : 3SI/4SC

II. Le calcul du PPCM

1. Présentation
Pour chercher le PPCM de deux entiers a et b, nous pouvons appliquer l’algorithme formel suivant:
▪ Si a=b, le PPCM est a (ou b)
▪ Sinon, chercher les multiples de a en ordre croissant et s’arrêter s’il est multiple aussi de b.

2. Définition
Le plus petit commun multiple de deux entiers a et b appelé aussi PPCM est le plus petit entier
multiple à la fois de a et de b. On le note PPCM (a,b).

3. Application
Ecrire un algorithme et son implémentation en Python d’une fonction qui permet de renvoyer le
PPCM de deux entiers donnés m et n.

➢ Solution:
En algorithme Implémentation en Python
Fonction PPCM (m, n : entier) : entier def PPCM (m,n) :
Début if m > n :
Si m > n alors max = m
max  m else :
Sinon max = n
i=m*n
max  n
while i>=max :
Fin Si if i%m==0 and i%n==0:
I=m*n multiple=i
Tantque (i>=max) Faire i=i-1
Si i mod m=0 et i mod n = 0 alors return(multiple)
Multiplei m=int(input('entrer m='))
Fin Si n=int(input('entrer n='))
Ii-1 print('PPCM de ',m,' et ',n,'=',PPCM(m,n))
Fin Tantque
Retourner (multiple)
Fin
▪ TDO.Locaux
Objet Type/Nature
max,multiple,i Entiers

III. Les nombres premiers

1. Présentation
Pour tester si un entier supérieur à 1 est premier, il suffit de :
▪ Déterminer ses diviseurs
▪ Vérifier que le nombre de ses diviseurs est exactement 2 (1 et lui même).

2. Définition
Un entier supérieur à 1 est dit premier s’il n’est divisible que par 1 et par lui-même.
3. Applications

a) Application1
Ecrire un algorithme et son implémentation en Python d’une fonction qui permet de vérifier si un
entier supérieur à 1 est premier ou non

Proposé par : Mr Y.G 41/61 A.S :22/23

 Niveau : 3SI/4SC

➢ Solution:
En algorithme Implémentation en Python
Fonction Premier (n : entier ) : booléen def Premier (n) :
Début i=2
i 2 while n % i != 0 and i
<= (n // 2) :
Tantque (n mod i ≠ 0) et (i ≤ (n div 2)) Faire
i=i+1
ii+1 if i>n//2 :
Fin Tantque P=True
Si (i > n div 2) alors else :
P  Vrai P=False
Sinon
P  Faux return(P)
Fin Si
Retourner (P)
Fin
▪ TDO.Locaux
Objet Type/Nature
i Entier
P Booléen
b) Application2
Utilisez l’application précédente pour écrire un programme qui cherche puis affiche les nombres
premiers de l’intervalle [100,300].
➢ Solution:
En algorithme Implémentation en Python
Algorithme AffichePremier def Premier(n) :
Début i=2
Ecrire ("les nombres premiers de l’intervalle [ while (n % i) != 0 and i <=
(n // 2) :
100,300 ] sont") i=i+1
Pour i de 100 à 300 Faire if i>(n//2) :
P  Premier (i) P=True
Si P=Vrai Alors else :
Ecrire (i, "|") P=False
Fin Si return(P)
Fin Pour
Fin print ("les nombres premiers de
▪ TDO.Globaux l’intervalle [ 100,300 ] sont")
Objet Type/Nature for j in range(100, 301) :
i Entier if Premier(j)==True :
P Booléen print (j, "|", end="")

Résultat d’exécution

Proposé par : Mr Y.G 42/61 A.S :22/23

 Niveau : 3SI/4SC

Proposé par : Mr Y.G 43/61 A.S :22/23

 Niveau : 3SI/4SC

IV. La décomposition en facteurs premiers

1. Présentation
Pour chercher la décomposition d’un entier n en produit de facteurs premiers, nous pouvons
appliquer l’algorithme formel suivant :
▪ Vérifier si n est divisible par 2, si oui continuer à le diviser par 2 et le remplacer par n div 2jusqu’a
ce qu’il ne soit plus multiple de2
▪ Refaire l’étape précédente pour 3, 5,...
▪ Refaire les deux étapes précédentes jusqu’à avoir n =1

2. Définition
La décomposition d’un entier en produit de facteurs premiers consiste à écrire cet entier sous la forme
d’un produit de ces diviseurs premiers.

3. Application
Ecrire un algorithme et son implémentation en Python d’un programme qui permet de chercher puis
d’afficher la décomposition en produit de facteurs premiers d’un entier n donné sachant que (4≤n≤100).

➢ Solution:
En algorithme Implémentation en Python
Algorithme FacteursPremiers from numpy import array
Début Fact =array ([int ( )] * 100)
n=Saisir (n)
RemplirFact (Fact, f, n) def saisir():
Afficher (Fact, f) while (True) :
Fin n = int(input("n="))
▪ TDNT if(4<=n<=100) :
Type break
Tab= tableau de 100 entiers return(n)
▪ TDO.Globaux
Objet Type/Nature def RemplirFact(n) :
n,f Entier i = 2
Fact Tab f = -1
Fonction Saisir( ) : entier while True :
if n % i == 0 :
Début
n = n // i
Répéter
f = f + 1
Ecrire ("n="), Lire (n)
Fact[f] =i
Jusqu’à (5≤n≤20)
else :
retourner (n)
i = i + 1
Fin
if(n==1):
▪ TDO.Locaux break
Objet Type/Nature return(Fact,f)
n entier
Fonction RemplirFact ( n : entier) def Afficher (Fact , f) :
Début for i in range (f):
i2 print (Fact[i], " * ",end="")
f  -1 print (Fact[f])
Répéter
Si n Mod i = 0 Alors
n  n Div i n=Saisir()

Proposé par : Mr Y.G 44/61 A.S :22/23

 Niveau : 3SI/4SC

ff+1 Fact,f =RemplirFact(n)

Fact[f]  i Afficher (Fact, f)
Sinon
ii+1
Fin Si
Jusqu’à (n = 1) Résultat d’exécution pour n=120
Retourner (Fact, f)
Fin
▪ TDO.Locaux
Objet Type/Nature
i entier
Procédure Afficher (Fact :Tab ; f : entier )
Début
Pour i de 0 à (f-1) Faire
Ecrire (Fact[i], “ *“)
Fin Pour
Ecrire (Fact[f], "|")
Fin
▪ TDO.Locaux
Objet Type/Nature
i entier

V. Le calcul du factoriel
1. Présentation
Pour calculer la factorielle d’un entier, il suffit de le multiplier par le produit de tous les entiers
naturels non nuls qui le précèdent.
n ! = 1*2*3*…*(n-1)*n

2. Définition
La factorielle d’un entier n donné est le produit de tous les entiers de l’intervalle [1,n]. Le factoriel de
n est noté n !

3. Application
Ecrire un algorithme et son implémentation en Python d’une fonction qui permet de calculer la
factorielle d’un entier n donné.
➢ Solution:
En algorithme Implémentation en Python
Fonction Fact (n : entier) : entier
Début
f 1
Pour i de 1 a n+1Faire
ff*i
Fin Pour
Retourner (f)
Fin
▪ TDO locaux
Objet Type/Nature
i, f Entier

Proposé par : Mr Y.G 45/61 A.S :22/23

 Niveau : 3SI/4SC

VI. Conversion entre les bases de numération

VI.1 décimal-binaire :
1. Principe :
(325)10=(………………)2
2. Application :
Ecrire une Fonction qui convertit un entier saisi de la base décimale à la base binaire :
ALGORITHME :
Fonction conv_10_2(x :entier) :chaine
Début
ch‶″
Tant que x !=0 faire
rx mod 2
xx div 2
ch convch(r)+ch
Fin Tq
Retourner (ch)
Fin
TDOL
Ch chaine
r entier
VI.2 Binaire-décimal :
1. Principe :
(101000101)2=(….)10
2. Application :
Ecrire une Fonction qui convertit une valeur de la base binaire à la base décimale :
Fonction conv_2_10(ch :chaine) :entier
Début
S0
P1
Pour i de long(ch)-1 à 0 (pas=-1) faire
S s+p*valeur(ch[i])
Pp*2
Fin pour
Retourner s
Fin
TDOL
S,p,i entier

Proposé par : Mr Y.G 46/61 A.S :22/23

 Niveau : 3SI/4SC

VI. 3 Binaire-octal :
1. Principe :
(1010)2=(….)8
2. Application :
Ecrire une Fonction qui convertit une valeur de la base binaire à la base octale

VI.4 Binaire-hexadécimal :
1. Principe :
(11010)2=(….)16
2. Application :
Ecrire une Fonction qui convertit une valeur de la base binaire à la base hexadécimale

Proposé par : Mr Y.G 47/61 A.S :22/23

 Niveau : 3SI/4SC

Proposé par : Mr Y.G 48/61 A.S :22/23

 Niveau : 3SI/4SC

1. Définition
Convertir un entier positif N dans une base b au moins égale à 2 consiste à chercher la représentation
de N dans la base b. En effet, dans un système de numération b, tout entier positif N admet une et une
seule décomposition : N = an*bn + an-1*bn-1 + an-2*bn-2 + … + a1b + a0
Ou les aksont des naturels compris entre 0 et (b-1) inclus. b est appelée base de numération.
2. Applications
a) Application1
Ecrire un algorithme et son implémentation en Python d’un programme qui permet de convertir un
nombre entier positif N en binaire. La conversion se fera de la base de numération 10 (ou base décimale)
a la base 2 (ou base binaire).

➢ Solution:
En algorithme Implémentation en Python

Proposé par : Mr Y.G 49/61 A.S :22/23

 Niveau : 3SI/4SC

Algorithme Conversion_10_2 from numpy import array

Début Fact =array ([int ( )] * 100)
Ecrire ("n="), Lire(n)
T, c = Chercher2 (n) def Chercher2(n) :
Afficher2 (T, c) c = -1
Fin while True :
▪ TDNT c = c + 1
Type T[c] = n % 2
Tab= tableau de 100 entiers n = n //2
▪ TDO.Globaux if(n==0):
Objet Type/Nature break
N,c Entier return(T,c)
T Tab
Fonction Chercher2 (n : entier)
Début
def Afficher2 (T , c) :
c  -1
for i in range (c,-1, -1):
Répéter
print (T[i],end="")
cc+1
T[c]  n Mod 2
n  n div 2 n=int(input("n="))
Jusqu’à (n=0) T,c = Chercher2(n)
Retourner (T, c) Afficher2 (T, c)
Fin
▪ TDO.Locaux
Objet Type/Nature
c Entier Résultat d’exécution pour n=562
T Tab
Procédure Afficher2 (T : Tab ; c : entier)
Début
Pour i de c à 0 faire
Ecrire (T[i])
Fin Pour
Fin

Proposé par : Mr Y.G 50/61 A.S :22/23

 Niveau : 3SI/4SC

b) Application2
Ecrire un algorithme et son implémentation en Python d’un programme qui permet de convertir un
nombre entier positif N en hexadécimal. La conversion se fera de la base de numération 10 (ou base
décimale) a la base 16 (ou base hexadécimale).

➢ Solution:
En algorithme Implémentation en Python
Algorithme Conversion_10_2 from numpy import array
Début Fact =array ([int ( )] * 100)
Ecrire ("n="), Lire(n)
T, c = Chercher16 (n) def Chercher16(n) :
Afficher16 (T, c) c = -1
Fin while True :
c = c + 1
▪ TDNT T[c] = n %16
Type n = n // 16
Tab= tableau de 100 entiers if (n==0):
break
▪ TDO.Globaux return(T,c)
Objet Type/Nature
N,c Entier
T Tab
def Afficher16 (T , c) :
for i in range (c,-1, -1) :
Fonction Chercher16 (n : entier)
if 0<=T[i]<=9:
Début
print (T[i],end="")
c  -1
else:
Répéter print(chr(ord('A')+ T[i]-
cc+1 10),end="")
T[c]  n Mod 16
n  n div 16 n=int(input("n="))
Jusqu’à (n=0) T,c = Chercher16(n)
Retourner (T, c) Afficher16 (T, c)
Fin

▪ TDO.Locaux
Objet Type/Nature Résultat d’exécution pour n=5625
c Entier
T Tab

Procédure Afficher16 (T : Tab ; c : entier)

Début
Pour i de c à 0 faire
Ecrire (T[i])
Fin Pour
Fin

▪ TDO.Locaux
Objet Type/Nature
i Entier

Proposé par : Mr Y.G 51/61 A.S :22/23

 Niveau : 3SI/4SC

Proposé par : Mr Y.G 52/61 A.S :22/23

 Niveau : 3SI/4SC

Chapitre 7 : Les algorithmes d’optimisations et d’approximations

I. Introduction :
• Un algorithme d’approximation est utilisé pour trouver une valeur approchée de la solution d’un
problème donné
• Un algorithme d’optimisation est utilisé pour trouver une solution optimale à un problème de
minimisation ou de maximisation
Activité1 : (Problème d’optimisation) :
Dans une feuille de carton carrée de 10 cm de côté, on découpe aux quatre coins quatre carrés de
côté x de telle façon qu’en relevant les quatre bords restants, on obtient une boîte de forme
parallélépipédique. On veut trouver la valeur de x telle que le volume de la boîte ainsi formée soit
maximum

Questions :
1) Déterminer le volume de la boîte en fonction de x sachant que : v= surface de base * hauteur
2) Ecrire l’algorithme de la fonction nommée Valeur (pas) permettant de déterminer la valeur de x pour que le
volume v de la boîte soit maximal.
3) écrire le programme en Python qui permet de varier le pas de variation de 10-1 à 10-5 ( en multipliant dans
chaque cas le pas par 10-1 ), déterminer et afficher la valeur de x pour que le volume v de la boîte soit maximal
ainsi que le pas utilisé et la valeur approchée du volume de la boîte Sachant que la valeur exacte de x qui
correspond à un volume maximum est théoriquement égale à 10/6, donc de l’ordre de 1.666666666666666
4) En observant les résultats du programme précédent que constatez-vous ? Constatation : Remarquons que si la
valeur du pas diminue, on s’approche de plus en plus de la valeur exacte de x

Proposé par : Mr Y.G 53/61 A.S :22/23

 Niveau : 3SI/4SC

Chapitre 8 : Les enregistrements

I. Introduction:
1. Activité 1:
Un Lycée organise les informations concernant ses classes dans une liste identique à la suivante :
Numéro Nom Prénom Genre Date de naissance Moyenne annuelle
1 Ben abdallâh Boudour F 20/10/2002 13.53
2 Ben Ali Taki M 01/09/2002 18.24
… … … … … …
… … … … … …
150 Ben Mohamed Dorra F 19/02/2002 11.20

Le directeur de lycée veut créer un programme permettant la saisie et le traitement de ces listes sachant
que chaque classe comporte au maximum 40 élèves.
a. Donnez la structure de données nécessaire pour les objets à utiliser.
b. Donnez une déclaration algorithmique de cesobjets.
Solution :
a. On peut utiliser 6 tableaux, un tableau pour chaque colonne(champ).
b. Déclaration algorithmique :
Objet Type/Nature Rôle
Num Tableau de 40 entiers Tableau contenant les numéros des élèves d’une classe
Nom Tableau de 40 chaînes Tableau contenant les noms des élèves d’une classe
Prenom Tableau de 40 chaînes Tableau contenant les prénoms des élèves d’une classe
Genre Tableau de 40 caractères Tableau contenant les genres des élèves d’une classe
Date Tableau de 40 chaînes Tableau contenant les dates de naissance des élèves d’une classe
Moy Tableau de 40 Réels Tableau contenant les moyennes annuelles des élèves d’une classe

Remarque :
Nous remarquons que la solution proposée est trop longue car on ne peut pas ranger des données de types
différents dans un seul tableau.
Nous allons voir une nouvelle structure appelée ENREGISTREMENT (CLASS en Python) qui permet
de réaliser cette tache.

2. Définition:
Un enregistrement est un type de données défini par l'utilisateur et qui permet de grouper un nombre fini
d'éléments (ou champs) de types éventuellement différents.

3. Déclaration :
En algorithme En Python
▪ TDNT
Type
class NomEnregistrement :
NomEnregistrement=Enregistrement
Champ1 = valeur d’initialisation
Champ1 : Type1
----
----
ChampN = valeur d’initialisation
ChampN : TypeN
Fin
▪ TDO
O T/N
NomVariable = NomEnregistrement ( )
NomVariable NomEnregistrement

Proposé par : Mr Y.G 54/61 A.S :22/23

 Niveau : 3SI/4SC

4. Solution optimale de l’activité 1:

On peut utiliser un seul enregistrement pour toutes les colonnes.

En algorithme En Python
▪ TDNT
Type
class Fiche :
Fiche = Enregistrement
Num = 0
Num : Entier
Nom = ""
Nom : Chaîne
Prénom = ""
Prénom : Chaîne
Genre = ""
Genre : Caractère
Date = ""
Date : Chaîne
Moy = 0
Moy : Réel
Fin
▪ TDO
O T/N
Eleve = Fiche ( )
Eleve Fiche

5. Activité 2:

Déclarez en algorithmique et en Python, une variable enregistrement Date qui comporte :

– le numéro du jour (jj) de 1 à31,
– le numéro du mois (mm) de 1 à12,
– l'an (aa) qui est unentier.
Déclarez une variable nommée "calendrier" qui permettra l'utilisation de cet enregistrement.

Solution :
En algorithme En Python

▪ TDNT
Type
Date = Enregistrement class Date :
jj : 1..31 jj = 1
mm : 1..12 mm = 1
aa :Entier aa = 2020
Fin
▪ TDO
O T/N
Calendrier Date Calendrier = Date ( )

II. Utilisation des enregistrements:

1. Affectation:
En Algorithme En Python
variable.champ  valeur variable.champ = valeur

Activité 3 :
On se pose que Eleve est une variable de type Fiche de l’activité 1, affectez respectivement les valeurs
suivantes à cette variable : 15, "Kéfi", "Nour", "F", "27/11/2006" et 13.25

Proposé par : Mr Y.G 55/61 A.S :22/23

 Niveau : 3SI/4SC

Solution : Au niveau de l’algorithmique

Eleve.Num  15
Eleve.Nom  "Kéfi"
Eleve.Prénom  "Nour"
Eleve.Genre  "F"
Eleve.Date  "27/11/1997"
Eleve.Moy  13.25

Remarque :
a. Il est possible d'affecter une variable enregistrement dans une autre à condition qu'ils aient la même
structure.
Exemple :
e1, e2 = Fiche ( )
Il est possible d'écrire : e1= e2
Tous les champs de la variable enregistrement à affecter seront recopies dans les champs de l'autre.
b. Un champ a exactement les mêmes propriétés qu'une variable du mêmetype.
c. Le champ d'une variable enregistrement peut être lui-même unenregistrement.

Activité 4 :
Reprenez l'activité 1 et déclarez le champ Date comme étant un enregistrement de l’activité 2.

Solution :
En algorithme En Python

▪ TDNT
Type
Date = Enregistrement class Date :
jj : 1..31 jj = 1
mm : 1..12 mm = 1
aa :Entier aa = 2020
Fin

Fiche = Enregistrement class Fiche :

Num : Entier Num = 0
Nom : Chaîne Nom = ""
Prénom : Chaîne Prénom = ""
Genre : Caractère Genre = ""
Date : Date Date = Date
Moy : Réel Moy = 0
Fin
▪ TDO
O T/N
Eleve Fiche Eleve = Fiche ( )

2. Lecture:

En Algorithme En Python
Lire (variable.champ) variable.champ = input()

Exemple :
En Algorithme En Python
Lire (Eleve.Nom) Eleve.nom = input()

Proposé par : Mr Y.G 56/61 A.S :22/23

 Niveau : 3SI/4SC

3. Ecriture:

En Algorithme En Python
Ecrire (variable.champ) print (variable.champ)

Exemple :
En Algorithme En Python
Ecrire (Eleve.Nom) print (Eleve.Nom )

Activité 5 :
Soit la structure Fiche constituée par :
Num : Entier
Nom : Chaîne
Prénom : Chaîne
Genre : Caractère
Date : Chaîne
Moy : Réel
Ecrivez les algorithmes des différents modules d'un programme nommé FicheEleve, qui permet la saisie
et l'affichage de l'enregistrement d'un Elève. Puis les implémenter en Python.

Solution :

• Algorithme du programme principal :

AlgorithmeFicheEleve
Début
Saisir (Eleve)
Afficher (Eleve)
Fin

✓ TDNT :
Type
FicheEleve = Enregistrement
Num : Entier
Nom : Chaîne
Prénom : Chaîne
Genre : Caractère
Date : Chaîne
Moy : Réel
Fin

✓ TDO :
Objet Type/Nature
Eleve FicheEleve
Saisir Procédure
Afficher Procédure

Proposé par : Mr Y.G 57/61 A.S :22/23

 Niveau : 3SI/4SC

• Algorithme de la procédureSaisir

Procédure Saisir (@Eleve : FicheEleve)

Début
Ecrire ("Entrer le numéro de l’élève: ") ; Lire (Eleve.Num)
Ecrire ("Entrer son nom : ") ; Lire (Eleve.Nom)
Ecrire ("Entrer sa prénom : ") ; Lire (Eleve.Prénom)
Ecrire ("Entrer son genre : ") ; Lire (Eleve.Genre)
Ecrire ("Entrer sa date de naissance : ") ; Lire (Eleve.Date)
Ecrire ("Entrer sa moyenne : ") ; Lire (Eleve.Moy)
Fin

• Algorithme de la procédure Afficher

Procédure Afficher (Eleve :FicheEleve)

Début
Ecrire ("Num : ", Eleve.Num)
Ecrire ("Nom : ", Eleve.Nom)
Ecrire (Prénom : ", Eleve.Prénom)
Ecrire ("Genre : ", Eleve.Genre)
Ecrire ("Date de naissance : ", Eleve.Date)
Ecrire ("Moyenne : ", Eleve.Moy)
Fin

• Implimentation en Python:
classFiche :
num =0
nom =""
prenom =""
genre =""
date =""
moy =0

eleve = Fiche

defSaisir (eleve) :
eleve.num = int(input("Entrer le numéro de l’élève: "))
eleve.nom = str(input ("Entrer son nom : "))
eleve.prenom = str(input("Entrer sa prénom : "))
eleve.genre = str(input("Entrer son genre : "))
eleve.date = str(input("Entrer sa date de naissance : "))
eleve.moy = float(input("Entrer sa moyenne : "))

defAfficher (eleve) :
print ("Num :",eleve.num)
print ("Nom :",eleve.nom)
print ("Prénom :",eleve.prenom)
print ("Genre :",eleve.genre)
print ("Date de naissance :",eleve.date)
print ("Moyenne :",eleve.moy)

# Programme Principal

Saisir (eleve)
Afficher (eleve)

Proposé par : Mr Y.G 58/61 A.S :22/23

 Niveau : 3SI/4SC

4. Vecteur d'enregistrements:
Activité 6 :
Reprenons l'enregistrement Fiche de l'activité 5
Nous voulons utiliser cet enregistrement non pas pour un seul élève, mais pour tous les élèves d'une
classe.
Question : Pouvons-nous déclarer un tableau d'enregistrements ?

Solution :
Un tableau ne peut contenir que des éléments de même type, y compris le type enregistrement. Nous
pouvons donc utiliser un tableau ou un vecteur d'enregistrements.

Activité 7 :
Nous supposons que le nombre d'étudiants dans une classe est égal à N (4 < N < 31).
Question : Proposez une structure de données utilisant un vecteur d'enregistrements pour représenter ces
N étudiants ?

Solution :
En algorithme En Python

▪ TDNT from numpy import *

Type class Fiche :
Fiche = Enregistrement Num = 0
Num : Entier Nom = ""
Nom : Chaîne Prénom = ""
Prénom : Chaîne Genre = ""
Genre : Caractère Date = ""
Date : Chaîne Moy = 0
Moy : Réel
Fin Tab = zeros((30), dtype = Fiche)
# déclaration d’un tableau de 30 éléments
Tab = tableau de 30 Fiche #de type Fiche, initialisés au vide
▪ TDO
O T/N
T Tab T = Tab

Remarque :
• numpy est une bibliothèque destinée à manipuler des matrices ou tableaux
multidimensionnels ainsi que desfonctions
• Pour utiliser la bibliothèque « numpy » on doit l’installer : Dans la console cmd de Windows
tapez la commande « pip install numpy » avec version de python 3.6 ou plus (le pc doit être
connecté àinternet)

Activité 8 :

Une société veut informatiser la gestion de ses employés. Elle détient pour chacun les informations
suivantes :
- Le nom et le prénom (chaîne decaractères)
- Le grade : uniquement G1, G2, G3 ouG4
- Le code fiscal (un entier nonsigné)
- L’assurance maladie (O pour oui et N pournon)
- Le nombre d'employés est N avec 4 ≤ N ≤120.

Proposé par : Mr Y.G 59/61 A.S :22/23

 Niveau : 3SI/4SC

Questions :
Ecrivez un programme modulaire nommé GESTION, qui permet la saisie de toutes les fiches de
renseignements puis d'afficher :
1. Toutes les fiches (une par une et avec une attente jusqu'à l'appui sur la toucheENTREE).
2. Le nombre d'employés ayant un grade donné et leur pourcentage par rapport au nombre total des
employés.
Implémentez ce programme en Python et l'enregistrez sous le nom GestEmployés.

Proposé par : Mr Y.G 60/61 A.S :22/23

 Niveau : 3SI/4SC

Chapitre 9 : Les fichiers

II. Introduction:
Avec les structures précédemment utilisées, les données d’un programme seront perdues dès l’arrêt de
l’exécution de ce programme. Dans certains cas la sauvegarde des données est nécessaire d’où on fait
recours à une nouvelle structure les fichiers.
Un fichier est un ensemble structuré des données de même type réunis sous un même nom et stockés
sur un support de stockage tel que : disque dur, cd, dvd, etc.

On distingue deux types de fichiers :

▪ Les fichiers textes : les informations sont sous un format texte qui est lisible par n’importe quel
éditeur detexte.
▪ Les fichiers de données (ou binaires) : les informations ne sont lisibles que par le programme qui les a
conçus.

III. Les fichiers textes:

1. Déclaration :
En algorithme
▪ TDNT
Type
NomFichier = Fichier texte
▪ TDO
O T/N
NomLogique NomFichier

2. Les fonctions et les procédures prédéfinies sur les fichiers textes:

En algorithme En Python Rôle

Ouvrir("Chemin\NomPhysiq NomLogique= open Ouverture d’un fichier
ue", NomLogique , "Mode") ("Chemin\NomPysique", "Mode") • Mode d’ouverture:
- "r" :Lecture
- "w" : Ecriture(création)
- "a" : Ecriture à la fin dufichier
Lire (NomLogique, ch) ch = NomLogique.read ( ) Lecture de la totalité d’un fichier
Lire_ligne (NomLogique, ch) ch = NomLogique.readline ( ) Lecture d’une ligne depuis un
fichier texte
Ecrire (NomLogique, ch) • Ecriture sans retour à laligne Ecriture dans un fichier texte
NomLogique.write (ch)
• Ecriture avec retour à laligne
NomLogique.write (ch+"\n")
Fin_fichier (NomLogique) Pas de correspondance en python Retourne Vrai si le pointeur est à la
try : fin du fichier sinon elle retourne
NomLogique.readline ( ) Faux
Fin_fichier = False
except :
Fin_fichier = True
Fermer (NomLogique) NomLogique.close ( ) Fermeture d’un fichier

Proposé par : Mr Y.G 61/61 A.S :22/23

 Niveau : 3SI/4SC

3. Activité 1 : Lecture en bloc avecread()

Soit le fichier texte "C:\Voitures.txt" suivant :

Ecrire l’algorithme et son implémentation en Python d’un programme qui permet d’ouvrir le fichier
"Voitures.txt" en lecture et de stoker leur contenu dans une chaine de caractère ch puis d’afficher le
contenu de ce fichier

➢ Solution

En algorithme En Python
#ouverture en lecture
Algorithme voiture f = open("C:\Voitures.txt","r")
Début #lecture
Ouvrir ("C:\Voitures.txt", f, "r") ch = f.read()
Lire (f, ch) #affichage
Ecrire ("** contenu de ch **") print("** contenu de ch **")
Ecrire (ch) print(ch)
Ecrire ("** fin contenu **") print("** fin contenu **")
Fermer ( f ) #fermeture
f.close()
Fin
Résultat d’exécution
▪ TDNT
Type
Fichtext = Fichier texte
▪ TDO
O T/N
f Fichtext
ch Chaine decaractère

➢ Remarque:

▪ open() permet d’ouvrir un fichier, en lecture ici avec l’option « r ». La fonction renvoie un objet
de type fichier stocké dansf
▪ le curseur de fichier est placé sur la premièreligne
▪ read() lit tout le contenu du fichier d’unbloc
▪ close() ferme le fichier (et donc ledéverrouille)

4. Activité 2 : Lecture ligne par ligne avec readline (sans « s »)

Ecrire l’algorithme et son implémentation en Python d’un programme qui permet d’ouvrir le fichier
"Voitures.txt" en lecture ligne par ligne itérativement et de stoker leur contenu dans une chaine de
caractère ch puis d’afficher le contenu de ce fichier

Proposé par : Mr Y.G 62/61 A.S :22/23

 Niveau : 3SI/4SC

➢ Solution
En algorithme En Python
#ouverture en lecture
f = open("C:\Voitures.txt","r")
Algorithme voiture #lecture ligne itérativement
Début while True:
Ouvrir ("C:\Voitures.txt", f, "r") ch = f.readline()
Répéter if (ch != ""):
Lire_ligne (f, ch) print(ch)
Ecrire (ch) else:
Jusqu’à (ch="") break;
Fermer ( f ) #fermeture
f.close()
Fin
Résultat d’exécution
▪ TDNT
Type
Fichtext = Fichier texte
▪ TDO
O T/N
f Fichtext
ch Chaine decaractère

➢ Remarque:

▪ readline() lit la ligne courante et place le curseur sur la lignesuivante.

▪ La fonction renvoie la chaîne vide lorsque nous arrivons à la fin du fichier (s’il y a une ligne blanche
entre 2 véhicules, readline() renvoie le caractère « \n », ce n’est pas une chaînevide)
▪ Dans le résultat d’exécution, il y a une ligne vide entre chaque véhicule parce que le caractère «\n
» est toujours là, print() le prend en compte [ pour que print() n’en tienne pas compte, il faudrait
faire print(ch,end="") ]
▪ On peut lire ligne par ligne en itérant sur l’objet fichier comme la suivante:

En Python
#ouverture en lecture ✓ C’est la forme la plus efficace – et la
f = open("C:\Voitures.txt","r") plus concise – pour une lecture ligne à
#lecture ligne itérativement ligne.
for ch in f:
print(ch)
✓ Le caractère \n est présenttoujours
#fermeture
f.close()

Résultat d’exécution

Proposé par : Mr Y.G 63/61 A.S :22/23

 Niveau : 3SI/4SC

5. Activité 3 : Lecture en bloc avec readlines(avec « s »)

Ecrire l’algorithme et son implémentation en Python d’un programme qui permet d’ouvrir le fichier
"Voitures.txt" (de l’activité 1) en lecture et de stoker leur contenu dans une liste lst puis d’afficher le
contenu de ce fichier

➢ Solution
En algorithme En Python
Algorithme voiture #ouverture en lecture
Début f = open("C:\Voitures.txt","r")
Ouvrir ("C:\Voitures.txt", f, "r") #lecture
Lire_Lignes (f, lst) lst = f.readlines()
#affichage
Ecrire ("** contenu de lst **")
print("** contenu de lst **")
Ecrire (lst) print(lst)
Ecrire ("** fin contenu **") print("** fin contenu **")
Fermer ( f ) #fermeture
Fin f.close()
▪ TDNT
Type Résultat d’exécution
Fichtext = Fichier texte
▪ TDO
O T/N
f Fichtext
lst Liste de chaine de caractère

➢ Remarque:
▪ Le contenu du fichier est stocké dans une liste, une ligne = unélément.
▪ Le caractère \n est maintenu. Il n’est pas présent sur la dernière ligne de notre fichierexemple.

6. Activité 4 : Ecriture d’un fichier texte avecwrite()

Ecrire l’algorithme et son implémentation en Python d’un programme qui permet d’ouvrir le fichier
"moto.txt" en écriture et d’écrire les trois noms suivants ("honda", "yamaha", "ducati") chacun dans
une ligne dans le fichier créer précédemment

➢ Solution1
En algorithme En Python
Algorithme moto #ouverture en écriture
Début f = open("C:\moto.txt","w")
Ouvrir ("C:\moto.txt", f, "w") #écriture
Ecrire (f, "honda") f.write("honda")
f.write("yamaha")
Ecrire (f, "yamaha")
f.write("ducati")
Ecrire (f, "ducati")
#fermeture
Fermer ( f ) f.close()
Fin
Résultat d’exécution
▪ TDNT
Type
Fichtext = Fichier texte
▪ TDO
O T/N
f Fichtext

Proposé par : Mr Y.G 64/61 A.S :22/23

 Niveau : 3SI/4SC

➢ Remarque:
▪ open() permet d’ouvrir un fichier en écriture avec l’option « w ». La fonction renvoie un objet de
type fichier référencée parf
▪ Avec « w », le fichier est écrasé s’il existedéjà
▪ write() permet d’écrire la chaîne decaractères
▪ Dans le résultat d’exécution, il manque les sauts de ligne pour distinguer chaque moto pour ce la il
faut que nous insérons le caractère saut de ligne « \n » après chaque moto, sauf la dernière comme
la suivante:

➢ Solution2
En algorithme En Python
Algorithme moto #ouverture en écriture
Début f = open("D:\moto.txt","w")
Ouvrir ("D:\moto.txt", f, "w") #écriture
EcrireNL (f, "honda") f.write("honda\n")
f.write("yamaha\n")
EcrireNL (f, "yamaha")
f.write("ducati")
Ecrire (f, "ducati") #fermeture
Fermer ( f ) f.close()
Fin
Résultat d’exécution
▪ TDNT
Type
Fichtext = Fichier texte
▪ TDO
O T/N
f Fichtext

7. Activité 5 : Ecriture d’un fichier texte avecwritelines()

Ecrire l’algorithme et son implémentation en Python d’un programme qui permet d’ouvrir le fichier
"moto.txt" en écriture et d’écrire le contenu de la liste lst dans le cet fichier sachant que lst=
["honda\n","yamaha\n","ducati"]

➢ Solution
En algorithme En Python
Algorithme moto #ouverture en écriture
Début f = open("D:\moto.txt","w")
Ouvrir ("D:\moto.txt", f, "w") #liste
lst←["honda\n","yamaha\n"," lst=["honda\n","yamaha\n","ducati"]
ducati"] #écriture
Ecrire_lignes (f, lst) f.writelines(lst)
Fermer ( f ) #fermeture
f.close()
Fin
Résultat d’exécution
▪ TDNT
Type
Fichtext = Fichier texte
▪ TDO
O T/N
f Fichtext
lst Liste de chaine de caractère

Proposé par : Mr Y.G 65/61 A.S :22/23

 Niveau : 3SI/4SC

➢ Remarque:

▪ writelines() permet d’écrire directement le contenu d’une liste. Nous devons quand même insérer
le caractère « \n » pour que le saut de ligne soit effectif dans lefichier.

8. Activité 6 : Ajout dans un fichiertexte

Ecrire l’algorithme et son implémentation en Python d’un programme qui permet d’ouvrir le fichier
"moto.txt" en mode ajout et d’ajouter un nouveau nom "laverda" à la fin de cet fichier.

➢ Solution

En algorithme En Python
#ouverture en ajout
Algorithme moto f = open("D:\moto.txt","a")
Début #ajouter un saut de ligne
Ouvrir ("D:\moto.txt", f, "a") f.write("\n")
Ecrire (f, "\n") #écriture
Ecrire (f, "laverda") f.write("laverda")
Fermer ( f ) #fermeture
f.c lose()
Fin
Résultat d’exécution
▪ TDNT
Type
Fichtext = Fichier texte
▪ TDO
O T/N
f Fichtext

➢ Remarque:
▪ open() avec l’option « a » permet d’ouvrir un fichier en modeajout
▪ write() permet d’écrire la chaîne decaractères
▪ Attention toujours au saut de ligne « \n»
▪ Une ouverture en mode lecture / écriture est possible avec l’option « r+ » mais se positionner sur
telle ou telle ligne pour y modifier ou insérer des informations estcompliqué.

Proposé par : Mr Y.G 66/61 A.S :22/23

 Niveau : 3SI/4SC

IV. Les fichiers de données:

1. Déclaration:
Déclaration en algorithme
▪ TDNT
Type
NomFichier = Fichier de Type _élément
▪ TDO
O T/N
NomLogique NomFichier

2. Activité 1:
Nous voulons saisir et enregistrer les notes des élèves d'une classe dans un fichier de réels.
Question : Déclarez en algorithmique la structure de fichier adéquate.

➢ Solution:
Déclaration en algorithme
▪ TDNT
Type
NotesElève = Fichier de réels
▪ TDO
O T/N
Notes NotesElève

3. Activité 2:
Au lieu de sauvegarder seulement les notes des élèves, nous proposons d'enregistrer dans un fichier
appelé CARNET, la fiche de renseignements et les notes de chaque élève.
Une fiche de renseignements comporte les informations suivantes :
- Nom etprénom,
- Genre (F ouG),
- Date denaissance,
- Les notes sont : Note1, Note2 etNote3.

➢ Solution:
Déclaration en algorithme
▪ TDNT
Type
FicheElève = enregistrement
NomPrenom : Chaîne de caractère
Genre : Caractère
DateNaissance : Chaîne
Note1, Note2, Note3 : Réel
Fin FicheElève

CarnetElèves = Fichier de FicheElève

▪ TDO
O T/N
Elève
FicheElève
Carnet

Proposé par : Mr Y.G 67/61 A.S :22/23

 Niveau : 3SI/4SC

CarnetElèves

4. Les fonctions et les procédures prédéfinies sur les fichiers textes:

En algorithme En Python Rôle

NomLogique= open Ouverture d’un fichier
("Chemin\NomPysique", "Mode") • Mode d’ouverture:
Ouvrir("Chemin\NomPhysique
- "rb" : Lecture (pointer audébut)
", NomLogique , "Mode")
- "wb" : Ecriture(création)
- "ab" : Ecriture à la fin dufichier
from pickle import load Lecture d’un enregistrement d’un
Lire (NomLogique, Objet)
Objet = load (NomLogique) fichier
from pickle import dump
Ecrire (NomLogique, Objet) Ecriture dans un fichier
dump (Objet, NomLogique)
Pas de correspondance en python
for c in range (p) :
try :
Pointer (NomLogique, p) Se pointer à une position p du fichier
load (NomLogique)
except:
break
Pas de correspondance en python
try :
Retourne Vrai si le pointeur est à la
load (NomLogique)
Fin_fichier (NomLogique) fin du fichier sinon elle retourne
Fin_fichier = False
Faux
except :
Fin_fichier = True
Pas de correspondance en python
Taille = 0
while True :
try :
Taille_fichier (NomLogique) Retourne la taille du fichier
load (NomLogique)
Taille += 1
except :
break
Fermer (NomLogique) NomLogique.close ( ) Fermeture d’un fichier

Proposé par : Mr Y.G 68/61 A.S :22/23

 Niveau : 3SI/4SC

➢ Remarque:
▪ Comme on a déjà dit un fichier doit être enregistré sur un support externe, donc ce fichier doit
avoir un nom et de préférence une extension. Ce nom est appelé le nom externe (ou le nom
physique)
▪ Le nom de l’objet déclaré dans le tableau des objets comme nom de fichier est le nom interne du
fichier (ou aussi le nom logique). C’est le nom utilisé dans les instructions duprogramme.
▪ Les fichiers de données (data) ont une extension .dat, .fch, …

5. Activité 3:

Un produit est caractérisé par un code, une désignation et son prix unitaire.

Ecrire l’algorithme et son implémentation en Python d’un programme permettant de saisir les
informations de n produits dans un fichier nommé FicheProd.dat

➢ Solution:
En Algorithme En Python
Algorithme Produit from pickle import *

class prod:
Début code=""
designation=""
prix_unitaire=0
Ouvrir ("D:\FicheProd.dat", f, wb ) p=prod()
{Ouvrir le fichier en mode écriture}
f = open("D:\FicheProd.dat ","wb")
Ecrire("Taper le nombre de produit"), n=int(input("Taper le nombre de produit
lire(n) "))

for i in range(n) :
Pour i de 0 à n-1 faire
p.code=str(input("saisir le code"))
Ecrire("saisir le code"), lire(p.code) p.designation=str(input("saisir la
désignation") )
p.prix_unitaire=float(input("saisir
Ecrire("saisir la désignation") , le prix unitaire "))
lire(p.designation)
dump(p,f)

Ecrire("saisir le prix unitaire "), f.close()

lire(p.prix_unitaire)

Proposé par : Mr Y.G 69/61 A.S :22/23

 Niveau : 3SI/4SC

Ecrire (p , f) {saisir les produits dans

le fichier}

Fin Pour

Fermer ( f )

Fin

Proposé par : Mr Y.G 70/61 A.S :22/23