4éme Scientifiques 2021-2022

INFORMATIQUE
4ème ANNEE DE L'ENSEIGNEMENT

SECONDAIRE
SECTIONS :
Mathématiques Sciences techniques Sciences expérimentales
Réalisé par :Mr Arfaoui nawfel
2021-2022 -1- Prof : Mr Arfaoui.Nawfel

Sommaire
chapitre 1) STRUCTURES DE DONNEES............................................................... 4
I LES constantes ................................................................................................... 4
II LES variables .................................................................................................... 4
III.1 LES TYPES SIMPLES : ................................................................................ 5
III.1.1 Le type Entier : ....................................................................................... 5
III.1.2 le type réel : ............................................................................................ 5
III.1.3 LE TYPE BOOLEEN : ........................................................................... 7
III.1.4 le type caractère : ................................................................................... 8
III.2 Les types composés : ..................................................................................... 9
III.2.1 le type chaîne de caractères : ................................................................... 9
III.2.2 Le type Tableau : ................................................................................. 12
Chapitre 2) LES STRUCTURES SIMPLES .......................................................... 15
I LES ENTREES : .............................................................................................. 15
II- L'AFFECTATION : ........................................................................................ 16
III- LES SORTIES : ............................................................................................ 17
Chapitre 3) LES STRUCTURES CONDITIONNELLES ...................................... 18
I. STRUCTURE CONDITIONNELLE SIMPLE : ........................................... 18
I.1 FORME REDUITE : .................................................................................. 18
I.2 FORME COMPLETE : .............................................................................. 19
II. STRUCTURE CONDITIONNELLE GENERALISEE :............................ 20
III. STRUCTURE CONDITIONNELLE A CHOIX MULTIPLE : ...................... 22
Chapitre 4) Les structures de contrôle itératives ....................................................... 24
I) LA STRUCTURE ITERATIVE COMPLETE (LA BOUCLE « POUR ») : .. 24
I.1 DEFINITION : ........................................................................................... 24
I.2 SYNTAXE : ................................................................................................... 24
II) LA STRUCTURE ITERATIVE A CONDITION D’ARRET : .................. 26
II.1 La boucle Répéter ….Jusqu’à ................................................................... 26
II.2 La boucle Tant que ………. Faire : ........................................................... 27
Chapitre 5) Les sous programmes ........................................................................ 28
I) LES PROCEDURES : .................................................................................. 28
I-1 Definition: .................................................................................................. 28
I-2 Déclaration d’une procedure .......................................................................... 28
I-3 mode de passage de paramètres : ................................................................ 30
II) LES FONCTIONS : .................................................................................. 33
II-1 Définition : ............................................................................................... 33
II-2 Déclaration d’une fonction : ...................................................................... 33
Chapitre 6) Les traitements avancés ........................................................................ 34
I) TRI PAR SELECTION :............................................................................... 34
Principe : ......................................................................................................... 34
Implémentation :.............................................................................................. 35
II) TRI A BULLES ........................................................................................ 36
Principe : ......................................................................................................... 36
Implémentation :.............................................................................................. 36
III) RECHERCHE SEQUENTIELLE :............................................................ 37
Principe : ......................................................................................................... 37
Implémentation :.............................................................................................. 37
IV) RECHERCHE DICHOTOMIE : ............................................................... 38
Principe : ......................................................................................................... 38
Implémentation :.............................................................................................. 38
Chapitre 7) Interface graphique .............................................................................. 40
I) Présentation de l’interface graphique (GUI) : ................................................ 40
II) Installation PyQt5 : ................................................................................... 40
III) Création d’interface graphique : ................................................................ 40
Implémentation : .............................................................................................. 41
IV) Projet : ...................................................................................................... 46

CHAPITRE 1) STRUCTURES DE DONNEES
ACTIVITE
Etablir un algorithme d’un problème qui calcule et affiche le périmètre et l’aire d’un
cercle de rayon donné de type entier.
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
I LES constantes
Une constante est une donnée dont la valeur reste inchangée au cours de l'exécution
d'un programme. Elle est caractérisée par son nom et sa valeur.
Exemple:
π = 3.14
g =9.8
II LES variables
Une variable est un objet dont la valeur peut être modifiée au cours de l'exécution d'un
programme. Elle est caractérisée par son nom, son type et son contenu.
Exemple:
Soit la suite d'instruction suivante :
A← 5
B←10
C←A
A←B
B←C
Tableau de déclaration des objets utilisés
Objet Nature/Type
……… ……….
……… ………
………. ………..

Donner le résultat d'exécution de cette séquence
N° Instruction A B C
1
2
3
4
5
A la fin de cette séquence : A ←………, B←…….., C←………
Le rôle de cette séquence est ………...…………………………………………………
………………………………………………………………………………………….
Les types d'objets :

Un type est désigné par un identificateur. Il détermine la nature d'une donnée. Les
plus connus sont : entier (int), réel (float), booléen (bool), chaîne de caractères (str).
III.1 LES TYPES SIMPLES :

III.1.1 Le type Entier :
Une variable de type entier contient un entier relatif appartenant au domaine de

validité suivant :
Les opérateurs sur les entiers
Opérateur Désignation
+ Addition
- Soustraction
* Multiplication
DIV Donne le quotient de la division
entière
MOD Donne le reste de la division
entière
En python : int
Div en python est : //
Mod en python est : %
III.1.2 le type réel :
Une variable de type réel contient un nombre appartenant à un sous ensemble de IR
Exemple :

0 0,2 -2,5 3,14 20.10-6
En python : float
Les opérateurs sur les réels
Opérateur Désignation Exemple

