Erstellen einer JSON-Antwort mit Django und Python

Lesezeit: 4 Minuten

Benutzer-Avatar
Schalter

Ich versuche, ein serverseitiges Ajax-Antwortskript in eine Django HttpResponse zu konvertieren, aber anscheinend funktioniert es nicht.

Dies ist das serverseitige Skript:

/* RECEIVE VALUE */
$validateValue=$_POST['validateValue'];
$validateId=$_POST['validateId'];
$validateError=$_POST['validateError'];

/* RETURN VALUE */
$arrayToJs = array();
$arrayToJs[0] = $validateId;
$arrayToJs[1] = $validateError;

if($validateValue =="Testuser"){  // Validate??
    $arrayToJs[2] = "true";       // RETURN TRUE
    echo '{"jsonValidateReturn":'.json_encode($arrayToJs).'}';  // RETURN ARRAY WITH success
}
else{
    for($x=0;$x<1000000;$x++){
        if($x == 990000){
            $arrayToJs[2] = "false";
            echo '{"jsonValidateReturn":'.json_encode($arrayToJs).'}';   // RETURNS ARRAY WITH ERROR.
        }
    }
}

Und das ist der konvertierte Code

def validate_user(request):
    if request.method == 'POST':
        vld_value = request.POST.get('validateValue')
        vld_id = request.POST.get('validateId')
        vld_error = request.POST.get('validateError')

        array_to_js = [vld_id, vld_error, False]

        if vld_value == "TestUser":
            array_to_js[2] = True
            x = simplejson.dumps(array_to_js)
            return HttpResponse(x)
        else:
            array_to_js[2] = False
            x = simplejson.dumps(array_to_js)
            error="Error"
            return render_to_response('index.html',{'error':error},context_instance=RequestContext(request))
    return render_to_response('index.html',context_instance=RequestContext(request))

Ich verwende simplejson, um die Python-Liste zu codieren (damit ein JSON-Array zurückgegeben wird). Ich konnte das Problem noch nicht erkennen. Aber ich denke, dass ich mit dem „Echo“ etwas falsch gemacht habe.

  • Sie können auch den Django-lästigen View Decorator verwenden @ajax_request.

    – Zopieux

    13. April 2014 um 23:22 Uhr

Benutzer-Avatar
Tom

Normalerweise verwende ich ein Wörterbuch, keine Liste, um JSON-Inhalte zurückzugeben.

import json

from django.http import HttpResponse

response_data = {}
response_data['result'] = 'error'
response_data['message'] = 'Some error message'

Vor Django 1.7 würden Sie es wie folgt zurückgeben:

return HttpResponse(json.dumps(response_data), content_type="application/json")

Verwenden Sie für Django 1.7+ JsonResponse wie in dieser SO-Antwort wie folgt gezeigt:

from django.http import JsonResponse
return JsonResponse({'foo':'bar'})

  • Es ist der Mimetyp, nicht die Liste, die ihn in Schwierigkeiten bringen sollte. Während die meisten JSON-Dateien normalerweise ein Objekt (“Wörterbuch”) auf der obersten Ebene sind, ist JSON mit einem Array auf der obersten Ebene vollkommen zufrieden.

    – Thanatos

    20. Juni 2012 um 21:39 Uhr


  • Entschuldigung, es ist aus dem, was ich geschrieben habe, nicht klar, aber ich meinte nur, dass ich ein Wörterbuch verwende, weil es sauberer/einfacher ist, wenn es in JSON serialisiert wird.

    – Tom

    21. Juni 2012 um 15:17 Uhr

  • „application/json“ wird in älteren Versionen von IE nicht richtig unterstützt. Hier ist eine Diskussion zu diesem Thema github.com/blueimp/jQuery-File-Upload/issues/123

    – Sieg

    25. April 2014 um 22:05 Uhr

Neu in Django 1.7

Du könntest benutzen JsonResponse Objekte.

aus den dokumenten:

from django.http import JsonResponse
return JsonResponse({'foo':'bar'})

  • Ein Nachteil: Es ist standardmäßig auf ensure_ascii und ich habe noch keine Möglichkeit gefunden, es zu überschreiben. Dazu eine neue Frage erstellt: stackoverflow.com/q/34798703/854477

    – int_ua

    14. Januar 2016 um 20:07 Uhr

  • @int_ua: einfach hinzufügen json_dumps_params={"ensure_ascii": False} (erfordert Django 1.9 oder neuer)

    – Martijn Pieters

    9. November 2019 um 16:18 Uhr


Benutzer-Avatar
Dingo

Ich benutze das, es funktioniert gut.

from django.utils import simplejson
from django.http import HttpResponse

def some_view(request):
    to_json = {
        "key1": "value1",
        "key2": "value2"
    }
    return HttpResponse(simplejson.dumps(to_json), mimetype="application/json")

Alternative:

from django.utils import simplejson

class JsonResponse(HttpResponse):
    """
        JSON response
    """
    def __init__(self, content, mimetype="application/json", status=None, content_type=None):
        super(JsonResponse, self).__init__(
            content=simplejson.dumps(content),
            mimetype=mimetype,
            status=status,
            content_type=content_type,
        )

In Django 1.7 JsonResponse Dem Django-Framework selbst wurden Objekte hinzugefügt, was diese Aufgabe noch einfacher macht:

from django.http import JsonResponse
def some_view(request):
    return JsonResponse({"key": "value"})

  • Das Problem ist hier, dass es den Wert nicht aus dem Eingabefeld erhält vld_value = request.POST.get(‘validateValue’)

    – Schalter

    11. März 2010 um 20:11 Uhr

  • Mit Python 2.7 sollte es nur “json importieren” sein.

    – Cullen Fluffy Jennings

    6. September 2012 um 22:22 Uhr

  • Ich finde from django.utils import simplejson dient der Abwärtskompatibilität.

    – Skylar Saveland

    10. Februar 2013 um 5:29 Uhr

  • JsonResponse(status=404, data={'status':'false','message':message})

    – Belter

    8. September 2017 um 14:28 Uhr

Seit Django 1.7 haben Sie einen Standard JsonResponse genau das brauchst du:

from django.http import JsonResponse
...
return JsonResponse(array_to_js, safe=False)

Sie müssen Ihr Array nicht einmal json.dumpen.

Benutzer-Avatar
elimin

Mit auf Django-Klassen basierenden Ansichten können Sie Folgendes schreiben:

from django.views import View
from django.http import JsonResponse

class JsonView(View):
    def get(self, request):
        return JsonResponse({'some': 'data'})

und mit Django-Rest-Framework können Sie schreiben:

from rest_framework.views import APIView
from rest_framework.response import Response

class JsonView(APIView):
    def get(self, request):
        return Response({'some': 'data'})

Benutzer-Avatar
Andreas

Für diejenigen, die Django 1.7+ verwenden

from django.http import JsonResponse

def your_view(request):
    json_object = {'key': "value"}
    return JsonResponse(json_object)

offizielle Dokumente

from django.http import HttpResponse
import json

class JsonResponse(HttpResponse):
    def __init__(self, content={}, mimetype=None, status=None,
             content_type="application/json"):
        super(JsonResponse, self).__init__(json.dumps(content), mimetype=mimetype,
                                           status=status, content_type=content_type)

Und in der Ansicht:

resp_data = {'my_key': 'my value',}
return JsonResponse(resp_data)

1119940cookie-checkErstellen einer JSON-Antwort mit Django und Python

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy