cours python ENREGISTRER /CHARGER LES DONNÉES SUR LE DISQUE

C’est le cours python numéro 20 de la série des cours d’initiation à python.

LE fichier TYPE DE DONNÉES

Une opération courante effectuée par de nombreux programmes que nous utilisons sur l’ordinateur consiste à enregistrer et à charger des données à partir du disque dur. Ces fonctionnalités sont supportées par tous les langages de programmation, qui implémentent généralement un système de fichiers, c’est-à-dire un ensemble d’instructions adaptées à cet effet.

En Python, il existe un type de données spécifique, le type de fichier : une fois qu’une variable de ce type a été créée, nous pouvons l’utiliser pour nos opérations.

LA FONCTION open ()

Pour créer un objet de type fichier vous avez besoin de la fonction open() : elle doit être appelée avec deux arguments : le premier est une chaîne qui contient le nom du fichier que nous voulons ouvrir, le second (optionnel) indique les opérations que nous voulons effectuer sur le fichier . Essayons avec IDLE :

>>> f = open ("myfile.tmp", "w")

Si vous exécutez cette ligne de code puis allez explorer le répertoire où Python est installé (sous Windows ce devrait être C:\Python34 ou C:\Program Files\Python34) vous devriez trouver le fichier myfile.tmp créé par Python.

La signification de la deuxième chaîne est la suivante :

value	Signification
“w”	write	Ouvre un fichier en écriture : si le fichier portant le nom indiqué n’est pas présent sur le disque, il en crée un, sinon il supprime le contenu du fichier et l’écrase avec les données que nous écrirons
“r”	read	Ouvre un fichier en lecture. Le fichier avec le nom donné doit déjà exister sur le disque, sinon vous obtiendrez une FileNotFoundError
“a”	append	Ouvre un fichier pour ajouter des données : si le fichier avec le nom indiqué n’est pas présent sur le disque il en crée un, sinon il écrira les nouvelles données à la fin du fichier, sans supprimer les anciennes
“r+”	read – write	Ouvre un fichier sur lequel nous pouvons à la fois écrire et lire. Encore une fois, le fichier doit déjà exister, sinon vous obtenez une erreur

le deuxième argument est facultatif et sa valeur par défaut est “r” (ainsi nous ne supprimons pas accidentellement un fichier si nous l’oublions !).

Malheureusement, la discussion ne s’arrête pas là, car aux valeurs indiquées on peut ajouter un “b” à la fin (“rb”, “wb”, “ab”, “r + b”) où b signifie binaire. La signification de ce b est plutôt obscure et due au fait que Windows, Linux et Mac écrivent et lisent des chaînes avec des formats différents. En pratique, nous n’aurons pas à mettre le b si nous avons l’intention d’écrire et de lire uniquement des chaînes (mode texte), alors que nous devrons le mettre si nous avons l’intention d’écrire et de lire des données d’un autre type (mode binaire). Même ainsi, il est cependant probable qu’une chaîne écrite par un ordinateur Windows ne soit pas lisible par un Mac. Si tout cela vous semble trop compliqué, sachez qu’heureusement, Python a trouvé un moyen de contourner le problème, ce que nous expliquerons à la fin, et cela pour que vous ne puissiez pas vous inquiéter pour l’instant si vous ne comprenez pas. Dans tous les cas, dans le paragraphe suivant, nous montrerons quelques opérations simples d’écriture et de lecture de chaînes, puis nous ouvrirons les fichiers en mode texte.

LIRE ET ÉCRIRE DES CHAÎNES

Une fois le fichier ouvert, notre programme verra l’objet fichier comme un flux (flux de caractères), c’est-à-dire une sorte de grande chaîne dans laquelle lire ou écrire des caractères en séquence. Au sein de ce flux les différentes chaînes sont délimitées par le caractère de retour chariot “\n” et peuvent être lues et écrites à l’aide des fonctions suivantes, qui utilisent toutes la syntaxe avec un point (dans le tableau suivant f est un objet de type file, qui nous supposons déjà créé avec open ()).

fonction	Signification
f.read()	renvoie tout le contenu du fichier sous la forme d’une seule chaîne. Si le fichier était composé de plusieurs chaînes, elles seront séparées par le caractère de retour chariot “\ n”
f.read(n)	comme le précédent, mais lit au plus n caractères (si le fichier est plus long il s’arrête)
f.readline()	lire et renvoyer la chaîne suivante du fichier (c’est-à-dire lire le fichier uniquement jusqu’au caractère “\ n” suivant). Si nous avons atteint la fin du fichier, il renvoie la chaîne nulle.
f.readline(n)	lit et renvoie la chaîne suivante, jusqu’à un maximum de n caractères
f.write(str)	écrire une chaîne dans le fichier. Si on veut terminer la chaîne il faut ajouter le caractère “\n” à la fin, sinon la prochaine écriture sera la suite de cette chaîne. Renvoie le nombre de caractères écrits.
f.close()	ferme le fichier. Il est toujours bon de fermer les fichiers dès que nous avons fini de lire ou d’écrire, car ils nécessitent des ressources du système d’exploitation (dans tous les cas, tous les fichiers sont fermés automatiquement à la fermeture du programme). Après avoir fermé un objet fichier, nous ne pouvons plus l’utiliser pour lire ou écrire (nous aurions une erreur).

Essayons maintenant de faire quelques exemples dans IDLE : rappelez-vous que nos exemples laisseront alors notre fichier de test dans le répertoire IDLE en tant que “garbage”, donc recherchez-le éventuellement et supprimez-le.

Nous créons d’abord un fichier et y écrivons quelque chose (nous notons que lorsque nous utilisons le write () IDLE, il répond comme d’habitude en écrivant la valeur renvoyée, c’est-à-dire le nombre de caractères écrits dans le fichier):

