python josn转换方法-字典

python_json常用的方法 

1. 什么是JSON?
JSON 可以将 JavaScript 对象中表示的一组数据转换为字符串，然后就可以在函数之间轻松地传递这个字符串，或者在异步应用程序中将字符串从 Web 客户机传递给服务器端程序.
2. JSON语法
数据在键值对中
数据由逗号分隔
花括号保存对象
方括号保存数组
3. json常用的方法
JSON到字典转化： ret_dict = json.loads(json_str)
字典到JSON转化： json_str = json.dumps(dict)
4. 示例

# -*- coding: utf-8 -*-
import json

json_content = '{"name":"test", "type":{"name":"seq", "parameter":["1", "2"]}}'

print u"JSON到字典转化（方法一）："
l = eval(json_content)
print l
print l.keys()
print l["name"]
print l["type"]["name"]
print l["type"]["parameter"][1]

print u"JSON到字典转化（方法二）："
s = json.loads(json_content)
print s
print s.keys()
print s["name"]
print s["type"]["name"]
print s["type"]["parameter"][1]


dict_content = {"name":"test", "type":{"name":"seq", "parameter":["1", "2"]}}

print u"字典到JSON"
s = json.dumps(dict_content)
print s
try:
    print s.keys() 
except AttributeError:
    print u"对象不是字典！"

Python JSON
本章节我们将为大家介绍如何使用 Python 语言来编码和解码 JSON 对象。
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写。

JSON 函数
使用 JSON 函数需要导入 json 库：import json。
函数
描述
json.dumps 
将 Python 对象编码成 JSON 字符串
json.loads
将已编码的 JSON 字符串解码为 Python 对象

json.dumps
json.dumps 用于将 Python 对象编码成 JSON 字符串。
语法
json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding="utf-8", default=None, sort_keys=False, **kw)
实例
以下实例将数组编码为 JSON 格式数据：
#!/usr/bin/python
import json

data = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]

json = json.dumps(data)
print json
以上代码执行结果为：
[{"a": 1, "c": 3, "b": 2, "e": 5, "d": 4}]
使用参数让 JSON 数据格式化输出：
>>> import json
>>> print json.dumps({'a': 'Runoob', 'b': 7}, sort_keys=True, indent=4, separators=(',', ': '))
{
    "a": "Runoob",
    "b": 7
}
python 原始类型向 json 类型的转化对照表：
Python
JSON
dict
object
list, tuple
array
str, unicode
string
int, long, float
number
True
true
False
false
None
null

json.loads
json.loads 用于解码 JSON 数据。该函数返回 Python 字段的数据类型。
语法
json.loads(s[, encoding[, cls[, object_hook[, parse_float[, parse_int[, parse_constant[, object_pairs_hook[, **kw]]]]]]]])
实例
以下实例展示了Python 如何解码 JSON 对象：
#!/usr/bin/python
import json

jsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

text = json.loads(jsonData)
print text
以上代码执行结果为：
{u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}
json 类型转换到 python 的类型对照表：


JSON
Python
object
dict
array
list
string
unicode
number (int)
int, long
number (real)
float
true
True
false
False
null
None
更多内容参考：https://docs.python.org/2/library/json.html。

使用第三方库：Demjson
Demjson 是 python 的第三方模块库，可用于编码和解码 JSON 数据，包含了 JSONLint 的格式化及校验功能。
Github 地址：https://github.com/dmeranda/demjson
官方地址：http://deron.meranda.us/python/demjson/
环境配置
在使用 Demjson 编码或解码 JSON 数据前，我们需要先安装 Demjson 模块。本教程我们会下载 Demjson 并安装：
$ tar -xvzf demjson-2.2.3.tar.gz
$ cd demjson-2.2.3
$ python setup.py install
更多安装介绍查看：http://deron.meranda.us/python/demjson/install
JSON 函数
函数
描述
encode 
将 Python 对象编码成 JSON 字符串
decode
将已编码的 JSON 字符串解码为 Python 对象

encode
Python encode() 函数用于将 Python 对象编码成 JSON 字符串。
语法
demjson.encode(self, obj, nest_level=0)
实例
以下实例将数组编码为 JSON 格式数据：
#!/usr/bin/python
import demjson

data = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]

json = demjson.encode(data)
print json
以上代码执行结果为：
[{"a":1,"b":2,"c":3,"d":4,"e":5}]