+ Addition
- Soustraction
* Multiplication
/ Division
Les fonctions arithmétiques standard :
Parmi les modules les plus importants, on note le module math qui regroupe un
ensemble de fonctions mathématiques définies sur le corps IR tels que la racine carré,
les fonctions trigonométriques, les fonctions log, exp…
Fonction Rôle
Algorithme Python
Tronc(x) trunc Supprime la partie
décimale d'un réel
Arrondi (x) Floor/ceil Donne l'entier le
plus proche de x
ABS (x) fabs Retourne la valeur
absolue de x
Sin (x) Sin Donne le sinus de x
Cos (x) Cos Donne le cosinus de
x
Exp (x) Exp Donne
l'exponentielle de x
Aléa ( Vi,Vf ) randint ( Vi,Vf ) Retourne un entier
aléatoire
appartenant à
l'intervalle [Vi ,
Vf].

III.1.3 LE TYPE BOOLEEN :
Une variable de type booléen ne peut prendre que les deux valeurs logiques
représentées par 0 et 1 c à d faux (false) ou vrai (true).
En python : bool
Les opérateurs logiques
Opérateur Signification
Algorithme python
() not Parenthèse
NON Negation
ET and Conjonction : les deux à la fois
OU or Disjonction : l'une ou l'autre ou les deux à la fois
Soient B1 et B2 deux variables de type booléen, on déduit le tableau suivant après

utilisation des opérateurs booléens (Non, Et, Ou, Ouex)
Exemple
Pour chacun des cas suivants, évaluer les expressions logiques
Pour (a, b, c, d) = (-1, 3, 2,7)
Pour (a, b, c, d) = (8, 1,-4,3)
(a<b) ET (c>d)
NON (a<b) ET (c>d)
((a>b) OU (c≠a)) > (c=d)
((a+b <c) OU (a+d >c)) < ((b-c=a) ET (b-c≠a))
1) 2)
a-…………… a-…………………
b-…………… b-…………………
c-…………… c-…………………
d-…………… d-…………………

III.1.4 le type caractère :
Une variable de type caractère peut contenir l'un des caractères suivants :
Les lettres de l'alphabet majuscules ("A", "B",………., "Z")
Les lettres de l'alphabet minuscules ("a", "b",………., "z")
Les chiffres ("0", "1", …………., "9")
Les signes de ponctuation (".", "?", ";"…..)
Les caractères spéciaux ("§", "%", "£"……)
L'espace est un caractère blanc (" ")
Remarques
Un caractère est placé entre deux guillemets ("A", "5", "c"….)

Chaque caractère possède un nombre (code ASCII), ces codes sont ordonnés de 0 à
255.
"0"<"1"<……<"9"<"A"<"B"<……..<"Z"<"a"<"b"<……………<"z"
Exemple
"A" <"F" …………..
"y" > "z"……………
Les fonctions prédéfinies
Supposons que c est une variable de type caractère et que n est un entier compris
entre 0 et 255.
Algorithme python
ORD (c ) Ord(c) Renvoi le code ASCII du
caractère c
CHR (n) Chr(c) Renvoie le caractère dont le
code ASCII est n
Exemple
CHR (ORD (c)) = ….. ; ORD (CHR (n)) =…….

III.2 Les types composés :
III.2.1 le type chaîne de caractères :
Une chaîne de caractères est une suite de N caractères avec N compris entre 0 et 255.
Si N = 0, on dit que la chaîne est vide.
En python : str
Exemple
"Bonjour" Chaîne de ….. caractères.
"2, rue de Caire" Chaîne de…….… caractères.

"" Chaîne………… (….caractères)
Accès aux éléments d’une chaîne de caractères :

Pour accéder au ième élément d’une chaîne de caractères, il suffit de donner le nom
(identificateur) de la chaîne suivi de l’indice i entre crochets [ ] (on commence par
0).
Exemples :
NOM "SAHAR" NOM [2] vaut …………
NOM[2] "M" NOM devient ………….
Les opérations permises sur les chaînes de caractères :
Syntaxe Rôle Exemples
Les opérateurs relationnels (<,>,<=,>=,=,<>) "Ali"<"ali" vaut ……… ;

"ALI"<> "ali" vaut………
+ Concaténation "BON " + "JOUR" vaut
……………………..

Les fonctions et les procédures standard sur les chaînes :
Algorithme En python Rôle

Majus (ch) ch.upper () Convertit la chaîne ch en
majuscules.
Long (ch) len (ch) Retourne le nombre de
caractères de la chaîne
ch.
Retourne la première
Pos (ch1 , ch2) ch2.find (ch1)
position de la chaîne
ch1 dans la
chaînech2.
Convch (n) str (n) Convertit une valeur
numérique n en une
chaîne de caractères.
int (ch) Convertit une chaîne de
Valeur (ch)
float (ch) caractères ch en une
valeur numérique,
si c’est possible.
ch.isnumeric() Retourne Vrai si la
Estnum (ch)
ch.isdigit () chaîne ch est
convertible en une
valeur
numérique, elle retourne
Faux sinon.
Retourne une partie de

Sous_Chaine(ch , d , f) ch [ d : f ]
la chaîne ch à partir de
la position d
jusqu’à la position f (f
exclue).
Efface des caractères de

Effacer(ch , d , f) ch [ : d] + ch [ f : ]
la chaîne ch à partir de
la position d
jusqu’à la position f (f
exclue).
2021-2022 - 10 - Prof : Mr Arfaoui.Nawfel

Remarque :
Taille : len(C)
Accès à un élément : C[index de l’élement] : Les index permis sont compris
entre 0 et len(C )-1
Accès à une partie des éléments avec notion de pas : C[i :j :k] : renvoie une
chaine stockant les éléments entre les deux positions i et j-1 en effectuant des
sauts d’amplitude k.
Répétition : C*n : l’opérateur * permet de créer une chaine contenant n copies
de C
Test de la nature de la chaine : alphabétique(isalpha), numérique(isidigit) ,
vide(isspace) ou alphanumérique(isalnum) :

