Como mudar um django QueryDict para Python Dict?

Vamos fingir que tenho o seguinte QueryDict:

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

Eu gostaria de ter um dicionário fora disso, por exemplo:

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

(Não me importo se o símbolo Unicode upermanece ou se vai.)

Se o fizer queryDict.dict(), conforme sugerido pelo site django , perco os valores extras pertencentes a var1, por exemplo:

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

Eu estava pensando em fazer isso:

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

Existe uma maneira melhor?

Isso deve funcionar: myDict = dict(queryDict.iterlists())

Novo no Django> = 1.4.

QueryDict.dict()

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

Isso é o que acabei 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()}

Pelo meu uso, isso parece lhe dar uma lista que você pode enviar de volta, por exemplo, um construtor de formulário.

EDIT: talvez este não seja o melhor método. Parece que se você deseja, por exemplo, gravar QueryDictem um arquivo por qualquer motivo maluco, QueryDict.urlencode()é o caminho a seguir. Para reconstruir o que QueryDictvocê simplesmente faz QueryDict(urlencoded_data).

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

Se você não quiser os valores como Arrays, pode fazer o seguinte:

# 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 é uma ferramenta poderosa, leia mais sobre ela aqui http://docs.python.org/2/library/functions.html#zip

Eu tive um problema semelhante, querendo salvar valores arbitrários de um formulário como valores serializados.

Minha resposta evita iterar explicitamente o conteúdo do dicionário: dict(querydict.iterlists())

Para recuperar um valor semelhante a um dicionário que funciona como o original, uma função inversa é usada QueryDict.setlist()para preencher um novo QueryDictvalor. Nesse caso, não acho que a iteração explícita seja evitável.

Minhas funções auxiliares são assim:

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

Atualizar:

myDict = dict(queryDict._iterlists())

Observação: sublinhado _no método iterlists de queryDict. Versão Django: 1.5.1

dict(request.POST) retorna um dicionário python estranho com valores agrupados de matriz.

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

onde como {x:request.POST.get(x) for x in request.POST.keys()}retorna a saída esperada.

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

simplesmente adicione

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

Em sua visualização, os dados serão salvos em querDict como python Dict.

Foi assim que resolvi esse problema:

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

Como eu, você provavelmente está mais familiarizado com os Dict()métodos em python. No entanto, o QueryDict()também é um objeto fácil de usar. Por exemplo, talvez você queira obter o valor de request.GET QueryDict().

Você pode fazer isso da seguinte forma: request.GET.__getitem__(<key>).

QueryDict()documentação: https://docs.djangoproject.com/en/2.0/ref/request-response/#django.http.QueryDict

Com, Django 2.2existem algumas soluções limpas:

1. QueryDict.dict()é mais simples, mas quebrará QueryDictcom listas como valores, por exemplo:

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)

irá produzir

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

2. dict(QueryDict) é melhor porque fará um dicionário correto 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)

irá produzir

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

qual é correto.

Experimentei os dois dict(request.POST)e request.POST.dict()percebi que, se você tiver listvalores, por exemplo, 'var1':['value1', 'value2']aninhados em seu request.POST, o último ( request.POST.dict()) apenas me deu acesso ao último item em uma lista aninhada, enquanto o anterior ( dict(request.POST)) me permitiu acessar todos os itens em uma lista aninhada.

Espero que isso ajude alguém.