decode
Python 可以使用 demjson.decode() 函数解码 JSON 数据。该函数返回 Python 字段的数据类型。
语法
demjson.decode(self, txt)
实例
以下实例展示了Python 如何解码 JSON 对象：
#!/usr/bin/python
import demjson

json = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

text = demjson.decode(json)
print  text
以上代码执行结果为：
{u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}
　　

JSON包的引用

在文件头部引用json包



import json1





python对象与JSON对象的互相转换

json对象的类型为’str’：



dic = {'b':'I', 'a':123, 'c':'100'}
j1 = json.dumps(dic)
print (j1)
# {"b": "I", "a": 123, "c": "100"}
print (type(j1))
# <class 'str'> 
print (j1[0],j1[1],j1[2])
# { " b12345678

将sort_keys参数置为True时，生成的json对象是按键排序的，sort_keys默认为False：



dic = {'b':'I', 'a':123, 'c':'100'}
j2 = json.dumps(dic, sort_keys = True)
print (j2)
# {"a": 123, "b": "I", "c": "100"}1234

通过indent参数可以设置json对象的缩进格式：



dic = {'b':'I', 'a':123, 'c':'100'}
j3 = json.dumps(dic, sort_keys = True, indent = 4)
print (j3)
# {
#     "a": 123,
#     "b": "I",
#     "c": "100"
# }12345678

通过separators参数可以设置json对象的分隔符：



dic = {'b':'I', 'a':123, 'c':'100'}
j4 = json.dumps(dic, sort_keys = True, separators = ('$','@'))
print (j4)
# {"a"@123$"b"@"I"$"c"@"100"}1234

列表也可以转化为json对象：



list1 = [1, 'big', [1, 'a', {'p':'+'}], (['t',2],{'1':'o'}), {'c':0,'d':1}]
j5 = json.dumps(list1)
print (j5)
# [1, "big", [1, "a", {"p": "+"}], [["t", 2], {"1": "o"}], {"c": 0, "d": 1}]1234

元组转化为json对象：



tuple1 = (1, 0)
j6 = json.dumps(tuple1)
print (j6)
# [1, 0]1234

将字典转换为json字符串时，key需为数字或字母，否则报错，可通过skipkeys参数跳过这些键：



dic1 = {1:'one', 2.3:'tPt', 'two':2, (3,4):'thr&four'}
j7 = json.dumps(dic1)
print (j7)
# TypeError: keys must be a string
j8 = json.dumps(dic1, skipkeys = True)
print (j8)
# {"1": "one", "2.3": "tPt", "two": 2}1234567

dumps对中文使用ascii编码方式，通过将ensure_ascii参数设置为False可输出中文：



dic_info = {'name':'Elizabeth', 'husband':'达西', 'age':22}
j9 = json.dumps(dic_info)
print (j9)
# {"name": "Elizabeth", "husband": "u8fbeu897f", "age": 22}
j10 = json.dumps(dic_info,ensure_ascii=False)
print (j10)
# {"name": "Elizabeth", "husband": "达西", "age": 22}1234567

将json对象解码为python对象：



dic = {'b':'I', 'a':123, 'c':'100'}
j1 = json.dumps(dic)
decode1 = json.loads(j1)
print (decode1)
# {'b': 'I', 'a': 123, 'c': '100'}12345





存取JSON文件

存json文件，将python对象存到json格式的文件中不再用dumps，而是要用dump：



dic_info = {'name':'Elizabeth', 'husband':'达西', 'age':22}
filew = open ('Elizabeth.json', 'w', encoding='utf-8')
json.dump(dic_info, filew)
filew.close()1234

json文件如下图所示： 
 
读取json文件，从json文件中读取内容存入python对象，不再用loads而是要用load：



filer = open ('Elizabeth.json', 'r', encoding='utf-8')
Elizabeth = json.load(filer)
filer.close()
print (Elizabeth)
# {'name': 'Elizabeth', 'husband': '达西', 'age': 22}
print (type(Elizabeth))
# <class 'dict'>
--------------------- 

1. 读取【列表】格式的 json 文件： 
源文件：

[
    {
            "Country Name": "Arab World",
            "Country Code": "ARB",
            "Year": "1960",
            "Value": "96388069"
    },
    {
            "Country Name": "Arab World",
            "Country Code": "ARB",
            "Year": "1961",
            "Value": "98882541.4"
    }
]1234567891011121314

代码：



import json

