用python怎么实现json和xml的互转

Posted 2023-05-01

ajax是属于template里面的一个异步请求而已，如果你在views里面传回来是你说的“实体对像（models）”的话，我就有点搞不明白了。。。

不知道你在那个view方法直接return的是什么？
如果使用json处理对象的话请使用：
from django.http import HttpResponse
from models import mymodels

import simplejson

...
def ajax(request):
a = mymodels.objects.all()[0]
'''
此处假设a中有name、age参数
model对象是不能直接作为json可以处理,必须先转换为dict类型
'''
result =
result['name'] = a.name
result['age'] = a.age
result = simplejson.dumps(result)
return HttpResponse(result)

此时用ajax访问这个试图返回的内容就是：

上面这种办法不是很好，建议先写一个template模板专门来显示此model内容。

假设模板ajax.html的内容为：
===================ajax.html===============
name: <br />
age:
=======================================

views视图如下:

from django.http import HttpResponse
from models import mymodels
from django.shortcuts import render_to_response

...
def ajax(request):
a = mymodels.objects.all()[0]
return render_to_response("ajax.html",)

此时用ajax访问这个视图返回的内容就是:

name: Jim Green
age: 14

以上的代码可能会有错误，因为是随手写的，希望能够帮到你

＝＝＝＝修改了一下＝＝＝＝
模板文件名打错了。。。
修改了一下就到了楼上的下面了，楼上你也太没水准了。直接复制

=====修改＝＝＝＝＝

使用model.__dict__属性可以获得字典，希望能帮到你
你的串号我已经记下，采纳后我会帮你制作 参考技术A 直接转换的包是没有的。但python都有相关的处理json和xml的模块：
python <->json 推荐用simplejson或json；
python <->xml 推荐使用 ElementTree, python2.5已自带。
所以，你可以尝试做xml->python的，再利用simplejson的python->json的，就可以xml->json了（反之亦然）
不过要注意几点：
（1）再jsonify python object之前，需要先把python object unicode化，反正要注意编码问题就是了。
（2）xml->python，或者说xml->json有很多种conversion，常见的比如 tuple tree，JsonML, javascript-like JSON (Parker convention), XML-like JSON (see the BadgerFish convention). 各有优缺点，看你怎么选择啦。
（3）有一些现成的通过xslt把xml直接转成json的。

参考资料：http://markmail.org/message/u7kb7shzhozv35ky#query:+page:1+mid:4bmcksgglo5jeumr+state:results

参考技术B

如果你想看怎么实现，你可以去看xmltodict这个第三方库，

如果你想直接使用，也是去看xnltodict这个库，

总的来说，就是你可以用xmltodict实现，先转换成python标准的dict，再用python自带的json.dumps()转换即可

参考技术C 去搜我写的：
【折腾】Python中xml和Json之间相互转换：xml转json，json转xml

JSON基础

JSON

• • 导读模块
  • JSON 语法规则
  • • json的定义
    • json的访问
    • json的两个常用方法
  • JSON 在java中的使用
  • • javaBean和json的互转
    • List和json的互转
    • map和json的互转

导读模块

发展史：21世纪初，Douglas Crockford寻找一种简便的数据交换格式，

能够在服务器之间交换数据。当时通用的数据交换语言是XML，

但是Douglas Crockford觉得XML的生成和解析都太麻烦，

所以他提出了一种简化格式，也就是Json。

