J'écris un script en Python qui crachera des données organisées comme une liste de dict:

[{'name': 'first_thing', 'color': 'blue', 'flavour': 'watermelon' },
 {'name': 'second_thing', 'color': 'red' },
 {'name': 'third_thing', 'color': 'blue', 'size': 'huge!' }]

J'essaie de décider d'un moyen de stocker ces données dans un fichier. Mes considérations:

  1. Je voudrais que ce soit aussi facile à lire qu'à écrire, donc je peux charger les données dans un script et les manipuler davantage.
  2. Je voudrais que ce soit un format non spécifique à Python. Peut-être plus tard, je veux utiliser ces données en PHP ou quelque chose comme ça, qui sait?
  3. J'aimerais que ce soit un format auquel il est facile d'ajouter plus de données. Si mon fichier contient une liste de 1000 de mes petits éléments dict, je ne veux pas charger tous les 1000 en mémoire juste pour ajouter un élément à la fin.

Mon premier essai a été d'utiliser Pickle, qui répond aux critères faciles, mais il dépend de Python et je devrais décompresser, ajouter, puis repickle.

D'autres formats auxquels j'ai pensé qui semblent réalisables (avec mes objections):

  • JSON (l'ajout va être ennuyeux, peut-être)
  • Shelve (spécifique à python)
  • CSV (comme du ruban adhésif, pas si classe, mais ça marcherait probablement)
  • Une sorte de base de données légère comme sqlite (peut-être trop sophistiquée ici)

Quelqu'un at-il des arguments pour l'un ou l'autre de ces formats?

3
ben author 19 oct. 2011 à 07:03

4 réponses

Meilleure réponse

Étant donné votre besoin d'ajouter des données ultérieurement, YAML pourrait être le format que vous recherchez. Il est conçu explicitement pour prendre en charge les éléments de données ajoutés sous forme de fichier journal, json est délibérément un sous-ensemble approprié du langage, et il possède un méta-balisage utile conçu pour une sérialisation multilingue efficace des classes personnalisées.

1
Eli Collins 19 oct. 2011 à 04:00

D'après votre exemple d'extrait de données, il semble que vos données correspondent mieux à un format tabulaire que les formats plus complexes. Si les clés de vos pronostics sont connues à l'avance et utilisées dans chaque entrée, je pense que CSV est le bon choix. Python dispose également d'un module csv pour faciliter cela.

0
retracile 19 oct. 2011 à 03:19

Pour la plupart des cas, je pense que JSON devrait être votre meilleur pari.

Utilisez simplejson pour convertir votre liste de dict en JSON, ce sera aussi simple que:

import simplejson as json
my_list = [{'name': 'first_thing', 'color': 'blue', 'flavour': 'watermelon'}, {'name': 'second_thing','color': 'red' }, {'name': 'third_thing', 'color': 'blue', 'size': 'huge!'}]
output = json.dumps(my_list, ident=4)

Le résultat JSON sera:

[
    {
        "color": "blue",
        "flavour": "watermelon",
        "name": "first_thing"
    },
    {
        "color": "red",
        "name": "second_thing"
    },
    {
        "color": "blue",
        "name": "third_thing",
        "size": "huge!"
    }
]

Maintenant, ce JSON est une chaîne JSON parfaitement valide.

Il s'agit d'un tableau JSON. Je ne pense donc pas que vous ayez besoin de faire un hack pour supprimer "[" et "]". Puisque vous passez une liste python à simplejson, vous obtiendrez une liste JSON.

1
zengr 19 oct. 2011 à 04:42

Le cornichon devrait bien fonctionner. Stockez les textes directement (pas dans une liste) pour faciliter l'ajout:

>>> from pickle import dump, load
>>> f = open('stor.bin', 'w')
>>> dump(dict(a=1), f)
>>> dump(dict(b=2), f)
>>> dump(dict(c=3), f)
>>> f.close()

Dans les sessions suivantes, ajoutez un autre dump () directement à la fin du fichier:

>>> f = open('store.bin', 'a')
>>> dump(dict(d=4), f)
>>> f.close()   

Pour lire, exécutez simplement load () à plusieurs reprises jusqu'à ce que vous atteigniez la fin du fichier:

>>> f = open('stor.bin', 'r')
>>> load(f)
{'a': 1}
>>> load(f)
{'b': 2}
>>> load(f)
{'c': 3}
>>> load(f)
{'d': 4}
>>> load(f)

Traceback (most recent call last):
   ...
EOFError
2
Raymond Hettinger 19 oct. 2011 à 05:28
7816113