Python JSON: Encode (dumps), Decode (loads) & Read File JSON
ฮฃฮต ฯฮน ฮตฮฏฮฝฮฑฮน ฯฮฟ JSON Python?
JSON in Python ฮตฮฏฮฝฮฑฮน ฮผฮนฮฑ ฯฯ ฯฮนฮบฮฎ ฮผฮฟฯฯฮฎ ฮตฮผฯฮฝฮตฯ ฯฮผฮญฮฝฮท ฮฑฯฯ Javaฮฃฮตฮฝฮฌฯฮนฮฟ ฮณฮนฮฑ ฮฑฮฝฯฮฑฮปฮปฮฑฮณฮฎ ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ ฮบฮฑฮน ฮผฮตฯฮฑฯฮฟฯฮฌ ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ ฯฯ ฮผฮฟฯฯฮฎ ฮบฮตฮนฮผฮญฮฝฮฟฯ ฮผฮญฯฯ ฮดฮนฮบฯฯฮฟฯ . ฮฮตฮฝฮนฮบฮฌ, ฯฮฟ JSON ฮตฮฏฮฝฮฑฮน ฯฮต ฮผฮฟฯฯฮฎ ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌฯ ฮฎ ฮบฮตฮนฮผฮญฮฝฮฟฯ . ฮฯฮฟฯฮตฮฏ ฮฝฮฑ ฯฯฮทฯฮนฮผฮฟฯฮฟฮนฮทฮธฮตฮฏ ฮฑฯฯ API ฮบฮฑฮน ฮฒฮฌฯฮตฮนฯ ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ ฮบฮฑฮน ฮฑฮฝฯฮนฯฯฮฟฯฯฯฮตฯฮตฮน ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฑ ฯฯ ฮถฮตฯฮณฮท ฮฟฮฝฯฮผฮฑฯฮฟฯ/ฯฮนฮผฮฎฯ. ฮคฮฟ JSON ฯฮทฮผฮฑฮฏฮฝฮตฮน Javaฮฃฮทฮผฮตฮนฮฟฮณฯฮฑฯฮฏฮฑ ฮฑฮฝฯฮนฮบฮตฮนฮผฮญฮฝฮฟฯ ฯฮตฮฝฮฑฯฮฏฮฟฯ .
Python ฮฃฯฮฝฯฮฑฮพฮท JSON:
ฮคฮฟ JSON ฮณฯฮฌฯฮตฯฮฑฮน ฯฯ ฮถฮตฯฮณฮฟฯ ฮบฮปฮตฮนฮดฮนฮฟฯ ฮบฮฑฮน ฯฮนฮผฮฎฯ.
{
"Key": "Value",
"Key": "Value",
}
ฮคฮฟ JSON ฮผฮฟฮนฮฌฮถฮตฮน ฯฮฟฮปฯ ฮผฮต Python ฮปฮตฮพฮนฮบฯ. Python ฯ ฯฮฟฯฯฮทฯฮฏฮถฮตฮน JSON ฮบฮฑฮน ฮญฯฮตฮน ฮผฮนฮฑ ฮตฮฝฯฯฮผฮฑฯฯฮผฮญฮฝฮท ฮฒฮนฮฒฮปฮนฮฟฮธฮฎฮบฮท ฯฯ JSON.
JSON Library in Python
ยปฮดฮนฮตฯ ฮธฮตฯฯ'ฮฮฑฮน'ฯฮฏฮบฮปฮฑ' ฮตฮพฯฯฮตฯฮนฮบฮญฯ ฮตฮฝฯฯฮทฯฮตฯ ฯฮฟฯ Python ฮดฮนฮฑฯฮทฯฮฟฯฮฝ ฮผฮนฮฑ ฮญฮบฮดฮฟฯฮท ฯฮฟฯ JSON Python ฮฒฮนฮฒฮปฮนฮฟฮธฮฎฮบฮท. ฮฯฮณฮฑฯฮฏฮฑ ฮผฮต JSON ฯฮต Python ฮณฮนฮฑ ฮฝฮฑ ฮตฮบฯฮตฮปฮญฯฮตฯฮต ฮปฮตฮนฯฮฟฯ ฯฮณฮฏฮตฯ ฯฮฟฯ ฯฯฮตฯฮฏฮถฮฟฮฝฯฮฑฮน ฮผฮต JSON, ฯฯฯฯ ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฮบฮฑฮน ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท, ฯฯฮญฯฮตฮน ฯฯฯฯฮฑ ฮฝฮฑ ฯฮฟ ฮบฮฌฮฝฮตฯฮต ฮตฮนฯฮฑฮณฯฮณฮฎ ฮฒฮนฮฒฮปฮนฮฟฮธฮฎฮบฮท JSON ฮบฮฑฮน ฮณฮนฮฑ ฮฑฯ ฯฯ ฯฯฮท ฮดฮนฮบฮฎ ฯฮฑฯ .py ฮฑฯฯฮตฮฏฮฟฯ ,
import json
ฮฮน ฮฑฮบฯฮปฮฟฯ ฮธฮตฯ ฮผฮญฮธฮฟฮดฮฟฮน ฮตฮฏฮฝฮฑฮน ฮดฮนฮฑฮธฮญฯฮนฮผฮตฯ ฯฯฮฟ JSON Python ฮตฮฝฯฯฮทฯฮฑ
| ฮฮญฮธฮฟฮดฮฟฯ | ฮ ฮตฯฮนฮณฯฮฑฯฮฎ |
|---|---|
| ฮบฮฑฯฮฎฯฮตฮนฮฑ() | ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฯฮต ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฑ JSON |
| ฮตฮณฮบฮฑฯฮฑฮปฮตฮฏฯฯ() | ฮบฯฮดฮนฮบฮฟฯฮฟฮนฮทฮผฮญฮฝฮท ฮตฮณฮณฯฮฑฯฮฎ ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌฯ ฯฮต ฮฑฯฯฮตฮฏฮฟ |
| ฯฮฟฯฯฮฏฮฑ () | ฮฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮนฮฎฯฯฮต ฯฮท ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌ JSON |
| ฯฮฟฯฯฯฮฝฯ() | ฮฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฮบฮฑฯฮฌ ฯฮทฮฝ ฮฑฮฝฮฌฮณฮฝฯฯฮท ฯฮฟฯ ฮฑฯฯฮตฮฏฮฟฯ JSON |
Python ฯฮต JSON (ฮฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท)
JSON ฮฮนฮฒฮปฮนฮฟฮธฮฎฮบฮท ฯฮฟฯ Python ฮตฮบฯฮตฮปฮตฮฏ ฯฮทฮฝ ฮฑฮบฯฮปฮฟฯ ฮธฮท ฮผฮตฯฮฌฯฯฮฑฯฮท ฯฮฟฯ Python ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฑ ฯฮต ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฑ JSON ฮฑฯฯ ฯฯฮฟฮตฯฮนฮปฮฟฮณฮฎ
| Python | JSON |
|---|---|
| dict | ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ |
| ฮปฮฏฯฯฮฑ | ฮ ฮฑฯฮฌฯฮฑฮพฮท |
| unicode | ฮฃฯฮฌฮณฮณฮฟฯ |
| ฮฑฯฮนฮธฮผฯฯ โ int, long | ฮฑฯฮนฮธฮผฯฯ โ ฮตฮฝฮธ |
| ฯฮปฮฟฯฮญฯ | ฮฑฯฮนฮธฮผฯฯ โ ฯฯฮฑฮณฮผฮฑฯฮนฮบฯฯ |
| ฮฮน ฮฑฮปฮทฮธฮนฮฝฮฟฮฏ | ฮฮน ฮฑฮปฮทฮธฮนฮฝฮฟฮฏ |
| ฮจฮตฯ ฮดฮฎฯ | ฮจฮตฯ ฮดฮฎฯ |
| ฮ/ฮ | Null |
ฮฮตฯฮฑฯฯฮฟฯฮฎ Python ฮคฮฑ ฮดฮตฮดฮฟฮผฮญฮฝฮฑ ฯฮต JSON ฮฟฮฝฮฟฮผฮฌฮถฮฟฮฝฯฮฑฮน ฮปฮตฮนฯฮฟฯ ฯฮณฮฏฮฑ ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮทฯ. ฮ ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฮณฮฏฮฝฮตฯฮฑฮน ฮผฮต ฯฮท ฮฒฮฟฮฎฮธฮตฮนฮฑ ฯฮทฯ ฮผฮตฮธฯฮดฮฟฯ ฮฒฮนฮฒฮปฮนฮฟฮธฮฎฮบฮทฯ JSON โ ฮบฮฑฯฮฎฯฮตฮนฮฑ()
JSON dumps() ฯฮต Python
json.dumps() in Python ฮตฮฏฮฝฮฑฮน ฮผฮนฮฑ ฮผฮญฮธฮฟฮดฮฟฯ ฯฮฟฯ ฮผฮตฯฮฑฯฯฮญฯฮตฮน ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฑ ฮปฮตฮพฮนฮบฮฟฯ ฯฮฟฯ Python ฯฮต ฮผฮฟฯฯฮฎ ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌฯ JSON. ฮฮฏฮฝฮฑฮน ฯฯฮฎฯฮนฮผฮฟ ฯฯฮฑฮฝ ฯฮฑ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฑ ฮฑฯฮฑฮนฯฮตฮฏฯฮฑฮน ฮฝฮฑ ฮตฮฏฮฝฮฑฮน ฯฮต ฮผฮฟฯฯฮฎ ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌฯ ฮณฮนฮฑ ฮปฮตฮนฯฮฟฯ ฯฮณฮฏฮตฯ ฯฯฯฯ ฮฑฮฝฮฌฮปฯ ฯฮท, ฮตฮบฯฯฯฯฯฮท ฮบ.ฮปฯ.
ฮคฯฯฮฑ ฮฑฯ ฮตฮบฯฮตฮปฮญฯฮฟฯ ฮผฮต ฯฮฟ ฯฯฯฯฮฟ ฮผฮฑฯ ฯฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮทฯ json.dumps ฮผฮต Python:
import json
x = {
"name": "Ken",
"age": 45,
"married": True,
"children": ("Alice","Bob"),
"pets": ['Dog'],
"cars": [
{"model": "Audi A1", "mpg": 15.1},
{"model": "Zeep Compass", "mpg": 18.1}
]
}
# sorting result in asscending order by keys:
sorted_string = json.dumps(x, indent=4, sort_keys=True)
print(sorted_string)
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
{"person": {"name": "Kenn", "sex": "male", "age": 28}})
ฮฯ ฮดฮฟฯฮผฮต ฮญฮฝฮฑ ฯฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ ฯฮฟฯ Python ฮณฯฮฌฯฯฮต JSON ฯฯฮฟ ฮฑฯฯฮตฮฏฮฟ ฮณฮนฮฑ ฯฮท ฮดฮทฮผฮนฮฟฯ ฯฮณฮฏฮฑ ฮตฮฝฯฯ ฮฑฯฯฮตฮฏฮฟฯ JSON ฯฮฟฯ ฮปฮตฮพฮนฮบฮฟฯ ฯฯฮทฯฮนฮผฮฟฯฮฟฮนฯฮฝฯฮฑฯ ฯฮทฮฝ ฮฏฮดฮนฮฑ ฮปฮตฮนฯฮฟฯ ฯฮณฮฏฮฑ ฮตฮณฮบฮฑฯฮฑฮปฮตฮฏฯฯ()
# here we create new data_file.json file with write mode using file i/o operation
with open('json_file.json', "w") as file_write:
# write json data into file
json.dump(person_data, file_write)
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
ฮฮตฮฝ ฯ ฯฮฌฯฯฮตฮน ฯฮฏฯฮฟฯฮฑ ฮณฮนฮฑ ฮตฮผฯฮฌฮฝฮนฯฮทโฆฮฃฯฮฟ ฯฯฯฯฮทฮผฮฌ ฯฮฑฯ ฮดฮทฮผฮนฮฟฯ ฯฮณฮตฮฏฯฮฑฮน ฯฮฟ json_file.json. ฮฯฮฟฯฮตฮฏฯฮต ฮฝฮฑ ฮตฮปฮญฮณฮพฮตฯฮต ฮฑฯ ฯฯ ฯฮฟ ฮฑฯฯฮตฮฏฮฟ ฯฯฯฯ ฯฮฑฮฏฮฝฮตฯฮฑฮน ฯฯฮทฮฝ ฯฮฑฯฮฑฮบฮฌฯฯ ฮตฮณฮณฯฮฑฯฮฎ JSON ฯฮต ฮฑฯฯฮตฮฏฮฟ Python ฯฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ.
JSON ฯฮต Python (ฮฯฮฟฮบฯฯ ฯฯฮฟฮณฯฮฌฯฮทฯฮท)
ฮ ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฯฮฝ JSON ฮณฮฏฮฝฮตฯฮฑฮน ฮผฮต ฯฮท ฮฒฮฟฮฎฮธฮตฮนฮฑ ฯฮทฯ ฮตฮฝฯฯฮผฮฑฯฯฮผฮญฮฝฮทฯ ฮผฮตฮธฯฮดฮฟฯ json.loads() & json.load() ฯฮทฯ ฮฒฮนฮฒฮปฮนฮฟฮธฮฎฮบฮทฯ JSON ฯฯฮฟ Python. ฮฮดฯ ฮฟ ฯฮฏฮฝฮฑฮบฮฑฯ ฮผฮตฯฮฌฯฯฮฑฯฮทฯ ฮดฮตฮฏฯฮฝฮตฮน ฯฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ ฮฑฮฝฯฮนฮบฮตฮนฮผฮญฮฝฯฮฝ JSON ฯฮต Python ฮฑฮฝฯฮนฮบฮตฮนฮผฮญฮฝฯฮฝ ฯฮฟฯ ฮตฮฏฮฝฮฑฮน ฯฯฮฎฯฮนฮผฮฑ ฮณฮนฮฑ ฯฮทฮฝ ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท Python ฯฮทฯ ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌฯ JSON.
| JSON | Python |
|---|---|
| ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ | dict |
| ฮ ฮฑฯฮฌฯฮฑฮพฮท | ฮปฮฏฯฯฮฑ |
| ฮฃฯฮฌฮณฮณฮฟฯ | unicode |
| ฮฑฯฮนฮธฮผฯฯ โ ฮตฮฝฮธ | ฮฑฯฮนฮธฮผฯฯ โ int, long |
| ฮฑฯฮนฮธฮผฯฯ โ ฯฯฮฑฮณฮผฮฑฯฮนฮบฯฯ | ฯฮปฮฟฯฮญฯ |
| ฮฮน ฮฑฮปฮทฮธฮนฮฝฮฟฮฏ | ฮฮน ฮฑฮปฮทฮธฮนฮฝฮฟฮฏ |
| ฮจฮตฯ ฮดฮฎฯ | ฮจฮตฯ ฮดฮฎฯ |
| Null | ฮ/ฮ |
ฮฯ ฮดฮฟฯฮผฮต ฮผฮนฮฑ ฮฒฮฑฯฮนฮบฮฎ ฮฑฮฝฮฌฮปฯ ฯฮท JSON Python ฯฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮทฯ ฮผฮต ฯฮท ฮฒฮฟฮฎฮธฮตฮนฮฑ ฯฮฟฯ json.loads ฮปฮตฮนฯฮฟฯ ฯฮณฮฏฮฑ,
import json # json library imported
# json data string
person_data = '{ "person": { "name": "Kenn", "sex": "male", "age": 28}}'
# Decoding or converting JSON format in dictionary using loads()
dict_obj = json.loads(person_data)
print(dict_obj)
# check type of dict_obj
print("Type of dict_obj", type(dict_obj))
# get human object details
print("Person......", dict_obj.get('person'))
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
{'person': {'name': 'Kenn', 'sex': 'male', 'age': 28}}
Type of dict_obj <class 'dict'>
Person...... {'name': 'John', 'sex': 'male'}
ฮฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฮฑฯฯฮตฮฏฮฟฯ JSON ฮฎ ฮฑฮฝฮฌฮปฯ ฯฮท ฮฑฯฯฮตฮฏฮฟฯ JSON ฯฮต Python
ฮคฯฯฮฑ, ฮธฮฑ ฮผฮฌฮธฮฟฯ ฮผฮต ฯฯฯ ฮฝฮฑ ฮดฮนฮฑฮฒฮฌฮถฮฟฯ ฮผฮต ฯฮฟ ฮฑฯฯฮตฮฏฮฟ JSON Python ฮผฮฑฮถฮฏ ฯฮฟฯ , Python ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ ฮฑฮฝฮฌฮปฯ ฯฮทฯ JSON:
ฮฃฮฮฮฮฮฉฮฃฮ: ฮ ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฯฮฟฯ ฮฑฯฯฮตฮฏฮฟฯ JSON ฮตฮฏฮฝฮฑฮน ฮปฮตฮนฯฮฟฯ ฯฮณฮฏฮฑ ฯฮฟฯ ฯฯฮตฯฮฏฮถฮตฯฮฑฮน ฮผฮต ฯฮทฮฝ ฮฮนฯฮฑฮณฯฮณฮฎ/ฮฮพฮฟฮดฮฟ ฮฑฯฯฮตฮฏฮฟฯ (I/O). ฮคฮฟ ฮฑฯฯฮตฮฏฮฟ JSON ฯฯฮญฯฮตฮน ฮฝฮฑ ฯ ฯฮฌฯฯฮตฮน ฯฯฮฟ ฯฯฯฯฮทฮผฮฌ ฯฮฑฯ ฯฯฮทฮฝ ฮบฮฑฮธฮฟฯฮนฯฮผฮญฮฝฮท ฯฮฟฯฮฟฮธฮตฯฮฏฮฑ ฯฮฟฯ ฮฑฮฝฮฑฯฮญฯฮตฯฮต ฯฯฮฟ ฯฯฯฮณฯฮฑฮผฮผฮฌ ฯฮฑฯ.
Python ฮฮนฮฑฮฒฮฌฯฯฮต ฯฮฟ ฮฑฯฯฮตฮฏฮฟ JSON ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ:
import json
#File I/O Open function for read data from JSON File
with open('X:/json_file.json') as file_object:
# store file data in object
data = json.load(file_object)
print(data)
ฮฮดฯ ฮดฮตฮดฮฟฮผฮญฮฝฮฑ ฮตฮฏฮฝฮฑฮน ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ ฮปฮตฮพฮนฮบฮฟฯ ฯฮฟฯ Python ฯฯฯฯ ฯฮฑฮฏฮฝฮตฯฮฑฮน ฯฯฮฟ ฯฮฑฯฮฑฯฮฌฮฝฯ ฮฑฮฝฮฑฮณฮฝฯฯฮผฮญฮฝฮฟ ฮฑฯฯฮตฮฏฮฟ JSON Python ฯฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ.
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
{'person': {'name': 'Kenn', 'sex': 'male', 'age': 28}}
ฮฃฯ ฮผฯฮฑฮณฮฎฯ ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฯฮต Python
ฮฯฮฑฮฝ ฯฯฮญฯฮตฮน ฮฝฮฑ ฮผฮตฮนฯฯฮตฯฮต ฯฮฟ ฮผฮญฮณฮตฮธฮฟฯ ฯฮฟฯ ฮฑฯฯฮตฮฏฮฟฯ JSON, ฮผฯฮฟฯฮตฮฏฯฮต ฮฝฮฑ ฯฯฮทฯฮนฮผฮฟฯฮฟฮนฮฎฯฮตฯฮต ฯฯ ฮผฯฮฑฮณฮฎ ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท Python.
ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ,
import json
# Create a List that contains dictionary
lst = ['a', 'b', 'c',{'4': 5, '6': 7}]
# separator used for compact representation of JSON.
# Use of ',' to identify list items
# Use of ':' to identify key and value in dictionary
compact_obj = json.dumps(lst, separators=(',', ':'))
print(compact_obj)
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
'["a", "b", "c", {"4": 5, "6": 7}]'
** Here output of JSON is represented in a single line which is the most compact representation by removing the space character from compact_obj **
ฮฮฟฯฯฮฟฯฮฟฮฏฮทฯฮท ฮบฯฮดฮนฮบฮฑ JSON (ฯฮผฮฟฯฯฮท ฮตฮบฯฯฯฯฯฮท)
- ฮ ฯฯฯฯฮฟฯ ฮตฮฏฮฝฮฑฮน ฮฝฮฑ ฮณฯฮฑฯฮตฮฏ ฮบฮฑฮปฮฌ ฮดฮนฮฑฮผฮฟฯฯฯฮผฮญฮฝฮฟฯ ฮบฯฮดฮนฮบฮฑฯ ฮณฮนฮฑ ฯฮทฮฝ ฮฑฮฝฮธฯฯฯฮนฮฝฮท ฮบฮฑฯฮฑฮฝฯฮทฯฮท. ฮฮต ฯฮท ฮฒฮฟฮฎฮธฮตฮนฮฑ ฯฮทฯ ฯฮผฮฟฯฯฮทฯ ฮตฮบฯฯฯฯฯฮทฯ, ฮฟ ฮบฮฑฮธฮญฮฝฮฑฯ ฮผฯฮฟฯฮตฮฏ ฮตฯฮบฮฟฮปฮฑ ฮฝฮฑ ฮบฮฑฯฮฑฮปฮฌฮฒฮตฮน ฯฮฟฮฝ ฮบฯฮดฮนฮบฮฑ.
ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ:
import json
dic = { 'a': 4, 'b': 5 }
''' To format the code use of indent and 4 shows number of space and use of separator is not necessary but standard way to write code of particular function. '''
formatted_obj = json.dumps(dic, indent=4, separators=(',', ': '))
print(formatted_obj)
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
{
"a" : 4,
"b" : 5
}
ฮฮนฮฑ ฮฝฮฑ ฯฮฟ ฮบฮฑฯฮฑฮฝฮฟฮฎฯฮตฯฮต ฮบฮฑฮปฯฯฮตฯฮฑ ฮฑฯ ฯฯ, ฮฑฮปฮปฮฌฮพฯฮต ฯฮทฮฝ ฮตฯฮฟฯฮฎ ฯฮต 40 ฮบฮฑฮน ฯฮฑฯฮฑฯฮทฯฮฎฯฯฮต ฯฮทฮฝ ฮญฮพฮฟฮดฮฟ-
ฮ ฮฑฯฮฑฮณฮณฮตฮปฮฏฮฑ ฯฮฟฯ ฮบฯฮดฮนฮบฮฟฯ JSON:
ฯฮปฮฎฮบฯฯฮฑ ฯฮฑฮพฮนฮฝฯฮผฮทฯฮทฯ ฯฮฑฯฮฑฮบฯฮทฯฮนฯฯฮนฮบฯ ฯฮต Python ฮคฮฟ ฯฯฮนฯฮผฮฑ ฯฮทฯ ฯฯ ฮฝฮฌฯฯฮทฯฮทฯ dumps ฮธฮฑ ฯฮฑฮพฮนฮฝฮฟฮผฮฎฯฮตฮน ฯฮฟ ฮบฮปฮตฮนฮดฮฏ ฯฮต JSON ฯฮต ฮฑฯฮพฮฟฯ ฯฮฑ ฯฮตฮนฯฮฌ. ฮคฮฟ ฯฯฮนฯฮผฮฑ sort_keys ฮตฮฏฮฝฮฑฮน ฮญฮฝฮฑ Boolean ฯฮฑฯฮฑฮบฯฮทฯฮนฯฯฮนฮบฯ. ฮฯฮฑฮฝ ฮตฮฏฮฝฮฑฮน ฮฑฮปฮทฮธฮนฮฝฮฎ ฮท ฯฮฑฮพฮนฮฝฯฮผฮทฯฮท ฮตฯฮนฯฯฮญฯฮตฯฮฑฮน ฮดฮนฮฑฯฮฟฯฮตฯฮนฮบฮฌ ฯฯฮน. ฮฯ ฮบฮฑฯฮฑฮปฮฌฮฒฮฟฯ ฮผฮต ฮผฮต Python ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ ฯฮฑฮพฮนฮฝฯฮผฮทฯฮทฯ ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌฯ ฯฮต JSON.
ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ,
import json
x = {
"name": "Ken",
"age": 45,
"married": True,
"children": ("Alice", "Bob"),
"pets": [ 'Dog' ],
"cars": [
{"model": "Audi A1", "mpg": 15.1},
{"model": "Zeep Compass", "mpg": 18.1}
],
}
# sorting result in asscending order by keys:
sorted_string = json.dumps(x, indent=4, sort_keys=True)
print(sorted_string)
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
{
"age": 45,
"cars": [ {
"model": "Audi A1",
"mpg": 15.1
},
{
"model": "Zeep Compass",
"mpg": 18.1
}
],
"children": [ "Alice",
"Bob"
],
"married": true,
"name": "Ken",
"pets": [
"Dog"
]
}
ฮฯฯฯ ฮผฯฮฟฯฮตฮฏฯฮต ฮฝฮฑ ฯฮฑฯฮฑฯฮทฯฮฎฯฮตฯฮต ฯฮฑ ฮบฮปฮตฮนฮดฮนฮฌ ฮทฮปฮนฮบฮฏฮฑฯ, ฯฮฑ ฮฑฯ ฯฮฟฮบฮฏฮฝฮทฯฮฑ, ฯฮฑ ฯฮฑฮนฮดฮนฮฌ ฮบ.ฮปฯ. ฮตฮฏฮฝฮฑฮน ฮดฮนฮฑฯฮตฯฮฑฮณฮผฮญฮฝฮฑ ฯฮต ฮฑฯฮพฮฟฯ ฯฮฑ ฯฮตฮนฯฮฌ.
ฮฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฯฯฮฝฮธฮตฯฮฟฯ ฮฑฮฝฯฮนฮบฮตฮนฮผฮญฮฝฮฟฯ ฯฮฟฯ Python
ฮฮฝฮฑ ฯฯฮฝฮธฮตฯฮฟ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ ฮญฯฮตฮน ฮดฯฮฟ ฮดฮนฮฑฯฮฟฯฮตฯฮนฮบฮฌ ฮผฮญฯฮท ฮดฮทฮปฮฑฮดฮฎ
- ฮ ฯฮฑฮณฮผฮฑฯฮนฮบฯ ฮผฮญฯฮฟฯ
- ฮฆฮฑฮฝฯฮฑฯฯฮนฮบฯ ฮผฮญฯฮฟฯ
ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ: 3 +2i
ฮ ฯฮนฮฝ ฮตฮบฯฮตฮปฮญฯฮตฯฮต ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฮตฮฝฯฯ ฯฯฮฝฮธฮตฯฮฟฯ ฮฑฮฝฯฮนฮบฮตฮนฮผฮญฮฝฮฟฯ , ฯฯฮญฯฮตฮน ฮฝฮฑ ฮตฮปฮญฮณฮพฮตฯฮต ฯฯฮน ฮผฮนฮฑ ฮผฮตฯฮฑฮฒฮปฮทฯฮฎ ฮตฮฏฮฝฮฑฮน ฯฯฮฝฮธฮตฯฮท ฮฎ ฯฯฮน. ฮ ฯฮญฯฮตฮน ฮฝฮฑ ฮดฮทฮผฮนฮฟฯ ฯฮณฮฎฯฮตฯฮต ฮผฮนฮฑ ฯฯ ฮฝฮฌฯฯฮทฯฮท ฯฮฟฯ ฮตฮปฮญฮณฯฮตฮน ฯฮทฮฝ ฯฮนฮผฮฎ ฯฮฟฯ ฮตฮฏฮฝฮฑฮน ฮฑฯฮฟฮธฮทฮบฮตฯ ฮผฮญฮฝฮท ฯฮต ฮผฮนฮฑ ฮผฮตฯฮฑฮฒฮปฮทฯฮฎ ฯฯฮทฯฮนฮผฮฟฯฮฟฮนฯฮฝฯฮฑฯ ฮผฮนฮฑ ฮผฮญฮธฮฟฮดฮฟ ฯฮฑฯฮฟฯ ฯฮฏฮฑฯ.
ฮฯ ฮดฮทฮผฮนฮฟฯ ฯฮณฮฎฯฮฟฯ ฮผฮต ฯฮท ฯฯ ฮณฮบฮตฮบฯฮนฮผฮญฮฝฮท ฯฯ ฮฝฮฌฯฯฮทฯฮท ฮณฮนฮฑ ฮญฮปฮตฮณฯฮฟ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ ฮตฮฏฮฝฮฑฮน ฯฯฮฝฮธฮตฯฮฟ ฮฎ ฮบฮฑฯฮฌฮปฮปฮทฮปฮฟ ฮณฮนฮฑ ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท.
import json
# create function to check instance is complex or not
def complex_encode(object):
# check using isinstance method
if isinstance(object, complex):
return [object.real, object.imag]
# raised error using exception handling if object is not complex
raise TypeError(repr(object) + " is not JSON serialized")
# perform json encoding by passing parameter
complex_obj = json.dumps(4 + 5j, default=complex_encode)
print(complex_obj)
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
'[4.0, 5.0]'
ฮฃฯฮฝฮธฮตฯฮฟ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ JSON ฯฮต ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท Python
ฮฮนฮฑ ฮฝฮฑ ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮนฮฎฯฮตฯฮต ฯฯฮฝฮธฮตฯฮฟ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ ฯฮต JSON, ฯฯฮทฯฮนฮผฮฟฯฮฟฮนฮฎฯฯฮต ฮผฮนฮฑ ฯฮฑฯฮฌฮผฮตฯฯฮฟ object_hook ฯฮฟฯ ฮตฮปฮญฮณฯฮตฮน ฯฯฮน ฮท ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌ JSON ฯฮตฯฮนฮญฯฮตฮน ฮฎ ฯฯฮน ฯฮฟ ฯฯฮฝฮธฮตฯฮฟ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ. ฮฯ ฮบฮฑฯฮฑฮปฮฌฮฒฮฟฯ ฮผฮต ฮผฮต ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌ ฯฮต JSON Python ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ,
import json
# function check JSON string contains complex object
def is_complex(objct):
if '__complex__' in objct:
return complex(objct['real'], objct['img'])
return objct
# use of json loads method with object_hook for check object complex or not
complex_object =json.loads('{"__complex__": true, "real": 4, "img": 5}', object_hook = is_complex)
#here we not passed complex object so it's convert into dictionary
simple_object =json.loads('{"real": 6, "img": 7}', object_hook = is_complex)
print("Complex_object......",complex_object)
print("Without_complex_object......",simple_object)
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
Complex_object...... (4+5j)
Without_complex_object...... {'real': 6, 'img': 7}
ฮฯฮนฯฮบฯฯฮทฯฮท ฯฮฟฯ JSON Serialization class JSONEncoder
ฮ ฮบฮปฮฌฯฮท JSONEncoder ฯฯฮทฯฮนฮผฮฟฯฮฟฮนฮตฮฏฯฮฑฮน ฮณฮนฮฑ ฯฮตฮนฯฮนฮฟฯฮฟฮฏฮทฯฮท ฮฟฯฮฟฮนฮฟฯ ฮดฮฎฯฮฟฯฮต Python ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ ฮบฮฑฯฮฌ ฯฮทฮฝ ฮตฮบฯฮญฮปฮตฯฮท ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮทฯ. ฮ ฮตฯฮนฮญฯฮตฮน ฯฯฮตฮนฯ ฮดฮนฮฑฯฮฟฯฮตฯฮนฮบฮญฯ ฮผฮตฮธฯฮดฮฟฯ ฯ ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮทฯ ฯฮฟฯ ฮตฮฏฮฝฮฑฮน
- ฯฯฮฟฮตฯฮนฮปฮฟฮณฮฎ(ฮฟ) โ ฮฅฮปฮฟฯฮฟฮนฮฎฮธฮทฮบฮต ฯฯฮทฮฝ ฯ ฯฮฟฮบฮปฮฌฯฮท ฮบฮฑฮน ฮตฯฮนฯฯฯฮฟฯฮฎ ฯฮตฮนฯฮนฮฑฮบฯ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ ฮณฮนฮฑ o ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ.
- ฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท(ฮฟ) โ ฮคฮฟ ฮฏฮดฮนฮฟ ฮผฮต ฯฮฑ JSON dumps Python ฮผฮญฮธฮฟฮดฮฟฯ ฮตฯฮนฯฯฯฮฟฯฮฎฯ ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌฯ JSON ฯฮฟฯ Python ฮดฮฟฮผฮฎ ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ.
- iterencode(o) โ ฮฮฝฯฮนฯฯฮฟฯฯฯฮตฯฯฯฮต ฯฮท ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌ ฮผฮฏฮฑ ฯฯฮฟฯ ฮผฮฏฮฑ ฮบฮฑฮน ฮบฯฮดฮนฮบฮฟฯฮฟฮนฮฎฯฯฮต ฯฮฟ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ o.
ฮฮต ฯฮท ฮฒฮฟฮฎฮธฮตฮนฮฑ ฯฮทฯ ฮผฮตฮธฯฮดฮฟฯ encode() ฯฮทฯ ฮบฮปฮฌฯฮทฯ JSONEncoder, ฮผฯฮฟฯฮฟฯฮผฮต ฮตฯฮฏฯฮทฯ ฮฝฮฑ ฮบฯฮดฮนฮบฮฟฯฮฟฮนฮฎฯฮฟฯ ฮผฮต ฮฟฯฮฟฮนฮฑฮดฮฎฯฮฟฯฮต Python ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ ฯฯฯฯ ฯฮฑฮฏฮฝฮตฯฮฑฮน ฯฮฑฯฮฑฮบฮฌฯฯ Python ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ ฮบฯฮดฮนฮบฮฟฯฮฟฮนฮทฯฮฎ JSON.
# import JSONEncoder class from json
from json.encoder import JSONEncoder
colour_dict = { "colour": ["red", "yellow", "green" ]}
# directly called encode method of JSON
JSONEncoder().encode(colour_dict)
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
'{"colour": ["red", "yellow", "green"]}'
ฮฯฮนฯฮบฯฯฮทฯฮท ฯฮทฯ ฮบฮปฮฌฯฮทฯ JSON Deserialization JSONDecoder
ฮ ฮบฮปฮฌฯฮท JSONDecoder ฯฯฮทฯฮนฮผฮฟฯฮฟฮนฮตฮฏฯฮฑฮน ฮณฮนฮฑ ฯฮทฮฝ ฮฑฯฮฟฯฮตฮนฯฮนฮฟฯฮฟฮฏฮทฯฮท ฮฟฯฮฟฮนฮฟฯ ฮดฮฎฯฮฟฯฮต Python ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ ฮบฮฑฯฮฌ ฯฮทฮฝ ฮตฮบฯฮญฮปฮตฯฮท ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮทฯ. ฮ ฮตฯฮนฮญฯฮตฮน ฯฯฮตฮนฯ ฮดฮนฮฑฯฮฟฯฮตฯฮนฮบฮญฯ ฮผฮตฮธฯฮดฮฟฯ ฯ ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮทฯ ฯฮฟฯ ฮตฮฏฮฝฮฑฮน
- ฯฯฮฟฮตฯฮนฮปฮฟฮณฮฎ(ฮฟ) โ ฮฅฮปฮฟฯฮฟฮนฮฎฮธฮทฮบฮต ฯฯฮทฮฝ ฯ ฯฮฟฮบฮปฮฌฯฮท ฮบฮฑฮน ฮตฯฮนฯฯฯฮฟฯฮฎ ฮฑฯฮฟฯฮตฮนฯฯฮผฮญฮฝฮฟ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ o ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ.
- ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท(ฮฟ) โ ฮฮดฮนฮฟ ฮผฮต ฯฮทฮฝ ฮตฯฮนฯฯฯฮฟฯฮฎ ฯฮทฯ ฮผฮตฮธฯฮดฮฟฯ json.loads(). Python ฮดฮฟฮผฮฎ ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌฯ ฮฎ ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ JSON.
- raw_decode(o) โ ฮฮฝฯฮนฯฯฮฟฯฯฯฮตฯฯ Python ฮปฮตฮพฮนฮบฯ ฮญฮฝฮฑ ฯฯฮฟฯ ฮญฮฝฮฑ ฮบฮฑฮน ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮนฮฎฯฯฮต ฯฮฟ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ o.
ฮฮต ฯฮท ฮฒฮฟฮฎฮธฮตฮนฮฑ ฯฮทฯ ฮผฮตฮธฯฮดฮฟฯ decode() ฯฮทฯ ฮบฮปฮฌฯฮทฯ JSONDecoder, ฮผฯฮฟฯฮฟฯฮผฮต ฮตฯฮฏฯฮทฯ ฮฝฮฑ ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮนฮฎฯฮฟฯ ฮผฮต ฯฮท ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌ JSON ฯฯฯฯ ฯฮฑฮฏฮฝฮตฯฮฑฮน ฯฮฑฯฮฑฮบฮฌฯฯ Python ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮนฮทฯฮฎ JSON.
import json
# import JSONDecoder class from json
from json.decoder import JSONDecoder
colour_string = '{ "colour": ["red", "yellow"]}'
# directly called decode method of JSON
JSONDecoder().decode(colour_string)
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
{'colour': ['red', 'yellow']}
ฮฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ JSON ฮฑฯฯ ฯฮท ฮดฮนฮตฯฮธฯ ฮฝฯฮท URL: ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ ฯฯฮฑฮณฮผฮฑฯฮนฮบฮฎฯ ฮถฯฮฎฯ
ฮฮฑ ฮปฮฌฮฒฮฟฯ ฮผฮต ฮดฮตฮดฮฟฮผฮญฮฝฮฑ ฯฮฟฯ CityBike NYC (ฮฃฯฯฯฮทฮผฮฑ ฮบฮฟฮนฮฝฮฎฯ ฯฯฮฎฯฮทฯ ฯฮฟฮดฮทฮปฮฌฯฯฮฝ) ฮฑฯฯ ฮบฮฑฮธฮฟฯฮนฯฮผฮญฮฝฮท ฮดฮนฮตฯฮธฯ ฮฝฯฮท URL(https://gbfs.citibikenyc.com/gbfs/2.3/gbfs.json) ฮบฮฑฮน ฮผฮตฯฮฑฯฯฮญฯฯฮต ฯฮต ฮผฮฟฯฯฮฎ ฮปฮตฮพฮนฮบฮฟฯ.
Python ฯฯฯฯฯฯฮท JSON ฮฑฯฯ ฯฮฟ ฮฑฯฯฮตฮฏฮฟ ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ:
ฮฃฮฮฮฮฮฉฮฃฮ: - ฮฮตฮฒฮฑฮนฯฮธฮตฮฏฯฮต ฯฯฮน ฮท ฮฒฮนฮฒฮปฮนฮฟฮธฮฎฮบฮท ฮฑฮนฯฮทฮผฮฌฯฯฮฝ ฮตฮฏฮฝฮฑฮน ฮฎฮดฮท ฮตฮณฮบฮฑฯฮตฯฯฮทฮผฮญฮฝฮท ฯฯฮท ฯฯ ฯฮบฮตฯ ฮฎ ฯฮฑฯ Python, ฮฮฌฮฝ ฯฯฮน, ฮฑฮฝฮฟฮฏฮพฯฮต ฯฮฟ Terminal ฮฎ CMD ฮบฮฑฮน ฯฮปฮทฮบฯฯฮฟฮปฮฟฮณฮฎฯฯฮต
- (ฮฮนฮฑ Python 3 ฮฎ ฯฮฑฯฮฑฯฮฌฮฝฯ) ฮฑฮนฯฮฎฮผฮฑฯฮฑ ฮตฮณฮบฮฑฯฮฌฯฯฮฑฯฮทฯ pip3
import json
import requests
# get JSON string data from CityBike NYC using web requests library
json_response= requests.get("https://gbfs.citibikenyc.com/gbfs/2.3/gbfs.json")
# check type of json_response object
print(type(json_response.text))
# load data in loads() function of json library
bike_dict = json.loads(json_response.text)
#check type of news_dict
print(type(bike_dict))
# now get stationBeanList key data from dict
print(bike_dict['stationBeanList'][0])
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
<class 'str'>
<class 'dict'>
{
'id': 487,
'stationName': 'E 20 St & FDR Drive',
'availableDocks': 24,
'totalDocks': 34,
'latitude': 40.73314259,
'longitude': -73.97573881,
'statusValue': 'In Service',
'statusKey': 1,
'availableBikes': 9,
'stAddress1': 'E 20 St & FDR Drive',
'stAddress2': '',
'city': '',
'postalCode': '',
'location': '',
'altitude': '',
'testStation': False,
'lastCommunicationTime': '2018-12-11 10:59:09 PM', 'landMark': ''
}
ฮฮพฮฑฮนฯฮญฯฮตฮนฯ ฯฮฟฯ ฯฯฮตฯฮฏฮถฮฟฮฝฯฮฑฮน ฮผฮต ฯฮท ฮฒฮนฮฒฮปฮนฮฟฮธฮฎฮบฮท JSON in Python:
- ฮคฮฌฮพฮท json.JSONDecoderError ฯฮตฮนฯฮฏฮถฮตฯฮฑฮน ฯฮทฮฝ ฮตฮพฮฑฮฏฯฮตฯฮท ฯฮฟฯ ฯฯฮตฯฮฏฮถฮตฯฮฑฮน ฮผฮต ฯฮท ฮปฮตฮนฯฮฟฯ ฯฮณฮฏฮฑ ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮทฯ. ฮบฮฑฮน ฮตฮฏฮฝฮฑฮน ฮผฮนฮฑ ฯ ฯฮฟฮบฮฑฯฮทฮณฮฟฯฮฏฮฑ ฯฮฟฯ ValueError.
- ฮฮพฮฑฮฏฯฮตฯฮท - json.JSONDecoderError(msg, doc)
- ฮฮน ฯฮฑฯฮฌฮผฮตฯฯฮฟฮน ฯฮทฯ ฮตฮพฮฑฮฏฯฮตฯฮทฯ ฮตฮฏฮฝฮฑฮน,
- msg โ ฮฮท ฮผฮฟฯฯฮฟฯฮฟฮนฮทฮผฮญฮฝฮฟ ฮผฮฎฮฝฯ ฮผฮฑ ฯฯฮฌฮปฮผฮฑฯฮฟฯ
- doc โ ฮคฮฑ ฮญฮณฮณฯฮฑฯฮฑ JSON ฮฑฮฝฮฑฮปฯฮธฮทฮบฮฑฮฝ
- pos โ ฮญฮฝฮฑฯฮพฮท ฮตฯ ฯฮตฯฮทฯฮฏฮฟฯ ฮตฮณฮณฯฮฌฯฮฟฯ ฯฯฮฑฮฝ ฮฑฯฮฟฯฯฯฮตฮน
- lineno โ ฮท ฮณฯฮฑฮผฮผฮฎ no ฮดฮตฮฏฯฮฝฮตฮน ฮฑฮฝฯฮนฯฯฮฟฮนฯฮตฮฏ ฯฯฮท ฮธฮญฯฮท
- ฮฌฮฝฯ ฮบฮฑฮน ฮบฮฌฯฯ ฯฮตฮปฮตฮฏฮฑ โ ฮท ฯฯฮฎฮปฮท ฮดฮตฮฝ ฮฑฮฝฯฮนฯฯฮฟฮนฯฮตฮฏ ฯฯฮท ฮธฮญฯฮท
Python ฯฯฯฯฯฯฮท JSON ฮฑฯฯ ฯฮฟ ฮฑฯฯฮตฮฏฮฟ ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ:
import json
#File I/O Open function for read data from JSON File
data = {} #Define Empty Dictionary Object
try:
with open('json_file_name.json') as file_object:
data = json.load(file_object)
except ValueError:
print("Bad JSON file format, Change JSON File")
ฮฯฮตฮนฯฮฟ ฮบฮฑฮน NaN Numbers in Python
ฮ ฮผฮฟฯฯฮฎ ฮฑฮฝฯฮฑฮปฮปฮฑฮณฮฎฯ ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ JSON (RFC โ ฮฮฏฯฮทฮผฮฑ ฮณฮนฮฑ ฯฯฯฮปฮนฮฑ) ฮดฮตฮฝ ฮตฯฮนฯฯฮญฯฮตฮน ฯฮทฮฝ ฮฌฯฮตฮนฯฮท ฮฎ ฯฮทฮฝ ฯฮนฮผฮฎ Nan, ฮฑฮปฮปฮฌ ฮดฮตฮฝ ฯ ฯฮฌฯฯฮตฮน ฯฮตฯฮนฮฟฯฮนฯฮผฯฯ ฯฮต Python- ฮฮนฮฒฮปฮนฮฟฮธฮฎฮบฮท JSON ฮณฮนฮฑ ฮตฮบฯฮญฮปฮตฯฮท ฮปฮตฮนฯฮฟฯ ฯฮณฮนฯฮฝ ฯฮฟฯ ฯฯฮตฯฮฏฮถฮฟฮฝฯฮฑฮน ฮผฮต Infinite ฮบฮฑฮน Nan Value. ฮฮฌฮฝ ฯฮฟ JSON ฮปฮฌฮฒฮตฮน INFINITE ฮบฮฑฮน ฯฯฯฮฟ ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ Nan, ฮผฮตฯฮฑฯฯฮญฯฮตฯฮฑฮน ฯฮต ฮบฯ ฯฮนฮฟฮปฮตฮบฯฮนฮบฯ.
ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ,
import json
# pass float Infinite value
infinite_json = json.dumps(float('inf'))
# check infinite json type
print(infinite_json)
print(type(infinite_json))
json_nan = json.dumps(float('nan'))
print(json_nan)
# pass json_string as Infinity
infinite = json.loads('Infinity')
print(infinite)
# check type of Infinity
print(type(infinite))
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
Infinity <class 'str'> NaN inf <class 'float'>
ฮฯฮฑฮฝฮฑฮปฮฑฮผฮฒฮฑฮฝฯฮผฮตฮฝฮฟ ฮบฮปฮตฮนฮดฮฏ ฯฯฮฟ JSON String
ฮคฮฟ RFC ฮบฮฑฮธฮฟฯฮฏฮถฮตฮน ฯฯฮน ฯฮฟ ฯฮฝฮฟฮผฮฑ ฮบฮปฮตฮนฮดฮนฮฟฯ ฯฯฮญฯฮตฮน ฮฝฮฑ ฮตฮฏฮฝฮฑฮน ฮผฮฟฮฝฮฑฮดฮนฮบฯ ฯฮต ฮญฮฝฮฑ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ JSON, ฮฑฮปฮปฮฌ ฮดฮตฮฝ ฮตฮฏฮฝฮฑฮน ฯ ฯฮฟฯฯฮตฯฯฮนฮบฯ. Python ฮ ฮฒฮนฮฒฮปฮนฮฟฮธฮฎฮบฮท JSON ฮดฮตฮฝ ฮดฮทฮผฮนฮฟฯ ฯฮณฮตฮฏ ฮตฮพฮฑฮฏฯฮตฯฮท ฮตฯฮฑฮฝฮฑฮปฮฑฮผฮฒฮฑฮฝฯฮผฮตฮฝฯฮฝ ฮฑฮฝฯฮนฮบฮตฮนฮผฮญฮฝฯฮฝ ฯฯฮฟ JSON. ฮฮณฮฝฮฟฮตฮฏ ฯฮปฮฑ ฯฮฑ ฮตฯฮฑฮฝฮฑฮปฮฑฮผฮฒฮฑฮฝฯฮผฮตฮฝฮฑ ฮถฮตฯฮณฮฟฯ ฮบฮปฮตฮนฮดฮนฮฟฯ-ฯฮนฮผฮฎฯ ฮบฮฑฮน ฮปฮฑฮผฮฒฮฌฮฝฮตฮน ฯ ฯฯฯฮท ฮผฯฮฝฮฟ ฯฮฟ ฯฮตฮปฮตฯ ฯฮฑฮฏฮฟ ฮถฮตฯฮณฮฟฯ ฮบฮปฮตฮนฮดฮนฮฟฯ-ฯฮนฮผฮฎฯ ฮผฮตฯฮฑฮพฯ ฯฮฟฯ ฯ.
- ฮ ฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ,
import json
repeat_pair = '{"a": 1, "a": 2, "a": 3}'
json.loads(repeat_pair)
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
{'a': 3}
CLI (ฮฮนฮตฯฮฑฯฮฎ ฮณฯฮฑฮผฮผฮฎฯ ฮตฮฝฯฮฟฮปฯฮฝ) ฮผฮต JSON in Python
json.tool ฯฮฑฯฮญฯฮตฮน ฯฮท ฮดฮนฮตฯฮฑฯฮฎ ฮณฯฮฑฮผฮผฮฎฯ ฮตฮฝฯฮฟฮปฯฮฝ ฮณฮนฮฑ ฯฮทฮฝ ฮตฯฮนฮบฯฯฯฯฮท ฯฮทฯ ฯฯฮฝฯฮฑฮพฮทฯ ฯฮผฮฟฯฯฮทฯ ฮตฮบฯฯฯฯฯฮทฯ JSON. ฮฯ ฮดฮฟฯฮผฮต ฮญฮฝฮฑ ฯฮฑฯฮฌฮดฮตฮนฮณฮผฮฑ CLI
$ echo '{"name" : "Kings Authur" }' | python3 -m json.tool
ฮ ฮฑฯฮฑฮณฯฮณฮฎ:
{
"name": " Kings Authur "
}
ฮ ฮปฮตฮฟฮฝฮตฮบฯฮฎฮผฮฑฯฮฑ ฯฮฟฯ JSON ฯฮต Python
- ฮฯฮบฮฟฮปฮท ฮผฮตฯฮฑฮบฮฏฮฝฮทฯฮท ฮผฮตฯฮฑฮพฯ ฮบฮฟฮฝฯฮญฮนฮฝฮตฯ ฮบฮฑฮน ฯฮนฮผฮฎฯ (JSON ฯฮต Python Python ฯฮต JSON)
- ฮฮฝฮฑฮณฮฝฯฯฮนฮผฮฟ ฮฑฯฯ ฯฮฟฮฝ ฮฌฮฝฮธฯฯฯฮฟ (ฯฮผฮฟฯฯฮท ฮตฮบฯฯฯฯฯฮท) ฮฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ JSON
- ฮงฯฮทฯฮนฮผฮฟฯฮฟฮนฮตฮฏฯฮฑฮน ฮตฯ ฯฮญฯฯ ฯฯฮฟฮฝ ฯฮตฮนฯฮนฯฮผฯ ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ.
- ฮฮตฮฝ ฮญฯฮตฮน ฯฮทฮฝ ฮฏฮดฮนฮฑ ฮดฮฟฮผฮฎ ฮดฮตฮดฮฟฮผฮญฮฝฯฮฝ ฯฯฮฟ ฮผฮตฮผฮฟฮฝฯฮผฮญฮฝฮฟ ฮฑฯฯฮตฮฏฮฟ.
ฮ ฮตฯฮนฮฟฯฮนฯฮผฮฟฮฏ ฯ ฮปฮฟฯฮฟฮฏฮทฯฮทฯ JSON ฯฮต Python
- ฮฃฮต ฮฑฯฮฟฯฮตฮนฯฮนฮฟฯฮฟฮนฮทฯฮฎ ฮตฯฯฮฟฯ ฯ JSON ฮบฮฑฮน ฯฯฯฮฒฮปฮตฯฮท ฮฑฯฮนฮธฮผฮฟฯ
- ฮคฮฟ ฮผฮญฮณฮนฯฯฮฟ ฮผฮฎฮบฮฟฯ ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌฯ JSON ฮบฮฑฮน ฯฮฏฮฝฮฑฮบฮตฯ JSON ฮบฮฑฮน ฮญฮฝฮธฮตฯฮฑ ฮตฯฮฏฯฮตฮดฮฑ ฮฑฮฝฯฮนฮบฮตฮนฮผฮญฮฝฮฟฯ .
Python ฮฆฯฮปฮปฮฟ ฮตฮพฮฑฯฮฌฯฮทฯฮทฯ JSON
| Python ฮฮตฮนฯฮฟฯ ฯฮณฮฏฮฑ JSON | ฮ ฮตฯฮนฮณฯฮฑฯฮฎ |
|---|---|
| json.dumps(person_data) | ฮฮทฮผฮนฮฟฯ ฯฮณฮฏฮฑ ฮฑฮฝฯฮนฮบฮตฮนฮผฮญฮฝฮฟฯ JSON |
| json.dump(person_data, file_write) | ฮฮทฮผฮนฮฟฯ ฯฮณฮฎฯฯฮต ฮฑฯฯฮตฮฏฮฟ JSON ฯฯฮทฯฮนฮผฮฟฯฮฟฮนฯฮฝฯฮฑฯ ฯฮฟ File I/O of Python |
| compact_obj = json.dumps(ฮดฮตฮดฮฟฮผฮญฮฝฮฑ, ฮดฮนฮฑฯฯฯฮนฯฯฮนฮบฮฌ=(',',':')) | ฮฃฯ ฮผฯฯ ฮบฮฝฯฯฯฮต ฯฮฟ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ JSON ฮฑฯฮฑฮนฯฯฮฝฯฮฑฯ ฯฮฟฮฝ ฯฮฑฯฮฑฮบฯฮฎฯฮฑ ฮดฮนฮฑฯฯฮฎฮผฮฑฯฮฟฯ ฮฑฯฯ ฯฮฟ ฮฑฮฝฯฮนฮบฮตฮฏฮผฮตฮฝฮฟ JSON ฯฯฮทฯฮนฮผฮฟฯฮฟฮนฯฮฝฯฮฑฯ ฮดฮนฮฑฯฯฯฮนฯฯฮนฮบฯ |
| formatted_obj = json.dumps(dic, indent=4, separators=(',', ': ')) | ฮฮฟฯฯฮฟฯฮฟฮฏฮทฯฮท ฮบฯฮดฮนฮบฮฑ JSON ฮผฮต ฯฯฮฎฯฮท ฮตฯฮฟฯฮฎฯ |
| sorted_string = json.dumps(x, indent=4, sort_keys=True) | ฮคฮฑฮพฮนฮฝฯฮผฮทฯฮท ฮบฮปฮตฮนฮดฮนฮฟฯ ฮฑฮฝฯฮนฮบฮตฮนฮผฮญฮฝฮฟฯ JSON ฮบฮฑฯฮฌ ฮฑฮปฯฮฑฮฒฮทฯฮนฮบฮฎ ฯฮตฮนฯฮฌ |
| complex_obj = json.dumps(4 + 5j, default=complex_encode) | Python ฮฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฯฯฮฝฮธฮตฯฮฟฯ ฮฑฮฝฯฮนฮบฮตฮนฮผฮญฮฝฮฟฯ ฯฮต JSON |
| JSONEncoder().encode(colour_dict) | ฮงฯฮฎฯฮท ฯฮทฯ ฮบฮปฮฌฯฮทฯ JSONEncoder ฮณฮนฮฑ ฯฮตฮนฯฮนฮฟฯฮฟฮฏฮทฯฮท |
| json.loads(data_string) | ฮฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฯฯ ฮผฮฒฮฟฮปฮฟฯฮตฮนฯฮฌฯ JSON ฮผฮญฯฮฑ Python ฮปฮตฮพฮนฮบฯ ฯฮฟฯ ฯฯฮทฯฮนฮผฮฟฯฮฟฮนฮตฮฏ ฯฮท ฯฯ ฮฝฮฌฯฯฮทฯฮท json.loads(). |
| json.loads('{โ__complex__โ: true, โrealโ: 4, โimgโ: 5}', object_hook = is_complex) | ฮฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮท ฯฯฮฝฮธฮตฯฮฟฯ ฮฑฮฝฯฮนฮบฮตฮนฮผฮญฮฝฮฟฯ JSON ฯฯฮฟ Python |
| JSONDecoder().decode(colour_string) | ฮงฯฮฎฯฮท ฮฑฯฮฟฮบฯฮดฮนฮบฮฟฯฮฟฮฏฮทฯฮทฯ JSON ฯฮต Python ฮผฮต ฮฯฮฟฯฮตฮนฯฮฟฯฮฟฮฏฮทฯฮท |








