Preface

• JSON (JavaScript Object Notation, JavaScript Object Representation) is a lightweight data exchange language

• JSON is a language-independent text format, and JSON data format is language-independent.

• The characteristics of JSON data format:
  • Objects are represented as key-value pairs
  • Data is separated by commas
  • Curly brackets save objects
    • An object contains a series of unordered name/value pairs, and an object begins with {and ends with}. Use between each name/value pair: split
  • Square brackets hold arrays.
    • An array is a collection of values, and an array begins and ends with. Use and partition between group members

JSON Data Reading

First, we need to import modules

 import json

Reading json data, json module provides two methods, loads and load, to achieve "deserialization". So, there are differences between them. The comparison is as follows:

 def load(fp, *, cls=None, object_hook=None, parse_float=None,
        parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
        
  """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
    a JSON document) to a Python object.""" 

def loads(s, *, encoding=None, cls=None, object_hook=None, parse_float=None,
        parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
        
    """Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance
    containing a JSON document) to a Python object."""

It's easy to see that load needs to pass in a file object, while loads needs a memory object.

Now there is a document. data.json The data are as follows:

  {
    "id": "2016984", 
    "title": "Heading 2", 
    "publish_data": "2019/4/15", 
    "publish_place": "Guangzhou", 
    "software": "boss",
    "skill": ["Go", "Ruby", "Java", "Python"]
}

Now use load and loads to read and print out the contents of data.json, respectively.

    with open('datas.json', 'r', encoding='utf-8') as fo:
        d= json.load(fo)
    print(d, type(d))
        
    print('-'*150) # Divide it up to make a good distinction.
    
    with open('datas.json', 'r', encoding='utf-8') as fo:
        '''
            //Because loads need to pass in a memory object, so
            //You need to save it temporarily in memory, and then use loads to do it.
            //Data reading operation
        '''
        data = fo.read()
        d2= json.loads(data)  
    print(d2, type(d2))

The printing effect is as follows:

Writing of JSON Data

The json module also provides two writing methods, dump and dumps, as follows:

def dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True,
        allow_nan=True, cls=None, indent=None, separators=None,
        default=None, sort_keys=False, **kw):
    """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
    ``.write()``-supporting file-like object)."""

def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
        allow_nan=True, cls=None, indent=None, separators=None,
        default=None, sort_keys=False, **kw):
    """Serialize ``obj`` to a JSON formatted ``str``."""

In fact, the two are much the same as reading, they are different objects needed.

So here's a data:

    data = {
        'id': '2016982',
        'title': 'Heading 1',
        'publish_data': '2019/4/15',
        'publish_place': 'Shenzhen',
        'software': 'lg',
    }

Writing files with dump and dumps respectively

    with open('datas.json', 'w', encoding='utf-8') as f:
        json.dump(data, f, ensure_ascii=False, indent=4, separators=(', ', ': '))

    with open('datas.json', 'w', encoding='utf-8') as f:
        # Format a dictionary into a string object
        f.write(json.dumps(data2, ensure_ascii=False, indent=4, separators=(', ', ': ')))

After writing, you will get a file named datas.json, which reads as follows:

{
        'id': '2016982',
        'title': 'Heading 1',
        'publish_data': '2019/4/15',
        'publish_place': 'Shenzhen',
        'software': 'lg',
    }

The role of each parameter in the method