1. 概述

JSON (JavaScript Object Notation)是一種使用廣泛的輕量數(shù)據(jù)格式. Python標準庫中的json模塊提供了JSON數(shù)據(jù)的處理功能.

Python中一種非常常用的基本數(shù)據(jù)結(jié)構(gòu)就是字典(Dictionary). 它的典型結(jié)構(gòu)如下:

d = {
'a': 123,
'b': {
'x': ['A', 'B', 'C']
}
} 

而JSON的結(jié)構(gòu)如下:

{
"a": 123,
"b": {
"x": ["A", "B", "C"]
}
} 

可以看到, Dictionary和JSON非常接近, 而Python中的json庫提供的主要功能, 也是兩者之間的轉(zhuǎn)換.

2. 讀取JSON

json.loads方法可以將包含了一個JSON數(shù)據(jù)的str, bytes或者bytearray對象, 轉(zhuǎn)化為一個Python Dictionary. 它的完型接口簽名如下:

2.1 最簡單的例子

json.loads最基本的使用方式就是將一個包含JSON數(shù)據(jù)的str傳遞給這個方法:

>>> json.loads('{"a": 123}')
{'a': 123} 

注意

在Python中, str值可以放在一對單引號中, 也可以放在一對雙引號中:

>>> 'ABC' == "ABC"
True 

所以, 在定義Dictionary的str類型的鍵和值的時候, 使用單引號或者雙引號都是合法和等價的:

>>> {"a": 'ABC'} == {'a': "ABC"}
True 

但是, 在JSON中, 字符串?dāng)?shù)據(jù)只能放在雙引號中, 因而json.loads方法處理的字符串的JSON內(nèi)容中, 字符串必須使用雙引號. 否則就會發(fā)生解碼錯誤:

>>> json.loads("{'a': 123}")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/__init__.py", line 354, in loads
return _default_decoder.decode(s)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/decoder.py", line 339, in decode
obj, end = self.raw_decode(s, idx=_w(s, 0).end())
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/decoder.py", line 355, in raw_decode
obj, end = self.scan_once(s, idx)
json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

如果被處理的Python字符串是包含在雙引號中的, 那么JSON中的雙引號就需要轉(zhuǎn)義:

>>> json.loads("{\"a\": 123}")
{'a': 123} 

2.2 bytes和bytearray數(shù)據(jù)

對于內(nèi)容是JSON數(shù)據(jù)的bytes和bytearray, json.loads方法也可以處理:

>>> json.loads('{"a": 123}'.encode('UTF-8'))
{'a': 123}
>>> json.loads(bytearray('{"a": 123}', 'UTF-8'))
{'a': 123} 

2.3 編碼格式

json.loads的第二個參數(shù)是encoding沒有實際作用.

由于Python 3中str類型總是使用UTF-8編碼, 所以s參數(shù)為str類型時, json.loads方法自動使用UTF-8編碼. 并且, str不能以BOM字節(jié)開頭.

當(dāng)s參數(shù)為bytes或者bytearray時, json.loads方法會自動判斷為UTF-8, UTF-16還是UTF-32編碼. 默認也是將其按照UTF-8編碼轉(zhuǎn)化為str對象進行后續(xù)處理.

2.4 數(shù)據(jù)類型轉(zhuǎn)換

JSON可以表示四種主類型數(shù)據(jù)

• 1.字符串 string
• 2.數(shù)字 number
• 3.布爾類 boolean
• 4.空值 null

以及兩結(jié)數(shù)據(jù)結(jié)構(gòu)

• 1.對象 object
• 2.數(shù)組 array

默認實現(xiàn)中, JSON和Python之間的數(shù)據(jù)轉(zhuǎn)換對應(yīng)關(guān)系如下表:

實際轉(zhuǎn)換情況如下例:

>>> json.loads("""
... {
... "obj": {
... "str": "ABC",
... "int": 123,
... "float": -321.89,
... "bool_true": true,
... "bool_false": false,
... "null": null,
... "array": [1, 2, 3]
... }
... }""")
{'obj': {'str': 'ABC', 'int': 123, 'float': -321.89, 'bool_true': True, 'bool_false': False, 'null': None, 'array': [1, 2, 3]}} 

