Python implements objects that support JSON storage and parsing

We know that the JSON module can be used to conveniently store Python basic type (dict, list, etc.) data into files permanently, and at the same time, it can also be converted through custom functions and InheritThe JSON encode&decode method implements the storage of custom classes. This article is based on the previous "Python JSON module" to implement objects that Python supports JSON storage.

It makes great sense for objects to be stored and parsed in JSON. For example, there is a large amount of data calculation in the training process of all classification algorithms in machine learning. If the classification algorithm needs to be retrained every time the classification is started, it is a waste of resources and inefficient. If the classification algorithm object generated by the training can be saved, then unless needed Algorithm tuning only needs to be loaded later. On the other hand, the ability of objects to parse and store JSON also allows them to be transmitted over the network, which is of great significance in current cloud computing and distributed data processing.

In order to realize self-storage and parsing, the key operations of defining an object are:

0, add object_json.py copy to the package, The module that defines the object imports object_json: import object_json.

1. The init() function must support a variable number of function calls, that is, it must be written as init(self, …, , **args). Only by defining the object in this way can it have properties other than the properties that need to be initialized during the construction phase.

2. For attributes that must be initialized during the object construction phase, the formal parameters in the init() function must be exactly the same as the names of these attributes, so that they can be constructed through the dictionary 'key': value pair object.

3. Define an attribute ‘name’ – the name of the object instance, implemented using the inspect module. The ‘name’ attribute is mainly used to generate the default file name when storing objects.

4, define jsonDumps() and jsonLoadTransfer() methods, complete object JSON file loading and new object creation through objectLoadFromFile().

(i) jsonDumps() is used to convert objects into dict and store objects into json files through json.dumps(). If the user does not specify a file name, instancename.json will be the default storage file. Since JSON only supports Python basic types, if there are some other types in the object (such as numpy matrix), they need to be converted into Python basic types (such as matrix.tolist() to convert matrix into list).

(ii) jsonLoadTransfer() is used to complete the conversion of data format and convert some object attributes from basic types to required types (such as mat(list) to convert the type from list to matrix). If the object only has Python basic types can omit this method. The process of creating a complete and usable object is:

obj = objectLoadFromFile()   
obj.jsonLoadTransfer()

The following code is the source code of the object_json module that supports custom objects for JSON storage and parsing.

import json   
import inspect    
import pdb   
def object2dict(obj):      
    #convert object to a dict      
    d = {'class':obj.class.name, 'module':obj.module}      
    d.update(obj.dict)      
    return d   
def objectDumps2File(obj, jsonfile):   
    objDict = object2dict(obj)   
    with open(jsonfile, 'w') as f:   
        f.write(json.dumps(objDict))   

def dict2object(d):      
    '''convert dict to object, the dict will be changed'''       
    if'class' in d:      
        class_name = d.pop('class')      
        module_name = d.pop('module')      
        module = import(module_name)      
        #print 'the module is:', module      
        class_ = getattr(module,class_name)      
        args = dict((key.encode('ascii'), value) for key, value in d.items()) #get args     
        #print 'the atrribute:', repr(args)   
        #pdb.set_trace()   
        inst = class_(**args) #create new instance      
    else:      
        inst = d      
    return inst   
def objectLoadFromFile(jsonFile):   
    '''load json file and generate a new object instance whose name filed  
    will be 'inst' '''  
    with open(jsonFile) as f:   
        objectDict =json.load(f)   
    obj = dict2object(objectDict)   
    return obj   
#test function      
if name  == 'main':   
    class Person(object):      
        def init(self,name,age, **args):   
            obj_list = inspect.stack()[1][-2]   
            self.name = obj_list[0].split('=')[0].strip()#object instance name   
            self.name = name      
            self.age = age   

        def repr(self):      
            return 'Person Object name : %s , age : %d' % (self.name,self.age)   
        def say(self):   
            #d = inspect.stack()[1][-2]   
            #print d[0].split('.')[0].strip()   
            return self.name  
        def jsonDumps(self, filename=None):   
            '''essential transformation to Python basic type in order to  
            store as json. dumps as objectname.json if filename missed '''  
            if not filename:   
                jsonfile = self.name+'.json'   
            else: jsonfile = filename   
            objectDumps2File(self, jsonfile)   

        def jsonLoadTransfer(self):#TBD   
            '''essential transformation to object required type,such as  
            numpy matrix.call this function after newobject = objectLoadFromFile(jsonfile)'''  
            pass  

    p = Person('Aidan',22)        
    #json.dumps(p)#error will be throwed   

    #objectDumps2File(p,'Person.json')   
    p.jsonDumps()   
    p_l = objectLoadFromFile('p.json')   

    print 'the decoded obj type: %s, obj:%s' % (type(p_l),repr(p_l))

There are two types of Python classes, old and new. The purpose of inheriting object after py 2.2 is to make this class a new style class. Those that do not inherit object are traditional classic classes (which will eventually inherit object).

The following two methods are included in the class definition:

class Person():   
class Person(object)

The difference is:

If a new Person instanc test is created, the output of type (test) is:

<type &#39;instance&#39;>   
<class &#39;main.Person&#39;>

The inspect module provides a series of introspection functions, which can obtain information about modules, classes, methods, functions, tracebacks, frame objects, and code objects. Commonly used methods are getmembers, ismodule, getcallargs, isclass, etc.,

The above is the detailed content of Python implements objects that support JSON storage and parsing. For more information, please follow other related articles on the PHP Chinese website!