Ajouter une liste de dictionnaires Python dans un fichier sans le charger

Suppose que j'ai besoin d'avoir un fichier de base de données constituée d'une liste de dictionnaires:

fichier:

[
  {"name":"Joe","data":[1,2,3,4,5]},
  {   ...                         },
           ...
]

J'ai besoin d'avoir une fonction qui reçoit une liste de dictionnaires comme indiqué ci-dessus et l'ajoute au fichier. Est-il un moyen de le réaliser, en utilisant json (ou toute autre méthode), sans charger le fichier?

EDIT1:
Remarque: Ce dont j'ai besoin, consiste à ajouter de nouveaux dictionnaires à un fichier déjà existant sur le disque.

Qu'entendez-vous par "sans chargement"?
Eh bien, une façon est de charger le fichier dans la mémoire, ajouter la nouvelle liste et vider le résultat dans le disque. Est-il possible de simplement écrire la nouvelle liste pour le disque, d'ajouter à la fin du fichier, sans charger le fichier de la mémoire?
Cela pourrait être utile: stackoverflow.com/questions/12460943/... Charger le nouveau dict dans un nouveau fichier, puis de fusionner les deux fichiers, peut-être?

InformationsquelleAutor jazzblue | 2013-08-06

22

Vous pouvez utiliser json pour vider les dicts, un par ligne. Maintenant, chaque ligne est un json unique dict que vous avez écrit. Vous perdez la liste externe, mais vous pouvez ajouter des enregistrements avec un simple ajout au fichier existant.
```
import json
import os

def append_record(record):
    with open('my_file', 'a') as f:
        json.dump(record, f)
        f.write(os.linesep)

# demonstrate a program writing multiple records
for i in range(10):
    my_dict = {'number':i}
    append_record(my_dict)
```
La liste peut être monté ultérieurement
```
with open('my_file') as f:
    my_list = [json.loads(line) for line in f]
```
Le fichier ressemble à
```
{"number": 0}
{"number": 1}
{"number": 2}
{"number": 3}
{"number": 4}
{"number": 5}
{"number": 6}
{"number": 7}
{"number": 8}
{"number": 9}
```
- Ici, il semble que vous ne sont pas réellement ajout de dictionnaires pour le fichier existant sur le disque, mais plutôt de la création de tous les dictionnaires dans le code et de les écrire dans un fichier. Ce dont j'ai besoin est de les ajouter à un fichier existant. Je devrais sans doute remarque que dans ma question initiale.
- Non, son ajout dans le fichier comme vous le souhaitez. La boucle for est juste une démo d'un programme qui ajoute des enregistrements dans le fichier plusieurs fois. Exécuter la démo de deux fois et vous obtenez plus de dossiers sur la fin. Je vais modifier pour plus de clarté.
- Une bonne solution si vous ne souhaitez pas utiliser assez json (ce qui rend l'assemblage de la partie plus difficile si vous le souhaitez)
- ouais, d'enregistrer les fichiers ne sont pas censés être joli!!! C'est vraiment une question de ce que vous souhaitez utiliser comme un séparateur d'enregistrement. Si vous n'avez pas assez d'impression, puis json ne pas ajouter de nouvelles lignes et c'est une bonne séparateur (c'est ce que j'ai fait ici). Si vous voulez assez d'impression, vous pouvez choisir quelque chose comme "\n---\n", mais vous auriez à analyser et de faire de l'enregistrement de blocage de vous-même.
InformationsquelleAutor tdelaney
5

Si elle est nécessaire pour maintenir le fichier json valide, il peut être fait comme suit:
```
import json

with open (filepath, mode="r+") as file:
    file.seek(0,2)
    position = file.tell() -1
    file.seek(position)
    file.write( ",{}]".format(json.dumps(dictionary)) )
```
Le fichier s'ouvre pour les deux la lecture et l'écriture. Ensuite, il va à la fin du fichier (en octets zéro à partir de la fin) pour trouver le fichier de la fin de la position (par rapport au début du fichier) et va au dernier octet du dos, qui dans un fichier json est prévu pour représenter le caractère ]. En fin de compte, il ajoute un nouveau dictionnaire de la structure, en remplaçant le dernier caractère du fichier et à le garder pour être json valide. Il ne lit pas le fichier dans la mémoire. Testé avec les deux ANSI et codé en utf-8 fichiers en Python 3.4.3 avec petit et grand (5 GO) fichiers factices.

