¿Cómo cambiar un QueryDict de django a Python Dict?

Supongamos que tengo el siguiente QueryDict:

<QueryDict: {u'num': [0], u'var1': [u'value1', u'value2'], u'var2': [u'8']}>

Me gustaría tener un diccionario de esto, por ejemplo:

{'num': [0], 'var1':['value1', 'value2'], 'var2':['8']}

(No me importa si el símbolo Unicode upermanece o desaparece).

Si lo hago queryDict.dict(), como sugiere el sitio de django , pierdo los valores adicionales que pertenecen a var1, por ejemplo:

{'num': [0], 'var1':['value2'], 'var2':['8']}

Estaba pensando en hacer esto:

myDict = {}
for key in queryDict.iterkeys():
    myDict[key] = queryDict.getlist(key)

¿Existe una forma mejor?

Esto debería funcionar: myDict = dict(queryDict.iterlists())

Nuevo en Django> = 1.4.

QueryDict.dict()

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

Esto es lo que terminé usando:

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

Según mi uso, esto parece proporcionarle una lista que puede enviar, por ejemplo, un constructor de formularios.

EDITAR: tal vez este no sea el mejor método. Parece que si quieres, por ejemplo, escribir QueryDicten un archivo por alguna loca razón, QueryDict.urlencode()es el camino a seguir. Para reconstruir el QueryDictsimplemente hazlo QueryDict(urlencoded_data).

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

Si no desea los valores como matrices, puede hacer lo siguiente:

# 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 es una herramienta poderosa. Lea más sobre ella aquí http://docs.python.org/2/library/functions.html#zip

Me encontré con un problema similar, queriendo guardar valores arbitrarios de un formulario como valores serializados.

Mi respuesta evita iterar explícitamente el contenido del diccionario: dict(querydict.iterlists())

Para recuperar un valor similar a un diccionario que funciona como el original, se usa una función inversa QueryDict.setlist()para completar un nuevo QueryDictvalor. En este caso, no creo que la iteración explícita sea evitable.

Mis funciones de ayuda se ven así:

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

Actualizar:

myDict = dict(queryDict._iterlists())

Tenga en cuenta: subrayar _en el método iterlists de queryDict. Versión de Django: 1.5.1

dict(request.POST) devuelve un diccionario de Python extraño con valores envueltos en matriz.

{'start': ['2017-01-14T21:00'], 'stop': ['2017-01-14T22:00'], 'email': ['[email protected]']}

donde como {x:request.POST.get(x) for x in request.POST.keys()}devuelve la salida esperada.

{'start': '2017-01-14T21:00', 'stop': '2017-01-14T22:00', 'email': '[email protected]'}

simplemente agrega

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

En su vista, los datos se guardarán en querDict como python Dict.

Así es como resolví ese problema:

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

Como yo, probablemente esté más familiarizado con los Dict()métodos en Python. Sin embargo, QueryDict()también es un objeto fácil de usar. Por ejemplo, tal vez quisiera obtener el valor de request.GET QueryDict().

Esto se puede hacer de esta manera: request.GET.__getitem__(<key>).

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

Con Django 2.2pocas soluciones limpias:

1. QueryDict.dict()es más simple pero se romperá QueryDictcon listas como valores, por ejemplo:

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)

saldrá

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

2. dict(QueryDict) es mejor porque hará un diccionario correcto de listas:

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)

saldrá

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

cual es correcta.

Probé ambos dict(request.POST)y me request.POST.dict()di cuenta de que si tiene listvalores, por ejemplo, 'var1':['value1', 'value2']anidados en su request.POST, el later ( request.POST.dict()) solo me dio acceso al último elemento en una lista anidada, mientras que el anterior ( dict(request.POST)) me permitió acceder a todos los elementos en una lista anidada.

Espero que esto ayude a alguien.