Vous êtes sur la page 1sur 8

Chapitre 2 : Notions de base en algorithmique et python

1. Introduction
Un algorithme est une méthode de résolution qui décrit la solution d’un problème.
Il contient deux parties essentielles:
*la première est appelé entête, elle contient l’ensemble des constantes et leurs valeurs, les
types personnalisées et les variables et leurs types,
*la deuxième est appelé corps (ou pseudo code), elle contient une suite d’actions (traitement
ou ensemble d’instructions) à exécuter pour arriver en un temps fini à la solution du
problème.
En python, la structuration d’un bloc d’instructions est définie par son indentation (nombre
d’espace).
Le début d’un bloc est défini par un double-point (:),
Le corps du bloc est alors indenté d’un nombre d’espaces fixes (quatre par défaut), et le retour
à l’indentation de l’en-tête marque la fin du bloc.
en-tête:
bloc ...........................
................................
d'instructions .................

2. Les types simples

2.1 Le type entier et le type réel


Le type entier est associé aux objets prenant leurs valeurs dans l'intervalle des entiers finis
relatifs Z avec borne inférieure et borne supérieure prédéfinies.
Un objet de type entier pourra donc être positif, négatif ou nul.
Le type réel correspond aux objets qui prennent leurs valeurs dans l’ensemble fini des
nombres réels R.

2.1.1. Déclaration

Variable
identificateur1_e, identificateur2_e, …, identificateurn_e : entier
identificateur1_r, identificateur2_r, …, identificateurn_r : réel

En algorithmique, il est complètement indifférent que les identificateurs soient écrits en


majuscule ou en minuscule dans un algorithme.

En python les mots clés int et float spécifient respectivement la classe entier et la classe réel.

2.1.2. Opérations de manipulation


Un objet de type entier ou réel peut subir les opérations suivantes :
 Les actions algorithmiques simples (lire, écrire et affecter)
 Les opérations arithmétiques : la division réelle (/), l’addition (+), la soustraction (-), la
multiplication (*) ;
 La puissance, notée « ** », telle que « n**p » donne n à la puissance p.
 Les opérateurs de comparaison (<, <=, > ,>=, ==, !=)

Avec l'ajout des opérations suivantes pour le type entier :

1
 La division entière, notée « DIV », telle que n DIV p donne la partie entière du quotient
de la division de n par p. En python l’instruction n // p donne ce quotient.
 Le modulo, noté « MOD », tel que n MOD p donne le reste de la division entière de n par
p. En python l’instruction n % p donne ce reste.

Application : Ecrire un algorithme qui permet de saisir un nombre de secondes et de le


convertir en nombre d'heures, minutes et secondes.

2.2. Le type caractère


Ce type permet de définir les objets représentant un élément pris dans l’ensemble des
caractères éditables (lettres majuscules, minuscules, caractères de ponctuation, le blanc, etc.).
Un caractère sera toujours noté entre apostrophes : cela nous permet de distinguer un
caractère chiffre (‘3’) de l’entier correspondant (3) ou d’un caractère alphabétique (‘A’) du
nom d’une variable (A).
Le caractère « espace » se note par deux apostrophes séparés par un espace : ‘ ’.

2.2.1. Déclaration

Variable
identificateur1, identificateur2, …, identificateurn : caractère

En python le mot clé str spécifie la classe chaîne de caractère.

2.2.2. Opérations de manipulation


Les opérations permises sur le type caractère sont les suivantes :
 Les actions algorithmiques simples (lire, écrire et affecter)
 Les opérateurs de comparaison (<, <=, > ,>=, ==, !=)

Exemples :
‘a’ != ‘b’ c’est évident
‘0’< … < ‘9’ < … < ‘A’ < … < ‘Z’ < … <‘a’ < … < ‘z’

 ord ( c ) : donne le code ASCII (ordre dans la table ASCII) du caractère existant dans
l’objet c. Le résultat est de type entier.
Exemple : ord ( ‘A’ ) = 65

 chr ( n ) : donne le caractère correspondant au code ASCII numéro n. Le résultat est de


type caractère.
Exemple : chr (65 ) =’A’

Remarque : Les deux fonctions chr et ord sont réciproques. c’est à dire que
chr ( ord (c) ) = c.

2.3 Le type logique


il s’agit d’un type associé à un objet prenant ses valeurs dans l’ensemble Vrai, Faux ou 1,
0.
Les objets de type logique sont souvent utilisés dans les structures conditionnelles (si).

2
2.3.1. Déclaration
Variable
identificateur1, identificateur2, …, identificateurn : booléen

En python le mot clé bool spécifie la classe logique.

2.3.2. Opérations de manipulation


 La négation : (notée « NON » ou « ») ( not en python)
A Ā Par défaut, si une condition teste sur
Vrai Faux
Faux Vrai  A : elle aura la valeur Vrai (True en python);
 Ā (not A): elle aura la valeur Faux (False)

 L’intersection : (notée « ET » ou « . » ou «  ») ( and en python)