>>> f = open ("myfile.tmp", "w") # file open for writing
>>> f.write ("I love mom so much \ n") # carriage return at the end of the string
26
>>> f.write ("But really a lot!") # without carriage return
20
>>> f.write ("So much! \ n")
13
>>> f.close ()
>>> f.write ("I can't write anymore!")
Traceback (most recent call last):
   File "<pyshell # 9>", line 1, in <module>
     f.write ("I can't write anymore!")
ValueError: I / O operation on closed file.

Finalement, j’ai volontairement fait une erreur en essayant d’écrire après la fermeture. Maintenant rouvrons notre dossier pour la lecture et relisons ce que nous vous avons écrit :

>>> f = open ("myfile.tmp", "r")
>>> f.read ()
'I love Mom so much \ NBut so much! So much! \ N '

Nous remarquons que les deuxième et troisième write() n’ont en fait écrit qu’une seule chaîne ‘Mais vraiment beaucoup ! Tant pis !\N’, car dans le premier des deux nous n’avions pas ajouté le retour chariot. Si nous essayons maintenant de lire à nouveau à partir du fichier, nous obtiendrons des chaînes vides, car nous avons atteint la fin du fichier (anglais : EOF, fin de fichier). Si nous voulons lire les chaînes une par une, nous devons fermer et rouvrir :

readline () # I've already read everything, can't read anymore
''
>>> f.close () # close and reopen
>>> f = open ("myfile.tmp", "r")
>>> f.readline ()
'I love mom so much \ N'
>>> f.readline ()
'But really a lot! So much! \ N '

Maintenant une question se pose : que dois-je faire si je voulais enregistrer des nombres (entiers ou flottants) ? Une méthode simple consiste à les convertir en chaînes avec la fonction str(). Voyons un exemple :

576 / 5 000
Résultats de traduction
>>> f.close ()
>>> f = open ("myfile.tmp", "a") # open the file to add data at the end
>>> f.write (str (10) + "\ n") # write the number 10 as a string
3
>>> f.close () # close the file ...
>>> f = open ("myfile.tmp", "r") # ... and we reopen it to read
>>> f.readline () # the two lines already written ...
'I love mom so much \ N'
>>> f.readline ()
'But really a lot! So much! \ N '
>>> n = int (f.readline ()) # ,,, and our number (converted from string to integer)
>>> n
10 

Cependant, cette méthode est assez lourde : si nous devions sauvegarder un objet assez complexe comme une liste (ou une liste de listes) nous aurions besoin de beaucoup d’instructions de conversion. De plus, le fait mentionné précédemment demeure que, par exemple, un ordinateur Mac peut ne pas lire les chaînes écrites par un ordinateur Windows.

LE MODULE pickle

Pour résoudre ces problèmes, les programmeurs Python ont décidé de prendre une voie assez radicale, c’est-à-dire de sauvegarder les données sur disque dans un format spécifique à Python. Les fonctions de lecture et d’écriture dans ce format sont contenues dans le module pickle. Les plus utilisés sont les suivants :

Une fonction	Signification
dump (obj, file)	écrit la variable obj dans le fichier file, qui doit avoir été ouvert en mode binaire. obj peut être une variable de n’importe quel type (chaîne, nombre, liste …)
load(file)	renvoie un objet lu depuis le fichier fichier (également ouvert en mode binaire)

Ces deux fonctions nous facilitent grandement la vie. N’oubliez pas d’ouvrir les fichiers en mode binaire (“wb”, “rb”, “ab”, “r + b”), après quoi nous pouvons enregistrer ou charger n’importe quoi avec une seule instruction. Notez également que, contrairement aux précédents, ils n’utilisent pas la syntaxe à points et doivent être appelés en mettant le nom du fichier entre les arguments.

Voyons une application : revenons à notre ancien jeu guess_numerp.py et modifions-le pour qu’il se souvienne de l’enregistrement et du nom de celui qui l’a établi :

from random import *
from pickle import *

seed ()

try:
    f = open ("records.dat", "rb") # open the file "records.dat"
    record = load (f) # load the record
    name = load (f) # load player name
    f.close ()
except FileNotFoundError:
    record = 1000000000 # if file does not exist initialize as before
    name = ""
resp = "s" # from here the program continues as before
while resp == "s":
    num = randrange (1, 21)
    attempts = 0
    print ("I thought of a number from 1 to 20. Try to guess it!")
    my_num = -1
    while my_num! = num:
        attempts + = 1
        my_num = int (input ("???"))
        if my_num <num:
            print ("Too low")
        elif my_num> num:
            print ("Too high")
    print ("You guessed it! It took", attempts, "attempts")
    if attempts <record:
        print ("You broke the record!")
        record = attempts
        name = input ("Enter your name:")
                                        # also asks for the player's name
    resp = input ("Do you want to play again (y / n)?")
                                        # exit the program
f = open ("records.dat", "wb") # reopen the file for writing ...
dump (record, f) # ... save record ...
dump (name, f) # ... and the name
f.close ()

Arrêtons-nous un instant sur les premières lignes : notez que l’instruction open() est insérée dans un try : c’est une astuce courante pour gérer la possibilité que le fichier n’existe pas (par exemple la première fois que le programme est lancé). Si le fichier n’existe pas, sauf sera exécuté et nous initialiserons nos variables d’enregistrement et de nom comme nous l’avons fait auparavant, sinon nous les chargerons à partir du fichier. À la fin du programme, nous rouvrons le même fichier en écriture et sauvegardons à nouveau les deux variables, afin qu’elles soient disponibles au prochain lancement du programme.