對于JSON中數(shù)字number類型的數(shù)據(jù), 有以下幾點需要注意:

1.JSON中的實數(shù)real number類型的精度不能超過Python中的float類型的精度范圍, 否則就有精度損失. 如下例:

>>> json.loads('3.141592653589793238462643383279')
3.141592653589793

2.JSON標準不包括非數(shù)字NaN, 正無窮Infinity和負無窮-Infinity, 但是json.loads方法默認會將JSON字符串中的NaN, Infinity, -Infinity轉(zhuǎn)化為Python中的float('nan'), float('inf')和float('-inf'). 注意, 這里JSON中的NaN, Infinity, -Infinity必須大小寫正確并且拼寫完整. 如下例

>>> json.loads('{"inf": Infinity, "nan": NaN, "ninf": -Infinity}')
{'inf': inf, 'nan': nan, 'ninf': -inf}

2.5 自定義JSON對象轉(zhuǎn)換類型

json.loads默認將JSON中的對象數(shù)據(jù)轉(zhuǎn)化為Dictionary類型, object_hook參數(shù)可以用來改變構(gòu)造出的對象.

object_hook接受一個函數(shù), 這個函數(shù)的輸入?yún)?shù)為JSON中對象數(shù)據(jù)轉(zhuǎn)化出的Dictionary對象, 其返回值則為自定義的對象. 如下例所示:

>>> class MyJSONObj:
... def __init__(self, x):
... self.x = x
...
>>> def my_json_obj_hook(data):
... print('obj_hook data: %s' % data)
... return MyJSONObj(data['x'])
...
>>> result = json.loads('{"x": 123}', object_hook=my_json_obj_hook)
obj_hook data: {'x': 123}
>>> type(result)
<class '__main__.MyJSONObj'>
>>> result.x
123 

當(dāng)JSON中的對象有嵌套時, json.loads方法會按照深度優(yōu)先的方式遍歷對象樹, 將各層的對象數(shù)據(jù)傳遞給object_hook. 葉節(jié)點的JSON對象構(gòu)造出的Python對象, 會作為父節(jié)點的一個值, 傳遞給父節(jié)點的object_hook方法. 如下例:

>>> class MyJSONObj:
... def __init__(self, x, y):
... self.x = x
... self.y = y
...
>>> def my_json_obj_hook(data):
... print('obj_hook data: %s' % data)
... return MyJSONObj(**data)
...
>>> result = json.loads('{"x": {"x": 11, "y": 12}, "y": {"x": 21, "y":22}}', object_hook=my_json_obj_hook)
obj_hook data: {'x': 11, 'y': 12}
obj_hook data: {'x': 21, 'y': 22}
obj_hook data: {'x': <__main__.MyJSONObj object at 0x10417ef28>, 'y': <__main__.MyJSONObj object at 0x10417ed68>} 

除了object_hook參數(shù)以外, 還有一個object_pairs_hook參數(shù). 這個參數(shù)同樣可以用來改變json.loads方法構(gòu)造出的Python對象的類型. 這個參數(shù)和object_hook的不同, 在于傳入的方法所接收到的輸入數(shù)據(jù)不是一個Dictionary, 而是一個包含tuple的list. 每個tuple都有兩個元素, 第一個元素是JSON數(shù)據(jù)中的鍵, 第二個元素是這個鍵對應(yīng)的值. 如JSON對象

{
"a": 123,
"b": "ABC"
} 

對應(yīng)的輸入數(shù)據(jù)是

[
('a': 123),
('b', 'ABC')
]

當(dāng)調(diào)用json.loads方法時, 同時指定object_hook和object_pairs_hook, object_pairs_hook會覆蓋object_hook參數(shù).

2.6 自定義JSON數(shù)字轉(zhuǎn)換類型

