Come cambiare un django QueryDict in Python Dict?

Facciamo finta di avere il seguente QueryDict:

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

Mi piacerebbe avere un dizionario fuori da questo, ad esempio:

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

(Non mi interessa se il simbolo Unicode urimane o scompare.)

Se lo faccio queryDict.dict(), come suggerito dal sito django , perdo i valori extra appartenenti a var1, es:

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

Stavo pensando di fare questo:

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

C'è un modo migliore?

Questo dovrebbe funzionare: myDict = dict(queryDict.iterlists())

Nuovo in Django> = 1.4.0

QueryDict.dict()

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

Questo è quello che ho finito per usare:

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

Dal mio utilizzo questo sembra darti un elenco che puoi inviare ad esempio a un costruttore di form.

EDIT: forse questo non è il metodo migliore. Sembra che se si desidera, ad esempio, scrivere QueryDictsu un file per qualsiasi motivo folle, QueryDict.urlencode()è la strada da percorrere. Per ricostruire il QueryDictfai semplicemente QueryDict(urlencoded_data).

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

Se non vuoi i valori come array puoi fare quanto segue:

# 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 è un potente strumento per saperne di più qui http://docs.python.org/2/library/functions.html#zip

Mi sono imbattuto in un problema simile, volendo salvare valori arbitrari da un modulo come valori serializzati.

La mia risposta evita di iterare esplicitamente il contenuto del dizionario: dict(querydict.iterlists())

Per recuperare un valore simile a un dizionario che funzioni come l'originale, una funzione inversa utilizza QueryDict.setlist()per popolare un nuovo QueryDictvalore. In questo caso, non credo che l'iterazione esplicita sia evitabile.

Le mie funzioni di supporto hanno questo aspetto:

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

Aggiornare:

myDict = dict(queryDict._iterlists())

Nota: il carattere di sottolineatura _nel metodo degli elenchi di queryDict. Versione Django: 1.5.1

dict(request.POST) restituisce uno strano dizionario Python con valori avvolti da array.

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

dove as {x:request.POST.get(x) for x in request.POST.keys()}restituisce l'output atteso.

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

basta semplicemente aggiungere

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

Nella tua visualizzazione i dati verranno salvati in querDict come python Dict.

Ecco come ho risolto il problema:

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

Come me, probabilmente hai più familiarità con i Dict()metodi in Python. Tuttavia, QueryDict()è anche un oggetto facile da usare. Ad esempio, forse volevi ottenere il valore da request.GET QueryDict().

È possibile farlo in questo modo: request.GET.__getitem__(<key>).

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

Con Django 2.2ci sono poche soluzioni pulite:

1. QueryDict.dict()è più semplice ma si romperà QueryDictcon gli elenchi come valori, ad esempio:

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)

verrà prodotto

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

2. dict(QueryDict) è migliore perché renderà il dizionario corretto degli elenchi:

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)

verrà prodotto

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

che è corretto.

Ho provato sia dict(request.POST)e request.POST.dict()e mi sono reso conto che se hai listvalori ad esempio 'var1':['value1', 'value2']nidificati nel tuo request.POST, il later ( request.POST.dict()) mi dava accesso solo all'ultimo elemento in un elenco nidificato mentre il primo ( dict(request.POST)) mi consentiva di accedere a tutti gli elementi in un elenco nidificato.

Spero che questo aiuti qualcuno.