# 将数据加载到一个列表中
filename = '123.json'
with open(filename) as f:
    pop_data = json.load(f)

    # 打印每个国家2010年的人口数量
    for pop_dict in pop_data:
        country_name = pop_dict['Country Name']
        population = pop_dict['Value']
        print(country_name + ": " + population)123456789101112





2. 读取 {字典} 类型的 json 文件： 
源文件：

{
     "fontFamily": "微软雅黑",
     "fontSize": 12,
     "BaseSettings":{
         "font":1,
         "size":2
                    }
}12345678

代码：



# 设置以utf-8解码模式读取文件，encoding参数必须设置，否则默认以gbk模式读取文件，当文件中包含中文时，会报错
f = open("repositories.json", encoding='utf-8')
setting = json.load(f)

# 注意多重结构的读取语法
family = setting['BaseSettings']['font']
style = setting['fontFamily']

print(family)
print(style)12345678910





3. json模块的使用 
 - json: 用于字符串和python数据类型间进行转换  
 - Json模块提供了四个功能：dumps、dump、loads、load

json dumps把数据类型转换成字符串 dump把数据类型转换成字符串并存储在文件中  loads把字符串转换成数据类型  load把文件打开从字符串转换成数据类型

(1). dumps：将字典 转换为 字符串

import json

test_dict = {'bigberg': [7600, {1: [['iPhone', 6300], ['Bike', 800], ['shirt', 300]]}]}
print(test_dict)
print(type(test_dict))

#dumps 将数据转换成字符串
json_str = json.dumps(test_dict)
print(json_str)
print(type(json_str))12345678910

(2). dump: 将字典 转换为 字符串, 并写入json文件中



with open("../config/record.json","w") as f:
    json.dump(json_str,f)
    print("加载入文件完成...")123

(3). loads: 将 字符串 转换为 字典

new_dict = json.loads(json_str)
print(new_dict)
print(type(new_dict))123

(4). load:把文件打开，并把字符串变换为数据类型



with open("../config/record.json",'r') as load_f:
    load_dict = json.load(load_f)
    print(load_dict)

load_dict['smallberg'] = [8200,{1:[['Python',81],['shirt',300]]}]
print(load_dict)

with open("../config/record.json","w") as dump_f:
    json.dump(load_dict,dump_f)
--------------------- 

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。这些特性使JSON成为理想的数据交换语言。

JSON建构于两种结构：

“名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。 
值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）。 
这些都是常见的数据结构。事实上大部分现代计算机语言都以某种形式支持它们。这使得一种数据格式在同样基于这些结构的编程语言之间交换成为可能。

jso官方说明参见：http://json.org/

Python操作json的标准api库参考：http://docs.python.org/library/json.html

对简单数据类型的encoding 和 decoding：

使用简单的json.dumps方法对简单数据类型进行编码，例如：

import json
 
obj = [[1,2,3],123,123.123,'abc',{'key1':(1,2,3),'key2':(4,5,6)}]
encodedjson = json.dumps(obj)
print repr(obj)
print encodedjson

输出：

[[1, 2, 3], 123, 123.123, 'abc', {'key2': (4, 5, 6), 'key1': (1, 2, 3)}] 
[[1, 2, 3], 123, 123.123, "abc", {"key2": [4, 5, 6], "key1": [1, 2, 3]}]

通过输出的结果可以看出，简单类型通过encode之后跟其原始的repr()输出结果非常相似，但是有些数据类型进行了改变，例如上例中的元组则转换为了列表。在json的编码过程中，会存在从python原始类型向json类型的转化过程，具体的转化对照如下：

json.dumps()方法返回了一个str对象encodedjson，我们接下来在对encodedjson进行decode，得到原始数据，需要使用的json.loads()函数：

decodejson = json.loads(encodedjson)
print type(decodejson)
print decodejson[4]['key1']
print decodejson

输出：

<type 'list'> 
[1, 2, 3]

[[1, 2, 3], 123, 123.123, u'abc', {u'key2': [4, 5, 6], u'key1': [1, 2, 3]}]

loads方法返回了原始的对象，但是仍然发生了一些数据类型的转化。比如，上例中‘abc’转化为了unicode类型。从json到python的类型转化对照如下：

json.dumps方法提供了很多好用的参数可供选择，比较常用的有sort_keys（对dict对象进行排序，我们知道默认dict是无序存放的），separators，indent等参数。

排序功能使得存储的数据更加有利于观察，也使得对json输出的对象进行比较，例如：

