web-dev-qa-db-fra.com

Stockage de Python dictionnaires

Je suis habitué à importer des données dans Python à l'aide de fichiers .csv, mais cela pose des problèmes évidents. Des conseils sur des moyens simples de stocker un dictionnaire (ou des ensembles de dictionnaires) dans un fichier json ou pck? Par exemple:

data = {}
data ['key1'] = "keyinfo"
data ['key2'] = "keyinfo2"

Je voudrais savoir à la fois comment enregistrer cela, puis comment le charger.

pythonjsondictionarysavepickle
153
mike

Pickle enregistrer: 

try:
    import cPickle as pickle
except ImportError:  # python 3.x
    import pickle

with open('data.p', 'wb') as fp:
    pickle.dump(data, fp, protocol=pickle.HIGHEST_PROTOCOL)

Voir la documentation du module pickle pour plus d'informations sur l'argument protocol.

Pickle charge: 

with open('data.p', 'rb') as fp:
    data = pickle.load(fp)

JSON enregistrer: 

import json

with open('data.json', 'w') as fp:
    json.dump(data, fp)

Fournissez des arguments supplémentaires tels que sort_keys ou indent pour obtenir un résultat intéressant. L'argument sort_keys trie les clés par ordre alphabétique et indent indente votre structure de données avec indent=N espaces.

json.dump(data, fp, sort_keys=True, indent=4)

JSON charge: 

with open('data.json', 'r') as fp:
    data = json.load(fp)
368
Marty

Exemple minimal, écrivant directement dans un fichier:

import json
json.dump(data, open(filename, 'wb'))
data = json.load(open(filename))

ou ouverture/fermeture en toute sécurité:

import json
with open(filename, 'wb') as outfile:
    json.dump(data, outfile)
with open(filename) as infile:
    data = json.load(infile)

Si vous voulez l'enregistrer dans une chaîne au lieu d'un fichier:

import json
json_str = json.dumps(data)
data = json.loads(json_str)
31
agf

Voir aussi le paquet accéléré ujson. https://pypi.python.org/pypi/ujson

import ujson
with open('data.json', 'wb') as fp:
    ujson.dump(data, fp)
7
Elliott

Si vous êtes après la sérialisation mais que vous n'avez pas besoin des données d'autres programmes, je vous recommande fortement le module shelve. Pensez-y comme un dictionnaire persistant.

myData = shelve.open('/path/to/file')

# check for values.
keyVar in myData

# set values
myData[anotherKey] = someValue

# save the data for future use.
myData.close()
5
g.d.d.c

Pour écrire dans un fichier:

import json
myfile.write(json.dumps(mydict))

Pour lire à partir d'un fichier:

import json
mydict = json.loads(myfile.read())

myfile est l'objet fichier du fichier dans lequel vous avez enregistré le dict.

5
Rafe Kettler

Si vous voulez une alternative à pickle ou json, vous pouvez utiliser klepto.

>>> init = {'y': 2, 'x': 1, 'z': 3}
>>> import klepto
>>> cache = klepto.archives.file_archive('memo', init, serialized=False)
>>> cache        
{'y': 2, 'x': 1, 'z': 3}
>>>
>>> # dump dictionary to the file 'memo.py'
>>> cache.dump() 
>>> 
>>> # import from 'memo.py'
>>> from memo import memo
>>> print memo
{'y': 2, 'x': 1, 'z': 3}

Avec klepto, si vous aviez utilisé serialized=True, le dictionnaire aurait été écrit dans memo.pkl sous la forme d'un dictionnaire décapé au lieu d'un texte en clair.

Vous pouvez obtenir klepto ici: https://github.com/uqfoundation/klepto

dill est probablement un meilleur choix pour le décapage que pickle lui-même, étant donné que dill peut sérialiser presque tout ce qui est en python. klepto peut également utiliser dill.

Vous pouvez obtenir dill ici: https://github.com/uqfoundation/dill

Le mumbo-jumbo supplémentaire sur les premières lignes est dû au fait que klepto peut être configuré pour stocker des dictionnaires dans un fichier, dans un contexte de répertoire ou dans une base de données SQL. L'API est identique pour tout ce que vous choisissez comme archive principale. Il vous donne un dictionnaire "archivable" avec lequel vous pouvez utiliser load et dump pour interagir avec les archives.

3
Mike McKerns

Ceci est un vieux sujet, mais pour être complet, nous devrions inclure ConfigParser et configparser qui font partie de la bibliothèque standard dans Python 2 et 3, respectivement. Ce module lit et écrit dans un fichier config/ini et (au moins dans Python 3) se comporte de nombreuses manières comme un dictionnaire. Cela présente l'avantage supplémentaire de pouvoir stocker plusieurs dictionnaires dans des sections séparées de votre fichier config/ini et de les rappeler. Sucré!

Exemple Python 2.7.x.

import ConfigParser

config = ConfigParser.ConfigParser()

dict1 = {'key1':'keyinfo', 'key2':'keyinfo2'}
dict2 = {'k1':'hot', 'k2':'cross', 'k3':'buns'}
dict3 = {'x':1, 'y':2, 'z':3}

# make each dictionary a separate section in config
config.add_section('dict1')
for key in dict1.keys():
    config.set('dict1', key, dict1[key])

config.add_section('dict2')
for key in dict2.keys():
    config.set('dict2', key, dict2[key])

config.add_section('dict3')
for key in dict3.keys():
    config.set('dict3', key, dict3[key])

# save config to file
f = open('config.ini', 'w')
config.write(f)
f.close()

# read config from file
config2 = ConfigParser.ConfigParser()
config2.read('config.ini')

dictA = {}
for item in config2.items('dict1'):
    dictA[item[0]] = item[1]

dictB = {}
for item in config2.items('dict2'):
    dictB[item[0]] = item[1]

dictC = {}
for item in config2.items('dict3'):
    dictC[item[0]] = item[1]

print(dictA)
print(dictB)
print(dictC)

Exemple Python 3.X.

import configparser

config = configparser.ConfigParser()

dict1 = {'key1':'keyinfo', 'key2':'keyinfo2'}
dict2 = {'k1':'hot', 'k2':'cross', 'k3':'buns'}
dict3 = {'x':1, 'y':2, 'z':3}

# make each dictionary a separate section in config
config['dict1'] = dict1
config['dict2'] = dict2
config['dict3'] = dict3

# save config to file
f = open('config.ini', 'w')
config.write(f)
f.close()

# read config from file
config2 = configparser.ConfigParser()
config2.read('config.ini')

# ConfigParser objects are a lot like dictionaries, but if you really
# want a dictionary you can ask it to convert a section to a dictionary
dictA = dict(config2['dict1'] )
dictB = dict(config2['dict2'] )
dictC = dict(config2['dict3'])

print(dictA)
print(dictB)
print(dictC)

sortie de la console

{'key2': 'keyinfo2', 'key1': 'keyinfo'}
{'k1': 'hot', 'k2': 'cross', 'k3': 'buns'}
{'z': '3', 'y': '2', 'x': '1'}

contenu de config.ini

[dict1]
key2 = keyinfo2
key1 = keyinfo

[dict2]
k1 = hot
k2 = cross
k3 = buns

[dict3]
z = 3
y = 2
x = 1
2
bfris

Si vous enregistrez dans un fichier JSON, le moyen le plus simple et le plus simple de procéder est:

import json
with open("file.json", "wb") as f:
    f.write(json.dumps(dict).encode("utf-8"))
0
Adam Liu