Une variation, si vous aussi vous avez os module importé:
```
import os, json

with open (filepath, mode="r+") as file:
    file.seek(os.stat(filepath).st_size -1)
    file.write( ",{}]".format(json.dumps(dictionary)) )
```
Il définit la longueur en octets du fichier à aller à la position d'un octet de moins (comme dans l'exemple précédent).

InformationsquelleAutor
1

Si vous êtes à la recherche pour ne pas charge le fichier, allez à ce sujet avec json n'est pas vraiment la bonne approche. Vous pouvez utiliser un fichier mappé en mémoire... et ne jamais charger le fichier en mémoire -- un memmap tableau peut ouvrir le fichier et créer un tableau "sur le disque" sans charger quoi que ce soit dans la mémoire.

Créer un mappage de mémoire tableau des dicts:
```
>>> import numpy as np
>>> a = np.memmap('mydict.dat', dtype=object, mode='w+', shape=(4,))
>>> a[0] = {'name':"Joe", 'data':[1,2,3,4]}
>>> a[1] = {'name':"Guido", 'data':[1,3,3,5]}
>>> a[2] = {'name':"Fernando", 'data':[4,2,6,9]}
>>> a[3] = {'name':"Jill", 'data':[9,1,9,0]}
>>> a.flush()
>>> del a
```
Maintenant lire le tableau, sans charger le fichier:
```
>>> a = np.memmap('mydict.dat', dtype=object, mode='r')
```
Le contenu du fichier est chargé en mémoire lorsque la liste est créée, mais ce n'est pas nécessaire, vous pouvez utiliser le tableau sur le disque sans le charger.
```
>>> a.tolist()
[{'data': [1, 2, 3, 4], 'name': 'Joe'}, {'data': [1, 3, 3, 5], 'name': 'Guido'}, {'data': [4, 2, 6, 9], 'name': 'Fernando'}, {'data': [9, 1, 9, 0], 'name': 'Jill'}]
```
Il faut une quantité négligeable de temps (par exemple nanosecondes) pour créer un mappage de mémoire tableau qui peut un fichier d'index, indépendamment de la taille (ex: 100 GO) du fichier.

InformationsquelleAutor Mike McKerns

En utilisant la même approche que user3500511...

Supposons que nous avons deux listes de dictionnaires (dicts, dicts2). Les dicts sont convertis au format json cordes. Dicts est enregistrée dans un nouveau fichier de test.json. Test.json est rouvert et la chaîne des objets sont mis en forme avec le bon délimiteurs. Avec le reformaté objets, dict2 peut être ajouté et le fichier conserve encore la structure adéquate pour un objet JSON.

import json

dicts = [{ "name": "Stephen", "Number": 1 }
         ,{ "name": "Glinda", "Number": 2 }
         ,{ "name": "Elphaba", "Number": 3 }
         ,{ "name": "Nessa", "Number": 4 }]

dicts2= [{ "name": "Dorothy", "Number": 5 }
         ,{ "name": "Fiyero", "Number": 6 }]


f = open("test.json","w")
f.write(json.dumps(dicts))
f.close()

f2 = open("test.json","r+")
f2.seek(-1,2)
f2.write(json.dumps(dicts2).replace('[',',',1))
f2.close()

f3 = open('test.json','r')
f3.read()

InformationsquelleAutor Cindy Luu

Vous devez vous connecter pour publier un commentaire.