data1 = {'b':789,'c':456,'a':123}
data2 = {'a':123,'b':789,'c':456}
d1 = json.dumps(data1,sort_keys=True)
d2 = json.dumps(data2)
d3 = json.dumps(data2,sort_keys=True)
print d1
print d2
print d3
print d1==d2
print d1==d3

输出：

{"a": 123, "b": 789, "c": 456} 
{"a": 123, "c": 456, "b": 789} 
{"a": 123, "b": 789, "c": 456} 
False 
True

上例中，本来data1和data2数据应该是一样的，但是由于dict存储的无序特性，造成两者无法比较。因此两者可以通过排序后的结果进行存储就避免了数据比较不一致的情况发生，但是排序后再进行存储，系统必定要多做一些事情，也一定会因此造成一定的性能消耗，所以适当排序是很重要的。

indent参数是缩进的意思，它可以使得数据存储的格式变得更加优雅。

data1 = {'b':789,'c':456,'a':123}
d1 = json.dumps(data1,sort_keys=True,indent=4)
print d1

输出：

{ 
    "a": 123, 
    "b": 789, 
    "c": 456 
}

输出的数据被格式化之后，变得可读性更强，但是却是通过增加一些冗余的空白格来进行填充的。json主要是作为一种数据通信的格式存在的，而网络通信是很在乎数据的大小的，无用的空格会占据很多通信带宽，所以适当时候也要对数据进行压缩。separator参数可以起到这样的作用，该参数传递是一个元组，包含分割对象的字符串。

print 'DATA:', repr(data)
print 'repr(data)             :', len(repr(data))
print 'dumps(data)            :', len(json.dumps(data))
print 'dumps(data, indent=2)  :', len(json.dumps(data, indent=4))
print 'dumps(data, separators):', len(json.dumps(data, separators=(',',':')))

输出：

DATA: {'a': 123, 'c': 456, 'b': 789} 
repr(data)             : 30 
dumps(data)            : 30 
dumps(data, indent=2)  : 46 
dumps(data, separators): 25

通过移除多余的空白符，达到了压缩数据的目的，而且效果还是比较明显的。

另一个比较有用的dumps参数是skipkeys，默认为False。 dumps方法存储dict对象时，key必须是str类型，如果出现了其他类型的话，那么会产生TypeError异常，如果开启该参数，设为True的话，则会比较优雅的过度。

data = {'b':789,'c':456,(1,2):123}
print json.dumps(data,skipkeys=True)

输出：

{"c": 456, "b": 789}

 

处理自己的数据类型

json模块不仅可以处理普通的python内置类型，也可以处理我们自定义的数据类型，而往往处理自定义的对象是很常用的。

首先，我们定义一个类Person。

class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __repr__(self):
        return 'Person Object name : %s , age : %d' % (self.name,self.age)
if __name__  == '__main__':
    p = Person('Peter',22)
    print p

如果直接通过json.dumps方法对Person的实例进行处理的话，会报错，因为json无法支持这样的自动转化。通过上面所提到的json和python的类型转化对照表，可以发现，object类型是和dict相关联的，所以我们需要把我们自定义的类型转化为dict，然后再进行处理。这里，有两种方法可以使用。

方法一：自己写转化函数

 

'''
Created on 2011-12-14
@author: Peter
'''
import Person
import json
 
p = Person.Person('Peter',22)
 
def object2dict(obj):
    #convert object to a dict
    d = {}
    d['__class__'] = obj.__class__.__name__
    d['__module__'] = obj.__module__
    d.update(obj.__dict__)
    return d
 
def dict2object(d):
    #convert dict to object
    if'__class__' in d:
        class_name = d.pop('__class__')
        module_name = d.pop('__module__')
        module = __import__(module_name)
        class_ = getattr(module,class_name)
        args = dict((key.encode('ascii'), value) for key, value in d.items()) #get args
        inst = class_(**args) #create new instance
    else:
        inst = d
    return inst
 
d = object2dict(p)
print d
#{'age': 22, '__module__': 'Person', '__class__': 'Person', 'name': 'Peter'}
 
o = dict2object(d)
print type(o),o
#<class 'Person.Person'> Person Object name : Peter , age : 22
 
dump = json.dumps(p,default=object2dict)
print dump
#{"age": 22, "__module__": "Person", "__class__": "Person", "name": "Peter"}
 
load = json.loads(dump,object_hook = dict2object)
print load
#Person Object name : Peter , age : 22