默認實現(xiàn)中, JSON中的實數(shù)被轉(zhuǎn)換為Python的float類型, 整數(shù)被轉(zhuǎn)換為int或者long類型. 類似object_hook, 我們可以通過parse_float和parse_int參數(shù)指定自定義的轉(zhuǎn)換邏輯. 這兩個方法的輸入?yún)?shù)為表示JSON實數(shù)或者整數(shù)的字符串. 下例中, 我們將實數(shù)轉(zhuǎn)換為numpy.float64, 將整數(shù)轉(zhuǎn)換為numpy.int64:

>>> def my_parse_float(f):
... print('%s(%s)' % (type(f), f))
... return numpy.float64(f)
...
>>> def my_parse_int(i):
... print('%s(%s)' % (type(i), i))
... return numpy.int64(i)
...
>>> result = json.loads('{"i": 123, "f": 321.45}', parse_float=my_parse_float, parse_int=my_parse_int)
<type 'str'>(123)
<type 'str'>(321.45)
>>> type(result['i'])
<type 'numpy.int64'>
>>> type(result['f'])
<type 'numpy.float64'> 

2.6.1 自定義NaN, Infinity和-Infinity轉(zhuǎn)換類型

由于標準JSON數(shù)據(jù)不支持NaN, Infinity和-Infinity, 所以parse_float并不會接收到這幾個值. 當(dāng)需要自定義這幾個值轉(zhuǎn)換的對象的時候, 就需要使用另外一個接口parse_constant. 比如下例中, 將這幾個值同樣轉(zhuǎn)換為numpy.float64類型:

>>> def my_parse_constant(data):
... print('%s(%s)' % (type(data), data))
... return numpy.float64(data)
...
>>> result = json.loads('{"inf": Infinity, "nan": NaN, "ninf": -Infinity}', parse_constant=my_parse_constant)
<type 'str'>(Infinity)
<type 'str'>(NaN)
<type 'str'>(-Infinity)
>>> result['inf']
inf
>>> type(result['inf'])
<type 'numpy.float64'> 

2.7 非對象頂級值

根據(jù)JSON規(guī)范, 一個JSON數(shù)據(jù)中, 可以只包含一個值, 而不是一個完整的對象. 這個值可以是一個字符串, 一個數(shù)字, 布爾值, 空值, 或者一個數(shù)組. 除了這三種JSON規(guī)范中給出的類型, 還可以是NaN, Infinity或者-Infinity:

>>> json.loads('"hello"')
'hello'
>>> json.loads('123')
123
>>> json.loads('123.34')
123.34
>>> json.loads('true')
True
>>> json.loads('false')
False
>>> print(json.loads('null'))
None
>>> json.loads('[1, 2, 3]')
[1, 2, 3] 

2.8 重復(fù)鍵名

在同一層級JSON對象中, 不應(yīng)當(dāng)出現(xiàn)重復(fù)的鍵名, 不過JSON規(guī)范中沒有給出這種情況的處理標準. 在json.loads中, 當(dāng)JSON數(shù)據(jù)中有重復(fù)鍵名, 則后面的鍵值會覆蓋前面的:

>>> json.loads('{"a": 123, "b": "ABC", "a": 321}')
{'a': 321, 'b': 'ABC'} 

2.9 處理JSON數(shù)據(jù)文件

當(dāng)JSON數(shù)據(jù)是保存在一個文件中的時候, json.load方法可以用來從這個文件中讀取數(shù)據(jù), 并轉(zhuǎn)換為Python對象. json.load方法的第一個參數(shù)就是指向JSON數(shù)據(jù)文件的文件類型對象.

比如/tmp/data.json文件的內(nèi)含如下:

{
"a": 123,
"b": "ABC"
} 

可以使用下例中的代碼來讀取并轉(zhuǎn)化文件中的JSON數(shù)據(jù):

>>> with open('/tmp/data.json') as jf:
... json.load(jf)
...
{u'a': 123, u'b': u'ABC'} 

除了文件類型的對象, 只要是實現(xiàn)了read方法的類文件對象, 都可以作為fp參數(shù), 比如下例中的io.StringIO:

>>> sio = io.StringIO('{"a": 123}')
>>> json.load(sio)
{'a': 123} 

json.load方法的其他參數(shù)的意義和使用方法和上文中的json.loads相同, 這里不再贅述.

3 生成JSON

json.dumps方法可以將Python對象轉(zhuǎn)換為一個表示JONS數(shù)據(jù)的字符串. 它的完整接口簽名如下:

它的第一個參數(shù)obj即為要轉(zhuǎn)換的數(shù)據(jù)對象.

>>> json.dumps({'a': 123, 'b': 'ABC'})
'{"a": 123, "b": "ABC"}' 

3.1 編碼格式

json.dumps的ensure_ascii參數(shù)用來控制生成的JSON字符串的編碼. 其默認值為True, 此時, 所有的非ASCII碼字條都會轉(zhuǎn)義. 如果不希望自動進行轉(zhuǎn)義, 則會保持原有編碼, 限UTF-8. 如下例所示:

>>> json.dumps({'數(shù)字': 123, '字符': '一二三'})
'{"\\u6570\\u5b57": 123, "\\u5b57\\u7b26": "\\u4e00\\u4e8c\\u4e09"}'
>>> json.dumps({'數(shù)字': 123, '字符': '一二三'}, ensure_ascii=False)
'{"數(shù)字": 123, "字符": "一二三"}' 

3.2 數(shù)據(jù)類型轉(zhuǎn)換

在默認實現(xiàn)中, json.dumps可以處理的Python對象, 及其所有的屬性值, 類型必須為dict, list, tuple, str, float或者int. 這些類型與JSON的數(shù)據(jù)轉(zhuǎn)換關(guān)系如下表:

實際轉(zhuǎn)換情況如下示例:

>>> json.dumps(
... {
... 'str': 'ABC',
... 'int': 123,
... 'float': 321.45,
... 'bool_true': True,
... 'bool_false': False,
... 'none': None,
... 'list': [1, 2, 3],
... 'tuple': [12, 34]
... }
... )
'{"str": "ABC", "int": 123, "float": 321.45, "bool_true": true, "bool_flase": false, "none": null, "list": [1, 2, 3], "tuple": [12, 34]}' 

雖然JSON標準規(guī)范不支持NaN, Infinity和-Infinity, 但是json.dumps的默認實現(xiàn)會將float('nan'), float('inf')和float('-inf')轉(zhuǎn)換為常量NaN, Infinity, 和-Infinity. 如下例所示:

>>> json.dumps(
... {
... 'nan': float('nan'),
... 'inf': float('inf'),
... '-inf': float('-inf')
... }
... )
'{"nan": NaN, "inf": Infinity, "-inf": -Infinity}' 

由于這些常量可能會導(dǎo)致生成的JSON字符串不能被其他的JSON實現(xiàn)處理, 為了防止這種情況出現(xiàn), 可以將json.dumps的allow_nan參數(shù)設(shè)置為True. 此時, 當(dāng)處理的Python對象中出現(xiàn)這些值時, json.dumps方法會拋出異常.

3.3 循環(huán)引用

json.dumps方法會檢查Python對象中是否有循環(huán)引用, 如果發(fā)現(xiàn)了循環(huán)引用, 就會拋出異常. 如下例所示:

>>> circular_obj = {}
>>> circular_obj['self'] = circular_obj
>>> circular_obj
{'self': {...}}
>>> json.dumps(circular_obj)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/__init__.py", line 231, in dumps
return _default_encoder.encode(obj)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/encoder.py", line 199, in encode
chunks = self.iterencode(o, _one_shot=True)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/encoder.py", line 257, in iterencode
return _iterencode(o, 0)
ValueError: Circular reference detected 

如果不希望json.dumps方法檢查循環(huán)引用, 可以將參數(shù)check_circular設(shè)置為False. 但如果此時Python對象中有循環(huán)引用, 有可能發(fā)生遞歸嵌套過深的錯誤或者其他錯誤, 這么做是比較危險的. 如下例所示:

