[Django]-How to change a django QueryDict to Python Dict?

New in Django >= 1.4.

QueryDict.dict()

https://docs.djangoproject.com/en/stable/ref/request-response/#django.http.QueryDict.dict

This is what I’ve ended up using:

def qdict_to_dict(qdict):
    """Convert a Django QueryDict to a Python dict.

    Single-value fields are put in directly, and for multi-value fields, a list
    of all values is stored at the field's key.

    """
    return {k: v[0] if len(v) == 1 else v for k, v in qdict.lists()}

From my usage this seems to get you a list you can send back to e.g. a form constructor.

EDIT: maybe this isn’t the best method. It seems if you want to e.g. write QueryDict to a file for whatever crazy reason, QueryDict.urlencode() is the way to go. To reconstruct the QueryDict you simply do QueryDict(urlencoded_data).

just simply add

queryDict=dict(request.GET)
or queryDict=dict(QueryDict)

In your view and data will be saved in querDict as python Dict.

If you do not want the values as Arrays you can do the following:

# request = <QueryDict: {u'key': [u'123ABC']}>
dict(zip(request.GET.keys(), request.GET.values()))
{u'key': u"123ABC" }

# Only work for single item lists
# request = <QueryDict: {u'key': [u'123ABC',U 'CDEF']}>
dict(zip(request.GET.keys(), request.GET.values()))
{u'key': u"CDEF" } 

zip is a powerful tool read more about it here http://docs.python.org/2/library/functions.html#zip

from django.utils import six 
post_dict = dict(six.iterlists(request.POST))

I ran into a similar problem, wanting to save arbitrary values from a form as serialized values.

My answer avoids explicitly iterating the dictionary contents: dict(querydict.iterlists())

In order to retrieve a dictionary-like value that functions as the original, an inverse function uses QueryDict.setlist() to populate a new QueryDict value. In this case, I don’t think the explicit iteration is avoidable.

My helper functions look like this:

from django.http import QueryDict

def querydict_dict(querydict):
    """
    Converts a Django QueryDict value to a regular dictionary, preserving multiple items.
    """
    return dict(querydict.iterlists())

def dict_querydict(dict_):
    """
    Converts a value created by querydict_dict back into a Django QueryDict value.
    """
    q = QueryDict("", mutable=True)
    for k, v in dict_.iteritems():
        q.setlist(k, v)
    q._mutable = False
    return q

With Django 2.2 there are few clean solutions:

1. QueryDict.dict() is simplest but it will break QueryDict with lists as values, e.g:

from django.http.request import QueryDict, MultiValueDict

query_dict = QueryDict('', mutable=True)
query_dict.update(MultiValueDict({'a': ['one', 'two']}))
query_dict.update({'b': 'three'})

for key, value in query_dict.dict().items():  # ---> query_dict.dict()
    print(key, value)

will output

a two  # <--- missed 'one'
b three

2. dict(QueryDict) is better because it will make correct dictionary of lists:

from django.http.request import QueryDict, MultiValueDict

query_dict = QueryDict('', mutable=True)
query_dict.update(MultiValueDict({'a': ['one', 'two']}))
query_dict.update({'b': 'three'})

for key, value in dict(query_dict).items():  # ---> dict(query_dict)
    print(key, value)

will output

a ['one', 'two']
b ['three']

which is correct.

Update:

myDict = dict(queryDict._iterlists())

Please Note : underscore _ in iterlists method of queryDict. Django version :1.5.1

dict(request.POST) returns a weird python dictionary with array wrapped values.

{'start': ['2017-01-14T21:00'], 'stop': ['2017-01-14T22:00'], 'email': ['sandeep@sakethtech.com']}

where as {x:request.POST.get(x) for x in request.POST.keys()} returns expected output.

{'start': '2017-01-14T21:00', 'stop': '2017-01-14T22:00', 'email': 'sandeep@sakethtech.com'}

This is how I solved that problem:

dict_ = {k: q.getlist(k) if len(q.getlist(k))>1 else v for k, v in q.items()}

I tried out both dict(request.POST) and request.POST.dict() and realised that if you have list values for example 'var1':['value1', 'value2'] nested in your request.POST, the later(request.POST.dict()) only gave me access to the last item in a nested list while the former(dict(request.POST)) allowed me to access all items in a nested list.

I hope this helps someone.

Like me, you probably are more familiar with Dict() methods in python. However, the QueryDict() is also an easy object to use. For example, perhaps you wanted to get the value from the request.GET QueryDict().

You can do this like so: request.GET.__getitem__(<key>).

QueryDict() documentation: https://docs.djangoproject.com/en/2.0/ref/request-response/#django.http.QueryDict

You can use a simple trick just

queryDict._mutable = False
# Change queryDict
your_dict = {'num': [0], 'var1':['value1', 'value2'], 'var2':['8']}
queryDict.upate(your_dict)
# reset the state
queryDict._mutable = True 

I think this will help you better:
This QueryDict instance is immutable

    user_obj = get_object_or_404(NewUser,id=id)
    if request.method == 'POST':
        queryDict = request.POST
        data = dict(queryDict)
        print(data['user_permissions[]'])
        user_obj.user_permissions.clear()
        user_obj.user_permissions.set(data['user_permissions[]'])
        return HttpResponse('Done')