« Programmation Python/Fichiers » : différence entre les versions
Contenu supprimé Contenu ajouté
adaptation en wikisyntaxe, typo, retouches |
|||
Ligne 1 :
Jusqu'à présent, les programmes que nous avons réalisés ne traitaient qu'un très petit nombre de données. Nous pouvions donc à chaque fois inclure ces données dans le corps du programme lui-même (par exemple dans une liste). Cette façon de procéder devient cependant tout à fait inadéquate lorsque l'on souhaite traiter une quantité d'information plus importante.
== Utilité des fichiers ==
Imaginons par exemple que nous voulons écrire un petit programme exerciseur qui fasse apparaître à l'écran des questions à choix multiple, avec traitement automatique des réponses de l'utilisateur. Comment allons-nous mémoriser le texte des questions elles-mêmes ?
L'idée la plus simple consiste à placer chacun de ces textes dans une variable, en début de programme, avec des instructions d'affectation du genre :
<pre>
a = "Quelle est la capitale du Guatémala ?"
b = "Qui à succédé à Henri IV ?"
c = "Combien font 26 x 43 ?"
... etc.
</pre>
Cette idée est malheureusement beaucoup trop simpliste. Tout va se compliquer en effet lorsque nous essayerons d'élaborer la suite du programme, c'est-à-dire les instructions qui devront servir à sélectionner au hasard l'une ou l'autre de ces questions pour les présenter à l'utilisateur. Employer par exemple une longue suite d'instructions <code>if ... elif ... elif ...</code> comme dans l'exemple ci-dessous n'est certainement pas la bonne solution (ce serait d'ailleurs bien pénible à écrire : n'oubliez pas que nous souhaitons traiter un grand nombre de questions !) :
<pre>
if choix == 1:
selection = a
Ligne 16 ⟶ 24 :
selection = c
... etc.
</pre>
La situation se présente déjà beaucoup mieux si nous faisons appel à une liste :
<pre>
liste = ["Qui a vaincu Napoléon à Waterloo ?",
"Comment traduit-on 'informatique' en anglais ?",
"Quelle est la formule chimique du méthane ?", ... etc ...]
</pre>
On peut en effet extraire n'importe quel élément de cette liste à l'aide de son indice. Exemple :
<pre>
print liste[2] ===> "Quelle est la formule chimique du méthane ?"
</pre>
(rappel : l'indiçage commence à partir de zéro)
Même si cette façon de procéder est déjà nettement meilleure que la précédente, nous sommes toujours confrontés à plusieurs problèmes gênants :
* La lisibilité du programme va se détériorer très vite lorsque le nombre de questions deviendra important. En corollaire, nous accroîtrons la probabilité d'insérer l'une ou l'autre erreur de syntaxe dans la définition de cette longue liste. De telles erreurs seront bien difficiles à débusquer.
* L'ajout de nouvelles questions, ou la modification de certaines d'entre elles, imposeront à chaque fois de rouvrir le code source du programme. En corollaire, il deviendra malaisé de retravailler ce même code source, puisqu'il comportera de nombreuses lignes de données encombrantes.
* L'échange de données avec d'autres programmes (peut-être écrits dans d'autres langages) est tout simplement impossible, puisque ces données font partie du programme lui-même.
Cette dernière remarque nous suggère la direction à prendre : il est temps que nous apprenions à ''séparer les données, et les programmes qui les traitent, dans des fichiers différents''.
Pour que cela devienne possible, nous devrons doter nos programmes de divers mécanismes permettant de créer des fichiers, d'y envoyer des données et de les récupérer par après.
Les langages de programmation proposent des jeux d'instructions plus ou moins sophistiqués pour effectuer ces tâches. Lorsque les quantités de données deviennent très importantes, il devient d'ailleurs rapidement nécessaire de structurer les relations entre ces données, et l'on doit alors élaborer des systèmes appelés ''bases de données relationnelles'', dont la gestion peut s'avérer très complexe. Ce sera là l'affaire de logiciels très spécialisés tels que ''[[Oracle]]'', ''[[IBM DB]]'', ''[[Adabas]]'', ''[[PostgreSQL]]'', ''[[MySQL]]'', etc. Python est parfaitement capable de dialoguer avec ces systèmes, mais nous laisserons cela pour un peu plus tard (voir : « Gestion d'une base de données », page {{todo}}).
Nos ambitions présentes sont plus modestes. Nos données ne se comptent pas encore par centaines de milliers, aussi nous pouvons nous contenter de mécanismes simples pour les enregistrer dans un fichier de taille moyenne, et les en extraire ensuite.
L'utilisation d'un fichier ressemble beaucoup à l'utilisation d'un livre. Pour utiliser un livre, vous devez d'abord le trouver (à l'aide de son titre), puis l'ouvrir. Lorsque vous avez fini de l'utiliser, vous le refermez. Tant qu'il est ouvert, vous pouvez y lire des informations diverses, et vous pouvez aussi y écrire des annotations, mais généralement vous ne faites pas les deux à la fois. Dans tous les cas, vous pouvez vous situer à l'intérieur du livre, notamment en vous aidant des numéros de pages. Vous lisez la plupart des livres en suivant l'ordre normal des pages, mais vous pouvez aussi décider de consulter n'importe quel paragraphe dans le désordre.
Tout ce que nous venons de dire des livres s'applique aussi aux fichiers informatiques.
Un fichier se compose de données enregistrées sur votre disque dur, sur une disquette ou sur un CD-ROM. Vous y accédez grâce à son nom (lequel peut inclure aussi un nom de répertoire). Vous pouvez toujours considérer le contenu d'un fichier comme une suite de caractères, ce qui signifie que vous pouvez traiter ce contenu, ou une partie quelconque de celui-ci, à l'aide des fonctions servant à traiter les chaînes de caractères.
Pour simplifier les explications qui vont suivre, nous indiquerons seulement des noms simples pour les fichiers que nous allons manipuler. Si vous procédez ainsi dans vos exercices, les fichiers en question seront créés et/ou recherchés par Python ''dans le répertoire courant''. Celui-ci est habituellement le répertoire où se trouve le script lui-même, sauf si vous lancez ce script depuis la fenêtre d'un shell IDLE, auquel cas le répertoire courant est défini au lancement de IDLE lui-même (Sous Windows, la définition de ce répertoire fait partie des propriétés de l'icône de lancement).
Si vous travaillez avec IDLE, vous souhaiterez donc certainement forcer Python à changer son répertoire courant, afin que celui-ci corresponde à vos attentes. Pour ce faire, utilisez les commandes suivantes en début de session. (Nous supposons ici que le répertoire visé est le répertoire <code>/home/jules/exercices</code>. Vous pouvez franchement utiliser cette syntaxe (c'est-à-dire des caractères / et non \ en guise de séparateurs : c'est la convention en vigueur dans le monde Unix). Python effectuera automatiquement les conversions nécessaires, suivant que vous travaillez sous MacOS, Linux, ou Windows.<ref>Dans le cas de Windows, vous pouvez également inclure dans ce chemin la lettre qui désigne le périphérique de stockage où se trouve le fichier. Par exemple : <code>D:/home/jules/exercices</code>.</ref>
<pre>
>>> from os import chdir
>>> chdir("/home/jules/exercices")
</pre>
La première commande importe la fonction <code>chdir()</code> du module <code>os</code>. Le module <code>os</code> contient toute une série de fonctions permettant de dialoguer avec le système d'exploitation (os = ''operating system''), quel que soit celui-ci.
La seconde commande provoque le changement de répertoire (<code>chdir</code> = ''change directory'')
;Notes
* Vous avez également la possibilité d'insérer ces commandes en début de script, ou encore d'indiquer le chemin d'accès complet dans le nom des fichiers que vous manipulez, mais cela risque peut-être d'alourdir l'écriture de vos programmes.
* Choisissez de préférence des noms de fichiers courts. Évitez dans toute la mesure du possible les caractères accentués, les espaces et les signes typographiques spéciaux.
== Les deux formes d'importation ==
Les lignes d'instructions que nous venons d'utiliser sont l'occasion d'expliquer un mécanisme intéressant. Vous savez qu'en complément des fonctions intégrées dans le module de base, Python met à votre disposition une très grande quantité de fonctions plus spécialisées, qui sont regroupées dans des ''modules''. Ainsi vous connaissez déjà fort bien le module <code>math</code> et le module <code>Tkinter</code>.
Pour utiliser les fonctions d'un module, il suffit de les importer. Mais cela peut se faire de deux manières différentes, comme nous allons le voir ci-dessous. Chacune des deux méthodes présente des avantages et des inconvénients.
Voici un exemple de la première méthode :
<pre>
>>>>>> import os
>>> rep_cour = os.getcwd()
>>> print rep_cour
C:\Python22\essais
</pre>
La première ligne de cet exemple importe l'intégralité du module <code>os</code>, lequel contient de nombreuses fonctions intéressantes pour l'accès au système d'exploitation. La seconde ligne utilise la fonction <code>getcwd()</code> du module os<ref>Le point séparateur exprime donc ici une relation d'appartenance. Il s'agit d'un exemple de la ''qualification des noms'' qui sera de plus en plus largement exploitée dans la suite de ce cours. Relier ainsi des noms à l'aide de points est une manière de désigner sans ambiguïté des éléments faisant partie d'ensembles, lesquels peuvent eux-mêmes faire partie d'ensembles plus vastes, etc. Par exemple, l'étiquette <code>systeme.machin.truc</code> désigne l'élément <code>truc</code>, qui fait partie de l'ensemble <code>machin</code>, lequel fait lui-même partie de l'ensemble <code>systeme</code>. Nous verrons de nombreux exemples de cette technique de désignation, notamment lors de notre étude des classes d'objets.</ref>. Comme vous pouvez le constater, la fonction <code>getcwd()</code> renvoie le nom du répertoire courant (getcwd = ''get current working directory'').
Par comparaison, voici un exemple similaire utilisant la seconde méthode d'importation :
<pre>
>>> from os import getcwd
>>> rep_cour = getcwd()
>>> print rep_cour
C:\Python22\essais
</pre>
Dans ce nouvel exemple, nous n'avons importé du module <code>os</code> que la fonction <code>getcwd()</code> seule. Importée de cette manière, la fonction s'intègre à notre propre code comme si nous l'avions écrite nous-mêmes. Dans les lignes où nous l'utilisons, il n'est pas nécessaire de rappeler qu'elle fait partie du module <code>os</code>.
Nous pouvons de la même manière importer plusieurs fonctions du même module :
<pre>
>>> from math import sqrt, pi, sin, cos
>>> print pi
3.14159265359
>>> print sqrt(5)
2.2360679775
>>> print sin(pi/6)
0.5
</pre>
Nous pouvons même importer toutes les fonctions d'un module, comme dans :
<pre>
from Tkinter import *
</pre>
Cette méthode d'importation présente l'avantage d'alléger l'écriture du code. Elle présente l'inconvénient (surtout dans sa dernière forme, celle qui importe toutes les fonctions d'un module) d'encombrer l'espace de noms courant. Il se pourrait alors que certaines fonctions importées aient le même nom que celui d'une variable définie par vous-même, ou encore le même nom qu'une fonction importée depuis un autre module. (Si cela se produit, l'un des deux noms en conflit n'est évidemment plus accessible).
Dans les programmes d'une certaine importance, qui font appel à un grand nombre de modules d'origines diverses, il sera donc toujours préférable de privilégier plutôt la première méthode, c'est-à-dire celle qui utilise des noms pleinement qualifiés.
On fait généralement exception à cette règle dans le cas particulier du module <code>Tkinter</code>, parce que les fonctions qu'il contient sont très sollicitées (dès lors que l'on décide d'utiliser ce module).
== Écriture séquentielle dans un fichier ==
Sous Python, l'accès aux fichiers est assuré par l'intermédiaire d'un ''objet-fichier'' que l'on crée à l'aide de la fonction interne <code>open()</code>. Après avoir appelé cette fonction, vous pouvez lire et écrire dans le fichier en utilisant les méthodes spécifiques de cet objet-fichier.
L'exemple ci-dessous vous montre comment ouvrir un fichier « en écriture », y enregistrer deux chaînes de caractères, puis le refermer. Notez bien que si le fichier n'existe pas encore, il sera créé automatiquement. Par contre, si le nom utilisé concerne un fichier préexistant qui contient déjà des données, les caractères que vous y enregistrerez viendront s'ajouter à la suite de ceux qui s'y trouvent déjà. Vous pouvez faire tout cet exercice directement à la ligne de commande :
<pre>
>>> obFichier = open('Monfichier','a')
>>> obFichier.write('Bonjour, fichier !')
Ligne 95 ⟶ 150 :
>>> obFichier.close()
>>>
</pre>
;Notes
* La première ligne crée l'objet-fichier « obFichier », lequel fait référence à un fichier véritable (sur disque ou disquette) dont le nom sera <code>Monfichier</code>. ''Ne confondez pas le nom de fichier avec le nom de l'objet-fichier qui y donne accès''. A la suite de cet exercice, vous pouvez vérifier qu'il s'est bien créé sur votre système (dans le répertoire courant) un fichier dont le nom est <code>Monfichier</code> (et vous pouvez en visualiser le contenu à l'aide d'un éditeur quelconque).
* La fonction <code>open()</code> attend deux arguments, qui doivent être des chaînes de caractères. Le premier argument est le nom du fichier à ouvrir, et le second est le mode d'ouverture.
* La méthode <code>write()</code> réalise l'écriture proprement dite. Les données à écrire doivent être fournies en argument. Ces données sont enregistrées dans le fichier les unes à la suite des autres (c'est la raison pour laquelle on parle de fichier à accès ''séquentiel''). Chaque nouvel appel de <code>write()</code> continue l'écriture à la suite de ce qui est déjà enregistré.
* La méthode <code>close()</code> referme le fichier. Celui-ci est désormais disponible pour tout usage.
== Lecture séquentielle d'un fichier ==
Vous allez maintenant rouvrir le fichier, mais cette fois « en lecture », de manière à pouvoir y relire les informations que vous avez enregistrées dans l'étape précédente :
<pre>
>>> ofi = open('Monfichier', 'r')
>>> t = ofi.read()
Ligne 110 ⟶ 172 :
Bonjour, fichier !Quel beau temps, aujourd'hui !
>>> ofi.close()
</pre>
Comme on pouvait s'y attendre, la méthode <code>read()</code> lit les données présentes dans le fichier et les transfère dans une variable de type « chaîne » (''string'') . Si on utilise cette méthode sans argument, la totalité du fichier est transférée.
;Notes
<ul>
<li>Le fichier que nous voulons lire s'appelle <code>Monfichier</code>. L'instruction d'ouverture de fichier devra donc nécessairement faire référence à ce nom-là. Si le fichier n'existe pas, nous obtenons un message d'erreur. Exemple :
<pre>
>>> ofi = open('Monficier','r')
IOError: [Errno 2] No such file or directory: 'Monficier'
</pre>
Par contre, nous ne sommes tenus à aucune obligation concernant le nom à choisir pour l'objet-fichier. C'est un nom de variable quelconque. Ainsi donc, dans notre première instruction, nous avons choisi de créer un objet-fichier <code>ofi</code>, faisant référence au fichier réel <code>Monfichier</code>, lequel est ouvert en lecture (argument <code>r</code>).</li>
<li>Les deux chaînes de caractères que nous avions entrées dans le fichier sont à présent accolées en une seule. C'est normal, puisque nous n'avons fourni aucun caractère de séparation lorsque nous les avons enregistrées. Nous verrons un peu plus loin comment enregistrer des lignes de texte distinctes.</li>
<li>La méthode <code>read()</code> peut également être utilisée avec un argument. Celui-ci indiquera combien de caractères doivent être lus, à partir de la position déjà atteinte dans le fichier :
<pre>
>>> ofi = open('Monfichier', 'r')
>>> t = ofi.read(7)
Ligne 127 ⟶ 200 :
>>> print t
, fichier !Quel
</pre>
S'il ne reste pas assez de caractères au fichier pour satisfaire la demande, la lecture s'arrête tout simplement à la fin du fichier :
<pre>
>>> t = ofi.read(1000)
>>> print t
beau temps, aujourd'hui !
</pre>
Si la fin du fichier est déjà atteinte, <code>read()</code> renvoie une chaîne vide :
<pre>
>>> t = ofi.read()
>>> print t
Ligne 139 ⟶ 219 :
>>> ofi.close()
</pre></li>
</ul>
== L'instruction break pour sortir d'une boucle ==
Il va de soi que les boucles de programmation s'imposent lorsque l'on doit traiter un fichier dont on ne connaît pas nécessairement le contenu à l'avance. L'idée de base consistera à lire ce fichier morceau par morceau, jusqu'à ce que l'on ait atteint la fin du fichier.
La fonction ci-dessous illustre cette idée. Elle copie l'intégralité d'un fichier, quelle que soit sa taille, en transférant des portions de 50 caractères à la fois :
<pre>
def copieFichier(source, destination):
"copie intégrale d'un fichier"
Ligne 154 ⟶ 241 :
fd.close()
return
</pre>
Si vous voulez tester cette fonction, vous devez lui fournir deux arguments : le premier est le nom du fichier original, le second est le nom à donner au fichier qui accueillera la copie. Exemple :
<pre>
copieFichier('Monfichier','Tonfichier')
</pre>
Vous aurez remarqué que la boucle <code>while</code> utilisée dans cette fonction est construite d'une manière différente de ce que vous avez rencontré précédemment. Vous savez en effet que l'instruction <code>while</code> doit toujours être suivie d'une condition à évaluer ; le bloc d'instructions qui suit est alors exécuté en boucle, aussi longtemps que cette condition reste vraie. Or nous avons remplacé ici la condition à évaluer par une simple constante, et vous savez
Une boucle <code>while</code> construite comme nous l'avons fait ci-dessus devrait donc boucler indéfiniment, puisque la condition de continuation reste toujours vraie. Nous pouvons cependant interrompre ce bouclage en faisant appel à l'instruction <code>break</code>, laquelle permet éventuellement de mettre en place plusieurs mécanismes de sortie différents pour une même boucle :
<pre>
while <condition 1> :
--- instructions diverses ---
Ligne 167 ⟶ 261 :
if <condition 3>:
break
etc.
</pre>
Dans notre fonction <code>copieFichier()</code>, il est facile de voir que l'instruction break s'exécutera seulement lorsque la fin du fichier aura été atteinte.
== Fichiers texte ==
Un fichier texte est un fichier qui contient des caractères imprimables et des espaces organisés en lignes successives, ces lignes étant séparées les unes des autres par un caractère spécial non-imprimable appelé « marqueur de fin de ligne »<ref>Suivant le système d'exploitation utilisé, le codage correspondant au marqueur de fin de ligne peut être différent. Sous Windows, par exemple, il s'agit d'une séquence de deux caractères (Retour chariot et Saut de ligne), alors que dans les systèmes de type Unix (comme Linux) il s'agit d'un seul saut de ligne, MacOS pour sa part utilisant un seul retour chariot. En principe, vous n'avez pas à vous préoccuper de ces différences. Lors des opérations d'écriture, Python utilise la convention en vigueur sur votre système d'exploitation. Pour la lecture, Python interprète correctement chacune des trois conventions (qui sont donc considérées comme équivalentes).</ref>.
Il est très facile de traiter ce genre de fichiers sous Python. Les instructions suivantes créent un fichier texte de quatre lignes :
<pre>
>>> f = open("Fichiertexte", "w")
>>> f.write("Ceci est la ligne un\nVoici la ligne deux\n")
>>> f.write("Voici la ligne trois\nVoici la ligne quatre\n")
>>> f.close()
</pre>
Notez bien le marqueur de fin de ligne
Lors des opérations de lecture, les lignes d'un fichier texte peuvent être extraites séparément les unes des autres. La méthode <code>readline()</code>, par exemple, ne lit qu'une seule ligne à la fois (en incluant le caractère de fin de ligne) :
<pre>
>>> f = open('Fichiertexte','r')
>>> t = f.readline()
Ligne 186 ⟶ 290 :
>>> print f.readline()
Voici la ligne deux
</pre>
La méthode <code>readlines()</code> transfère toutes les lignes restantes dans une liste de chaînes :
<pre>
>>> t = f.readlines()
>>> print t
['Voici la ligne trois\012', 'Voici la ligne quatre\012']
>>> f.close()
</pre>
;Remarques
* La liste apparaît ci-dessus en format brut, avec des apostrophes pour délimiter les chaînes, et les caractères spéciaux sous forme de codes numériques. Vous pourrez bien évidemment parcourir cette liste (à l'aide d'une boucle <code>while</code>, par exemple) pour en extraire les chaînes individuelles.
* La méthode <code>readlines()</code> permet donc de lire l'intégralité d'un fichier en une instruction seulement. Cela n'est possible toutefois que si le fichier à lire n'est pas trop gros (Puisqu'il est copié intégralement dans une variable, c'est-à-dire dans la mémoire vive de l'ordinateur, il faut que la taille de celle-ci soit suffisante). Si vous devez traiter de gros fichiers, utilisez plutôt la méthode <code>readline()</code> dans une boucle, comme le montrera l'exemple de la page suivante.
* Notez bien que <code>readline()</code> est une méthode qui renvoie une chaîne de caractères, alors que la méthode <code>readlines()</code> renvoie une liste. A la fin du fichier, <code>readline()</code> renvoie une chaîne vide, tandis que <code>readlines()</code> renvoie une liste vide.
Le script qui suit vous montre comment créer une fonction destinée à effectuer un certain traitement sur un fichier texte. En l'occurrence, il s'agit ici de recopier un fichier texte en omettant toutes les lignes qui commencent par un caractère <code>#</code> :
<pre>
def filtre(source,destination):
"recopier un fichier en éliminant les lignes de remarques"
Ligne 213 ⟶ 326 :
fd.close()
return
</pre>
Pour appeler cette fonction, vous devez utiliser deux arguments : le nom du fichier original, et le nom du fichier destiné à recevoir la copie filtrée. Exemple :
<pre>
filtre('test.txt', 'test_f.txt')
</pre>
L'argument de la méthode <code>write()</code> doit être une chaîne de caractères. Avec ce que nous avons appris jusqu'à présent, nous ne pouvons donc enregistrer d'autres types de valeurs qu'en les transformant d'abord en chaînes de caractères.
Nous pouvons réaliser cela à l'aide de la fonction intégrée <code>str()</code> :
<pre>
>>> x = 52
>>> f.write(str(x))
</pre>
Nous verrons plus loin qu'il existe d'autres possibilités pour convertir des valeurs numériques en chaînes de caractères (voir à ce sujet : ''Formatage des chaînes de caractères'', page {{todo}}). Mais la question n'est pas vraiment là. Si nous enregistrons les valeurs numériques en les transformant d'abord en chaînes de caractères, nous risquons de ne plus pouvoir les re-transformer correctement en valeurs numériques lorsque nous allons relire le fichier. Exemple :
<pre>
>>> a = 5
>>> b = 2.83
Ligne 236 ⟶ 360 :
52.8367
>>> f.close()
</pre>
Nous avons enregistré trois valeurs numériques. Mais comment pouvons-nous les distinguer dans la chaîne de caractères résultante, lorsque nous effectuons la lecture du fichier ? C'est impossible ! Rien ne nous indique d'ailleurs qu'il y a là trois valeurs plutôt qu'une seule, ou 2, ou 4,…
Il existe plusieurs solutions à ce genre de problèmes. L'une des meilleures consiste à importer un module Python spécialisé : le module pickle<ref>En anglais, le terme ''pickle'' signifie "conserver". Le module a été nommé ainsi parce qu'il sert effectivement à enregistrer des données en conservant leur type.</ref>. Voici comment il s'utilise :
<pre>
>>> import pickle
>>> f = open('Monfichier', 'w')
Ligne 257 ⟶ 384 :
67 <type 'int'>
>>> f.close()
</pre>
Pour cet exemple, on considère que les variables <code>a</code>, <code>b</code> et <code>c</code> contiennent les mêmes valeurs que dans l'exemple précédent. La fonction <code>dump()</code> du module ''pickle'' attend deux arguments : le premier est la variable à enregistrer, le second est l'objet fichier dans lequel on travaille. La fonction <code>pickle.load()</code> effectue le travail inverse, c'est-à-dire la restitution de chaque variable avec son type.
Vous pouvez aisément comprendre ce que font exactement les fonctions du module ''pickle'' en effectuant une lecture « classique » du fichier résultant, à l'aide de la méthode <code>read()</code> par exemple.
Les ''exceptions'' sont les opérations qu'effectue un interpréteur ou un compilateur lorsqu'une erreur est détectée au cours de l'exécution d'un programme. En règle générale, l'exécution du programme est alors interrompue, et un message d'erreur plus ou moins explicite est affiché.
Exemple :
<pre>
>>> print 55/0
ZeroDivisionError: integer division or modulo
</pre>
{{remarque|D'autres informations complémentaires sont affichées, qui indiquent notamment à quel endroit du script l'erreur a été détectée, mais nous ne les reproduisons pas ici.}}
Le message d'erreur proprement dit comporte deux parties séparées par un double point : d'abord le type d'erreur, et ensuite une information spécifique de cette erreur.
Dans de nombreux cas, il est possible de prévoir à l'avance certaines des erreurs qui risquent de se produire à tel ou tel endroit du programme, et d'inclure à cet endroit des instructions particulières, qui seront activées seulement si ces erreurs se produisent. Dans les langages de niveau élevé comme Python, il est également possible d'associer un mécanisme de surveillance à tout ''un ensemble d'instructions'', et donc de simplifier le traitement des erreurs qui peuvent se produire dans n'importe laquelle de ces instructions.
Un mécanisme de ce type s'appelle en général ''mécanisme de traitement des exceptions''. Celui de Python utilise l'ensemble d'instructions <code>try - except – else</code>, qui permettent d'intercepter une erreur et d'exécuter une portion de script spécifique de cette erreur. Il fonctionne comme suit :
Le bloc d'instructions qui suit directement une instruction <code>try</code> est exécuté par Python ''sous réserve''. Si une erreur survient pendant l'exécution de l'une de ces instructions, alors Python annule cette instruction fautive et exécute à sa place le code inclus dans le bloc qui suit l'instruction <code>except</code>. Si aucune erreur ne s'est produite dans les instructions qui suivent <code>try</code>, alors c'est le bloc qui suit l'instruction else qui est exécuté (si cette instruction est présente). Dans tous les cas, l'exécution du programme peut se poursuivre ensuite avec les instructions ultérieures.
Considérons par exemple un script qui demande à l'utilisateur d'entrer un nom de fichier, lequel fichier étant destiné à être ouvert en lecture. Si le fichier n'existe pas, nous ne voulons pas que le programme se « plante ». Nous voulons qu'un avertissement soit affiché, et éventuellement que l'utilisateur puisse essayer d'entrer un autre nom.
<pre>
filename = raw_input("Veuillez entrer un nom de fichier : ")
try:
Ligne 279 ⟶ 418 :
except:
print "Le fichier", filename, "est introuvable"
</pre>
Si nous estimons que ce genre de test est susceptible de rendre service à plusieurs endroits d'un programme, nous pouvons aussi l'inclure dans une fonction :
<pre>
def existe(fname):
try:
Ligne 295 ⟶ 436 :
else:
print "Le fichier", filename, "est introuvable."
</pre>
Il est également possible de faire suivre l'instruction try de plusieurs blocs except, chacun d'entre eux traitant un type d'erreur spécifique, mais nous ne développerons pas ces compléments ici. Veuillez consulter un ouvrage de référence sur Python si nécessaire.
{{Exercices}}
<ol>
<li>Écrivez un script qui permette de créer et de relire aisément un fichier texte. Votre programme demandera d'abord à l'utilisateur d'entrer le nom du fichier. Ensuite il lui proposera le choix, soit d'enregistrer de nouvelles lignes de texte, soit d'afficher le contenu du fichier.<br />
L'utilisateur devra pouvoir entrer ses lignes de texte successives en utilisant simplement la touche <Enter> pour les séparer les unes des autres. Pour terminer les entrées, il lui suffira d'entrer une ligne vide (c'est-à-dire utiliser la touche <Enter> seule).<br />
L'affichage du contenu devra montrer les lignes du fichier séparées les unes des autres de la manière la plus naturelle (les codes de fin de ligne ne doivent pas apparaître).</li>
<li>Considérons que vous avez à votre disposition un fichier texte contenant des phrases de différentes longueurs. Écrivez un script qui recherche et affiche la phrase la plus longue.</li>
<li>Écrivez un script qui génère automatiquement un fichier texte contenant les tables de multiplication de 2 à 30 (chacune d'entre elles incluant 20 termes seulement).</li>
<li>Écrivez un script qui recopie un fichier texte en triplant tous les espaces entre les mots.</li>
<li>Vous avez à votre disposition un fichier texte dont chaque ligne est la représentation d'une valeur numérique de type réel (mais sans exposants). Par exemple :<br />
14.896<br />
7894.6<br />
123.278<br />
etc.<br />
Écrivez un script qui recopie ces valeurs dans un autre fichier en les arrondissant en nombres entiers (l'arrondi doit être correct).</li>
<li>Écrivez un script qui compare les contenus de deux fichiers et signale la première différence rencontrée.</li>
<li>A partir de deux fichiers préexistants A et B, construisez un fichier C qui contienne alternativement un élément de A, un élément de B, un élément de A, ... et ainsi de suite jusqu'à atteindre la fin de l'un des deux fichiers originaux. Complétez ensuite C avec les éléments restant sur l'autre.</li>
<li>Écrivez un script qui permette d'encoder un fichier texte dont les lignes contiendront chacune les noms, prénom, adresse, code postal et n° de téléphone de différentes personnes (considérez par exemple qu'il s'agit des membres d'un club)</li>
<li>Écrivez un script qui recopie le fichier utilisé dans l'exercice précédent, en y ajoutant la date de naissance et le sexe des personnes (l'ordinateur devra afficher les lignes une par une, et demander à l'utilisateur d'entrer pour chacune les données complémentaires).</li>
<li>Considérons que vous avez fait les exercices précédents et que vous disposez à présent d'un fichier contenant les coordonnées d'un certain nombre de personnes. Écrivez un script qui permette d'extraire de ce fichier les lignes qui correspondent à un code postal bien déterminé.</li>
<li>Modifiez le script de l'exercice précédent, de manière à retrouver les lignes correspondant à des prénoms dont la première lettre est située entre F et M (inclus) dans l'alphabet.</li>
<li>Écrivez des fonctions qui effectuent le même travail que celles du module pickle (voir page 118). Ces fonctions doivent permettre l'enregistrement de variables diverses dans un fichier texte, en les accompagnant systématiquement d'informations concernant leur format exact.</li>
</ol>
{{fin}}
| |||