>>> json.dumps(circular_obj, check_circular=False)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/__init__.py", line 238, in dumps
**kw).encode(obj)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/encoder.py", line 199, in encode
chunks = self.iterencode(o, _one_shot=True)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/encoder.py", line 257, in iterencode
return _iterencode(o, 0)
RecursionError: maximum recursion depth exceeded while encoding a JSON object 

3.4 JSON字符串輸出格式

json.dumps方法的indent參數(shù)可以用來控制JSON字符串的換行和縮進效果.

indent參數(shù)默認值為None. 此時, JSON字符串不會有換行和縮進效果. 如下示:

>>> print(json.dumps({'a': 123, 'b': {'x': 321, 'y': 'ABC'}}))
{"a": 123, "b": {"x": 321, "y": "ABC"}} 

當(dāng)indent為0或者負數(shù)時, JSON字符會包含換行:

>>> print(json.dumps({'a': 123, 'b': {'x': 321, 'y': 'ABC'}}, indent=-1))
{
"a": 123,
"b": {
"x": 321,
"y": "ABC"
}
}
>>> print(json.dumps({'a': 123, 'b': {'x': 321, 'y': 'ABC'}}, indent=0))
{
"a": 123,
"b": {
"x": 321,
"y": "ABC"
}
} 

而當(dāng)indent為正整數(shù)時, 除了換行, JSON還會以指定數(shù)量的空格為單位在對象層次間進行縮進:

>>> print(json.dumps({'a': 123, 'b': {'x': 321, 'y': 'ABC'}}, indent=2))
{
"a": 123,
"b": {
"x": 321,
"y": "ABC"
}
} 

indent還可以是str, 此時, JSON會以str內(nèi)容為單位進行縮進, 比如制表符\t:

>>> print(json.dumps({'a': 123, 'b': {'x': 321, 'y': 'ABC'}}, indent='\t'))
{
"a": 123,
"b": {
"x": 321,
"y": "ABC"
}
} 

json.dumps的另外一個參數(shù)separators可以用來設(shè)置輸出的分隔符. 這個參數(shù)的值應(yīng)當(dāng)是一個有兩個元素的tuple. 其第一個值為成員間的分隔符, 第二個值為鍵值之間的分隔符. 其默認值也會隨上文中的indent參數(shù)影響. 當(dāng)indent為None時, separators的默認值為(', ', ': '), 即分隔符后都有一個空格. 當(dāng)indent不為None時, 其默認值則為(',', ':'), 即只有鍵值間分隔符后會有一個空格, 而元素間分隔符則不帶空格, 因為此時會有換行.

separators參數(shù)的一種可能的使用場景是希望移除所有的非必要格式字符, 以此來減小JSON字符串的大小. 此時可以將separator設(shè)置為(',', ';'), 并不設(shè)置indent參數(shù), 或者將其顯式設(shè)置為None:

>>> print(json.dumps({'a': 123, 'b': {'x': 321, 'y': 'ABC'}}, indent=None, separators=(',', ':')))
{"a":123,"b":{"x":321,"y":"ABC"}} 

3.5 轉(zhuǎn)換自定義Python對象

json.dumps的默認實現(xiàn)只能轉(zhuǎn)換Dictionary類型的對象. 如果想要轉(zhuǎn)換自定義對象, 需要使用default參數(shù). 這個參數(shù)接收一個函數(shù), 這個函數(shù)的參數(shù)是一個要轉(zhuǎn)換的Python對象, 返回值是能夠表示這個Python對象的Dictionary對象. default函數(shù)會從對象引用樹的頂層開始, 逐層遍歷整個對象引用樹. 因此, 不用自己實現(xiàn)對象樹的遍歷邏輯, 只需要處理當(dāng)前層次的對象. 如下例所示:

>>> class MyClass:
... def __init__(self, x, y):
... self.x = x
... self.y = y
...
>>> def my_default(o):
... if isinstance(o, MyClass):
... print('%s.y: %s' % (type(o), o.y))
... return {'x': o.x, 'y': o.y}
... print(o)
... return o
...
>>> obj = MyClass(x=MyClass(x=1, y=2), y=11)
>>> json.dumps(obj, default=my_default)
<class '__main__.MyClass'>.y: 11
<class '__main__.MyClass'>.y: 2
'{"x": {"x": 1, "y": 2}, "y": 11}' 