III.2.2 Le type Tableau :
Activité :
Écrire l’algorithme qui permet de calculer l’âge moyen de trois personnes.
Algorithme :
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
Remarques
Soit à calculer l’age moyenne de 1000 personnes ; on doit alors
Définir 1000 variables pour contenir les valeurs des âges.
Ecrire 1000 instructions de lecture.
Quelle sera donc la solution ???
Solution
Il est plus convenable de définir un espace mémoire de 1000 valeurs indicées. Cet
espace sera appelé un TABLEAU à une dimension (vecteur).
Un tableau est représenté en mémoire par un ensemble fini de cases mémoires

consécutives.
Chaque case représente un élément du tableau.
Le passage d'un élément à un autre se fait par l'ajout de 1 (+1).
Un tableau contient des éléments de même type.
Représentation en mémoire d'un tableau
Pour notre activité, le tableau est représenté comme suit :

Identificateur 4 48 20 90 10 25 …. 1
Age
Age [0] Age [1] Age [2] Age [3] Age [4]
Case à ranger une Indice de l'élément Valeurs rangées dans les

valeur cases
Remarque
Dans une case, on ne peut ranger qu'une valeur à la fois.

Un tableau se compose au moins de deux cases.
L'accès à un élément du tableau

L'accès à un élément du tableau est direct. Il suffit d'écrire le ……… du tableau suivi
par …………de l'élément placé entre crochets.
Exemple
L'instruction qui permet de lire le 2 ème élément du tableau Age est :
………………………………………………….
L'instruction qui permet d'afficher le 2ème élément du tableau Age est :
…………………………………………………..
l'instruction qui permet de calculer la somme du 1èr et du 3 ème élément du tableau
Age est : ………………………….
Déclaration en algorithmique
1ère méthode
Tableau de Déclaration des Objets (T.D.O)
Objet Type/Nature
Nom_Tableau Tableau de N Type_élément
2ème méthode
Tableau de Déclaration des Nouveaux Types (T.D.N.T)
Nom_Type_Tableau = Tableau de N Type_élément
Tableau de Déclaration des Objets (T.D.O)

Objet Type/Nature
Nom_Tableau Nom_Type_Tableau
Déclaration en Python en utilisant la bibliothèque Numpy

Déclaration dans le cas général
import numpy as np
Nom_Tableau = np.array ([Type_élément ( )] * N [,dtype = object])

Exemples de déclarations en
Python
Déclaration Explication
import numpy as np Pour déclarer un tableau de 20 entiers avec importation de
T = np.array ([int ( )] * 20) la bibliothèque Numpy.
import numpy as np Pour déclarer un tableau de 100 réels avec importation de
T = np.array ([float ()] * 100) la bibliothèque Numpy.
import numpy as np
Pour déclarer un tableau de 50 chaînes de caractères avec
T = np.array ([str ( )] * 50 , dtype = object)
importation de la bibliothèque Numpy.
ou bien T = np.array ([str] * 50)
import numpy as np Pour déclarer un tableau de 10 booléens avec importation
T = np.array ([bool ( )] * 10) de la bibliothèque Numpy.

CHAPITRE 2) LES STRUCTURES SIMPLES
Une structure est dite simple si c'est une:

- Entrée ou………………..de données.
- Affectation.
- Sortie ou………………..de données.
I LES ENTREES :
Les entrées regroupent toutes les opérations de……………….de données. La source

de lecture est par défaut…………………..mais elle peut être un disque ou toute
source d'entrée ou d'entrée/ sortie.
Vocabulaire et syntaxe
 Au niveau de l'algorithme
Forme générale: Exemple:
Ecrire ("commentaire sur A") La lecture de la moyenne (moy) d'un élève
Lire (A) s'écrit:
Ecrire ("Entrer la moyenne: ")
Lire (A)
 Au niveau de python
Forme générale: Exemple:

A=input('commentaire sur A') La lecture de la moyenne (moy) d'un élève
s'écrit:
A=input('Entrer la moyenne')

II- L'AFFECTATION :
L'affectation consiste à affecter une………………..à une ………………….. La
nouvelle valeur remplacera l'ancienne. Nous notons cette opération comme suit:
Variable ← valeur
Le symbole " ← " signifie que la variable située à sa………………prend la valeur de
l'expression située à sa……………..
Exemple 1:
A ← 25.5
B← (A * 2) / 3
La variable A reçoit la valeur réelle 25.5
La variable B reçoit le continu de la variable A multiplié par 2 et divisé par 3 c'est à
dire 17.0
Exemple 2:
X←X+1
X reçoit l'ancienne valeur de X incrémentée de 1.
NB: La valeur ou le résultat de l'expression à droite du signe d'affectation doit être de

même type ou de type compatible avec celui de la variable à gauche.
Syntaxe
Au niveau de l'algorithme Au niveau de python

Forme générale: Forme générale:
Variable ← valeur Variable= valeur
Exemple: Exemple:
Calcul de la moyenne (moy) de deux notes: Calcul de la moyenne (moy) de deux notes:
moy ← (Note 1 + Note 2) / 2 moy = (Note 1 + Note 2) / 2
Activité 1:
A et B étant deux variables entières:

a) Quel est le résultat des variables A, B et C après l'exécution de la séquence
suivante ?
1) A ← 5
2) B ← 2
3) C ← A / B
4) A ← B + B
5) C ← C + (2 * A)
b) Préciser le type de la variable C.

Réponse:
a)
Variable
A B C
Étape
Avant le 1) ? ? ?
1 ….. ? ?
2 ….. ….. ?
3 ….. ….. …..
4 ….. ….. …..
5 ….. ….. …..
A = ………, B = …………, C = …………
b) La variable C doit être de type ……………….
III- LES SORTIES :
Les sorties regroupent toutes les opérations…………………ou d'écriture de données.

