CODEWITHSUNDEEP
pythonjsondictionaryserialization
AJ00200
AJ00200

Reputation: 17297

Convert a python dict to a string and back

I am writing a program that stores data in a dictionary object, but this data needs to be saved at some point during the program execution and loaded back into the dictionary object when the program is run again. How would I convert a dictionary object into a string that can be written to a file and loaded back into a dictionary object? This will hopefully support dictionaries containing dictionaries.

Upvotes: 428

Views: 898985

Answers (12)

ismail
ismail

Reputation: 47672

Use the pickle module to save it to disk and load later on.

Upvotes: 15

Eyal Ch
Eyal Ch

Reputation: 10066

I use json:

import json

# convert to string
input_ = json.dumps({'id': id_ })
    
# load to dict
my_dict = json.loads(input_)

Upvotes: 217

PabloG
PabloG

Reputation: 26745

If your dictionary isn't too big maybe str + eval can do the work:

dict1 = {'one':1, 'two':2, 'three': {'three.1': 3.1, 'three.2': 3.2 }}
str1 = str(dict1)

dict2 = eval(str1)

print(dict1 == dict2)

You can use ast.literal_eval instead of eval for additional security if the source is untrusted.

Upvotes: 269

mathandy
mathandy

Reputation: 2010

You may find the json.dumps() method needs help handling some object types.

Credit goes to the top answer of this post for the following:

import json
json.dumps(my_dictionary, indent=4, sort_keys=True, default=str)

Upvotes: 4

Abdul Muiz Khan
Abdul Muiz Khan

Reputation: 11

I figured out the problem was not with my dict object it was the keys and values that were of RubyString type after loading it with RubyMarshl 'loads' method

So i did this:

dic_items = dict.items()
new_dict = {str(key): str(value) for key, value in dic_items}

Upvotes: 1

beta
beta

Reputation: 57

In Chinese language you should do the following adjustments:

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')

Upvotes: 4

Tyler Eaves
Tyler Eaves

Reputation: 13133

The json module is a good solution here. It has the advantages over pickle that it only produces plain text output, and is cross-platform and cross-version.

import json
json.dumps(dict)

Upvotes: 473

Tomasz Bartkowiak
Tomasz Bartkowiak

Reputation: 15058

If you care about the speed use ujson (UltraJSON), which has the same API as 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]

Upvotes: 3

Hrvoje
Hrvoje

Reputation: 15222

Convert dictionary into JSON (string)

import json 

mydict = { "name" : "Don", 
          "surname" : "Mandol", 
          "age" : 43} 

result = json.dumps(mydict)

print(result[0:20])

will get you:

{"name": "Don", "sur

Convert string into dictionary

back_to_mydict = json.loads(result)

Upvotes: 11

FightWithCode
FightWithCode

Reputation: 2252

Why not to use Python 3's inbuilt ast library's function literal_eval. It is better to use literal_eval instead of eval

import ast
str_of_dict = "{'key1': 'key1value', 'key2': 'key2value'}"
ast.literal_eval(str_of_dict)

will give output as actual Dictionary

{'key1': 'key1value', 'key2': 'key2value'}

And If you are asking to convert a Dictionary to a String then, How about using str() method of Python.

Suppose the dictionary is : 

my_dict = {'key1': 'key1value', 'key2': 'key2value'}

And this will be done like this : 

str(my_dict)

Will Print : 

"{'key1': 'key1value', 'key2': 'key2value'}"

This is the easy as you like.

Upvotes: 32

martineau
martineau

Reputation: 123541

I think you should consider using the shelve module which provides persistent file-backed dictionary-like objects. It's easy to use in place of a "real" dictionary because it almost transparently provides your program with something that can be used just like a dictionary, without the need to explicitly convert it to a string and then write to a file (or vice-versa).

The main difference is needing to initially open() it before first use and then close() it when you're done (and possibly sync()ing it, depending on the writeback option being used). Any "shelf" file objects create can contain regular dictionaries as values, allowing them to be logically nested.

Here's a trivial example:

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()

Output:

{'three': {'three.1': 3.1, 'three.2': 3.2}, 'two': 2, 'one': 1}

Upvotes: 3

Gerard
Gerard

Reputation: 158

I use yaml for that if needs to be readable (neither JSON nor XML are that IMHO), or if reading is not necessary I use pickle.

Write

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)

Read back

from pickle import dumps, loads
rev = loads(open('/var/tmp/dump.txt').read())
print rev

Upvotes: 1

Related Questions