JSON：是一种轻量级的数据交换格式。它基于 ECMAScript (欧洲计算机协会制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率

轻量级是指跟xml作比较。

数据交换指的是客户端和服务器之间业务数据的传递格式。

简而言之：是存储数据的一种方式/格式

与之类似的技术有：xml

JSON 语法规则

json的定义

json是由键值对组成，并且由花括号（大括号）包围。每个键由引号引起来，键和值之间使用冒号进行分割，多组键值对之间使用逗号进行分割。

var jsonObj=
				"key1":12,
				"key2":"abc",
				"key3":true,
				"key4":[11,"arr",false],
				"key5":
				    "key5_1":551,
					"key5_2":"key5_2_value"
				,
				"key6":[
                    "key6_1_1":6611,
                    "key6_1_2":"key6_1_2_value"
                ,
				    "key6_1_1":6621,
					"key6_1_2":"key6_2_2_value"
				]

json的访问

json本身就是一个对象

json中的key我们可以理解为是对象中的一个属性。

json中的key访问就跟访问对象的属性一样：json对象.key

 alert(typeof (jsonObj));//Object   json就是一个对象
 alert(jsonObj.key1);//12
 alert(jsonObj.key2);//abc
 alert(jsonObj.key3);//true
 alert(jsonObj.key4)//得到数组[11,"才",false]

//json中数组值的遍历,可以通过下标去访问
for (var i=0;i<jsonObj.key4.length;i++)
    alert(jsonObj.key4[i]);

 alert(jsonObj.key5.key5_1);//551
alert(jsonObj.key5.key5_2);//key5_2_value
			for (var j=0;j<jsonObj.key6.length;j++)
			   var jsonob=jsonObj.key6[j];//取出来每一个元素都是json对象
			   alert(jsonob.key6_1_1);
			   alert(jsonob.key6_1_2)
			

json的两个常用方法

json的两种存在形式

1、对象形式存在，json对象

2、字符串形式村子，json字符串

一般我们要操作json中的数据的时候，需要json对象的格式。

一般我们要在客户端和服务器之间进行数据交换的时候，使用json字符串。

json.stringify() 把json对象转换成json字符串

json.parse() 把json字符串转换成为json对象

JSON 在java中的使用

javaBean和json的互转

public void test1()
        Person person=new Person("杨过",1);
        //创建Gson对象实例
        Gson gson =new Gson();
        //toJson方法可以把java对象转换成为Json字符串
        String personJsonString=gson.toJson(person);
        System.out.println(personJsonString);//"name":"杨过","id":1
        //fromJson把字符串转换回java对象
        //第一个参数是json字符串
        //第二个参数是转换回去的Java对象类型
        Person person1= gson.fromJson(personJsonString,Person.class);
    	//Person person2=gson.fromJson(personJsonString,person.getclass());
        System.out.println(person1);//Personname='杨过', id=1
    

以上代码可以看到，在对一个对象进行toJson方法的时候，他会转变成一个Json字符串，但是如果想要转回java对象，则需要使用fromJson，而且参数为两个，第一个是Json字符串，第二个为java对象的类型，类名.class或者定义好的对象名.getclass()

List和json的互转

public void test2()
        List<Person> personList =new ArrayList<>();
       //personList中添加两个Person对象
        personList.add(new Person("杨过",1));
        personList.add(new Person("小龙女",2));

        Gson gson=new Gson();
    	//通过toJson（）方法将List转换为Json字符串
        String personListJsonString=gson.toJson(personList);
        System.out.println(personListJsonString);
    	//通过fromJson（）方法将Json字符串转为Java集合
    	//第一个参数为要转的Json字符串
    	//第二个参数为TypeToken<T>的匿名类
        List<Person> list=gson.fromJson(personListJsonString,new TypeToken<List<Person>>().getType());
        System.out.println(list);
        Person person = list.get(0);
        System.out.println(person);
    
/*
运行结果
["name":"杨过","id":1,"name":"小龙女","id":2]            Json字符串
[Personname='杨过', id=1, Personname='小龙女', id=2]		Json字符串转回的List
Personname='杨过', id=1									  Json字符串转回List中的元素
*/

Json字符串转换为List与Json字符串转换为JavaBean不同在于from的第二个参数，转换为JavaBean需要javaBean类的class，而List 的话，第二个参数为一个TypeToken的匿名类，而这个泛型为List 的类型，也可以通过去定义一个ListType的类，去继承TypeToken类，在第二个参数后面进行new ListType这个TypeToken的子类实现Json字符串转回JavaList

map和json的互转

public void test3()
        Map<Integer,Person> personMap=new HashMap<>();
    	//为personMap集合中添加两个Person对象
        personMap.put(1,new Person("磊哥",1));
        personMap.put(2,new Person("航哥",1));
        Gson gson = new Gson();
        //把map集合转换成为Json字符串
        String personMapJsonString =gson.toJson(personMap);
        Map<Integer,Person> personMap1 = gson.fromJson(personMapJsonString, new TypeToken<Map<Integer,Person>>().getType());
        System.out.println(personMap1);
        Person per=personMap1.get(1);
        System.out.println(per);
    
/*
打印结果
1=Personname='磊哥', id=1, 2=Personname='航哥', id=1
Personname='磊哥', id=1
*/

Json字符串转回Map与Json字符串转回List大体一样，不同的就是new的TypeToken类的泛型，要与之要转回的类型相同