La destination d'écriture est par défaut…………………..
Vocabulaire et syntaxe
Au niveau de l'algorithme Au niveau de python

Formes générales: Formes générales:
* Affichage d'un texte (exemple un commentaire * Affichage d'un texte.

ou un message).
Le texte a afficher doit être entre guillemets, le Le texte a afficher doit être entre apostrophes.
texte sera afficher tel qu'il est.
Exemple: Exemple:
Ecrire ("Bonjour") print('Bonjour')
affichage avec retour à la ligne * Affichage du contenu d'une variable.

Ecrire_nl ("Bonjour") Exemple:
* Affichage du contenu d'une variable. A = 165 ;
Exemple: print (A)
A ← 165 Attention: print('A'), affichera le caractère A.
Ecrire (A)
Attention: Ecrire ("A"), affichera le caractère * Affichage mixte (commentaires et variables).
A. Exemple:
print( 'La variable A = ' , A)
* Affichage mixte (commentaires et variables),
on utilisera la virgule comme séparateur.
Exemple:
Ecrire ("La variable A =", A)

CHAPITRE 3) LES STRUCTURES
CONDITIONNELLES
Les structures conditionnelles permettent d’exécuter un traitement en fonction

d’une condition.
Il existe différentes formes de structures conditionnelles :

 Structures conditionnelles à forme simple (réduite et complète)
 Structure conditionnelle à forme généralisée
 Structure conditionnelle à choix multiple
I. STRUCTURE CONDITIONNELLE SIMPLE :

I.1 FORME REDUITE :
« SI il fait beau ALORS je ferai une promenade »

Une structure de contrôle conditionnelle est de forme réduite si on se restreint à
l’exécution du traitement quand la condition a le résultat VRAI.
SI Condition ALORS Traitement
Vrai Traitement
Condition
Syntaxe
En algorithme En python
SI condition ALORS if condition :
Instruction 1 Instruction 1
… …
Instruction n Instruction n
FINSI

REMARQUES :
Lorsque l’évaluation de la condition produit la valeur :

VRAI : les instructions placées entre ALORS et FINSI seront exécutées.
FAUX : les instructions placées entre ALORS et FINSI ne seront pas exécutées.
APPLICATION
Ecrire un algorithme puis la traduction python d’un programme nommé RACINE
qui permet de saisir un entier et déterminer sa racine carrée.
I.2 FORME COMPLETE :
«SI il fait beau ALORS je ferai une promenade SINON je resterai à la maison »
Une structure de contrôle conditionnelle est de forme complète si selon la valeur de la
condition, on exécute le traitement 1 sinon le traitement 2.
SI Condition ALORS Traitement 1 SINON Traitement 2
Traitement 1
Vrai
Condition
Faux Traitement 2
Syntaxe :
SI condition ALORS if condition :
… …
SINON else :
Instruction2 Instruction 2
… …
FINSI

REMARQUES
 Lorsque l’évaluation de la condition produit la valeur

VRAI : Seules les instructions de la partie ALORS seront exécutées
FAUX : Seules les instructions de la partie SINON seront exécutées
APPLICATION
Ecrire un algorithme puis la traduction en python d’un programme qui affiche un

message indiquant la parité d’un entier E donné.
II. STRUCTURE CONDITIONNELLE GENERALISEE :
Les instructions de la partie ALORS ainsi que celles de la partie SINON peuvent
être elles même des structures conditionnelles. Dans ce cas, on parle de structures
conditionnelles généralisées ou imbriquées.
Syntaxe :
En algorithme En Python
SI condition 1 ALORS if condition 1 :
Traitement1 Traitement 1
SINON elif condition 2 :
SI condition 2 ALORS Traitement 2
Traitement 2 elif condition 3:
SINON Traitement 3
SI condition 3 ALORS ………
Traitement 3 elif condition (n-1):
……… Traitement (n-1)
SINON else:
SI condition (n-1) ALORS Traitement n
Traitement (n-1)
SINON Traitement n
FINSI

APPLICATION :
Ecrire un algorithme BULLETIN qui effectue les opérations suivantes :

- Saisir les trois notes N1, N2 et N3 de trois matières dont les coefficients sont
respectivement CF1=2, CF2=4 et CF3=1,
- Calculer la moyenne de trois notes,
- Déterminer l’appréciation adéquate :
20 > = Moyenne > = 18 Excellent
18 > Moyenne > = 16 Très Bien
16 > Moyenne > = 14 Bien
14 > Moyenne > = 12 Assez Bien
12 > Moyenne > = 10 Passable
10 > Moyenne > = 0 Redouble
Afficher la moyenne suivie de l’appréciation.

Traduire cet algorithme en python
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................

III. STRUCTURE CONDITIONNELLE A CHOIX MULTIPLE :
L’application qu’on vient de réaliser, montre bien que, dans certains cas, la
structure conditionnelle généralisée est assez longue.
IL est parfois possible d’éviter l'utilisation de cette structure en utilisant plutôt la
structure conditionnelle à choix multiple qui permet d’avoir une meilleure lisibilité de
la solution.
La structure conditionnelle à choix multiple permet de faire un choix parmi
plusieurs possibilités (traitements).
Syntaxe
match Sélecteur :
SELON Sélecteur case Val1 :
Valeur(s)1 : Traitement 1 Traitement1
Valeur(s)2 :Traitement2 case Val2 | Val3 | Val4 :
Valeur(s)3 : Traitement 3 Traitement2
……… case Sélecteur if
Valeur(s)n : Traitement n Val5<=Sélecteur<=Val6 :
SINON Traitement n+1 Traitement3
FINSELON case _:
TraitementN
REMARQUES
 La partie SINON est facultative.

 Le sélecteur doit être de type scalaire (entier, caractère ou booléen).
 Valeur(s)1, Valeur(s)2, …, Valeur(s)n peuvent se présenter sous la forme d’une
