How to convert an OrderedDict into a regular dict in python3

Question

I am struggling with the following problem: I want to convert an OrderedDict like this:

OrderedDict([('method', 'constant'), ('data', '1.225')])

into a regular dict like this:

{'method': 'constant', 'data':1.225}

because I have to store it as string in a database. After the conversion the order is not important anymore, so I can spare the ordered feature anyway.

Thanks for any hint or solutions,

Ben

`repr(dict(OrderedDict([('method', 'constant'), ('data', '1.225')])))`? — iruvar, Nov 23 '13 at 19:22

score 126 · Accepted Answer · answered Nov 23 '13 at 19:33

126

>>> from collections import OrderedDict
>>> OrderedDict([('method', 'constant'), ('data', '1.225')])
OrderedDict([('method', 'constant'), ('data', '1.225')])
>>> dict(OrderedDict([('method', 'constant'), ('data', '1.225')]))
{'data': '1.225', 'method': 'constant'}
>>>

However, to store it in a database it'd be much better to convert it to a format such as JSON or Pickle. With Pickle you even preserve the order!

answered Nov 23 '13 at 19:33

ThiefMaster

298,938
77
579
623

6

you can [preserve order with `json` too](http://stackoverflow.com/q/6921699/4279). – jfs Nov 23 '13 at 19:59
Thanks, and also for the advice using pickle. I would use pickle and I actually do it in other places, but some constraints demand using a dict converted to string. – Ben A. Nov 23 '13 at 20:00
Would converting ordereddict to dict loose order? – RamPrasadBismil Feb 06 '16 at 04:06
2

Yes it does lose order. – nael Jun 01 '16 at 21:21
json.loads also in python < 3.0 does not preserve the order. – nael Jun 01 '16 at 22:55
1

Please note that thos does not work for nested OrderedDictionary data, @thiruvenkadam should be the accepted answer. – Micheal J. Roberts Feb 24 '20 at 13:17
@WindUpLordVexxos I disagree, the OP's data wasn't nested, so this answers his question. And going through JSON for this purpose isn't very efficient... – ThiefMaster Feb 24 '20 at 13:20
@ThiefMaster Your method works. But for the OPs data. I'd argue that the structure outlined in his question could have been a dummy example, and that we can't assume that anyone reading this question would have his exact same structure. When answering these questions, we must assume a generalistic stance agnostic of the OPs specifics. – Micheal J. Roberts Feb 24 '20 at 13:23

score 94 · Answer 2 · edited Aug 30 '17 at 16:31

94

Even though this is a year old question, I would like to say that using dict will not help if you have an ordered dict within the ordered dict. The simplest way that could convert those recursive ordered dict will be

import json
from collections import OrderedDict
input_dict = OrderedDict([('method', 'constant'), ('recursive', OrderedDict([('m', 'c')]))])
output_dict = json.loads(json.dumps(input_dict))
print output_dict

edited Aug 30 '17 at 16:31

John Kugelman

330,190
66
504
555

answered Dec 09 '14 at 06:50

thiruvenkadam

3,923
2
25
26

8

Nice move for a script etc., i.e. _I don't care about performance for this one-off task, just gimme dicts so I can pretty print them_ – m_floer Apr 10 '16 at 17:10

score 8 · Answer 3 · answered Nov 23 '13 at 19:54

It is easy to convert your OrderedDict to a regular Dict like this:

dict(OrderedDict([('method', 'constant'), ('data', '1.225')]))

If you have to store it as a string in your database, using JSON is the way to go. That is also quite simple, and you don't even have to worry about converting to a regular dict:

import json
d = OrderedDict([('method', 'constant'), ('data', '1.225')])
dString = json.dumps(d)

Or dump the data directly to a file:

with open('outFile.txt','w') as o:
    json.dump(d, o)

score 6 · Answer 4 · answered Jan 25 '17 at 23:53

6

If you are looking for a recursive version without using the json module:

def ordereddict_to_dict(value):
    for k, v in value.items():
        if isinstance(v, dict):
            value[k] = ordereddict_to_dict(v)
    return dict(value)

answered Jan 25 '17 at 23:53

spg

8,451
4
33
39

1

Doesn't handle lists in data. – Rafe Aug 24 '17 at 16:47

radtek · Answer 5 · 2020-08-07T16:50:35.773

Here is what seems simplest and works in python 3.7

from collections import OrderedDict

d = OrderedDict([('method', 'constant'), ('data', '1.225')])
d2 = dict(d)  # Now a normal dict

Now to check this:

>>> type(d2)
<class 'dict'>
>>> isinstance(d2, OrderedDict)
False
>>> isinstance(d2, dict)
True

NOTE: This also works, and gives same result -

>>> {**d}
{'method': 'constant', 'data': '1.225'}
>>> {**d} == d2
True

As well as this -

>>> dict(d)
{'method': 'constant', 'data': '1.225'}
>>> dict(d) == {**d}
True

Cheers

score 1 · Answer 6 · edited May 20 '21 at 15:41

1

You can use "dict_constructor" parameters.

xmltodict.parse(text, attr_prefix='',dict_constructor=dict)

edited May 20 '21 at 15:41

greybeard

2,102
7
24
58

answered May 20 '21 at 14:09

CoInz

11
1

How do *XML* and *parse* enter the picture? – greybeard May 20 '21 at 15:43

score -2 · Answer 7 · answered May 26 '17 at 09:31

-2

Its simple way

>>import json 
>>from collection import OrderedDict

>>json.dumps(dict(OrderedDict([('method', 'constant'), ('data', '1.225')])))

answered May 26 '17 at 09:31

Ramesh K

212
4
13

score -2 · Answer 8 · edited Mar 03 '21 at 18:55

A version that handles nested dictionaries and iterables but does not use the json module. Nested dictionaries become dict, nested iterables become list, everything else is returned unchanged (including dictionary keys and strings/bytes/bytearrays).

def recursive_to_dict(obj):
    try:
        if hasattr(obj, "split"):    # is string-like
            return obj
        elif hasattr(obj, "items"):  # is dict-like
            return {k: recursive_to_dict(v) for k, v in obj.items()}
        else:                        # is iterable
            return [recursive_to_dict(e) for e in obj]
    except TypeError:                # return everything else
        return obj

How to convert an OrderedDict into a regular dict in python3

8 Answers8

Linked

Related