A
B Vrai Faux
Vrai Vrai Faux
Faux Faux Faux
 L’union : (notée « OU » ou « + » ou «  ») ( or en python)
A
B Vrai Faux
Vrai Vrai Vrai
Faux Vrai Faux

2.3.3. Théorèmes fondamentaux


Soit A une expression logique dont la valeur peut être Vrai ou Faux.
 A OU Vrai = Vrai  A OU Faux = A
 A OU Ā = Vrai  A OU A = A
 A ET Vrai = A  A ET Faux = Faux
 A ET Ā = Faux  A ET A = A

2.4 Le type intervalle


Un objet de type intervalle est un objet qui voit ses valeurs fixées par une valeur minimale et
une valeur maximale dans un intervalle donné.

2.4.1. Déclaration
Le type intervalle est personnalisé, il doit être déclaré dans un bloc TYPE qui précède la
déclaration des variables.
Type
nom_intervalle = b_inf .. b_sup
Variable
identificateur1, identificateur2, …, identificateurn : nom_intervalle .
avec b_inf  b_sup

Exemple
Type lettre_maj =‘A’..’Z’
Lettre_min =‘a’..’z’
Mois =1..2
Remarque : b_inf et b_sup doivent être du type scalaire (entier ou caractère).

En python le mot clé range spécifie la classe intervalle.

3
2.4.2. Opérations de manipulation
Un type intervalle hérite ses actions possibles de celles applicables sur le type duquel il
dérive.

3. Les actions simples


3.1. Affectation
C’est une opération qui permet d’associer une valeur à une variable. La valeur peut être le
contenu d’une autre variable ou constante, une valeur donnée, ou une expression arithmétique
ou logique.

Syntaxe
Nom_vble  Valeur
Avec :
 Nom_vble est le nom de la variable cible qui va recevoir la valeur (c’est le membre gauche
de l’affectation).
 Valeur peut être une valeur, un identificateur ou une expression arithmétique ou logique
(c’est le membre droit de l’affectation).

En python l’opérateur = permet de réaliser l’opération d’affectation :

Nom_vble = Valeur

3.2. Saisie
Cette action permet d’affecter, à une variable, une valeur communiquée de l’utilisateur à
l’ordinateur. L’exécution de cette action implique l’attente d’une valeur à introduire.

Syntaxe
Lire (nom_vble1, nom_vble2, … , nom_vblen)

Exemples : on peut lire chaque variable à part, comme on peut lire plusieurs variables avec le
même ordre LIRE.
LIRE (A)
LIRE (B)  LIRE (A, B, C)
LIRE (C)

En python la fonction input() permet la saisie :

Nom_vble = input()

3.3. Affichage
L’instruction d’affichage permet de communiquer un message ou le contenu d’une ou
plusieurs variables à l’utilisateur sur écran (ou imprimante).

Syntaxe
Ecrire (exp1, exp2, … , expn)

où expi (i[1..n]) peut être :


- l’identificateur d’un objet (constante ou variable) ;
- une expression arithmétique ou logique ;
- un message.

4
Exemples :

 ECRIRE (A) : affiche le contenu de l’objet A.

 ECRIRE (message) : affiche le mot ‘message’ intégralement.

 ECRIRE (B * B – 4 * a * c) : affiche le résultat de l’expression ; ceci suppose qu’on


dispose des valeurs de a, B et c.

 ECRIRE (le carré de  , A , est égal à  , A * A)

Message vble message expression

En python la fonction print permet l’affichage.

4. Les structures de contrôles


On distingue, les structures conditionnelles et les structures répétitives.

4.1. Structure conditionnelle


La structure conditionnelle alternative est définie par un test sur un ou plusieurs objets. Ces
objets peuvent être des expressions logiques et/ou de comparaisons constituant une condition.

En algorithmique, un schéma conditionnel peut être représenté tel que:

si Condition alors Faux Condition Vrai


Traitement1
sinon Traitement2 Traitement1
Traitement2
finsi
Fin
La structure conditionnelle alternative est définie à l’aide du mot clé if et prennent la forme
suivante :

if condition:
Traitement1
else:
Traitement2

Remarque : (10 <= Moyenne < 12) est une condition composée qui doit être décomposé en
deux sous conditions élémentaires : (Moyenne >= 10 ) ET ( Moyenne < 12 )

Application : Ecrire un algorithme qui permet de lire un entier dans une variable NB et de
déterminer sa parité.

5
Imbrication des schémas conditionnels
On peut avoir besoin parfois d’imbriquer des schémas conditionnels et ce selon le problème à
résoudre. Le schéma général peut être présenté comme suit :

Algorithmique Python

si condition1 alors traitement1 if condition1 :


