Les bases de

l’Algorithmique
 Introduction
• Qu’est-ce qu’un algorithme ?
Un algorithme est une suite logique d’instructions permettant de résoudre
un problème (ou de répondre à un besoin).

• Qu’est ce que veut dire « écrire un algorithme »

- Analyser et comprendre le problème : étude des données fournies et des
résultats attendus.

- Résoudre le problème :
C’est trouver les structures de données adaptées ainsi que l’enchaînement
des actions à réaliser pour passer des données aux résultats.
• Comment exécuter un algorithme sur un ordinateur ?
Il faut traduire cet algorithme à l’aide d’un langage de programmation connu
par l’ordinateur.
 Enoncé d’un problème

Analyse, compréhension
Pseudo code
Résolution

Algorithme
Langage de
Codification programmation
(code)

Programme

Interprétation

Exécution par l’ordinateur

Langage machine
 Règles à respecter pour l'écriture d'un
algorithme
• Il est défini sans ambiguïté
• Il se termine après un nombre fini
d'opérations
• Il manipule des objets définis de manière
très précise.

Définition 2
Un algorithme est une suite d'actions ordonnées en séquence qui portent
sur les objets d'un univers fini.
 Règles de mise en forme d’un algorithme

Nom de l’algorithme

Début
*commentaires*
Instruction 1
*commentaires*
Instruction 2

Fin
 Les objets utilisés dans un algorithme
Les différents objets
• Les variables
Une variable est un objet contenant une valeur appelée à être modifiée au
cours de l'algorithme.
• Les constantes
Une constante est un objet dont la valeur ne change pas au cours de
l'algorithme.

Définition des objets

Un objet est définis par :

• Un identificateur : suite quelconque de caractères.

• Un type : Booléen, numérique (entier ou réel), caractère ou chaîne
de caractères.

• Une valeur : c'est le contenu de l'objet.

 Règles de mise en forme d’un algorithme

Nom de l’algorithme
Déclaration des variables et constantes
Début
*commentaires*

Instructions1
Instructions 2

Fin
 • Exemple

:
Algo Prix_du_pain
Variables
Nom : chaîne de caractères
Nb : Entier
Prx, Mtt, Rem : Réel
Constantes
Txrem=0,1
Début
*commentaires*
Instruction1
Instruction2

Fin
 Instructions élémentaires

• Affectation
L'opération consiste à affecter une valeur à une variable. Elle est

représentée par une flèche orientée à gauche 

Exemple :
1/ A  15
2/ A  B+3
3/ A  A+5

1/ Le terme de droite (15) est affecté au terme de gauche (variable A)

2/ Le terme de droite (valeur de la variable B + 3) est affecté au terme de gauche (variable A)
3/ Le terme de droite (valeur de A (avant instruction) + 5) est affecté au terme de gauche (variable A)
Dans ce dernier cas la nouvelle valeur de A remplace l'ancienne.
• Instruction d'entrée
Une instruction d'entrée permet de récupérer une valeur sur un périphérique d'entrée.

Notation :
Saisir nom variable ou
Lire nom variable

Exemple précédent :
Lire Nom
(saisir sur le clavier des caractères qui représenteront la valeur de la variable nom)

• Instruction de sortie
Permet d'afficher à l'écran du "texte", le contenu d'un objet (variable ou
constante) voir le résultat d'une expression.

Notation :
Afficher nom variable ou Afficher « texte » ou
Ecrire nom variable
Exemple :
Ecrire « Saisir un nom », Nom
• Expressions
Des opérations sur les objets - variables, constantes ou encore littéraux
(valeurs numériques ou alphanumériques) - peuvent être réalisées à l'aide
d'opérateurs arithmétiques ou logiques pour former des expressions.
Les principaux opérateurs arithmétiques (à partir des variables
déclarées ci-dessus)
-Une expression est un ensemble de valeurs reliées par des opérateurs, et
équivalent à une seule valeur
Exemple :
4+2, 5*6, 4<9, A>6, C+B,…

Opérations Opérateurs Exemple

Addition + Prx + Nb
Soustraction - Mtt - Rem
Multiplication * Mtt * 1,206
Division réelle / Map / Nb
Division entière Div 16 Div 5
Puissance ^ (1+ i)^2
Les opérateurs de comparaison
Opérateur de Description
Comparaison
= Égal à

< Inférieur à
> Supérieur à

<= Inférieur ou égal à

>= Supérieur ou égal à

<> Différent de
Les opérateurs logiques
Opérateur Description
Logique
ET l’un et l’autre
OU l’un ou l’autre
NON Inverse la valeur
• Exemple
• Etape1 : on veut calculer la surface d’un cercle
• Etape 2 :
• Résultat: La surface du cercle (Surf)
• Données: Le rayon (R), 3,14 (Pi)
• Traitement: Surf = Pi * R*R
• Etape 3 : Ecriture d’un algorithme

Algorithme Surface_cercle L’entête

Constante Pi = 3,14 ;
Les déclarations
Variable R, Surf : Réel
Début
Ecrire (' Donnez la valeur de rayon: ')
Lire (R) Le corps
Surf  Pi*R^2 ;
Ecrire (' La surface de cercle est : ', Surf)
Fin.
 • Exemple
Algo : prix_du_pain
Variables
Nb : Entier
Prx, Mtt : Réel
Début
Ecrire " Prix ?"
Lire Prx
Ecrire "Nombre ?"
Lire Nb
Mtt Prx * Nb
Ecrire "Montant :", Mtt
Fin
Les structures alternatives et conditionnelles

• La structure alternative
Notation :
SI condition
Alors action1
Sinon action2
FIN SI

Remarque : L'expression de la condition est souvent de forme logique dont

voici les opérateurs : < > = >= <= <> ET OU NON
Exemple :
Algo : prix_du_pain
Variables
Nom : chaîne de caractères
Nb : Entier
Prx, Mtt, Rem : Réel
Constantes
Tx1 = 0,1
Tx2 = 0,05
Début
*calcul d'une remise client*
Ecrire " Prix ?"
Lire Prx
Ecrire "Nombre ?"
Lire Nb
Mtt ← Prx * Nb
Si Mtt > 2000
Alors Rem ← Mtt * Tx1
Sinon Rem ← Mtt * Tx2
Fin si
Ecrire "Montant :", Mtt
Fin
• La structure conditionnelle
Notation :

SI condition
Alors action
FIN SI
Exemple :
Algo : prix_du_pain
Variables
Nom : chaîne de caractères
Nb : Entier
Prx, Mtt, Rem : Réel
Constantes
Tx1 = 0,1
Début
*calcul d'une remise client*
Ecrire" Prix ?"
Lire Prx
Ecrire"Nombre ?"
Lire Nb
Mtt ← Prx * Nb
Si Mtt > 1000
Alors Rem ← Mtt * Tx1
Fin si
Ecrire "Montant de la remise :", Rem
Fin
• La structure de choix

Notation
Selon expression Faire
Valeur 1 : action1
Valeur 2 : action2
…
Valeur n : action n
Sinon : action par défaut
Fin selon
 Les structures itératives
• La structure Tant que… Fin Tant que
Permet la répétition d'une (ou plusieurs) action(s) tant qu'une condition est
satisfaite.

