Comment mettre à jour le contenu d’un fichier

Certains trouvent que mettre à jour un fichier est une tâche complexe. En fait, ce n’est vrai que si vous voyez tout cela comme une tâche unique. En fait, ce processus se décompose en trois temps ^三个阶段 :

1. Lire le contenu du fichier en mémoire.
2. Modifier la présentation en mémoire des données.
3. Écrire le résultat du traitement dans le fichier.

Dans la plupart des applications, la seconde étape peut même être à son tour découpée en plusieurs actions ^几个动作 :

Dans ce chapitre, vous avez appris à écrire un fichier sur le disque, puis à relire son contenu. Vous avez aussi ajouté des enregistrements à une liste et présenté ceux-ci à l’écran. Il ne reste donc qu’une seule tâche intéressante à étudier : la suppression de données dans une liste. Comme indiqué ci-dessus, le processus de modification revient bien souvent à ajouter un nouvel enregistrement dans lequel sont copiées les données à modifier, puis à supprimer l’ancienne version une fois les changements terminés.

Ne tombez pas en syncope en pensant que vous devriez effectuer chacune des activités mentionnées dans cette section pour chacune de vos applications. Ainsi, un programme de monitoring n’aura pas besoin d’afficher des données à l’écran (sauf si c’est indispensable avant de devenir totalement ennuyeux). Une application de journalisation ne fait que créer de nouvelles entrées (elle ne supprime rien et ne modifie rien). Une messagerie permet d’ajouter des enregistrements et d’en supprimer, mais pas de les modifier (vous ne pouvez rien changer dans les e-mails que vous recevez, uniquement les supprimer ou y répondre, créant ainsi un nouveau message). D’un autre côté, un traitement de texte a besoin de savoir tout faire. C’est donc à vous de réfléchir à cette question selon l’application que vous développez.

Séparer l’interface utilisateur des activités qui se déroulent en arrière-plan est important. Pour rester simple, l’exemple qui suit se concentre sur le travail à effectuer en arrière-plan pour apporter des modifications au fichier créé plus haut. Ces étapes vous montrent comment lire, modifier et enregistrer des données dans un fichier afin de le tenir à jour. Les modifications se décomposent en trois étapes : une addition, un changement, et une suppression. Pour que vous puissiez effectuer plusieurs tests, les données modifiées sont sauvegardées dans un nouveau fichier. Cet exemple peut également être retrouvé dans les fichiers téléchargeables FormattedData.py and UpdateCSV.py.

1. Ouvrez une fenêtre de fichier Python.
   Vous pouvez par exemple lancer Python en mode Shell, puis choisir dans le menu File la commande New File.
2. Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne :

   from FormattedData import FormatData
   import os.path
   
   if not os.path.isfile("Testfile.csv"):
      print("SVP exécutez le fichier d'exemple CreateFile.py !")
      quit()
   
   NewData = FormatData.ReadData("TestFile.csv")
   for Entry in NewData:
      print(Entry)
   
   print("\r\nAjout d'un enregistrement pour Antoine.")
   NewRecord = "'Antoine', 23, False"
   NewData.append(NewRecord)
   for Entry in NewData:
      print(Entry)
   
   print("\r\nSuppression de l'enregistrement de Pierre.")
   Location = NewData.index("'Pierre', 52, True")
   Record = NewData[Location]
   NewData.remove(Record)
   for Entry in NewData:
      print(Entry)
   
   print("\r\nModification de l'enregistrement de Sophie.")
   Location = NewData.index("'Sophie', 47, False")
   Record = NewData[Location]
   Split = Record.split(",")
   NewRecord = FormatData(Split[0].replace("'", ""),
                          int(Split[1]),
                          bool(Split[2]))
   NewRecord.Married = True
   NewRecord.Age = 48
   NewData.append(NewRecord.__str__())
   NewData.remove(Record)
   for Entry in NewData:
      print(Entry)
   
   FormatData.SaveData("ChangedFile.csv", NewData)

   Cet exemple est plus long que les précédents. Il commence par s’assurer que le fichier Testfile.csv est bien présent dans le dossier de l’application. C’est un contrôle que vous devriez effectuer systématiquement. Dans ce cas, vous ne créez pas un nouveau fichier. Vous ne faites que modifier un fichier, qui doit donc effectivement exister. Sinon, l’application se termine tout de suite.
   L’étape suivante consiste à lire les données dans NewData. Cette partie du code ressemble à ce qui a été développé dans la section précédente.
   Vous avez déjà étudié du code utilisant des fonctions de liste dans le Chapitre 12. Cet exemple les met en œuvre dans un travail pratique. La fonction append () ajoute un nouvel enregistrement à NewData. Remarquez cependant que les données sont ajoutées sous la forme d’une chaîne, et non d’un objet FormatData. Du fait que, dans cet exemple, les données sont enregistrées sous la forme de chaîne dans le fichier disque, c’est aussi ce que vous obtenez quand vous les lisez. Vous pouvez au choix procéder comme dans ce code, ou bien créer un objet FormatData puis utiliser la méthode __str__() afin de sortir les données sous une forme de chaîne.
   La prochaine étape consiste à supprimer un enregistrement de NewData. Pour cela, vous devez tout d’abord retrouver cet enregistrement. Bien entendu, cela n’est pas bien difficile avec seulement quatre enregistrements (n’oubliez pas qu’Antoine vient d’être ajouté). Dans une situation plus complexe, vous devriez faire appel à la fonction index(). Celle-ci retourne la position de l’enregistrement, valeur que vous pouvez ensuite utiliser pour le retrouver. Lorsque c’est fait, il ne vous reste plus qu’à supprimer l’enregistrement périmé en appelant la fonction remove().
   Modifier l’enregistrement de Sophie semble plus compliqué, mais, là encore, l’essentiel de la question se résume à gérer l’enregistrement des chaînes sur le disque. Lorsque vous obtenez l’enregistrement à partir de NewData, vous récupérez une chaîne formée de trois éléments. La fonction split () produit une liste qui contient ces trois entrées sous la forme de chaînes, ce qui ne convient pas pour cette application. De plus, le nom de Sophie est délimité à la fois par des guillemets et des apostrophes.
   La manière la plus simple de traiter ce problème consiste à créer un objet FormatData et à convertir chacune de ces chaînes dans le format approprié. Cela signifie supprimer les guillemets en trop pour le nom, convertir la seconde valeur en entier (int), et la troisième en un booléen (bool). La classe FormatData ne fournit pas d’accesseurs, et donc l’application doit modifier directement les champs Married et Age. L’emploi d’accesseurs serait évidemment une meilleure technique.
   L’application ajoute ensuite le nouvel enregistrement et supprime l’ancien de NewData. Remarquez l’utilisation de NewRecord.__str()__ pour convertir le nouvel enregistrement de l’objet FormatData en chaîne afin de respecter les conventions CSV.
   L’acte final consiste à sauvegarder l’enregistrement modifié. Normalement, vous devriez conserver le même fichier, puisqu’il s’agit d’une mise à jour de celui-ci. Cependant, le code crée ici un nouveau fichier pour que vous puissiez comparer les deux états, avant et après, ou encore effectuer d’autres tests.
3. Choisissez la commande Run Module dans le menu Run.
   Vous voyez la sortie illustrée sur la Figure 15.5. Remarquez que l’application liste les changements au fur et à mesure des opérations, de manière à ce que vous puissiez vérifier l’état de NewData. Ce genre de technique est utile lors du développement d’une application afin de vérifier pas à pas les étapes d’une procédure. Bien entendu, le code d’affichage doit être retiré avant de finaliser l’application.
4. Ouvrez le fichier ChangedFile.csv en utilisant l’application appropriée.
   Sur la Figure, la sortie est affichée avec WordPad, mais le résultat serait identique avec d’autres programmes. Dans tous les cas, vous devriez retrouver les mêmes données.
   Figure : L’application montre chaque modification au fur et à mesure de son exécution.
   
   Figure : Les informations mises à jour sont enregistrées dans le fichier ChangedFile.csv.