sinon traitement1
si condition 2 alors traitement2
sinon elif condition2 :
si condition 3 alors traitement3 traitement 2
sinon
... elif condition3 :
traitement 3
si conditionn alors traitementn ...
sinon traitementn+1
finsi elif conditionn :
finsi traitementn
finsi else :
finsi traitementn+1

Application : Ecrire un algorithme qui permet de déterminer le plus grand de deux nombres.

4.2. Structures répétitives


On appelle itération toute répétition de l'exécution d'une ou plusieurs instructions. Le nombre
de répétitions peut être connu à l'avance (a priori), comme il peut ne pas l'être.
Une répétition peut être représentée par une partie d'organigramme fermée appelée boucle.

4.2.1. La boucle pour im


Cette boucle est utilisée lorsque le nombre de répétitions est connu a priori.
Elle peut être représentée par la partie d'organigramme suivante:
i  i+ p
La syntaxe de la boucle pour en algorithmique est:
Traitement
Pour i de m à n par p faire
Traitement Faux ? Vrai
Fin pour i  n

L'élément permettant le contrôle de la boucle (le compteur i) prendra ses valeurs dans
l'intervalle fermé [m..n].
Le nombre de répétition dépendra alors de cet ensemble tout en tenant compte du pas p. Il est
déterminé par la formule: (n -m) div p + 1

Si le pas p n'est pas spécifié, il vaut par défaut 1 . Dans ce cas, la boucle devient:

Pour i de 1 à n faire
Traitement
Fin pour

6
Remarques:
 l'incrémentation du compteur (i  i + p) se fait d'une manière automatique,
 après chaque itération il y a test de la condition i <= n. Si i > n on sort automatiquement
de la boucle avec la valeur i = n + p,
 si m > n, il s'agit dans ce cas d'un décompteur par pas -p.

En python on utilise une boucle énumérée à l’aide de la fonction range :


La fonction range peut prendre entre 1 et 3 arguments entiers :
– range(n) énumère les entiers 0,1,2,… ,n - 1 ;
– range(m, n) énumère les entiers m,m + 1,m + 2, … ,n - 1 ;
– range(m, n, p) énumère les entiers m,m+p,m+2p … ,m+kp où k est le plus grand entier
vérifiant m+kp < n.

On définit une boucle indexée à l’aide de la fonction for, en suivant la structure suivante :
for i in range(1,n+1):
bloc ...........................
................................
d'instructions .................

Immédiatement après le mot-clé for doit figurer le nom d’une variable, qui va prendre les
différentes valeurs de l’énumération produite par l’instruction range. Pour chacune de ces
valeurs, le bloc d’instructions qui suit sera exécuté.
La fonction break quant à elle, permet d’interrompre le déroulement des instructions du bloc
interne à la boucle pour passer à la suite.

Application : Ecrire un algorithme qui permet de calculer la somme des entiers positifs pairs
inférieurs à dix avec deux méthodes.

4.2.2. La boucle Répéter jusqu'à


La boucle répéter jusqu'à est généralement utilisée lorsque le nombre de répétitions n'est pas
connu a priori.

La syntaxe de la boucle répéter jusqu'à en algorithmique est:

Répéter Traitement
Traitement
Jusqu’à condition

Vrai Faux
Condition

Remarques:
 la condition peut être une expression logique ou une expression de comparaison,
 le test et l'évaluation de la condition sont réalisés après l'exécution du traitement. Il en
résulte que le traitement est exécuté au moins une fois,
 si le résultat de l'évaluation de la condition est faux, le traitement est ré-exécuté de
nouveau,
 il doit exister au moins une instruction faisant partie du traitement qui permet de changer
après un certain nombre d'itérations le résultat de la condition.
 La boucle répéter jusqu’à n’existe pas en python.

7
Application : Ecrire un algorithme qui permet de saisir un caractère alphabétique.

4.2.3. La boucle tant que


Cette boucle est généralement utilisée lorsque le nombre de répétitions n'est pas connu a
priori.

La syntaxe de la boucle tant que en algorithmique est:


Traitement
Tant que condition faire
Traitement Faux Vrai
Fin tant que Condition

La syntaxe d’une boucle conditionnelle (tant que) en python est la suivante :

while condition:
bloc ...........................
................................
d'instructions .................

Remarques:
 cette boucle est similaire à la précédente. La différence réside dans le fait que le test et
l'évaluation de la condition sont réalisés avant l'exécution du traitement,
 il est possible que le traitement ne soit pas exécuté si la première évaluation de la
condition donne un résultat faux,
 il est toujours possible de remplacer une boucle répéter jusqu'à par une boucle tant que.
L'opération inverse n'est possible que si on soit certains que le traitement soit exécuté au
moins une fois.

Traitement
Répéter  Tant que (non condition) faire
Traitement
Traitement
Fin tant que
Jusqu’à condition

Application : En utilisant une boucle tant que, écrire un algorithme qui permet de saisir un
caractère alphabétique.

Vous aimerez peut-être aussi