Notation :
Teste si la condition est
Tant que condition Faire vérifiée . Si c'est le cas il y a
exécution des actions.

Dans le cas contraire

l'algorithme se poursuit après
action 1
la boucle (structure).
action 2

Fin Tant Que

Exemple :
Algo : prix_du_pain
Variables
--------------------
Rep : chaîne de caractères
Constantes
-------------------
Début
Ecrire "voulez-vous calculer une facture ?(oui/non)"
Lire Rep
Tant que Rep= "oui" Faire
Ecrire " Prix ?"
Lire Prx
Ecrire "Nombre ?"
Lire Nb
Mtt ← Prx * Nb
Si Mtt > 2000
Alors Rem ← Mtt * Tx1
Sinon Rem ← Mtt * Tx2
Fin si
Mtt ← Mtt – Rem
Ecrire « Voulez-vous une autre facture ? (oui/non) "
Lire Rep
Fin Tant que
Fin
• La structure Répéter Jusqu’à

Permet la répétition d'une (ou plusieurs) action(s) jusqu’à la satisfaction

d’une condition.

Notation : Teste si la condition est

vérifiée . Si ce n’est pas le
Répéter cas il y a exécution des
actions.

action 1
Quand la condition est
action 2 vérifiée l'algorithme se
poursuit après la boucle
Jusqu’à Condition (structure).
Exemple :
Algo : prix_du_pain
Variables
--------------------
Rep : chaîne de caractères
Constantes
-------------------
Début
(* remarque : une facture sera obligatoirement éditée *)
Répéter
Ecrire" Prix ?"
Lire Prx
Ecrire "Nombre ?"
Lire Nb
Mtt ← Prx * Nb
Si Mtt > 2000
Alors Rem ← Mtt * Tx1
Sinon Rem ← Mtt * Tx2
Fin si
Mtt ← Mtt – Rem
Ecrire « Voulez-vous une autre facture ? (oui/non) "
Lire Rep
Jusqu’à Rep = « non »
Fin
 La structure répétitive
• La structure Pour … allant de … à … faire Fin Pour
Permet de répéter un nombre déterminé de fois une (ou plusieurs) action(s).

Notation :

Pour compteur allant de 1 à n Faire Permet de compter le nombre

de répétition de l’action.

Lorsque le nombre voulu de

action 1 répétition est atteint,
action 2 l'algorithme se poursuit après
la boucle (structure).
Finpour
Exemple :
Algo : prix_du_pain
Variables
--------------------
Compteur : entier
Nbfact : entier
Constantes
-------------------
Début
Ecrire « Combien de factures voulez-vous ? »
Lire Nbfact
Pour Compteur allant de 1 à Nbfact faire
Ecrire" Prix ?"
Lire Prx
Ecrire "Nombre ?"
Lire Nb
Mtt ← Prx * Nb
Si Mtt > 2000
Alors Rem ← Mtt * Tx1
Sinon Rem ← Mtt * Tx2
Fin si
Mtt ← Mtt – Rem
Finpour
Fin
 Les variables cumulatives
Ce sont des variables qui permettent de cumuler des valeurs calculées dans la boucle ou encore
pour dénombrer le nombre de passage.

Exemple :
……………..
Début
Ecrire "voulez-vous calculer une facture ?(oui/non)"
Lire Rep
Nb←0
Mtttot←0
Tant que Rep= "oui" Faire
Ecrire " Prix ?"
Lire Prx
Ecrire "Nombre ?"
Lire Nb
Mtt ← Prx * Nb
Nb ← Nb+1
Mtttot ← Mtttot + Mtt
Ecrire "Autre facture ? (oui/non) "
Lire Rep
Fin Tant que
Ecrire « montant total des »,Nb, « factures : » ,Mtttot
Fin
ALGORITHMIQUE
Les tableaux

28
 Exemple introductif
• Supposons qu'on veut conserver les notes d'une classe de 10 étudiants
pour extraire quelques informations. Par exemple : calcul du nombre
d'étudiants ayant une note supérieure à 10
• Le seul moyen dont nous disposons actuellement consiste à déclarer 10
variables, par exemple N1, …, N10. Après 10 instructions lire, on doit écrire
10 instructions Si pour faire le calcul
nbre ← 0
Si (N1 >10) alors nbre ←nbre+1 FinSi
….
Si (N10>10) alors nbre ←nbre+1 FinSi
c'est lourd à écrire
• Heureusement, les langages de programmation offrent la possibilité de
rassembler toutes ces variables dans une seule structure de donnée
appelée tableau
29
 indice Tableaux
element 0 1 2 3 4 5 6 7 8 9

notes 15 8 11 6,5 19 5 13 17 18 7

• Un tableau est un ensemble d'éléments de même type désignés

par un identificateur unique
• Une variable entière nommée indice permet d'indiquer la position
d'un élément donné au sein du tableau et de déterminer sa valeur
• La déclaration d'un tableau s'effectue en précisant le type de ses
éléments et sa dimension (le nombre de ses éléments)
– En pseudo code :
variable tableau
identificateur[dimension] : type
– Exemple :
variable tableau notes[10] : réel
• On peut définir des tableaux de tous types : tableaux d'entiers, de
réels, de caractères, de booléens, de chaînes de caractères, … 30
 indice Tableaux : remarques
element 0 1 2 3 4 5 6 7 8 9

notes 15 8 11 6,5 19 5 13 17 18 7

• L'accès à un élément du tableau se fait au moyen de l'indice. Par exemple,

notes[i] donne la valeur de l'élément i du tableau notes
• Selon les langages, le premier indice du tableau est soit 0, soit 1. Le plus
souvent c'est 0 (c'est ce qu'on va adopter en pseudo-code). Dans ce cas,
notes[i] désigne l'élément i+1 du tableau notes
• On peut changer la valeur d'une case par notes[i]=valeur
• Un grand avantage des tableaux est qu'on peut traiter les données qui y
sont stockées de façon simple en utilisant des boucles

31
 indice Tableaux : exemples (1)
element 0 1 2 3 4 5 6 7 8 9

notes 15 8 11 6,5 19 5 13 17 18 7

• Pour le calcul du nombre d'étudiants ayant une note supérieure à

10 avec les tableaux, on peut écrire :

Variables i ,nbre : entier

tableau notes[10] : réel
Début
nbre ← 0
Pour i allant de 0 à 9
Si (notes[i] >10) alors
nbre ←nbre+1
FinSi
FinPour
écrire ("le nombre de notes supérieures à 10 est : ", nbre)
Fin
32
 indice Tableaux : saisie et affichage
element 0 1 2 3 4 5 6 7 8 9

T 15 8 11 6,5 19 5 13 17 18 7

• Boucles qui permettent de saisir et d'afficher les éléments d'un tableau :

Tableau A[n]: entier
variable i: entier

Pour i allant de 0 à n-1

écrire ("Saisie de l'élément ", i + 1)
lire (T[i] )
FinPour

Pour i allant de 0 à n-1

écrire ("T[",i, "] =", T[i])
FinPour

33
 Tableaux à deux dimensions

• Les langages de programmation permettent de déclarer des

