什么是json:
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方法对简单数据类型进行编码,例如:
1
2
3
4
5
6
|
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()函数:
1
2
3
4
|
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输出的对象进行比较,例如:
1
2
3
4
5
6
7
8
9
10
|
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参数是缩进的意思,它可以使得数据存储的格式变得更加优雅。
1
2
3
|
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参数可以起到这样的作用,该参数传递是一个
元组,包含分割对象的字符串。
1
2
3
4
5
|
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的话,则会比较优雅的过度。
1
2
|
data
=
{
'b'
:
789
,
'c'
:
456
,(
1
,
2
):
123
}
print
json.dumps(data,skipkeys
=
True
)
|
输出:
{"c": 456, "b": 789}
处理自己的数据类型
json模块不仅可以处理普通的python内置类型,也可以处理我们自定义的数据类型,而往往处理自定义的对象是很常用的。
首先,我们定义一个类Person。
1
2
3
4
5
6
7
8
9
|
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,然后再进行处理。这
里,有两种方法可以使用。
方法一:自己写转化函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
import
Person
import
json
p
=
Person.Person(
'Peter'
,
22
)
def
object2dict(obj):
d
=
{}
d[
'__class__'
]
=
obj.__class__.__name__
d[
'__module__'
]
=
obj.__module__
d.update(obj.__dict__)
return
d
def
dict2object(d):
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())
inst
=
class_
(
*
*
args)
else
:
inst
=
d
return
inst
d
=
object2dict(p)
print
d
o
=
dict2object(d)
print
type
(o),o
dump
=
json.dumps(p,default
=
object2dict)
print
dump
load
=
json.loads(dump,object_hook
=
dict2object)
print
load
|
上面代码已经写的很清楚了,实质就是自定义object类型和dict类型进行转化。object2dict函数将对象模块名、类名以及
__dict__存储在dict对象里,并返回。dict2object函数则是反解出模块名、类名、参数,创建新的对象并返回。在json.dumps
方法中增加default参数,该参数表示在转化过程中调用指定的函数,同样在decode过程中json.loads方法增加object_hook,
指定转化函数。
方法二:继承JSONEncoder和JSONDecoder类,覆写相关方法
JSONEncoder类负责编码,主要是通过其default函数进行转化,我们可以override该方法。同理对于JSONDecoder。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
import
Person
import
json
p
=
Person.Person(
'Peter'
,
22
)
class
MyEncoder(json.JSONEncoder):
def
default(
self
,obj):
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):
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())
inst
=
class_
(
*
*
args)
else
:
inst
=
d
return
inst
d
=
MyEncoder().encode(p)
o
=
MyDecoder().decode(d)
print
d
print
type
(o), o
转载于糖拌咸鱼,http://www.cnblogs.com/coser/archive/2011/12/14/2287739.html
|
分享到:
相关推荐
`dumps()`还接受一些可选参数,如`sort_keys`,用于对字典的键进行排序,`separators`用于设置输出的分隔符,以及`indent`用于控制输出的缩进,提高可读性。 `loads()`方法则用于将JSON字符串解析回Python对象。在...
这个模块提供了两个主要的函数来实现JSON与Python数据类型之间的转换:`json.dumps()`用于编码(encoding)Python对象到JSON字符串,而`json.loads()`则用于解码(decoding)JSON字符串回Python对象。 编码...
Python中处理JSON数据的标准化API库是`json`,提供了一套完整的方法来对JSON数据进行编码和解码。`json.dumps()`方法用于将Python对象编码为JSON字符串,而`json.loads()`方法则用于将JSON字符串解码回Python对象。 ...
总的来说,JSON作为数据交换格式在软件开发中扮演着重要角色,而Python的`json`模块提供了方便的工具,使得开发者可以轻松地在Python对象和JSON数据之间进行转换。理解和熟练掌握这些操作,有助于提升开发效率并确保...
### Python 实现 JSON 格式转换为文本或 SQL 文件 #### 概述 在实际开发过程中,经常需要处理不同格式的数据文件,例如将 JSON 格式的文件转换为其他格式如文本文件或 SQL 文件等。这样的操作有助于数据的进一步...
python-json-logger, 标准 python 记录器的Json格式化程序 概述这里库提供了允许标准 python 日志记录输出日志数据作为json对象的标准。 使用 JSON,我们可以让计算机更容易读取日志,并且可以停止为syslog类型记录...
JSON在源码中的应用广泛,例如,Web API通常返回JSON格式的响应数据,前端开发者可以使用Ajax技术或现代的Fetch API获取这些数据,并通过JSON.parse()进行解析,然后在网页上展示或进行进一步操作。同时,JSON也常...
**Python库jsonmodel-1.0.zip概述** Python是一种广泛使用的高级编程语言,以其简洁、易读的语法和丰富的库支持而闻名。在Python的世界里,库是开发者的重要工具,它们提供了一系列预先编写好的功能,使得开发人员...
Python 标准库的 json 模块可以用来处理 JSON 格式数据的基本操作。 2. 使用 json 模块主要提供了 dump、dumps、load、loads 方法对 JSON 数据进行编解码。 2.1 dumps json 模块的 dumps 方法可以将 Python 对象转为...
Python-jws是一个Python实现的库,专门用于处理JSON Web签名的相关操作,包括签名、验证签名等。在这个项目中,我们将深入探讨Python-jws库的使用方法以及它在Python开发中的应用。 1. **JWS概述** JSON Web签名...
### 对JSON字符串与Python字符串的不同之处详解 #### 引言 在进行Web开发或数据分析时,经常需要处理JSON格式的数据。JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,易于人阅读和编写,同时也...
Python-simdjson是Python对simdjson库的绑定,它是一个高性能的JSON解析器,利用了现代处理器的SIMD(单指令多数据)指令集来加速JSON解析过程。SIMD技术允许处理器同时处理多个数据元素,极大地提升了在处理大量...
1. 概述 JSON (JavaScript Object Notation)是一种使用广泛的轻量数据格式. Python标准库中的json模块提供了JSON数据的处理功能. Python中一种非常常用的基本数据结构就是字典(Dictionary). 它的典型结构如下: d...
3. JSON数据概述及解析 3.1 JSON数据格式 3.2 解析库json json模块是Python内置标准库,主要可以完成两个功能:序列化和反序列化。JSON对象和Python对象映射图如下: 3.2.1 json序列化 对象(字典/列表) 通过 json...
本文将深入探讨如何使用Python针对JSON中的特定字段进行排序,并详细解释所涉及的`json`模块以及`lambda`表达式的用法。 #### JSON数组排序概述 在Python中,可以通过内置的`sort()`方法对列表进行排序。如果想要...
2. **自动错误处理**:库内置了对JSON-RPC错误的处理机制,确保了错误信息的有效传递,并遵循JSON-RPC 1.0和2.0规范。 3. **多线程支持**:wsgi-jsonrpc可以处理并发请求,支持多线程或多进程环境,适应高并发的Web...
概述提供此库是为了允许标准python日志记录将日志数据输出为json对象。 使用JSON,我们可以使日志更易于机器读取,并且可以停止为syslog类型记录编写自定义解析器。消息嗨,我看到这个程序包还活着,很抱歉忽略了...