seule valeur, d’une liste de valeurs séparées par des virgules ou encore sous la
forme d’un intervalle de valeurs. Exemple : SELON S
3 : ……………
1, 5 , 9 : …………..
10 .. 15 : ………
FINSELON

APPLICATION :
Ecrire un algorithme nommé AFFICHE_SAISON qui affiche le nom de la saison

en fonction de sa première lettre S donnée.
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................

CHAPITRE 4) LES STRUCTURES DE CONTROLE
ITERATIVES
Introduction :
Dans la résolution de certains problèmes on répète une suite d’instruction plusieurs
fois ; pour éviter toutes ces répétition, on utilise les structures itératives appelées aussi
structure répétitives ou boucles. Dans ce chapitre nous allons résoudre des problèmes
faisant appel aux structures de contrôle itératives qui peuvent se présenter sous 2
formes :
 Les structures de contrôle itératives complète.
 Les structures de contrôle itératives à condition d’arrêt.
I) LA STRUCTURE ITERATIVE COMPLETE (LA BOUCLE

« POUR ») :
On se propose d’écrire un algorithme intitulé Somme permettant :
 De saisir n entiers (n étant comme donnée).

 De calculer et d’afficher la somme de ces entiers.
I.1 DEFINITION :
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.
I.2 SYNTAXE :
Pour compteur de Vi à Vf (pas=P) faire For compteur in range (Vi ,Vf , pas) :
….. …..
Instruction N Instruction N
FinPour
Remarques :

 Vi : Valeur initiale du compteur.
 Vf : Valeur finale du compteur, elle est exclue en python.
 Le compteur doit être de type scalaire (Entier, caractère ou booléen).
 Les instructions entre « Pour » et « FinPour » constitue le corps du traitement à
répéter.
 Dans la boucle « Pour » le nombre de répétitions est fini.
Application :
Ecrire un algorithme puis la traduction en python d’un programme intitulé
PUISSANCE permettant de déterminer puis d’afficher la valeur de P qui représente
X à la puissance N (P = XN)
N.B. : On suppose que dans tous les cas les valeurs de X et N sont strictement
positives.
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................

II) LA STRUCTURE ITERATIVE A CONDITION
D’ARRET :
II.1 La boucle Répéter ….Jusqu’à
a) Activité 1 :
Ecrire un algorithme d’un programme nommé Racine_C permettant de saisir un
entier strictement positif et d’afficher sa racine carrée.
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
b) Définition :
Un résultat à une définition itérative à condition d’arrêt s’il est la répétition d’une
suite d’instructions jusqu’à ce qu’une condition d’arrêt passe à l’état vrai.
c) Syntaxe :
En Algorithme En Python
Répéter valide = False

Instruction 1 while valide == False :
Instruction 2 Traitement
…… valide = ( Condition(s) de
sortie )
Instruction N valide = False
Jusqu’à Condition while valide == False :
Remarque :
Dans cette boucle, les instructions du traitement seront tout d’abord exécutées puis la
condition sera évaluée. Si la condition est VRAI alors le traitement de la boucle ne se
répète plus (la boucle s’arrête) sinon ce traitement sera de nouveau exécuté et ainsi
de suite.

II.2 La boucle Tant que ………. Faire :
a) Activité 2 :
Ecrire un algorithme d’un programme nommé Racine_2 permettant de saisir un entier

strictement positif et d’afficher sa racine carrée en utilisant la boucle : TANT QUE …
FAIRE.
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
b) Syntaxe :
En algorithme En Python
TantQue Condition Faire While Condition :

Instruction 1
Instruction 2 ……
…… Instruction N
Instruction N
Fin TantQue
Remarques :
 Dans cette boucle, la condition sera tout d’abord évaluée. Si elle est VRAI alors le
traitement de la boucle sera exécuté sinon ce traitement ne s’exécute pas.
 Pour les structures itératives à condition d’arrêt, le traitement de la boucle
«Répéter» s’exécute dans tous les cas au moins une fois alors que pour 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.

CHAPITRE 5) LES SOUS PROGRAMMES
Introduction
Un concept de la programmation structurée est la décomposition d’une tâche

(problème) complexe en tâches plus simples.
La modularité d’un programme assure :
 une meilleure qualité du programme
 plus de lisibilité
 moins d’erreurs…
Il est sûr que la qualité de la solution finale dépend fondamentalement de la qualité de
la décomposition choisie. Les modules crées sont appelés sous-programmes.
Un sous-programme est appelé aussi procédure ou fonction
I) LES PROCEDURES :
I-1 Definition:
Une procédure est un sous-programme qui peut avoir plusieurs résultats.
I-2 DECLARATION D’UNE PROCEDURE
Procédure Nom_procédure ( paramètres) Def Nom_procedure( p1 ,p2…):
Début
Instruction1
Instruction1
Instruction2
Instruction2
InstructionN
InstructionN t
Fin Nom_procédure

1- Les objets locaux
Tous les objets (constantes, types, variables et sous programmes) déclarés dans un
sous programme sont locaux à celui-ci. Ils ne sont accessibles que par le sous
programme qui les a déclaré.
2- Les objets globaux

Tout objet global est déclaré dans la partie déclarative d’un programme père. Il est
accessible par tous ses sous programmes fils sans qu’il soit déclaré dans ces
derniers.
Activité (procédure paramétré)
Ecrire un algorithme d’un programme intitulé PRODUIT qui permet de saisir

trois entiers A, B et C puis afficher dans un premier temps le produit de A et B et dans
un deuxième temps celui de B et C.
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
 Dans le premier appel de la procédure TRAIT, les variables X et Y remplacent

les variables ………….et ………..du programme principal.
Dans le deuxième appel de la procédure TRAIT, les variables X et Y
remplacent les variables………..et………….du programme principal.
 Les variables X et Y de la procédure TRAIT sont appelés
