Actions et objets élémentaires d`un algorithme

DAIGL – Algorithmique/Python – Fichiers séquentiels
Fichiers séquentiels
(Python/Perl : Fichiers textes)
Toutes les variables (scalaires, listes et données structurées) que nous avons utilisées jusqu'à présent
étaient stockées en mémoire (RAM). Cela pose plusieurs problèmes :
●La durée de vie d'une variable est égale au temps d'exécution d'une fonction/procédure dans le
cas d'une variable locale, et au temps d'exécution du programme dans le cas d'une variable
globale.
●En tout état de cause, mettre fin à l'application, ou mettre hors-tension le poste de travail (ou
tout simplement une coupure de courant), voire un "plantage" du système d'exploitation (!!!) a
pour conséquence la perte du contenu de ces variables.
Il est aisé de comprendre qu'une telle situation n'est pas envisageable dans un programme utilisé dans
un cadre professionnel. Prenons le cas d'une entreprise qui archive à l'aide de votre application, des
commandes. Ces données qui doivent être mémorisées plus longtemps que la durée de vie de
l'application sont alors enregistrées sur un support non volatile de type disque dur, bande, CD-ROM…
On sauvegardera ces données dans des fichiers.
1- Opérations sur les fichiers
On nomme enregistrement, la collection d'informations (chaque information correspond alors à une
rubrique) mémorisées pour définir un des "objets" traités. Un fichier est une collection
d'enregistrements.
Ouvrir : Avant toute consultation ou modification d'un fichier, il est nécessaire de l'ouvrir.
Fermer : Un fichier ouvert doit être fermé quand les traitements le concernant sont terminés.
Lire : Une instruction de lecture recopie du fichier vers la mémoire un enregistrement.
Ecrire : Une instruction d'écriture recopie de la mémoire vers le fichier un enregistrement.
Réécrire : Une instruction de ré-écriture recopie de la mémoire vers le fichier un enregistrement en
lieu et place du dernier enregistrement lu.
Supprimer : Une instruction de suppression met à jour un indicateur associé à un enregistrement pour
indiquer que celui-ci n'est logiquement plus à prendre en compte. On parle de suppression logique et
non physique, car il n'est pas supprimé physiquement du fichier (ce qui impliquerait un décalage de
tous les enregistrements, un décalage qui risque de consommer beaucoup de "temps machine"). Seul
cet indicateur permettra au système de savoir que cet employé n'est plus valide.
Positionner : Une instruction de positionnement permet de se positionner directement sur un
enregistrement. Cette instruction ne fonctionne qu'avec des fichiers à accès aléatoire (à accès direct)
mais son utilisation n'est pas autorisée pour les fichiers séquentiels.
2- Organisation d'un fichier et accès aux enregistrements
Organisation séquentielle : Les enregistrements d'un fichier séquentiel sont accessibles dans leur
ordre chronologique d'enregistrement. Pour lire un enregistrement donné, il faut lire tous les
enregistrements qui le précèdent. Ce type de fichier ne permet qu'un accès séquentiel à l'information.
Organisation relative : Les enregistrements portent chacun un numéro relatif à leur emplacement
dans le fichier. Le premier enregistrement porte le numéro 1, le deuxième enregistrement porte le
numéro 2… Ils peuvent être lus et écrits directement grâce à ce numéro d'ordre, ce qui autorise un
accès direct à l'information.
Organisation séquentielle indexée : Une structure supplémentaire associée au fichier appelée index
permet un accès plus rapide aux enregistrements. Cet index est construit à partir de certains champs de
l'enregistrement du fichier. Ce type de fichier permet un accès direct à l'information.
Dans ce cours, nous nous intéresseront seulement aux fichiers séquentiels.
3- Fichiers séquentiels
Dans un fichier séquentiel, les enregistrements sont écrits les uns à la suite des autres. Après ouverture
du fichier, la lecture commence toujours par le premier enregistrement, puis le deuxième, puis son
suivant… et ainsi de suite jusqu'au dernier enregistrement (lecture séquentielle du fichier).
Page 1

DAIGL – Algorithmique/Python – Fichiers séquentiels
3.1. Déclaration d'un fichier séquentiel (algorithmique uniquement)
Variable :
nom_attache : Attache sur fichier Séquentiel de type_enregistrement
3.2. Ouverture
[Algo] nom_attache <- Ouvrir(nom_fichier,mode_ouverture)
[Python] objet_fichier = open(nom_fichier,mode_ouverture)
[Python] objet_fichier = file(nom_fichier,mode_ouverture)
[Perl] etat_ouverture = open(nom_attache,mode_ouverture.nom_fichier) ;
Modes d'ouverture :
●en Lecture (Perl : < , Python : r)
●en Ecriture : supprime son contenu initial (Perl : > , Python : w)
●en Ajout : écrit en fin de fichier (Perl : >> , Python : a)
En Python, la fonction open retourne un objet de type file qui servira ensuite pour manipuler le
fichier. En Perl, la fonction open retourne une valeur qui peut être apparentée à une valeur booléenne
(VRAI ou FAUX) pour indiquer si l'opération a été réalisée avec succès.
3.3. Lecture de l'enregistrement courant
[Algo] Lire(nom_attache,enregistrement)
[Python] enregistrement = objet_fichier.readline()
[Perl] enregistrement = <nom_attache> ;
3.4. Ecriture d'un enregistrement (toujours en dernière position dans le cas d'un fichier séquentiel)
[Algo] Ecrire(nom_attache,enregistrement)
[Python] objet_fichier.write(enregistrement)
[Perl] print nom_attache enregistrement ;
3.5. Fin du fichier (VRAI, FAUX, ou chaîne vide en Python)
[Algo] FinFichier(nom_attache)
[Python] objet_fichier.read() # retourne une chaîne vide
[Perl] not defined(enregistrement) ;
Tester la "fin de fichier" doit toujours être précédé d'une opération de lecture. En Perl, lorsque l'on
tente une opération de lecture alors que l'on se trouve en fin de fichier (tous les enregistrements ont
déjà été lus), la variable prévue pour mémorisée l'enregistrement se voit alors affecter la valeur
undef). En python, le parcours d'un fichier peut se résumer à l'utilisation d'une boucle Pour. Dans ce
cas, à chaque itération de boucle, une ligne du fichier sera lue, et l'arrêt de la lecture aura lieu à la fin
du fichier... et ce, automatiquement.
Exemple : lecture et affichage ligne par ligne d'un fichier
fichier = open("/etc/password")
for ligne in fichier :
print ligne
3.6. Fermeture
[Algo] Fermer(nom_attache)
[Python] objet_fichier.close()
[Perl] close(nom_attache) ;
3.7. Remarque...
… sur les opérations de modification et de suppression d'enregistrements dans les fichiers
séquentiels : Ces deux opérations de modification et de suppression ne sont pas acceptées pour la
manipulation de fichiers séquentiels. Il est vrai que dans la réalité, les fichiers séquentiels se
présentent sous la forme de fichiers textes (une ligne du fichier représente un enregistrement). Ces
fichiers ne permettent pas la modification ou la suppression d'une ligne (enregistrement) directement.
Page 2

DAIGL – Algorithmique/Python – Fichiers séquentiels
La solution est d'exploiter le fait que les fichiers séquentiels sont le plus souvent des fichiers de petite
taille pouvant donc être mémorisés en mémoire (à l'aide de tableaux par exemple). La modification ou
la suppression d'une ligne (enregistrement) se fait alors en mémoire. Il faut donc prévoir d'"écraser"
le fichier d'origine et d'y enregistrer le contenu de la mémoire (après modification et/ou suppression
des enregistrements). De la même manière, et sans tableau en mémoire, on peut utiliser un deuxième
fichier pour reconstituer ligne par ligne le fichier d'origine contenant l'enregistrement modifié, ou en
en sautant un pour le supprimer.
4- Applications
Prenons le cas d'une PME qui se sert d'un simple fichier séquentiel pour mémoriser les informations
relatives à ses employés (nom, prénom et ancienneté).
Exemple de fichier Personnel :
4.1. Lecture d'un fichier séquentiel
Algorithme :
Algo ListeEmployés
Type
Structure Employé (
nom : Chaîne
prénom : Chaîne
ancienneté : Entier
)
Variable(s) :
f_emp : Attache sur fichier séquentiel d'Employés
un_employé : Employé
Début
Ouvrir(f_emp,"Personnel.txt",mode lecture)
Lire(f_emp,un_employé)
TantQue NON FinFichier(f_emp) Faire
Afficher("Nom : " , un_employé.nom)
Afficher("Prénom : " , un_employé.prénom)
Afficher("Ancienneté : " , un_employé.ancienneté)
Lire(f_emp,un_employé)
FinTantQue
Fermer(f_emp)
Fin
A l'ouverture du fichier en mode lecture, l'enregistrement courant est le premier enregistrement (on dit
que l'on "pointe sur le premier enregistrement". Certains parlent de "pointeur d'enregistrement" qui
indique l'enregistrement courant). Ce premier enregistrement est prêt à être lu et le sera lors du
premier appel à l'instruction Lire. L'opération de lecture permet de lire l'enregistrement courant et
déplace le curseur sur l'enregistrement suivant (l'enregistrement suivant devient l'enregistrement
courant… c.à.d. le prochain enregistrement prêt à être lu).
Script Python :
#!/usr/bin/python
# -*- coding: latin-1 -*-
try :
Page 3
Venti
Albert
10
Solo
Henri
8
Cadoul
Jean
7
Nouar
Pierre
10
Fichier Personnel.txt :
Nouar:Pierre:10
Venti:Albert:10
Solo:Henri:8
Cadoul:Jeau:7

DAIGL – Algorithmique/Python – Fichiers séquentiels
fichier = open("Personnel.txt","r")
except IOError :
print "fichier introuvable"
else :
try : for ligne in fichier :
ligne = ligne.rstrip()
unePersonne = ligne.split(":")
print "Nom : ",unePersonne[0]
print "Prenom : ",unePersonne[1]
print "Anciennete : ",unePersonne[2]
except IOError :
print "lecture impossible"
fichier.close()
Lors d'une ouverture en lecture, le "curseur" se trouve positionné sur la première ligne (celle-ci est
alors la "ligne courante"). Chaque opération de lecture transfère le contenu de la ligne courante dans
une zone interne du programme (variable de type str) et positionne le "curseur" sur la ligne suivante.
Quand le "curseur" se trouve en fin de fichier (il n'y a donc plus rien à lire), l'opération de lecture
retourne la valeur chaîne vide.
En utilisant l'objet fichier au sein d'un for (for ligne in fichier), à chaque itération de
boucle, la variable ligne prendra successivement la valeur de chaque ligne du fichier.
#!/usr/bin/python
# -*- coding: latin-1 -*-
try :
fichier = open("Personnel.txt","r")
except IOError :
print "fichier introuvable"
else :try :
ligne = fichier.readline()
while ligne != "" :
ligne = ligne.rstrip()
unePersonne = ligne.split(":")
print "Nom : ",unePersonne[0]
print "Prënom : ",unePersonne[1]
print "Anciennete : ",unePersonne[2]
ligne = fichier.readline()
except IOError :
print "lecture impossible"
fichier.close()
Script Perl :
#!c:/perl/bin/perl -w
if(-e "Personnel.txt" and -r "Personnel.txt")
{
my $ouverture_ok = open(F_EMP,"<Personnel.txt") ;
if($ouverture_ok)
{
my $un_employe = <F_EMP> ;
while(defined($un_employe))
{
chomp($un_employe) ;
my($nom,$prenom,$anciennete) = split(/:/,$un_employe) ;
print "Nom : $nom\n" ;
print "Prénom : $prenom\n" ;
Page 4

DAIGL – Algorithmique/Python – Fichiers séquentiels
print "Ancienneté : $anciennete\n" ;
$un_employe = <F_EMP> ;
}
close(F_EMP) ;
}
else
{
print "Echec à l'ouverture.\n" ;
}
}
else
{
print "Le fichier n'existe pas ou n'est pas accessible.\n" ;
}
Lors d'une ouverture en lecture, le "curseur" se trouve positionné sur la première ligne (celle-ci est
alors la "ligne courante"). Chaque opération de lecture transfère le contenu de la ligne courante dans
une zone interne du programme (variable scalaire) et positionne le "curseur" sur la ligne suivante.
Quand le "curseur" se trouve en fin de fichier (il n'y a donc plus rien à lire), l'opération de lecture
retourne la valeur undef. L'opérateur "diamant", utilisé dans un contexte de liste, permet de recopier
le contenu d'un fichier dans une variable tableau en une seule instruction (une ligne par élément) :
#!c:/perl/bin/perl -w
if(-e "Personnel.txt" and -r "Personnel.txt")
{
my $ouverture_ok = open(F_EMP,"<Personnel.txt") ;
if($ouverture_ok)
{
my @les_employes = <F_EMP> ;
close(F_EMP) ;
chomp @les_employes ;
foreach my $un_employe (@les_employes)
{
my($nom,$prenom,$anciennete) = split(/:/,$un_employe) ;
print "Nom : $nom\n" ;
print "Prénom : $prenom\n" ;
print "Ancienneté : $anciennete\n" ;
}
}
else
{
print "Echec à l'ouverture.\n" ;
}
}
else
{
print "Le fichier n'existe pas ou n'est pas accessible.\n" ;
}
4.2. Ecriture dans un fichier séquentiel
●Ecriture d'un enregistrement
Algorithme :
Algo AjouterEmployé
Type
Structure Employé (
nom : Chaîne
prénom : Chaîne
ancienneté : Entier
)
Page 5