Erstellen einer JSON-Antwort mit Django und Python

450

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 herausfinden. Aber ich denke, dass ich etwas falsch gemacht habe mit dem 'Echo'.

Schalter
quelle
Sie können auch den Django-nervigen Ansichtsdekorateur verwenden @ajax_request.
Zopieux

Antworten:

916

Normalerweise verwende ich ein Wörterbuch und 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'

Pre-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+ JsonResponsewie in dieser SO-Antwort gezeigt wie folgt :

from django.http import JsonResponse
return JsonResponse({'foo':'bar'})
Tom
quelle
4
Es ist der Mimetyp, nicht die Liste, die ihn in Schwierigkeiten bringen sollte. Während das meiste JSON normalerweise ein Objekt ("Wörterbuch") auf der obersten Ebene ist, ist JSON mit einem Array auf der obersten Ebene vollkommen zufrieden.
Thanatos
6
Entschuldigung, es ist nicht klar, was ich geschrieben habe, aber ich wollte nur, dass ich ein Wörterbuch verwende, weil es sauberer / einfacher ist, wenn ich es in JSON serialisiere.
Tom
'application / json' wird in älteren IE-Versionen nicht ordnungsgemäß unterstützt. Hier ist eine Diskussion des Problems github.com/blueimp/jQuery-File-Upload/issues/123
Victory
161

Neu in Django 1.7

Sie können JsonResponse- Objekte verwenden.

aus den Dokumenten:

from django.http import JsonResponse
return JsonResponse({'foo':'bar'})
srj
quelle
2
Ein Nachteil: Der Standardwert ist " ensure_asciiIch habe noch keinen Weg gefunden, ihn zu überschreiben". Erstellt eine neue Frage für diese: stackoverflow.com/q/34798703/854477
int_ua
@int_ua: einfach hinzufügen json_dumps_params={"ensure_ascii": False}(erfordert Django 1.9 oder neuer)
Martijn Pieters
139

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 wurden JsonResponse- Objekte zum Django-Framework selbst hinzugefügt, was diese Aufgabe noch einfacher macht:

from django.http import JsonResponse
def some_view(request):
    return JsonResponse({"key": "value"})
Dingo
quelle
1
Das Problem ist, dass hier nicht der Wert aus dem Eingabefeld vld_value = request.POST.get ('validateValue') abgerufen wird
Switch
2
Mit Python 2.7 sollte es nur "Import Json" sein
Cullen Fluffy Jennings
1
Ich denke, from django.utils import simplejsonist für die Abwärtskompatibilität.
Skylar Saveland
JsonResponse(status=404, data={'status':'false','message':message})
Belter
25

Seit Django 1.7 haben Sie eine Standard- JsonResponse , die genau das ist, was Sie brauchen:

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

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

Akhorus
quelle
16
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)
Dmitry Demidenko
quelle
15

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

Andres
quelle
11

Sie sollten den Django-Serializer verwenden, um bei Unicode-Dingen zu helfen:

from django.core import serializers

json_serializer = serializers.get_serializer("json")()
    response =  json_serializer.serialize(list, ensure_ascii=False, indent=2, use_natural_keys=True)
    return HttpResponse(response, mimetype="application/json")
ReduxDJ
quelle
2
Dies war meine bevorzugte Version, aber mir wurde klar, dass sie nur Django QuerySets frisst .
Patroqueeet
10

Mit Django Class-basierten Ansichten können Sie 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'})
elim
quelle
6

Es ist sehr praktisch mit Django Version 1.7 oder höher, da Sie die JsonResponse-Klasse haben, die eine Unterklasse von HttpResponse ist.

from django.http import JsonResponse
    def profile(request):
        data = {
            'name': 'Raghav',
            'location': 'India',
            'is_active': False,
            'count': 28
        }
        return JsonResponse(data)

Für ältere Versionen von Django müssen Sie ein HttpResponse-Objekt verwenden.

import json
from django.http import HttpResponse

def profile(request):
    data = {
        'name': 'Raghav',
        'location': 'India',
        'is_active': False,
        'count': 28
    }
    dump = json.dumps(data)
    return HttpResponse(dump, content_type='application/json')
Tanmay D.
quelle
6

Wie verwende ich die Google App Engine mit Ajax (JSON)?

Code Javascript mit JQuery:

$.ajax({
    url: '/ajax',
    dataType : 'json',
    cache: false,
    success: function(data) {
        alert('Load was performed.'+data.ajax_resp);
    }
});

Code Python

class Ajax(webapp2.RequestHandler):
    def get(self):
        my_response = {'ajax_resp':'Hello, webapp World!'}
        datos = json.dumps(my_response)

        self.response.headers.add_header('content-type', 'application/json', charset='utf-8')
        self.response.out.write(datos)
Samiro
quelle
4

Dies ist meine bevorzugte Version mit einer klassenbasierten Ansicht. Unterklassifizieren Sie einfach die Basisansicht und überschreiben Sie die Methode get () -.

import json

class MyJsonView(View):

    def get(self, *args, **kwargs):
        resp = {'my_key': 'my value',}
        return HttpResponse(json.dumps(resp), mimetype="application/json" )
Droidballon
quelle
4

Django-Code views.py:

def view(request):
    if request.method == 'POST':
        print request.body
        data = request.body
        return HttpResponse(json.dumps(data))

HTML-Code view.html:

<!DOCTYPE html>
<html>
<head>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<script>
$(document).ready(function(){
    $("#mySelect").change(function(){
        selected = $("#mySelect option:selected").text()
        $.ajax({
            type: 'POST',
            dataType: 'json',
            contentType: 'application/json; charset=utf-8',
            url: '/view/',
            data: {
                    'fruit': selected
                  },
            success: function(result) {
                        document.write(result)
                    }
    });
  });
});
</script>
</head>
<body>

<form>
    {{data}}
    <br>
Select your favorite fruit:
<select id="mySelect">
  <option value="apple" selected >Select fruit</option>
  <option value="apple">Apple</option>
  <option value="orange">Orange</option>
  <option value="pineapple">Pineapple</option>
  <option value="banana">Banana</option>
</select>
</form>
</body>
</html>
Rajan Mandanka
quelle
4

Importieren Sie zuerst Folgendes:

from django.http import HttpResponse

Wenn Sie den JSON bereits haben:

def your_method(request):
    your_json = [{'key1': value, 'key2': value}]
    return HttpResponse(your_json, 'application/json')

Wenn Sie den JSON von einer anderen HTTP-Anforderung erhalten:

def your_method(request):
    response = request.get('https://www.example.com/get/json')
    return HttpResponse(response, 'application/json')
Sakthivel Karthikeyan
quelle
2

Verwenden Sie JsonResponse

from django.http import JsonResponse
Suraj Verma
quelle
Diese Antwort braucht Kontext und Erklärung.
theUtherSide
1

Verwenden Sie in der Ansicht Folgendes:

form.field.errors|striptags

zum Abrufen von Validierungsnachrichten ohne HTML

Deepak Sharma
quelle