……………………………..
 Les variables A, B et C du programme appelant, dans les appels TRAIT (A, B)
et TRAIT (B, C), sont appelés
…………………………………………………………

1- Les paramètres formels
Ce sont les paramètres déclarés dans l’entête du sous programme. Ils sont
utilisés lors de la déclaration du sous programme
Les paramètres formels ne sont utilisés que par des instructions du sous
programme
2- Les paramètres effectifs
Ce sont les paramètres qui figurent dans l’instruction d’appel du sous
programme.
Remarques
 Lors de l’appel du sous programme, les paramètres effectifs sont substitués
aux paramètres formels. Cette substitution s’appelle passage des
paramètres
 Les paramètres effectifs et les paramètres formels doivent s’accorder de
point de vue :
o …………………….
o …………………….
o …………………….
I-3 mode de passage de paramètres :
Le passage des paramètres correspond à un transfert de données entre le programme

appelant et le sous programme appelé.
Il existe deux modes de passage de paramètres :
 Passage par valeur : le paramètre formel n’est pas précédé par @.
 Passage par variable : le paramètre formel est précédé par @.
I-3.1 Mode de passage par valeur
Dans le cas d’un passage de paramètres par valeur :

 Avant d’exécuter les instructions du sous programme appelé, la valeur du
paramètre effectif est ………………dans le paramètre formel correspondant.
 Toute modification du paramètre formel est ……………………………..sur
le paramètre effectif.
Le transfert d’informations se fait dans un seul sens :

Programme appelant sous programme appelé

Exemple : une procédure qui permet d’afficher les éléments d’un tableau t de
taille n.
Procédure affiche (t :tab, n :entier)

Début
Pour i de 1 à n répéter
Ecrire (t[i],"|")
FinPour
Fin affiche
I-3.2 Mode de passage par variable
Dans le cas d’un passage de paramètres par variable :

 Le paramètre formel et le paramètre effectif correspondant font référence à la
même case mémoire.
 Toute modification de paramètre formel entraîne automatiquement la même
modification du paramètre effectif correspondant.
Le transfert d’informations se fait dans les deux sens :

Programme appelant sous programme appelé
Exemple : une procédure qui permet de permuter deux entiers a et b.
Procédure permuter (@ a, b : entier)

Début
Aux  a
a b
b aux
Fin saisie
En python :
def permuter(a,b):
return b,a;

APPLICATION :
On se propose d’écrire un programme intitulé CALCUL qui permet de remplir un

tableau Note par N réels (N <= 100) puis afficher tous les éléments du tableau
NOTE qui sont supérieurs ou égal à sa moyenne arithmétique MOY.
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................
.......................................................................................................................................

II) LES FONCTIONS :
II-1 Définition :
Une fonction est un sous-programme qui renvoie (retourne) une seule valeur de type
simple. Ce type sera celui de la fonction
II-2 Déclaration d’une fonction :
Fonction Nom_fonction ( paramètres) :type résultat Def Nom_Fonction (p1, p2...) :
Début
Traitement
Traitement Return (R)
Fin Nom_fonction
Une fonction possède presque la même structure qu’une procédure sauf qu’il
faut également préciser dans l’entête le type de la fonction qui est en fait le type du
résultat retourné par l’appel de la fonction. Il doit y avoir nécessairement dans la
partie des instructions de la fonction (généralement à la fin) une instruction permettant
d’affecter au nom de la fonction son résultat. (C’est-à-dire que le nom de la fonction
contient le résultat de son traitement).
L’objectif d’une fonction est de retourner une valeur résultat et non pas de modifier
les valeurs des paramètres effectifs. De ce fait, il est interdit de passer des paramètres
par variable dans les fonctions.
Exemple : La fonction somme qui somme deux entiers a et b :
def somme(a,b):
s=a+b;
return(s);

CHAPITRE 6) LES TRAITEMENTS AVANCES
Le problème de tri est un classique de l'informatique ; les méthodes de tri sont

utilisées dans différentes applications.
Par exemple :
- classer les élèves par ordre alphabétique ou par ordre de mérite
- mettre en ordre un dictionnaire
- trier l'index d'un livre
I) TRI PAR SELECTION :
Principe :
- Commencer à chercher l’indice du minimum de la liste L ;

- Permuter le 1er élément de la liste avec l’élément minimum trouvé ;
- Chercher l’indice du minimum des éléments de la sous liste L[1 :] et le
permuter avec le 2ème élément…
- Continuer ce principe jusqu’à ce que la liste devienne triée.
 D’une manière générale, on échange l’élément à la position i avec le
minimum de la sous liste L[i+1 :]. L’algorithme se termine au bout de n-1
boucles quand on a trouvé les n-1 minimums successifs.
Exemple : L=[4,5,1,-6,2]
- Etape N°1 : le minimum de L est -6, on le permute avec 4 : L=[-6,5,1,4,2] ;
- Etape N°2 : le minimum de [5,1,4,2] est 1, on le permute avec 5 : L=[-6,1,
5,4,2]
- Etape N°3 : le minimum de [5,4,2] est 2, on le permute avec 5 : L=[-6,1,2,4,5]
- Etape N°4 : le minimum de [4,5] est 4, il est à sa bonne place.

Implémentation :

II) TRI A BULLES
Principe :
Parcourir la liste en comparant à chaque fois deux éléments successifs(L[i] et

L[i+1]), si l’ordre croissant n’est pas respecté (L[i]>L[i+1]) alors on permute
les deux éléments. On répète le parcours de la liste jusqu’à ce qu’on ne
permute plus. On est sûre d’obtenir une liste triée au bout de n-1 parcours
mais parfois le processus s’arrête un peu plus tôt.
Implémentation :

