serialize - Erstellen einer JSON-Antwort mit Django und Python




python json (9)

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

import json

class MyJsonView(View):

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

Ich versuche, ein serverseitiges Ajax-Antwort-Skript 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 benutze Simplejson, um die Python-Liste zu kodieren (so wird es ein JSON-Array zurückgeben). Ich konnte das Problem noch nicht herausfinden. Aber ich denke, dass ich mit dem "Echo" etwas falsch gemacht habe.


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')

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

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

Ich verwende normalerweise 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 so zurückgeben:

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

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

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

Neu in Django 1.7

Sie könnten JsonResponse Objekte verwenden.

aus der Dokumentation:

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

Seit Django 1.7 hast du eine Standard- JsonResponse , die genau das ist, was du brauchst:

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

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


Verwenden Sie in View Folgendes:

form.field.errors|striptags

um Validierungsnachrichten ohne HTML zu erhalten


Wie verwende ich 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)

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 Sicht:

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




json