tableaux dans lesquels les valeurs sont repérées par deux indices.
Ceci est utile par exemple pour représenter des matrices

• En pseudo code, un tableau à deux dimensions se déclare ainsi :

variable tableau identificateur[dimension1] [dimension2] : type

– Exemple : une matrice A de 3 lignes et 4 colonnes dont les éléments

sont réels
variable tableau A[3][4] : réel

• A[i][j] permet d'accéder à l’élément de la matrice qui se trouve à

l’intersection de la ligne i et de la colonne j
34
 Tableaux à deux dimensions

0 1 2 3 4 5 6 7 8 9

0
1 3 2 3 5 9 11 8 0 1
1 3 5 8 1 4 9 34 8 2 7
2 4 5 6 7 8 9 4 3 25 5
3 7 4 3 7 5 7 8 5 9 3
4 8 5 33 4 1 2 5 4 6 12

35
 Exemples : lecture d'une matrice

• Boucle qui permet de saisir les éléments d'une matrice :

Tableau A[n][m]: entier

variables i,j : entier
Pour i allant de 0 à n-1
écrire ("saisie de la ligne ", i + 1)
Pour j allant de 0 à m-1
écrire ("Entrez l'élément de la ligne ", i + 1, " et de la colonne ",
j+1)
lire (A[i][j])
FinPour
FinPour

36
 Exemples : affichage d'une matrice

• Boucle qui permet d'afficher les éléments d'une matrice :

Tableau A[n][m]: entier

variables i,j : entier
Pour i allant de 0 à n-1
Pour j allant de 0 à m-1
écrire ("A[",i, "] [",j,"]=", A[i][j])
FinPour
FinPour

37
 Exemples : somme de deux matrices

• Boucle qui calcule la somme de deux matrices :

Tableaux A[n][m], B[n][m], C[n][m]: entier

variables i,j : entier
Pour i allant de 0 à n-1
Pour j allant de 0 à m-1
C[i][j] ← A[i][j]+B[i][j]
FinPour
FinPour

38
 Tableaux : 2 problèmes classiques

• Recherche d’un élément dans un tableau

– Recherche séquentielle
– Recherche dichotomique

• Tri d'un tableau

– Tri par sélection
– Tri rapide

39
 Recherche séquentielle

• Recherche de la valeur x dans un tableau T de N éléments :

Variables i: entier, Trouvé : booléen
…
i←0 , Trouvé ← Faux
TantQue (i < N) ET (Trouvé=Faux)
Si (T[i]=x) alors
Trouvé ← Vrai
Sinon
i←i+1
FinSi
FinTantQue
Si Trouvé alors // c'est équivalent à écrire Si Trouvé=Vrai alors
écrire ("x appartient au tableau")
Sinon écrire ("x n'appartient pas au tableau")
FinSi
40
 Recherche dichotomique
• Dans le cas où le tableau est ordonné, on peut améliorer l'efficacité
de la recherche en utilisant la méthode de recherche dichotomique

• Principe : diviser par 2 le nombre d'éléments dans lesquels on

cherche la valeur x à chaque étape de la recherche. Pour cela on
compare x avec T[milieu] :

– Si x < T[milieu], il suffit de chercher x dans la 1ère moitié du tableau

entre (T[0] et T[milieu-1])

– Si x > T[milieu], il suffit de chercher x dans la 2ème moitié du tableau

entre (T[milieu+1] et T[N-1])

41
 Recherche dichotomique : algorithme

inf←0 , sup←N-1, Trouvé ← Faux

TantQue (inf <=sup) ET (Trouvé=Faux)
milieu←(inf+sup)div2
Si (x=T[milieu]) alors
Trouvé ← Vrai
SinonSi (x>T[milieu]) alors
inf←milieu+1
Sinon sup←milieu-1
FinSi
FinSi
FinTantQue
Si Trouvé alors écrire ("x appartient au tableau")
Sinon écrire ("x n'appartient pas au tableau")
FinSi
42
 Exemple d'exécution
• Considérons le tableau T : 4 6 10 15 17 18 24 27 30

• Si la valeur cherché est 20 alors les indices inf, sup et milieu vont évoluer
comme suit :
inf 0 5 5 6
sup 8 8 5 5
milieu 4 6 5
• Si la valeur cherché est 10 alors les indices inf, sup et milieu vont évoluer
comme suit :
inf 0 0 2
sup 8 3 3
milieu 4 1 2
43
Méthodes de tri
 Définition :
Un algorithme de tri est, en informatique ou en
mathématiques, un algorithme qui permet d'organiser
une collection d'objets selon un ordre déterminé
(croissant ou décroissant). Les objets à trier font donc
partie d'un ensemble muni d'une relation d'ordre. Les
ordres les plus utilisés sont l’ordre numérique et l'ordre
lexicographique.
Source : Wikipédia
Il existe plusieurs algorithmes connus pour trier les éléments
d’un tableau :
 Le tri par sélection
 Le tri à bulle
 Le tri par insertion
 Le tri rapide
 …
 I- Tri par sélection :
Principe :
– Recherche du plus petit élt du tableau et échange
avec le premier élt
– Recherche du plus petit élt du tableau entre les
positions 2 et n-1 et échange avec le second élt
– ...
– Recherche du plus petit élt entre les positions n-2
et n-1 et échange avec l'élt en position n-2
 Tri par sélection
• Principe : à l'étape i, on sélectionne le plus petit élément parmi les
(n - i +1) éléments du tableau les plus à droite. On l'échange ensuite avec
l'élément i du tableau
• Exemple : 9 4 1 7 3
– Étape 1: on cherche le plus petit parmi les 5 éléments du tableau. On
l’identifie en troisième position, et on l’échange alors avec l’élément 1 :

1 4 9 7 3
– Étape 2: on cherche le plus petit élément, mais cette fois à partir du
deuxième élément. On le trouve en dernière position, on l'échange avec
le deuxième:
1 3 9 7 4
– Étape 3:
1 3 4 7 9
47
 Tri par sélection : algorithme
• Supposons que le tableau est noté T et sa taille N

Pour i allant de 0 à N-2

indice_ppe ← i
Pour j allant de i + 1 à N-1
Si T[j] <T[indice_ppe] alors
indice_ppe ← j
Finsi
FinPour

temp ← T[indice_ppe]
T[indice_ppe] ← T[i]
T[i] ← temp
FinPour
48
 Exercice :
Ecrire la fonction triSelection(ls) qui permet de trier
les éléments de la liste ls en utilisant la méthode
de tri par sélection.
 Tri par sélection : Python
def triSelection (ls):
for i in range(0,len(ls)-1) :
indice = i
for j in range(i+1,len(ls)) :
if ls[j] < ls[indice] :
indice = j
if indice != i :
val=ls[indice]
ls[indice] = ls[i]
ls[i] = val
return ls
 II- Tri à bulles :

Principe :
Comparaison 2 à 2 des éléments adjacents
et échange s'ils ne sont pas ordonnés. Le
programme s'arrête lorsqu'on parcours la
liste sans faire d'échange
Comme les bulles, les plus grands éléments
remontent en fin de liste
 Exercice :
Ecrire la fonction triBulles(ls) qui permet de trier
les éléments de la liste ls en utilisant la méthode
de tri à bulles
 II- Tri à bulles :
def triBulles (ls):
echange= True
while echange==True :
echange=False
for i in range(0,len(ls)-1) :
if(ls[i]>ls[i+1]):
val=ls[i]
ls[i]=ls[i+1]
ls[i+1]=val
echange=True
 III- Tri par insertion :

Principe :
• La liste étant trié jusqu'à l'élt i-1,
• insérer l'élément i à sa place parmi
les i premiers éléments
 Exercice :
Ecrire la fonction tri_Insertion(ls) qui permet de
trier les éléments de la liste ls en utilisant la
méthode de tri par insertion.
 III- Tri par insertion :
• Supposons que le tableau est noté T et sa taille N

Pour i allant de 1 à N-1 faire

x ←T[i]
j←i
Tant que ( j > 0 ET T[j-1] > x ) alors
T[j] ← T[j-1]
j ← j -1
Fin Tant que
T[j] ← x
Fin Pour
III- Tri par insertion :
N=len(T)
for i in range(1,N):
x=T[i]
j=i
while j>0 and T[j-1]>x :
T[j]=T[j-1]
j=j-1
T[j]=x
print( T)
ALGORITHMIQUE
Les enregistrements

58
 Les enregistrements
Le type tableau nous a permis de définir une
structure composée de plusieurs éléments, cette
structure nous permettrait de réunir les éléments
de même type. Mais si nous voulons regrouper les
informations n'ayant pas nécessairement le même
type au sein d'une même structure, par exemple:
les informations concernant un étudiant. Une
nouvelle structure appelée enregistrement est plus
adaptée pour représenter ce type d'information.
 Les enregistrements
Un enregistrement est un objet composé statique et
hétérogène c'est-à-dire qui renferme plusieurs
informations qui peuvent être de type différent.
Un enregistrement est défini par un ensemble de
données ou élément encore appelé champ.
Les champs sont les données élémentaires ou
composées et peuvent être de type différent.
Déclaration d’un type enregistrement
type nom_type=enregistrement
champ1 : type1
champ2 : type2
........
champn : type;
fin enregistrement Exemple: Déclarons un type étudiant :

Type Etudiant=enregistrement
matricule: chaîne
nom : chaîne
prénom : chaîne
sexe : caractère
age : entier
note : réel
fin enregistrement
Déclaration d'un enregistrement à partir d'un type
structuré
Type Etudiant=enregistrement
matricule: chaîne
nom : chaîne
prénom : chaîne
 Syntaxe: Variable Nom_Variable: nom_type sexe : caractèree
age : entier
 Exemple: Variable e1, e2 : Etudiant note : réel
fin enregistrement
En général on manipule un enregistrement champ par champ. On accède à un
champ de l'enregistrement en indiquant le nom de l'enregistrement suivi du nom du
champ. Les deux sont séparés par un point.
 Exemple: e1.matricule e1.nom e1.prénom e1.sexe e1.age e1.note

e1.matricule e1 ‘05S001’ 'toto' 'Paul' 'M' 19 12.75

e1.nom
 Si un champ de l'enregistrement est d'un type donné alors on peut réaliser sur ce
champ toutes les opérations réalisables avec les objets de ce type.
Exemple d'application de valeur

e1.matricule ← '05S001‘
e1.nom ← 'toto' ou bien par lecture
e1.prénom ← 'Paul' lire(etud1.matricule)
e1.sexe ← 'M' lire(etud1.nom)
e1.age ← 19
e1.note ← 12.75
 Application aux tableaux
d’enregistrements
Nous voulons constituer une base de données des enseignants. Chaque
enseignant est caractérisé par:
Le code.
Le nom.
Le prénom.
Le grade.
Le sexe.
Les enseignants seront stockés dans un tableaux
Donner une déclaration du type enseignant.
Ecrire une procédure sui permet de créer un tableau de n enseignant.
Ecrire une procédure qui prend en paramètre le tableau d'enseignants et le
matricule d'un enseignant et qui recherche et test si un enseignant existe ou pas.
Ecrire une procédure qui affiche la liste des enseignants féminins
 Application
1. Donnons la déclaration du type enseignant
type enseignant=enregistrement
code : chaîne
nom : chaîne
prénom : chaîne
grade : chaîne
sexe : caractère
fin enregistrement
Tableau v[1..100] : enseignant
2.Ecrivons une procédure qui permet de remplir un tableau V de n enseignants.

procédure: créer_enseignant(V: Tableau, n: entier)

début
pour i allant de 1 à n faire
lire(V[i].code)
lire(V[i].nom)
lire(V[i].prénom)
lire(V[i].grade)
lire(V[i].sexe)
fin pour
fin
 Application
Ecrivons une procédure qui prend en paramètre le tableau
d'enseignants et le matricule d'un enseignant et qui recherche si
cet enseignant existe ou pas.

procédure: recherche(V: Tableau, n: entier, codeE: chaîne)