3.6 非字符串類型鍵名

在Python中, 只是可哈希(hashable)的對象和數(shù)據(jù)都可以做為Dictionary對象的鍵, 而JSON規(guī)范中則只能使用字符串做為鍵名. 所以在json.dumps的實現(xiàn)中, 對這個規(guī)則進行了檢查, 不過鍵名允許的范圍有所擴大, str, int, float, bool和None類型的數(shù)據(jù)都可以做為鍵名. 不過當(dāng)鍵名非str的情況時, 鍵名會轉(zhuǎn)換為對應(yīng)的str值. 如下例:

>>> json.dumps(
... {
... 'str': 'str',
... 123: 123,
... 321.54: 321.54,
... True: True,
... False: False,
... None: None
... }
... )
'{"str": "str", "123": 123, "321.54": 321.54, "true": true, "false": false, "null": null}' 

而當(dāng)出現(xiàn)其他類型的鍵名時, 默認出拋出異常:

>>> json.dumps({(1,2): 123})
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/__init__.py", line 231, in dumps
return _default_encoder.encode(obj)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/encoder.py", line 199, in encode
chunks = self.iterencode(o, _one_shot=True)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/json/encoder.py", line 257, in iterencode
return _iterencode(o, 0)
TypeError: keys must be a string 

json.dumps的skipkeys參數(shù)可以改變這個行為. 當(dāng)將skipkeys設(shè)置為True時, 遇到非法的鍵名類型, 不會拋出異常, 而是跳過這個鍵名:

>>> json.dumps({(1,2): 123}, skipkeys=True)
'{}' 

3.7 生成JSON文件

當(dāng)需要將生成的JSON數(shù)據(jù)保存到文件時, 可以使用json.dump方法. 這個方法比json.dumps多了一個參數(shù)fp, 這個參數(shù)就是用來保存JSON數(shù)據(jù)的文件對象. 比如, 下例中的代碼

>>> with open('/tmp/data.json', mode='a') as jf:
... json.dump({'a': 123}, jf)
... 

就會將JSON數(shù)據(jù)寫入到/tmp/data.json文件里. 代碼執(zhí)行完后, 文件內(nèi)容為

{"a": 123} 
json.dump方法也可以接受其他類文件對象:
>>> sio = io.StringIO()
>>> json.dump({'a': 123}, sio)
>>> sio.getvalue()
'{"a": 123}' 

json.dump的其他參數(shù)和json.dumps的用法相同, 這里不再贅述.

4 JSON解碼和編碼類實現(xiàn)

json.loads, json.load, json.dumps和json.dump這四個方法是通過json.JSONDecoder和json.JSONEncoder這兩個類來完成各自的任務(wù)的. 所以也可以直接使用這兩個類來完成前文描述的功能:

>>> json.JSONDecoder().decode('{"a": 123}')
{'a': 123}
>>> json.JSONEncoder().encode({'a': 123})
'{"a": 123}' 

json.loads, json.load, json.dumps和json.dump這個四個方法的參數(shù)主要都是傳遞給了json.JSONDecoder和json.JSONEncoder的構(gòu)造方法, 所以使用這些方法可以滿足絕大部分需求. 當(dāng)需要自定義json.JSONDecoder和json.JSONEncoder子類的時候, 只需要將子類傳遞給cls參數(shù). 同時, 這些方法都有**kw參數(shù). 當(dāng)自定義實現(xiàn)類的構(gòu)造函數(shù)需要標準參數(shù)列表之外的新參數(shù)時, 這個參數(shù)就會將新參數(shù)傳遞給實現(xiàn)類的構(gòu)造方法.

5 相關(guān)資源

1. JSON
2. The JavaScript Object Notation (JSON) Data Interchange Format - RFC 4627
3. json — JSON encoder and decoder
   

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。