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": "\u8fbe\u897f", "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成爲理想的數據交換語言。javascript
JSON建構於兩種結構：html
「名稱/值」對的集合（A collection of name/value pairs）。不一樣的語言中，它被理解爲對象（object），紀錄（record），結構（struct），字典（dictionary），哈希表（hash table），有鍵列表（keyed list），或者關聯數組 （associative array）。
值的有序列表（An ordered list of values）。在大部分語言中，它被理解爲數組（array）。
這些都是常見的數據結構。事實上大部分現代計算機語言都以某種形式支持它們。這使得一種數據格式在一樣基於這些結構的編程語言之間交換成爲可能。java
jso官方說明參見：http://json.org/python
Python操做json的標準api庫參考：http://docs.python.org/library/json.htmlgit
對簡單數據類型的encoding 和 decoding：github
使用簡單的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
輸出：json
[[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]}]flask
經過輸出的結果能夠看出，簡單類型經過encode以後跟其原始的repr()輸出結果很是類似，可是有些數據類型進行了改變，例如上例中的元組則轉換爲了列表。在json的編碼過程當中，會存在從python原始類型向json類型的轉化過程，具體的轉化對照以下：api
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
1、JSON是什麼？
JSON是一種輕量級的數據交換格式
2、Python處理JSON的思惟
其實很容易理解，無非是將數據編成JSON格式數據和吧JSON格式的數據解析出來
3、Python處理JSON的具體方法
一、json.dumps()
該函數能夠將簡單數據類型（int\float\string\tuple\list\dict\unicode）轉換成JSON格式，樣例代碼以下：
import json
src_data = {"name":"Tacey","age":13,"sex":"male","interst":("Programing","Reading")}
print json.dumps(src_data)
輸出以下：
{'interst':('Programing','Reading'),'age':23,'name':'Tacey','sex':'male'}
{"interst":["programing","Reading"],"age":23,"name":"Tacey","sex":mal"}
二、json.loads()
該函數能夠將JSON數據轉換成Python的簡單數據類型，接着上面的代碼：
json_data = json.dumps(src_data)
print json.loads(json_data)["name"]
輸出結果：
Tacey
4、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)
