Wie ändere ich ein Django QueryDict in Python Dict?

Stellen wir uns vor, ich hätte das folgende QueryDict:

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

Ich hätte gerne ein Wörterbuch daraus, zB:

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

(Es ist mir egal, ob das Unicode-Symbol ubleibt oder geht.)

Wenn ich dies tue queryDict.dict(), wie von der Django-Site vorgeschlagen , verliere ich die zusätzlichen Werte, die dazu gehören var1, z.

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

Ich dachte darüber nach:

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

Gibt es einen besseren Weg?

Das sollte funktionieren: myDict = dict(queryDict.iterlists())

Neu in Django> = 1.4.

QueryDict.dict()

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

Folgendes habe ich letztendlich verwendet:

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

Aus meiner Verwendung scheint dies eine Liste zu erhalten, die Sie beispielsweise an einen Formularkonstruktor zurücksenden können.

EDIT: Vielleicht ist dies nicht die beste Methode. Es scheint, wenn Sie zB QueryDictaus irgendeinem verrückten Grund in eine Datei schreiben möchten , QueryDict.urlencode()ist dies der richtige Weg. Um das zu rekonstruieren, QueryDictmachst du es einfach QueryDict(urlencoded_data).

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

Wenn Sie die Werte nicht als Arrays verwenden möchten, können Sie Folgendes tun:

# 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 ist ein leistungsstarkes Tool. Weitere Informationen finden Sie hier http://docs.python.org/2/library/functions.html#zip

Ich stieß auf ein ähnliches Problem und wollte beliebige Werte aus einem Formular als serialisierte Werte speichern.

Meine Antwort vermeidet es, den Wörterbuchinhalt explizit zu wiederholen: dict(querydict.iterlists())

Um einen wörterbuchähnlichen Wert abzurufen, der als Original fungiert, wird mit einer Umkehrfunktion QueryDict.setlist()ein neuer QueryDictWert aufgefüllt. In diesem Fall halte ich die explizite Iteration nicht für vermeidbar.

Meine Hilfsfunktionen sehen folgendermaßen aus:

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

Aktualisieren:

myDict = dict(queryDict._iterlists())

Bitte beachten Sie: Unterstreichen Sie _in der Iterlists-Methode von queryDict. Django-Version: 1.5.1

dict(request.POST) Gibt ein seltsames Python-Wörterbuch mit Array-umschlossenen Werten zurück.

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

Dabei wird die {x:request.POST.get(x) for x in request.POST.keys()}erwartete Ausgabe zurückgegeben.

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

einfach hinzufügen

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

Aus Ihrer Sicht werden Daten in querDict als Python Dict gespeichert.

So habe ich dieses Problem gelöst:

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

Wie ich sind Sie wahrscheinlich besser mit Dict()Methoden in Python vertraut . Das QueryDict()Objekt ist jedoch auch einfach zu bedienen. Zum Beispiel wollten Sie vielleicht den Wert von der erhaltenrequest.GET QueryDict() .

Sie können dies folgendermaßen tun : request.GET.__getitem__(<key>).

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

Mit Django 2.2gibt es nur wenige saubere Lösungen:

1. QueryDict.dict()ist am einfachsten, aber es wird QueryDictmit Listen als Werte gebrochen , zB:

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)

wird ausgegeben

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

2. dict(QueryDict) ist besser, weil es das richtige Wörterbuch der Listen macht:

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)

wird ausgegeben

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

welches ist richtig.

Ich habe versucht , aus beide dict(request.POST)und request.POST.dict()und erkennen , dass , wenn Sie listWerte zum Beispiel 'var1':['value1', 'value2']in Ihrem verschachtelt request.POST, die später ( request.POST.dict()) nur gab ich in einer verschachtelten Liste zum letzten Elemente zugreifen , während der ehemaligen (dict(request.POST) ) mich erlaubt , alle Elemente in einer verschachtelten Liste zuzugreifen.

Ich hoffe das hilft jemandem.