J'écris un programme qui stocke des données dans un objet dictionnaire, mais ces données doivent être sauvegardées à un moment donné au cours de l'exécution du programme et chargées dans l'objet dictionnaire lorsque le programme est exécuté à nouveau. Comment convertir un objet du dictionnaire en une chaîne pouvant être écrite dans un fichier et chargée dans un objet du dictionnaire? J'espère que cela aidera les dictionnaires contenant des dictionnaires.
Le module json est une bonne solution ici. Il présente les avantages par rapport au pickle de ne produire que du texte brut, et est multi-plateforme et multi-version.
import json
json.dumps(dict)
Si votre dictionnaire n'est pas trop volumineux, str + eval peut peut-être faire le travail:
dict1 = {'one':1, 'two':2, 'three': {'three.1': 3.1, 'three.2': 3.2 }}
str1 = str(dict1)
dict2 = eval(str1)
print dict1==dict2
Vous pouvez utiliser ast.literal_eval à la place de eval pour plus de sécurité si la source n'est pas fiable.
J'utilise json
:
import json
# convert to string
input = json.dumps({'id': id })
# load to dict
my_dict = json.loads(input)
Utilisez le module pickle
pour l’enregistrer sur le disque et le charger plus tard.
Pourquoi ne pas utiliser la fonction Python _ 3 intégrée ast de la bibliothèque literal_eval. Il vaut mieux utiliser literal_eval au lieu de eval
import ast
str_of_dict = "{'key1': 'key1value', 'key2': 'key2value'}"
ast.literal_eval(str_of_dict)
donnera la sortie sous forme de dictionnaire
{'key1': 'key1value', 'key2': 'key2value'}
Et si vous demandez de convertir une méthode Dictionnaire en chaîne, pourquoi ne pas utiliser la méthode str () de Python.
Supposons que le dictionnaire est:
my_dict = {'key1': 'key1value', 'key2': 'key2value'}
Et cela se fera comme ça:
str(my_dict)
Va imprimer:
"{'key1': 'key1value', 'key2': 'key2value'}"
C'est aussi facile que vous le souhaitez.
Si en chinois
import codecs
fout = codecs.open("xxx.json", "w", "utf-8")
dict_to_json = json.dumps({'text':"中文"},ensure_ascii=False,indent=2)
fout.write(dict_to_json + '\n')
Je pense que vous devriez envisager d’utiliser le module shelve
qui fournit des objets persistants de type dictionnaire. Il est facile à utiliser à la place d'un "vrai" dictionnaire car il fournit de manière presque transparente à votre programme quelque chose qui peut être utilisé comme un dictionnaire, sans qu'il soit nécessaire de le convertir explicitement en chaîne, puis d'écrire dans un fichier (ou vice-versa). vice versa).
La principale différence est qu'il faut d'abord open()
il avant de l'utiliser pour la première fois, puis close()
il quand vous avez terminé (et éventuellement sync()
ing, en fonction de l'option writeback
utilisée). Tout objet de fichier "étagère" créé peut contenir des dictionnaires standard en tant que valeurs, ce qui leur permet d'être imbriqués logiquement.
Voici un exemple trivial:
import shelve
shelf = shelve.open('mydata') # open for reading and writing, creating if nec
shelf.update({'one':1, 'two':2, 'three': {'three.1': 3.1, 'three.2': 3.2 }})
shelf.close()
shelf = shelve.open('mydata')
print shelf
shelf.close()
Sortie:
{'three': {'three.1': 3.1, 'three.2': 3.2}, 'two': 2, 'one': 1}
Si vous vous souciez de la vitesse, utilisez json (UltraJSON), qui possède la même API que json:
import ujson
ujson.dumps([{"key": "value"}, 81, True])
# '[{"key":"value"},81,true]'
ujson.loads("""[{"key": "value"}, 81, true]""")
# [{u'key': u'value'}, 81, True]
J'utilise yaml pour cela si doit être lisible (ni JSON ni XML ne sont que IMHO), ou si la lecture n'est pas nécessaire, j'utilise pickle.
Écrire
from pickle import dumps, loads
x = dict(a=1, b=2)
y = dict(c = x, z=3)
res = dumps(y)
open('/var/tmp/dump.txt', 'w').write(res)
Relire
from pickle import dumps, loads
rev = loads(open('/var/tmp/dump.txt').read())
print rev
Convertir un dictionnaire en JSON (chaîne)
import json
mydict = { "name" : "Don",
"surname" : "Mandol",
"age" : 43}
result = json.dumps(mydict)
print(result[0:20])
vous obtiendrez:
{"nom": "Don", "sur
Convertir une chaîne en dictionnaire
back_to_mydict = json.loads(result)