上面代码已经写的很清楚了，实质就是自定义object类型和dict类型进行转化。object2dict函数将对象模块名、类名以及__dict__存储在dict对象里，并返回。dict2object函数则是反解出模块名、类名、参数，创建新的对象并返回。在json.dumps 方法中增加default参数，该参数表示在转化过程中调用指定的函数，同样在decode过程中json.loads方法增加object_hook,指定转化函数。

方法二：继承JSONEncoder和JSONDecoder类，覆写相关方法

JSONEncoder类负责编码，主要是通过其default函数进行转化，我们可以override该方法。同理对于JSONDecoder。

'''
Created on 2011-12-14
@author: Peter
'''
import Person
import json
 
p = Person.Person('Peter',22)
 
class MyEncoder(json.JSONEncoder):
    def default(self,obj):
        #convert object to a dict
        d = {}
        d['__class__'] = obj.__class__.__name__
        d['__module__'] = obj.__module__
        d.update(obj.__dict__)
        return d
 
class MyDecoder(json.JSONDecoder):
    def __init__(self):
        json.JSONDecoder.__init__(self,object_hook=self.dict2object)
    def dict2object(self,d):
        #convert dict to object
        if'__class__' in d:
            class_name = d.pop('__class__')
            module_name = d.pop('__module__')
            module = __import__(module_name)
            class_ = getattr(module,class_name)
            args = dict((key.encode('ascii'), value) for key, value in d.items()) #get args
            inst = class_(**args) #create new instance
        else:
            inst = d
        return inst
 
 
d = MyEncoder().encode(p)
o =  MyDecoder().decode(d)
 
print d
print type(o), o

一、JSON是什么？

JSON是一种轻量级的数据交换格式

二、Python处理JSON的思维

其实很容易理解，无非是将数据编成JSON格式数据和吧JSON格式的数据解析出来

三、Python处理JSON的具体方法

1、json.dumps()

该函数可以将简单数据类型（intfloatstring	uplelistdictunicode）转换成JSON格式，样例代码如下：

import json
src_data = {"name":"Tacey","age":13,"sex":"male","interst":("Programing","Reading")}
#print repr(src_data)
print json.dumps(src_data)

输出如下：

{'interst':('Programing','Reading'),'age':23,'name':'Tacey','sex':'male'}
{"interst":["programing","Reading"],"age":23,"name":"Tacey","sex":mal"}

2、json.loads()

该函数可以将JSON数据转换成Python的简单数据类型，接着上面的代码：

json_data = json.dumps(src_data)
print json.loads(json_data)["name"]

输出结果：

Tacey

四、Flask中的JSON处理

Flask中也可以实用Python自带的json模块，也可以实用Flask中的jsonify，样例代码如下：

from flask import Flask, jsonify

app = Flask(name)

json_data = [
{"name":"Tacey","age":23,"sex":"male","interst":("Programing","Reading")} ,
{"name":"Amber","age":23,"sex":"female","interst":("Food","Dog")}
]

@app.route('/jsontest', methods=['GET'])
def get_json():
return jsonify({'json': json_data})
if name == 'main':
app.run(debug=True)

　　

python_json常用的方法

 

1. 什么是JSON?

JSON 可以将 JavaScript 对象中表示的一组数据转换为字符串，然后就可以在函数之间轻松地传递这个字符串，或者在异步应用程序中将字符串从 Web 客户机传递给服务器端程序.

2. JSON语法

• • 数据在键值对中
  • 数据由逗号分隔
  • 花括号保存对象
  • 方括号保存数组

3. json常用的方法

• JSON到字典转化： ret_dict = json.loads(json_str)
• 字典到JSON转化： json_str = json.dumps(dict)

4. 示例

# -*- coding: utf-8 -*-
import json

json_content = '{"name":"test", "type":{"name":"seq", "parameter":["1", "2"]}}'

print u"JSON到字典转化（方法一）："
l = eval(json_content)
print l
print l.keys()
print l["name"]
print l["type"]["name"]
print l["type"]["parameter"][1]

print u"JSON到字典转化（方法二）："
s = json.loads(json_content)
print s
print s.keys()
print s["name"]
print s["type"]["name"]
print s["type"]["parameter"][1]


dict_content = {"name":"test", "type":{"name":"seq", "parameter":["1", "2"]}}

print u"字典到JSON"
s = json.dumps(dict_content)
print s
try:
    print s.keys() 
except AttributeError:
    print u"对象不是字典！"