III) RECHERCHE SEQUENTIELLE :
Principe :
La recherche séquentielle consiste à parcourir un tableau d'éléments dans l'ordre de

ses indices jusqu'à ce qu'un élément recherché soit trouvé ou bien que la fin du tableau
soit atteinte et l’élément recherché est alors inexistant.
Implémentation :
Algorithme
Fonction Recherche_séquentielle (x:entier , T:tab, n:entier) : booleen

Début
i←0
Tant que ((i<n )et(T[i] <> x)) faire
i i+1
Fin tantque
Recherche_séquentielle ← (i<n)
Fin Recherche_séquentielle
En python :
Def recherche (t,x) :

i=0
while i<len(t) and x !=t[i] :
i+=1
return (i<len(t))

IV) RECHERCHE DICHOTOMIE :
Principe :
On suppose que le tableau C est trié d’une manière croissante

le principe est le suivant :
- On calcule m l’indice du milieu du tableau
- On compare C[m] à x :
 Si C[m]=x : c’est trouvé
 Si C[m]>x : on continue la recherche dans la partition C[0 :m]
 Si C[m]<c :on continue la recherche dans la partition C[m+1 :]
- Ce principe est répété jusqu’à ce que le conteneur C ne contienne plus
d’éléments.
Implémentation :
Algorithme
Soit le tableau T est trié d’une manière croissante.
DEF FN Recherche (n,x:Entier ; T:tab): Bouléen

Debut
a1
bn
rfaux
repeter
m(a+b)div2
si(x=T[m]) alors
r vrai
sinon
si (x<T[m] ) alors
bm-1
sinon
am+1
finsi
jusqu’à ( r ou (a>b))
Rechercher
Fin recherche

En python :
Def dichotomie(t,x) :
d=0
f=len(t)-1
While 1 :
m=(d+f)//2
if t[m]==x :
return true
elif t[m]>x :
f=m-1
else :
d=m+1
if d>f : break
return False

CHAPITRE 7) INTERFACE GRAPHIQUE
I) Présentation de l’interface graphique (GUI) :
Les interfaces graphiques (ou interfaces homme- machine) sont appelées GUI
(Graphical User Interface).Elles permettent à l'utilisateur d'interagir avec un
programme informatique, grâce aux différents objets graphiques (zone de
texte, case à cocher, bouton radio, bouton poussoir, menu, …).
La création d’une GUI peut se réaliser par la création des objets graphiques
(zone de texte, case à cocher, bouton radio, bouton poussoir, menu,…)
directement sur une fenêtre en utilisant un outil de conception et de création
d’interfaces graphiques (un éditeur graphique tel que Qt Designer ) qui
contient un éditeur d’interface utilisateur glisser et déposer (drag and drop)
II) Installation PyQt5 :

1. Ouvrir l’invite de commande (cliquer sur la fenêtre windows et taper
cmd)
2. Taper la commande pip install PyQt5
3. Taper la commande pip install pyqt5-tools.
L’ éditeur graphique Qt Designer se trouve dans l’emplacement :
C:\Users\....\AppData\Local\Programs\Python\Python-version\Lib\site-
packages\qt5_applications\Qt\bin.
III) Création d’interface graphique :

L’interface peut être créé par un outil de création d’interface
graphique GUI (fichier.ui) puis appelé ce fichier dans le code python
(fichier.py).

Implémentation :
Le fichier Nom_fichier.py qui contient de code de votre application :
import sys
from PyQt5 import QtWidgets, uic
# Slot : Définir une fonction

def nom_fonction( ) :
< Actions >
app=QtWidgets.QApplication(sys.argv)
Fen =uic.loadUi("path du fichier crée par Qt Designer " )
# Signal (événement) : Exemple clicked : Appel du fonction

Nom_objet_Fen.Nom_Widget.clicked.connect(nom_fonction)
app.exec()
sys.exit()
Application :
Programmer avec PyQt5 le bouton Fermer de l’interface créée par Qt
Designer (fenetre.ui)
Fichier Fenetre.py :
# Importations à faire pour réaliser une interface graphique
import sys
from PyQt5 import QtWidgets ,uic
# Définir une fonction
def Fermer ( ) :
f.close() # Fermer la fenêtre
App = QtWidgets.QApplication(sys.argv) # Création d'une instance de
QApplication
f = uic.loadUi("fenetre.ui" ) # Charger le fichier crée par Qt Designer
f.show() # Visualiser la fenêtre
# Signal (clicked) clic sur le bouton de fermeture BFermer
f.BFermer.clicked.connect(Fermer) # Appel de la fonction Fermer
App.exec_() # Exécution de l'application
Le clic sur le bouton Fermer permet la fermeture de la fenêtre.

Exemple N°1 : Surface d’un rectangle

import sys
def calculer():
l=float(ui.longeur.text())
L=float(ui.largeur.text())
s=l*L
ui.res.setText(str(s))
ui=uic.loadUi("surface.ui" )
ui.show()
ui.calcul.clicked.connect(calculer)
app.exec()
sys.exit()

Exemple N°2 : Test d’amitié entre deux entier a et b

import sys
def somme(a):
s=0
for i in range(1,a//2+1,1):
if a%i==0 :
s+=i
return s
def affiche():
a=int(ui.va.text())
b=int(ui.vb.text())
c=str(a+b)
x=somme(a)
y=somme(b)
if b==x and a==y :
ui.res.setText('amis')
else:
ui.res.setText('non amis')
ui=uic.loadUi("amis.ui" )
ui.show()
ui.amis.clicked.connect(affiche)
app.exec()
sys.exit()

IV) Projet :
Notre projet consiste à créer une interface graphique avec l’outil de création
Qt Designer qui permet de réaliser une calculatrice.
Voici ci-dessous le model a suivre.

