Lire et écrire des listes dans un fichier en Python

Introduction

Les programmeurs Python utilisent intensivement des tableaux, des listes et des dictionnaires comme structures de données sérialisées. Le stockage de ces structures de données nécessite en permanence un fichier ou une base de données pour fonctionner correctement.

Dans cet article, nous verrons comment écrire une liste dans un fichier et comment relire cette liste en mémoire.

À écrire des données dans un fichierEt à lire les données d'un fichier, le langage de programmation Python propose les méthodes standard write() ainsi que read() pour traiter une seule ligne, ainsi que writelines() ainsi que readlines() pour traiter plusieurs lignes. De plus, tant les pickle et par json permettent également de traiter intelligemment les ensembles de données sérialisés.

Le lis() ainsi que écrire () Méthodologie

Pour traiter les caractères (chaînes) la base read() ainsi que write() méthodes fonctionnent parfaitement. Enregistrer une telle liste ligne par ligne dans le fichier listfile.txt peut être fait comme suit :

places = ['Berlin', 'Cape Town', 'Sydney', 'Moscow']

with open('listfile.txt', 'w') as filehandle:
    for listitem in places:
        filehandle.write(f'{listitem}n')

La listitem est prolongé par un saut de ligne "n", d'abord, puis stocké dans le fichier de sortie. Maintenant, nous pouvons voir comment lire la liste entière à partir du fichier listfile.txt retour en mémoire :

places = []


with open('listfile.txt', 'r') as filehandle:
    for line in filehandle:
        
        curr_place = line[:-1]
        
        places.append(curr_place)

Gardez à l'esprit que vous devrez supprimer le saut de ligne à la fin de la chaîne. Dans ce cas, cela nous aide que Python autorise également les opérations de liste sur les chaînes. Cette suppression se fait simplement comme une opération de liste sur la chaîne elle-même, qui conserve tout sauf le dernier élément. Cet élément contient le caractère "n" qui représente le saut de ligne sur les systèmes UNIX/Linux.

Le lignes d'écriture() ainsi que lignes de lecture() Méthodologie

Comme mentionné au début de cet article, Python contient également les deux méthodes - writelines() ainsi que readlines() – pour écrire et lire plusieurs lignes en une seule étape, respectivement. Écrivons la liste entière dans un fichier sur le disque :

places_list = ['Berlin', 'Cape Town', 'Sydney', 'Moscow']

with open('listfile.txt', 'w') as filehandle:
    filehandle.writelines(f"{place for place in places_list}n")

Pour lire la liste complète à partir d'un fichier sur disque, nous devons :

places = []


with open('listfile.txt', 'r') as filehandle:
    filecontents = filehandle.readlines()
    for line in filecontents:
        
        curr_place = line[:-1]
        
        places.append(curr_place)

Le code ci-dessus suit une approche plus traditionnelle empruntée à d'autres langages de programmation. Écrivons-le dans un plus Pythonique façon:

places = []


with open('listfile.txt', 'r') as filehandle:
    places = [current_place.rstrip() for current_place in filehandle.readlines()]

Tout d'abord, le contenu du fichier est lu via readlines(). Deuxièmement, dans un for boucle de chaque ligne, le caractère de saut de ligne est supprimé à l'aide de la rstrip() méthode. Troisièmement, la chaîne est ajoutée à la liste des lieux en tant que nouvel élément de liste.

En comparaison avec la liste précédente, le code est beaucoup plus compact, mais peut être plus difficile à lire pour les programmeurs Python débutants.

Utilisation du module Joblib

Les méthodes initiales expliquées jusqu'à présent stockent la liste de manière à ce que les humains puissent encore la lire - littéralement une liste séquentielle dans un fichier. C'est idéal pour créer des rapports simples ou générer des fichiers d'exportation pour que les utilisateurs puissent les utiliser ultérieurement, tels que des fichiers CSV. Cependant, si votre objectif est simplement de sérialiser une liste dans un fichier, qui peut être chargé ultérieurement, il n'est pas nécessaire de la stocker dans un format lisible par l'homme.

La joblib module fournit le moyen le plus simple de vider un objet Python (il peut s'agir de n'importe quel objet):

import joblib

places = ['Berlin', 'Cape Town', 'Sydney', 'Moscow']

joblib.dump(places, 'places.sav')

places = joblib.load('places.sav')
print(places) 

joblib reste le moyen le plus simple et le plus propre de sérialiser des objets dans un format efficace et de les charger ultérieurement. Vous pouvez utiliser n'importe quel format arbitraire, tel que .sav, .data, etc. Cela n'a pas vraiment d'importance - les deux joblib et des alternatives comme pickle lira les fichiers très bien.

Le cornichon Module

Comme alternative à joblib, on peut utiliser pickle! Son dump() La méthode stocke efficacement la liste sous la forme d'un flux de données binaires. Tout d'abord, le fichier de sortie listfile.data est ouvert pour l'écriture binaire ("wb"). Deuxièmement, la liste est stockée dans le fichier ouvert à l'aide de la dump() méthode:

import pickle

places = ['Berlin', 'Cape Town', 'Sydney', 'Moscow']

with open('listfile.data', 'wb') as filehandle:
    
    pickle.dump(places, filehandle)

À l'étape suivante, nous lisons la liste du fichier comme suit. Tout d'abord, le fichier de sortie listfile.data est ouvert en binaire pour la lecture ("rb"). Deuxièmement, la liste des lieux est chargée à partir du fichier à l'aide de la load() méthode:

import pickle

with open('listfile.data', 'rb') as filehandle:
    
    placesList = pickle.load(filehandle)

Les deux exemples ici illustrent l'utilisation de chaînes. Bien que, pickle fonctionne avec toutes sortes d'objets Python tels que des chaînes, des nombres, des structures auto-définies et toutes les autres structures de données intégrées fournies par Python.

Utilisation du format JSON

Le format de données binaire pickle use est spécifique à Python. Pour améliorer l'interopérabilité entre différents programmes, la notation d'objet JavaScript (JSON) fournit un schéma facile à utiliser et lisible par l'homme, et est ainsi devenu très populaire pour la sérialisation de fichiers et leur partage via des API.

L'exemple suivant montre comment écrire une liste de types de variables mixtes dans un fichier de sortie à l'aide de la propriété json module. Après avoir ouvert le fichier de sortie en écriture, le dump() stocke la liste de base dans le fichier en utilisant la notation JSON :

import json


basic_list = [1, "Cape Town", 4.6]


with open('listfile.txt', 'w') as filehandle:
    json.dump(basic_list, filehandle)

La lecture du contenu du fichier de sortie dans la mémoire est aussi simple que l'écriture des données. La méthode correspondante à dump() est appelé load():

import json


with open('listfile.txt', 'r') as filehandle:
    basic_list = json.load(filehandle)

Conclusion

Les différentes méthodes que nous avons présentées ci-dessus vont de la simple écriture/lecture de données au vidage/chargement de données via des flux binaires utilisant pickle et JSON. Cela simplifie le stockage persistant d'une liste et sa relecture en mémoire.