var i: entier
début
i←1
tant que i<= N et codeE<>V[i].code faire
i←i+1
fin tant que
si codeE=V[i].code alors
écrire('Cet enseignant est dans la case N°: ',i)
sinon
écrire('Cet enseignant n'existe pas')
fin si
fin
 Application
Ecrivons une procédure qui affiche la liste des
enseignant féminins.

procédure affiche_femini(V: Tableau, n:entier)

var i: entier
début
pour i=1 à n faire
si V[i].sexe = 'F' alors
écrire(V[i].code)
écrire(V[i].nom)
écrire(V[i].prénom)
écrire(V[i].grade)
fin si
fin pour
fin
ALGORITHMIQUE
Fonctions et procédures

67
 Fonctions et procédures
• Certains problèmes conduisent à des programmes longs, difficiles à
écrire et à comprendre. On les découpe en des parties appelées
sous-programmes ou modules
• Les fonctions et les procédures sont des modules (groupe d'instructions)
indépendants désignés par un nom. Elles ont plusieurs intérêts :
– permettent de "factoriser" les programmes, càd de mettre en commun
les parties qui se répètent
– permettent une structuration et une meilleure lisibilité des programmes

– facilitent la maintenance du code (il suffit de modifier une seule fois)

– ces procédures et fonctions peuvent éventuellement être réutilisées dans

d'autres programmes

68
 Fonctions
• Le rôle d'une fonction en programmation est similaire à celui d'une
fonction en mathématique : elle retourne un résultat à partir des
valeurs des paramètres
• Une fonction s'écrit en dehors du programme principal sous la forme :

Fonction nom_fonction (paramètres et leurs types) : type_fonction

Instructions constituant le corps de la fonction
retourne …
Fin Fonction
• Pour le choix d'un nom de fonction il faut respecter les mêmes règles que celles
pour les noms de variables
• type_fonction est le type du résultat retourné
• L'instruction retourne sert à retourner la valeur du résultat
69
 Fonctions : exemples
• La fonction SommeCarre suivante calcule la somme des carrées
de deux réels x et y, c‘est à dire x2+y2 :
Fonction SommeCarre (x : réel, y: réel ) : réel
variable z : réel
z ←x^2+y^2
retourne (z)
Fin Fonction

• La fonction Pair suivante détermine si un nombre est pair :

Fonction Pair (n : entier ) : booléen

retourne (n%2=0)
Fin Fonction
70
 Utilisation des fonctions
• L'utilisation d'une fonction se fera par simple écriture de son nom
dans le programme principale. Le résultat étant une valeur, devra
être affecté ou être utilisé dans une expression, une écriture, ...
• Exemple : Algorithme exempleAppelFonction
variables z : réel, b : booléen
Début
b ←Pair(3)
z ←5*SommeCarre(7,2)+1
écrire("SommeCarre(3,5)= ", SommeCarre(3,5))
Fin
• Lors de l'appel Pair(3) le paramètre formel n est remplacé par le
paramètre effectif 3
71
 Procèdures
• Dans certains cas, on peut avoir besoin de répéter une tache dans plusieurs
endroits du programme, mais que dans cette tache on ne calcule pas de
résultats ou qu'on calcule plusieurs résultats à la fois
• Dans ces cas on ne peut pas utiliser une fonction, on utilise une procédure
• Une procédure est un sous-programme semblable à une fonction mais qui
ne retourne rien
• Une procédure s'écrit en dehors du programme principal sous la forme :

Procédure nom_procédure (paramètres et leurs types)

Instructions constituant le corps de la procédure

Fin Procédure
• Remarque : une procédure peut ne pas avoir de paramètres
72
 Appel d'une procédure
• L'appel d'une procédure, se fait dans le programme principale ou dans une
autre procédure par une instruction indiquant le nom de la procédure :
Procédure exemple_proc (…)
…
FinProcédure

Algorithme exepmleAppelProcédure
Début
exemple_proc (…)
…
Fin
• Remarque : contrairement à l'appel d'une fonction, on ne peut pas affecter la
procédure appelée ou l'utiliser dans une expression. L'appel d'une
procédure est une instruction autonome
73
 Paramètres d'une procédure
• Les paramètres servent à échanger des données entre le programme
principale (ou la procédure appelante) et la procédure appelée

• Les paramètres placés dans la déclaration d'une procédure sont appelés

paramètres formels. Ces paramètres peuvent prendre toutes les valeurs
possibles mais ils sont abstraits (n'existent pas réellement)

• Les paramètres placés dans l'appel d'une procédure sont appelés

paramètres effectifs. ils contiennent les valeurs pour effectuer le
traitement

• Le nombre de paramètres effectifs doit être égal au nombre de paramètres

formels. L'ordre et le type des paramètres doivent correspondre

74
 Transmission des paramètres
Il existe deux modes de transmission de paramètres dans les langages de
programmation :
• La transmission par valeur : les valeurs des paramètres effectifs sont
affectées aux paramètres formels correspondants au moment de l'appel de la
procédure. Dans ce mode le paramètre effectif ne subit aucune modification
• La transmission par adresse (ou par référence) : les adresses des
paramètres effectifs sont transmises à la procédure appelée. Dans ce mode,
le paramètre effectif subit les mêmes modifications que le paramètre formel
lors de l'exécution de la procédure
– Remarque : le paramètre effectif doit être une variable (et non une
valeur) lorsqu'il s'agit d'une transmission par adresse

• En pseudo-code, on va préciser explicitement le mode de transmission dans

la déclaration de la procédure
75
 Transmission des paramètres : exemples
Procédure incrementer1 (x : entier par valeur, y : entier par adresse)
x ← x+1
y ← y+1
Fin Procédure

Algorithme Test_incrementer1
variables n, m : entier
Début
n←3
m←3 résultat :
incrementer1(n, m)
écrire (" n= ", n, " et m= ", m) n=3 et m=4
Fin

Remarque : l'instruction x ← x+1 n'a pas de sens avec un passage par valeur

76
 Transmission par valeur, par adresse : exemples

Procédure qui calcule la somme et le produit de deux entiers :

Procédure SommeProduit (x,y: entier par valeur, som, prod : entier par adresse)
som ← x+y
prod ← x*y
Fin Procédure

Procédure qui échange le contenu de deux variables :

Procédure Echange (x : réel par adresse, y : réel par adresse)
variables z : réel
z←x
x←y
y←z
Fin Procédure

77
 Variables locales et globales (1)
• On peut manipuler 2 types de variables dans un module (procédure ou
fonction) : des variables locales et des variables globales. Elles se
distinguent par ce qu'on appelle leur portée (leur "champ de définition", leur
"durée de vie")
• La portée est le périmètre dans lequel un nom (de variable, fonction…) est
connu (visible) et utilisable.

• Une variable locale (déclarée dans la fonction ou procédure) n'est connue

qu'à l'intérieur de la fonction (ou procédure) où elle a été définie. Elle est créée
à l'appel de la fonction (ou procédure) et détruite à la fin de son exécution

• Une variable globale (déclarée dans le programme principale) est connue par
l'ensemble des fonctions (ou procédures) et le programme principale. Elle est
définie durant toute l’application et peut être utilisée et modifiée par les
différents fonctions (ou procédures) du programme

78
Variables locales et globales (2)
• La manière de distinguer la déclaration des variables locales et globales
diffère selon le langage

– En général, les variables déclarées à l'intérieur d'une fonction ou

procédure sont considérées comme variables locales

• En pseudo-code, on va adopter cette règle pour les variables locales et on

déclarera les variables globales dans le programme principale

• Conseil : Il faut utiliser autant que possible des variables locales plutôt que
des variables globales. Ceci permet d'économiser la mémoire et d'assurer
l'indépendance de la procédure ou de la fonction

79
 Fonctions et procédures en Python (1)
• En Python, il n'y a pas de distinction entre les notions de fonction et
procédure. Les deux se déclarent de la même façon comme suit :
def identificateur (paramètres) :
l1
global g1
instructions
résultat

• Identificateur est le nom de la fonction ou de la procédure

• Si on utilise le même nom de variable dans la fonction (locale) et
dans le programme principale (globale), alors la variable locale
masque la variable globale
• Si on veut utiliser ou modifier la variable globale à l’interieur de la
fonction, on doit préciser explicitement ceci en precedant cette
variable globale par le mot clé global. Sinon les variables utilisées
à l’intérieur de la fonction sont considérées comme locales 80
 Fonctions et procédures en Python (2)

• Une variable globale est connue en dehors de la procédure où elle a été

définie dans l'ensemble de la session de calcul
• Les paramètres, les variables locales et globales sont facultatifs, ils
peuvent ne pas figurer dans la déclaration
• Une fonction Python peut rendre un seul résultat (comme une fonction),
plusieurs résultats ou aucun résultat (None)
• Pour rendre plusieurs résultats, on peut utiliser une liste, un tuple, un set,
un dictionnaire

• return ( v1 ,v 2 ,…, vn) arrête le déroulement de la fonction et renvoie les

valeurs de ( v1 , v 2 , …, vn) sous forme d'un tuple

81
 Fonction Python : remarques

• Python n’utilise que la transmission par adresse, donc il peut

modifier la valeur d'un paramètre (modifiable comme liste ) à
l'intérieur d'une fonction.
• Les paramètres de types simples (entier, réel, chaine, booléen)
sont non modifiables
• En Python, une fonction peut être appelée sans être affectée. Elle
peut aussi être affectée à une variable

> def carre(x,y):

return x**2+y**2

> carre(1,2) #5
> a=carre(3,3) # a = 18

82
 Fonctions Python : exemples (1)

> def exemple(a,b):

c=a+b
d=a-b
e=a*b
return c,d,e
d=c+e;

> exemple(4,7)  (11, -3, 28)

Remarque : l'exécution s'arrête après return. L'instruction d=c+e n'est pas

exécutée, le résultat est donné sous forme d'un tuple

83
 Fonctions Python : exemples (2)

Exemple : une fonction qui calcule la somme des n premiers entiers

> def somme ():
som=0
n=int(input("entrez la valeur de n : "))
for i in range(1, n+1 ):
som=som+i
print("somme=",som)

> somme() sur l'écran apparaît le message :

entrez la valeur de n :
si on entre 3, on obtient somme=,6

84
 Récursivité

• Une fonction peut s'appeler lui-même: on dit que c'est une fonction
récursive

• Tout fonction récursive doit posséder un cas limite (cas trivial) qui
arrête la récursivité
• Exemple : Calcul du factorielle
Fonction fact (n : entier ) : entier
Si (n=0) alors
retourne (1)
Sinon
retourne (n*fact(n-1))
Finsi
Fin Fonction
85
 Fonctions récursives : exercice
• Ecrivez une fonction récursive (puis itérative) qui calcule le terme n
de la suite de Fibonacci définie par : U(0)=0, U(1)=1
U(n)=U(n-1)+U(n-
2)

Fonction Fib (n : entier ) : entier

Variable res : entier
Si (n=0) alors
res ←0
Sinon si (n=1) alors
res ←1
Sinon
res ← Fib(n-1)+Fib(n-2)
Fin si
Fin si
retourne (res)
86
Fin Fonction
 Fonctions récursives : exercice (suite)

• Une fonction itérative pour le calcul de la suite de Fibonacci :

Fonction Fib (n : entier ) : entier
Variables i, AvantDernier, Dernier, Nouveau : entier
Si (n=1 OU n=0) alors retourne (1)
Finsi
AvantDernier ←1, Dernier ←1
Pour i allant de 2 à n
Nouveau← Dernier+ AvantDernier
AvantDernier ←Dernier
Dernier ←Nouveau
FinPour
retourne (Nouveau)
Fin Fonction
Remarque: la solution récursive est plus facile à écrire
87
 Procédures récursives : exemple
• Une procédure récursive qui permet d'afficher la valeur binaire d'un entier n

Procédure binaire (n : entier )

Si (n<>0) alors
binaire (n DIV 2)
écrire (n mod 2)
Fin si
Fin Procédure

• Traduction en Python
def binaire(n):
if n !=0:
binaire(n//2)
print(n%2, end="")
88
Manipulation des fichiers
(Python)

89
 Fichier - collection d’informations stockées sur une mémoire
de
masse (non volatile, capacité plus importante que la mémoire vive)

Types de fichiers – Ils se distinguent par…

1. Organisation des données : structuré, les informations sont
organisées d’une manière particulière qu’il faut respecter (ex.
fichiers d’enregistrements) ; non-structuré, les informations sont
alignées à la suite (ex. fichier texte)
2. Mode d’accès aux données : accès indicé, utilisable comme un
tableau ; accès séquentiel, lecture ou écriture pas à pas (ex. ligne
par ligne dans un fichier texte)

La catégorisation n’est pas toujours très tranchée, un fichier XML par ex.
est un fichier texte (manipulable avec un éditeur de texte) mais qui obéit
à une organisation structurée

9
 Fichiers textes
Les fichiers textes sont ceux contenant ... du texte.
Ils sont utilisés dans de très nombreux contexte dont voici quelques uns :
fichiers textes bruts (plain text)
fichiers source de programmes
fichiers HTML, CSS
fichiers CSV (format tableur textuel)
La structure que partagent tous ces formats de fichiers textes est celle de
ligne. Une ligne est une chaîne de caractères terminée par un marqueur de
fin de ligne. Ce marqueur de fin de ligne peut différer d’un système
d’exploitation à l’autre. Dans les systèmes de type Unix (GNU-Linux et Mac
OSX par exemple), ce marqueur est par défaut constitué d’un caractère
ASCII de code 10 (0x0A) appelé LINE FEED. Dans les divers systèmes MS-
Windows, ce marqueur de fin de ligne est constitué de deux caractères ASCII
de code 13 (0x0D) appelé CARRIAGE RETURN (\r) et 10 (0x0A) ou (\n)
dans cet ordre.
Le principal outil informatique pour lire/produire un fichier texte est un éditeur
de texte.
 Fichiers binaires
On déclare binaire tout fichier qui n’est pas un fichier
texte.
fichiers exécutables résultant de la compilation
d’un fichier texte source
fichiers archives (formats ZIP, TGZ, ...)
fichiers images (formats PNG, JPG, GIF, TIFF, ...)
fichiers sons (formats WAV, OGG, FLAC,
MP3, ...)
fichiers videos (formats AVI, MPEG, ...)
Contrairement aux fichiers textes pour lesquels la
structure de ligne est une structure commune, il n’y a pas
de structure commune à tous les fichiers binaires. Les
outils informatiques pour lire/produire les fichiers binaires
dépendent évidemment du format de ces fichiers.
 1- Ouverture d’un fichier existant
Avant de pouvoir lire les informations contenues dans un fichier, ou de pouvoir écrire des
informations dans un fichier, il est nécessaire d’ouvrir un canal de communication entre le
programme et le fichier.

L’ouverture d’un canal peut se faire :

en mode lecture, et dans ce cas on ne peut que lire des informations contenues dans le
fichier ;
en mode écriture, et dans ce cas il n’est possible que d’écrire dans le fichier ;
ou enfin en mode lecture et écriture, mode permettant à la fois la lecture et l’écriture
d’informations dans le fichier.
En Python, c’est la fonction open qui permet l’ouverture de canaux.
2 - Ouverture et écriture dans
un fichier existant
Pour écrire dans un fichier existant, vous devez ajouter l'un des
paramètres à la fonction open():
"a" - Append - sera ajouté à la fin du fichier
"w" - Write - écrasera tout contenu existant
''r+'' Lecture et écriture en écrasant le contenu existant
On dira alors que le fichier est ouvert en mode écriture (write
mode) Pour écrire dans fichier ouvert en mode écriture, on utilise la
fonction write().
La syntaxe est:
file.write(contenu)
 Lecture de contenu d’un
fichier(1)
Pour boucler sur les lignes d'un fichier :
fh = open('myFile')
for line in fh:
print(line)
attention : ça fait du buffering, contrairement à un simple readline() ! Donc
utiliser readline() si on veut l'éviter.
On peut récupérer directement la liste des lignes d'un fichier en faisant :
[x.replace(‘ ', ‘ ') for x in open('myFile')]
Lecture d'un fichier avec fermeture automatique de celui-ci à la fin, comme s'il
y avait un finally (même en cas d'exception) :
with open('myfile.txt') as fh:
for line in fh:
print(line)
 Lecture de contenu d’un
fichier(2)
Pour boucler sur les lignes d'un fichier en utilisant
la methode readline():

f=open("c:\\test\\file.txt")
a=f.readline()
while a:
print(a)
a=f.readline()
f.close()
 3- Création des fichiers
Pour créer un nouveau fichier en Python, on utilise la méthode
open(), avec l'un les paramètres suivants:
"w" - Write - créera un fichier si le fichier spécifié n'existe pas
et si le fichier existe, il sera écrasé
"x" - ce mode d'ouverture, crée un fichier s'il n'existe pas et
renvoie une erreur si le fichier existe. Donc ce mode est plus
prudent que le mode w.
"a" - Append - créera un fichier si le fichier spécifié n'existe
pas
'' r+ '' - ouverture en mode lecture et écriture. Si le fichier
n'existe pas, une erreur est renvoyée.
Exemple. Création d'un fichier nommé "myFile.txt":
f = open ("myFile.txt", "x") # renvoie une erreur si le fichier existe,
 Exemple: ouvrir un fichier et
y ajouter du contenu:
# ouverture avec conservation du contenu existant
f = open ("myFile.txt", "a")
f.write ("Voici un contenu qui va s'ajouter au fichier sans
écraser le contenu!")
f.close () # fermeture du fichier :
# ouvrir et lire le fichier après l’ajout:
f = open ("myFile.txt", "r")
print (f.read())
Exemple: ouvrir le fichier "myFile.txt"
avec écrasement du contenu existant:

# -*- coding: utf-8 -*-

# ouverture avec écrasement du contenu existant
f = open ("myFile.txt", "w")
f.write ("Désolé ! J'ai supprimé le contenu!")
f.close() # ouvrir et lire le fichier après l’ajout:
f = open ("myFile.txt", "r")
print (f.read())
4 - Ajouter des lignes à un fichier en Python
avec la méthode writelines()

La méthode writelines(), permet d'ajouter une liste de

chaines ou une liste de lignes à un fichier ouvert en
mode écriture
Exemple. ajouter une liste des lignes à un fichier
f = open ("myFile.txt", "r+")
l = ["ligne1\n","ligne2\n,"ligne3\n"]
f.writelines(l)
print(f.read())
f.close()
 Ouverture et fermeture
automatique de fichier
On peut utiliser with ... as pour faire l’ouverture
et fermeture
with open(’files/fichier.txt’, ’w’) as mon_fichier:
print(mon_fichier.write(’bonjour’))
# affiche 7 (nombre de caractères écrits)
 5 - Fermeture d’un fichier
La fermeture d’un fichier permet de s’assurer que la
connexion entre le fichier sur le disque et la variable de
fichier est terminée. La fermeture des fichiers garantit
également que les autres programmes peuvent y
accéder et protège vos données. Alors, assurez-vous
toujours de fermer vos fichiers. Maintenant, fermons tous
nos fichiers en utilisant la fonction + <file> .close () +.
Exemple
days_file.close()
 6 - Récapitulatif des méthodes Python
associées à un objet fichier avec description :
file.close() : ferme un fichier ouvert.
file.fileno() : retourne un descripteur entier d'un fichier.
file.flush() : vide le tampon interne.
file.isatty() : renvoie true si le fichier est connecté à un périphérique tty.
file.next() : retourne la ligne suivante du fichier.
fichier.read(n) : lit les n premiers caractères du fichier (chaîne vide si fichier fini).
file.readline() : lit une seule ligne dans une chaine ou un fichier (chaîne vide si fichier
fini).
file.readlines() : lit et renvoie la liste de toutes les lignes du fichier.
file.seek( ) : définit la position actuelle du fichier.
file.seekable() : vérifie si le fichier prend en charge l'accès aléatoire. Renvoie true si
oui.
file.tell() : retourne la position actuelle dans le fichier.
file.truncate(n) : tronque la taille du fichier. Si n est fourni, le fichier est tronqué à n
octets, sinon tronqué à l'emplacement actuel.
file.write(str) : écrit la chaine str dans le fichier.
file.writelines(séquence) : écrit une séquence de lignes ou de chaines dans le
fichier.
fh.seek(offset, from_what) : repositionne le curseur :
si from_what = 0 : offset à partir du début (par defaut)
si from_what = 1 : offset à partir de la position courante
si from_what = 2 : offset à partir de la fin
si from_what omis : il vaut 0.
(offset peut être négatif)

Remarque
Pour manipuler from_what le fichier doit être ouvert en mode
binaire
Accès séquentiel, non
structuré
Exemple de manipulations sur:
FICHIER TEXTE

1
 Lecture en bloc avec read() megane
clio
# -*- coding: utf -*- Fichier texte à lire : twingo
safrane
#ouverture en lecture « voiture.txt » laguna
f = open("voitures.txt","r") vel satis

#lecture •open() permet d’ouvrir un fichier, en lecture ici

s = f.read() avec l’option « r ». La fonction renvoie un objet de
type fichier stocké dans f
#affichage
print("** contenu de s **") • le curseur de fichier est placé sur la première
print(s) ligne
print("** fin contenu **") • read() lit tout le contenu du fichier d’un bloc
• close() ferme le fichier (et donc le déverrouille)
#information sur s print("type
de s : ",type(s))
print("longueur de s : ",
len(s))

#fermeture
f.close()

s est de type « str »:

\n représente le caractère spécial « saut de ligne » (line feed),

c’est pour cela que print(s) fonctionne correctement.
R.R. – Université Lyon 2 4
 Lecture en bloc avec readlines (avec « s »)
# -*- coding: utf -*-

#ouverture en lecture
f = open("voitures.txt","r")

#lecture
lst = f.readlines()
Le contenu du fichier est stocké
#affichage dans une liste, une ligne= un
print("** contenu de lst **")
print(lst) élément. Le caractère \n est
print("** fin contenu **")
maintenu. Il n’est pas présent
#information sur lst sur la dernière ligne de notre
print("type de s : ",type(lst))
print("longueur de s : ",
fichier exemple.
len(lst))

#fermeture
f.close()

107
Lecture ligne par ligne avec readline (sans « s »)
# -*- coding: utf -*-

#ouverture en lecture
• readline() lit la ligne courante et
f = open("voitures.txt","r") place le curseur sur la ligne suivante.
#lecture ligne itérativement
•la fonction renvoie la chaîne vide
while True: lorsque nous arrivons à la fin du
s = f.readline()
if (s != ""): fichier (Remarque : s’il y a une ligne
print(s) blanche entre 2 véhicules,
else:
brea readline() renvoie le caractère « \n
k;
», ce n’est pas une chaîne vide).
#ferme
ture
f.close()

Il y a une ligne vide entre chaque véhicule parce que

le caractère « \n » est toujours là, print() le prend en
compte [ Remarque : pour que print() n’en tienne pas
compte, il faudrait faire print(s,end="") ]
108
Lecture ligne par ligne en itérant sur l’objet
fichier

# -*- coding: utf -*- C’est la forme la plus efficace – et la

plus concise – pour une lecture ligne à
#ouverture en lecture
ligne.
f = open("voitures.txt","r")
Le caractère \n est présent toujours,
#lecture ligne itérativement
for s in f: noter la longueur de la chaîne (+1 pour
print(s,len(s)) toutes sauf la dernière)
#fermeture
f.close()

109
Ecriture d’un fichier texte avec write()
# -*- coding: utf -*- • open() permet d’ouvrir un fichier en écriture avec
l’option « w ». La fonction renvoie un objet de type
#ouverture en écriture fichier référencée par f
f = open("moto.txt","w")
• avec « w », le fichier est écrasé s’il existe déjà
#écriture • write() permet d’écrire la chaîne de caractères
f.write("honda")
f.write("yamaha")

f.write("ducati")

#fermeture Il manque les sauts de ligne pour distinguer chaque moto

f.close()
# -*- coding: utf -*-

#ouverture en écriture Nous insérons le caractère saut de ligne « \n »

f = open("moto.txt","w") après chaque moto, sauf la dernière
#écriture
f.write("honda\n")
f.write("yamaha\n")
f.write("ducati")

#fermeture
f.close() R.R. – Université Lyon 2
110
Ecriture d’un fichier texte avec
writelines()
writelines() permet d’écrire
directement le contenu d’une liste.
Nous devons quand même
# -*- coding: utf -*- insérer le caractère « \n » pour
que le saut de ligne soit effectif
#ouverture en écriture
f = open("moto.txt","w") dans le fichier.
#liste
lst = ["honda\n","yamaha\n","ducati"]

#écriture
f.writelines(lst)

#fermeture
f.close()

11
 Ajout dans un fichier texte

• open() avec l’option « a » permet d’ouvrir

un fichier en mode ajout
• write() permet d’écrire la chaîne de
# -*- coding: utf -*- caractères
• attention toujours au saut de ligne
#ouverture en ajout
f = open("moto.txt","a") • une ouverture en mode lecture / écriture
est possible avec l’option « r+ » mais se
#ajouter un saut de ligne positionner sur telle ou telle ligne pour y
f.write("\n")
modifier ou insérer des informations est
#écriture compliqué.
f.write("laverda")

#fermeture
f.close()

R.R. – Université Lyon 2

112
Traiter un fichier texte comme un fichier binaire (fichier d’octets)

Exemple de manipulations sur:

FICHIER BINAIRE

113
 voitures.txt
binaire (1/2) megane
clio
Python peut traiter un fichier en mode binaire, il peut lire octet par octet, ou twingo
par blocs d’octets. safrane
laguna
#ouverture en lecture vel satis
f = open("voitures.txt","rb") #lire
un octet • option « rb » pour open() pour lecture et mode
a = f.read(1) binaire
print(a) • read() prend un paramètre : nb. d‘octets à lire
#type de a → array de beyts • decode() permet de transformer le tableau d’octets en
print(type(a)) chaîne de caractères, « utf-8 » est le mode d’encodage
#transformer en chaîne de • après un read(), le curseur de fichier se place sur
caractères l’octet suivant, on peut connaître la position du curseur
s = a.decode("utf-8") avec tell() [début du fichier = indice 0]
print(s)
print(type(s))
b pour indiquer
#lire une 2nde fois a =
qu’il s’agit d’un
f.read(1)
tableau de bytes
print(a)
#pos. du curseur
print("position : ",f.tell())
11
 Accès en mode binaire (2/2)
voitures.txt
#positionner le curseur megane
clio
f.seek(0,0) twingo
#lire un bloc d'octets safrane
laguna
a = f.read(6) vel satis
print(a)
print("longueur = • seek() permet de positionner le curseur, le 1er
",len(a)) paramètre est la position, le 2nd est la référence : 0 à
#aller à l'octet n°5 #à partir du début du fichier, 2 à partir de la fin, 1 à partir
partir du début de la position courante
f.seek(5,0) • noter le seek(-1,2) avec un indice négatif, comme
a = f.read(1) pour
print(a) les listes ou les tuples

#lire le dernier octet

f.seek(-1,2)
a = f.read(1)
print(a)
#fermeture
f.close()
11
 Module pickle
• pickle est un module de python qui
permet de sauvegarder une ou plusieurs
variables dans un fichier et de récupérer
leurs valeurs ultérieurement. Les variables
peuvent être de type quelconque.
• L'importation de ce module peut se faire
par:
• from pickle import *
 Enregistrer des variables
• Pour enregistrer des variables dans un
fichier, il faut d'abord l'ouvrir en mode
"wb":
• f = open (chemin du fichier,"wb")
Attention: ce type d'ouverture ne crée pas
un fichier texte, mais un fichier
binaire (d'où le "b"). Cela signifie que les
données ne seront pas codées sous forme
de texte et que si vous ouvrez un tel fichier
avec un éditeur de texte vous obtiendrez à
peu près n'importe quoi !
 Exemple 1
• Pour enregistrer ensuite une variable dans
le fichier, on utilise la procédure dump:
• dump (nom de la variable, f)
f = open("xyz","wb")
x = 1961
y = 1935
z = "eric thirion"
dump(x,f)
dump(y,f)
dump(z,f)
f.close()

• Ce programme enregistre les valeurs des

trois variables x, y et z dans le fichier "xyz"
du répertoire courant.
 Lire des valeurs
• Pour vous montrer la différence entre un fichier binaire et un fichier texte. Voici ce que l'on obtient si l'on affiche ce fichier avec Bloc Note !
• Les caractères bizarres que l'on observe au début représentent les deux nombres entiers !

• Pour récupérer les valeurs des variables

sauvegardées dans un fichier, il faut d'abord
l'ouvrir en mode "rb":
• f = open (chemin du fichier,"rb")
• On peut ensuite récupérer la valeur d'une
variable avec la fonction load:
• nom de la variable = load (f)
• Il faut bien sur lire les valeurs des
variables dans l'ordre où elles ont été
enregistrées.
 Exemple 2
• Nous supposons ici que les instructions de l'exemple 1 ont
été exécutées et qu'il existe donc un fichier nommé "xyz"
dans le repertoire courant, contenant dans l'ordre la valeur
de x, celle de y, puis celle de z. Les valeurs de ces
variables peuvent à présent être récupérées de la manière
suivante:
f = open("xyz","rb")
x = load(f)
y = load(f)
z = load(f)
f.close()
print("x = ",x)
print("y = ",y)
print("z = ",z)
 Utiliser un dictionnaire
• Lorsque l'on a plusieurs données à
sauvegarder comme dans les exemples
précédents, il est préférable de les
enregistrer dans une seule variable de
type dictionnaire. On évite ainsi le
problème de la cohérence de l'ordre des
instructions dump avec les
instructions load de récupération des
données.
 Exemple 3
• Sauvegarde des valeurs des
variables x, y, z avec un dictionnaire (à
comparer avec l'exemple 1):
f = open("xyz","wb")
x = 1961
y = 1935
z = "eric thirion"
d = { "x" : x, "y": y, "z" : z}
dump(d,f)
f.close()
Récupération des valeurs des
variables x, y, z (à comparer
avec l'exemple 2):
f = open("xyz","rb")
d = load(f)
x = d["x"]
y = d["y"]
z = d["z"]
f.close()
print("x = ",x)
print("y = ",y)
print("z = ",z)