import sys
from PyQt5 import QtWidgets, uic def affichpf():
def affich1(): Fen.le.setText(Fen.le.text()+')')
Fen.le.setText(Fen.le.text()+'1') def affichdel():
def affich2(): Fen.le.setText(Fen.le.text()[:-1])
Fen.le.setText(Fen.le.text()+'2') def affichegal():
def affich3(): Fen.le.setText(str(eval(Fen.le.text())))
Fen.le.setText(Fen.le.text()+'3') def affichv():
def affich4(): Fen.le.setText(Fen.le.text()+'.')
Fen.le.setText(Fen.le.text()+'4')
def affich5(): app=QtWidgets.QApplication(sys.argv)
Fen.le.setText(Fen.le.text()+'5') Fen =uic.loadUi("calcul.ui" )
def affich6(): Fen.show()
Fen.le.setText(Fen.le.text()+'6') Fen.pb1.clicked.connect(affich1)
def affich7(): Fen.pb2.clicked.connect(affich2)
def affichd(): Fen.pb0.clicked.connect(affich0)
Fen.le.setText(Fen.le.text()+'//') Fen.pbverg.clicked.connect(affichv)
def affichmd(): Fen.pbmod.clicked.connect(affichmd)
Fen.le.setText(Fen.le.text()+'%') Fen.pbdiv.clicked.connect(affichd)
def affichsou(): Fen.pbac.clicked.connect(affichac)
Fen.le.setText(Fen.le.text()+'-') Fen.pbpo.clicked.connect(affichpo)
def affichad(): Fen.pbpf.clicked.connect(affichpf)
Fen.le.setText(Fen.le.text()+'+') Fen.pbad.clicked.connect(affichad)
def affichmu(): Fen.pbmul.clicked.connect(affichmu)
Fen.le.setText(Fen.le.text()+'*') Fen.pbsous.clicked.connect(affichsou)
def affichsur(): Fen.pbsur.clicked.connect(affichsur)
Fen.le.setText(Fen.le.text()+'/') Fen.pbdel.clicked.connect(affichdel)
def affichac(): Fen.pbegal.clicked.connect(affichegal)
Fen.le.setText('') app.exec()
def affichpo(): sys.exit()
Fen.le.setText(Fen.le.text()+'(')

4éme Scientifiques 2021-2022

Transféré par

Droits d'auteur :

Formats disponibles

4éme Scientifiques 2021-2022

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

4éme Scientifiques 2021-2022

Transféré par

Droits d'auteur :

Formats disponibles

INFORMATIQUE

4ème ANNEE DE L'ENSEIGNEMENT

Réalisé par :Mr Arfaoui nawfel

2021-2022 -1- Prof : Mr Arfaoui.Nawfel

2021-2022 -3- Prof : Mr Arfaoui.Nawfel

Tableau de déclaration des objets utilisés

2021-2022 -4- Prof : Mr Arfaoui.Nawfel

Les types d'objets :

III.1 LES TYPES SIMPLES :

Une variable de type entier contient un entier relatif appartenant au domaine de

Les opérateurs sur les entiers

III.1.2 le type réel :

Une variable de type réel contient un nombre appartenant à un sous ensemble de IR

2021-2022 -5- Prof : Mr Arfaoui.Nawfel

Les opérateurs sur les réels

Opérateur Désignation Exemple

Les fonctions arithmétiques standard :

2021-2022 -6- Prof : Mr Arfaoui.Nawfel

Les opérateurs logiques

Soient B1 et B2 deux variables de type booléen, on déduit le tableau suivant après

2021-2022 -7- Prof : Mr Arfaoui.Nawfel

Un caractère est placé entre deux guillemets ("A", "5", "c"….)

Les fonctions prédéfinies

CHR (ORD (c)) = ….. ; ORD (CHR (n)) =…….

2021-2022 -8- Prof : Mr Arfaoui.Nawfel

"2, rue de Caire" Chaîne de…….… caractères.

Accès aux éléments d’une chaîne de caractères :

Les opérations permises sur les chaînes de caractères :

Syntaxe Rôle Exemples

Les opérateurs relationnels (<,>,<=,>=,=,<>) "Ali"<"ali" vaut ……… ;

2021-2022 -9- Prof : Mr Arfaoui.Nawfel

Algorithme En python Rôle

Retourne une partie de

Efface des caractères de

2021-2022 - 10 - Prof : Mr Arfaoui.Nawfel

2021-2022 - 11 - Prof : Mr Arfaoui.Nawfel

Un tableau est représenté en mémoire par un ensemble fini de cases mémoires

Représentation en mémoire d'un tableau

Pour notre activité, le tableau est représenté comme suit :

Case à ranger une Indice de l'élément Valeurs rangées dans les

Dans une case, on ne peut ranger qu'une valeur à la fois.

2021-2022 - 12 - Prof : Mr Arfaoui.Nawfel

Tableau de Déclaration des Objets (T.D.O)

Déclaration en Python en utilisant la bibliothèque Numpy

2021-2022 - 13 - Prof : Mr Arfaoui.Nawfel

2021-2022 - 14 - Prof : Mr Arfaoui.Nawfel

Une structure est dite simple si c'est une:

Les entrées regroupent toutes les opérations de……………….de données. La source

Forme générale: Exemple:

2021-2022 - 15 - Prof : Mr Arfaoui.Nawfel

NB: La valeur ou le résultat de l'expression à droite du signe d'affectation doit être de

Au niveau de l'algorithme Au niveau de python

A et B étant deux variables entières:

2021-2022 - 16 - Prof : Mr Arfaoui.Nawfel

III- LES SORTIES :

Les sorties regroupent toutes les opérations…………………ou d'écriture de données.

Au niveau de l'algorithme Au niveau de python

* Affichage d'un texte (exemple un commentaire * Affichage d'un texte.

affichage avec retour à la ligne * Affichage du contenu d'une variable.