python json 解析

最新推荐文章于 2023-12-28 11:42:59 发布
最新推荐文章于 2023-12-28 11:42:59 发布
阅读量326 收藏
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/amoychc/article/details/109406419
版权 
# -*- coding: utf-8 -*-
import sys, os, re


class JsonBaseType:
    single_type = 0
    object_type = 1
    array_type = 2


class ParseException():
    def __init__(self,error):
        self.error = error

    def __str__(self,*args,**kwargs):
        return self.error

# NUMBER_RE = re.compile(
#     r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?',
#     (re.VERBOSE | re.MULTILINE | re.DOTALL))
class JsonHelper(object):
    def __init__(self):
        self.jsObjectType = JsonBaseType.single_type
        self.dictResult = dict()

        self.jsEleName = ''
        self.jsArrayValue = []

    def __getitem__(self, item):
        return self.dictResult[item]

    def JsonParse(self, jsString):
        jsString = jsString.strip()
        jsString = jsString.replace('\r', '').replace('\n', '')

        if len(jsString) > 0:
            if jsString[0] == '{':
                self.jsObjectType = JsonBaseType.object_type
                self.ObjectParse(jsString[1:])
            elif jsString[0] == '[':
                self.jsObjectType = JsonBaseType.array_type
                self.ArrayParse(jsString[1:])
            else:
                jsString, ret_object, ret_string = self.SingleObjectParse(jsString)
                self.dictResult[''] = ret_object
                if 0 != len(ret_string):
                    self.dictResult['String' + ret_string] = ret_string
        else:
            raise ParseException('JsonParse json error 2|||' + jsString)

        return self.dictResult

    def ArrayParse(self, jsString):
        nIdxRet = 0
        bEndObject = False
        bCorrectFormat = True
        nLenString = len(jsString)
        jsStringBak = ''

        bCorrectFormat, bEndObject = self.CheckBlankByte(jsString, 0)
        if not bCorrectFormat:
            raise ParseException('ArrayParse json error 1|||' + jsString[0:20])

        nPos = jsString.find('{')
        if -1 != nPos:
            jsString = jsString[nPos+1:]

        while True:
            nIdxTmp = len(jsString)
            jsString = jsString.strip()
            jsString = jsString[1:]
            nIdxRet += nIdxTmp - len(jsString) + 1#清除开头的空白字符，并更新当前位置
            jsObj = JsonHelper()
            nIdxTmp, bEndObject = jsObj.ObjectParse(jsString, True)#非子节点
            self.jsArrayValue.append(jsObj)
            nIdxRet += nIdxTmp
            jsString = jsString[len(jsString)-nIdxTmp:]#抛弃已解析完的，保留还未解析的

            if 0 == len(jsString):
                break

            if bEndObject:
                bCorrectFormat, bEndObject = self.CheckBlankByte(jsString, 5)
                if not bCorrectFormat:
                    raise ParseException('ArrayParse json error 1|||' + jsString[0:20])
                else:
                    if bEndObject:
                        break

                    nPos = jsString.find(',')#直接找下一个object
                    if -1 != nPos:
                        jsString = jsString[nPos:]
                        bCorrectFormat, bEndObject = self.CheckBlankByte(jsString, 6)  # 1、{到"之间不能有其他可见字符
                        if bCorrectFormat:
                            nPos = jsString.find('"')
                            if -1 != nPos:
                                jsString = jsString[nPos:]
                                jsString = jsString.strip()
                    else:
                        bCorrectFormat, bEndObject = self.CheckBlankByte(jsString, 7)
                        if not bCorrectFormat:
                            raise ParseException('ArrayParse json error 2|||' + jsString[0:20])
                        else:
                            if bEndObject:
                                nPos = jsString.find(']')
                                if -1 != nPos:
                                    jsString = jsString[nPos+1:]
                                    jsString = jsString.strip()
                                    break

        jsStringBak = jsString
        self.dictResult[self.jsEleName] = self.jsArrayValue
        self.jsArrayValue = []
        return len(jsStringBak), bEndObject

    def ArrayParseEx(self, jsString):
        jsString = jsString.strip()
        nIdxRet = 0
        bEndObject = False
        bCorrectFormat = True
        nLenString = len(jsString)
        jsStringBak = ''

        while True:
            if jsString[0] == '[':
                pass
            elif jsString[0] == '{':
                pass
            else:
                jsString, ret_object, ret_string = self.SingleObjectParse(jsString)
                self.jsArrayValue.append(ret_object)
                if 0 != len(ret_string):
                    self.dictResult['String'] = ret_string

            jsString = jsString.strip()
            if 0 == len(jsString):
                break




# 就代码======================================================

            if bEndObject:
                bCorrectFormat, bEndObject = self.CheckBlankByte(jsString, 5)
                if not bCorrectFormat:
                    raise ParseException('ArrayParse json error 1|||' + jsString[0:20])
                else:
                    if bEndObject:
                        break

                    nPos = jsString.find(',')  # 直接找下一个object
                    if -1 != nPos:
                        jsString = jsString[nPos:]
                        bCorrectFormat, bEndObject = self.CheckBlankByte(jsString, 6)  # 1、{到"之间不能有其他可见字符
                        if bCorrectFormat:
                            nPos = jsString.find('"')
                            if -1 != nPos:
                                jsString = jsString[nPos:]
                                jsString = jsString.strip()
                    else:
                        bCorrectFormat, bEndObject = self.CheckBlankByte(jsString, 7)
                        if not bCorrectFormat:
                            raise ParseException('ArrayParse json error 2|||' + jsString[0:20])
                        else:
                            if bEndObject:
                                nPos = jsString.find(']')
                                if -1 != nPos:
                                    jsString = jsString[nPos + 1:]
                                    jsString = jsString.strip()
                                    break

        jsStringBak = jsString
        self.dictResult[self.jsEleName] = self.jsArrayValue
        self.jsArrayValue = []
        return len(jsStringBak), bEndObject

    def ObjectParse(self, jsString, bChildObj = False, bArrayObj = False):
        nIdxRet = 0
        bEndObject = False
        nLenString = len(jsString)
        jsStringBak = ''

        while True:
            nIdxTmp = len(jsString)
            jsString = jsString.strip()
            if jsString[0] == '"':
                jsString = jsString[1:]
            jsStringBak = jsString
            nIdxTmp, bEndObject = self.ElementParse(jsString)

            if bEndObject:
                jsString = jsString[len(jsString) - nIdxTmp:]
                if bChildObj or bArrayObj:
                    break
            else:
                jsString = jsString[len(jsString)-nIdxTmp+1:]#抛弃已解析完的，保留还未解析的

            if 0 == len(jsString):
                break

        jsStringBak = jsString
        return len(jsStringBak), bEndObject

    def SingleObjectParse(self, jsString):
        ret_object = None
        ret_string = ''
        if jsString[0] == 'n' and jsString[0:4] == 'null':
            jsString = jsString[4:]
        elif jsString[0] == 't' and jsString[0:4] == 'true':
            ret_object = True
            jsString = jsString[4:]
        elif jsString[0] == 'f' and jsString[0:5] == 'false':
            ret_object = False
            jsString = jsString[5:]
        elif jsString[0] == '"':
            ret_value, tmp_pos, end_object = self.ElementStringParse(jsString[1:], False, True)
            ret_object = ret_value
            jsString = jsString[len(jsString) - tmp_pos + 1:]
        else:
            match_res = re.match(r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?', jsString, re.M | re.I)
            if match_res:
                try:
                    str_num = match_res.group()
                    try:
                        ret_object = int(str_num)
                    except ValueError:
                        ret_object = float(str_num)  # 指数可能会失败，如果精度要求太高的话
                        ret_string = str_num

                    idx_ret = jsString.find(str_num) + len(str_num)
                    jsString = jsString[idx_ret:]
                except ValueError:
                    raise ParseException('SingleObjectParse json error 1|||' + jsString)
            else:
                raise ParseException('SingleObjectParse json error 2|||' + jsString)

        # 校验普通值后面的数据,值后面还有数值格式就不对了
        jsString = jsString.strip()
        if 0 != len(jsString):
            raise ParseException('SingleObjectParse json error 3|||' + jsString)

        return jsString, ret_object, ret_string

    #进到ElementParse已经是去掉当前Element的第一个"(ps  userId": "U46554751"...)
    def ElementParse(self, jsString):
        chNext = ''
        bEndObject = False  # 当前object是否结束
        nLenString = len(jsString)
        nIdxTmp = 0

        nIdxRet = len(jsString)
        jsString = jsString.strip()
        nIdxRet = nIdxRet - len(jsString)
        self.jsEleName, nIdxTmp, bEndObject = self.ElementStringParse(jsString)# 获得元素名
        jsString = jsString[nLenString - nIdxTmp + 1:]#把前面已解析完蛋抛弃掉
        jsStringBak = jsString
        nIdxTmp = len(jsString)
        jsString = jsString.strip()#移除开头空白字符
        nIdxRet += nIdxTmp - len(jsString)
        nIdxTmp = 0

        bCorrectFormat = True#默认是符合空白字符规则的
        if jsString[0:4] == 'true' or jsString[0:4] == 'null' or jsString[0:5] == 'false':
            bCorrectFormat = True
        else:
            matchRes = re.match(r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?', jsString, re.M | re.I)
            if not matchRes:
                bCorrectFormat, bEndObject = self.CheckBlankByte(jsString, 2)
                if not bCorrectFormat:#element name取出来后马上检查:到值之间是否有违规字符
                    raise ParseException('ElementParse json error 1|||' + jsString[0:20])

        bNtf = False #是否是null,true,false三种之一,这时候需要校验当前object是否结束，是否符合空白规则
        for idx in range(len(jsString)):
            try:
                chNext = jsString[idx]
            except IndexError:
                raise ParseException('ElementParse visit overstep the boundary 1|||' + jsString[idx:idx+20])

            if bNtf:  # null,true,false以及数值型数据这几种类型值取出来后马上检查结尾是否有违规字符（非空白）,结尾可能是,也可能是}
                bCorrectFormat, bEndObject = self.CheckBlankByte(jsString[nIdxTmp:], 4)
                if not bCorrectFormat:
                    raise ParseException('ElementParse json error 2|||' + jsString[nIdxTmp:nIdxTmp+20])

                if bEndObject:#解析到这里，说明当前的element已经结完，接下去不是空白字符就是,或者}
                    nIdxRet = jsString.find('}') + 1
                else:
                    nIdxRet = jsString.find(',') + 1
                jsStringBak = jsString[nIdxRet:]

                nIdxTmp = 0
                break

            if chNext == 'n' and jsString[idx:idx + 4] == 'null':
                bNtf = True
                nIdxTmp = idx + 4
                nIdxRet = nIdxRet + 4
                jsStringBak = jsStringBak[nIdxRet:]
                self.dictResult[self.jsEleName] = None
                continue
            elif chNext == 't' and jsString[idx:idx + 4] == 'true':
                bNtf = True
                nIdxTmp = idx + 4
                nIdxRet = nIdxRet + 4
                jsStringBak = jsStringBak[nIdxRet:]
                self.dictResult[self.jsEleName] = True
                continue
            elif chNext == 'f' and jsString[idx:idx + 5] == 'false':
                bNtf = True
                nIdxTmp = idx + 5
                nIdxRet = nIdxRet + 5
                jsStringBak = jsStringBak[nIdxRet:]
                self.dictResult[self.jsEleName] = False
                continue
            elif chNext == '"':#字符串
                jsStringValue, nIdxTmp, bEndObject = self.ElementStringParse(jsString[1:], True)
                jsString = jsString[len(jsString)-nIdxTmp+1:]
                jsStringBak = jsString
                nIdxRet = nIdxRet + nIdxTmp + 1
                self.dictResult[self.jsEleName] = jsStringValue
                nIdxTmp = 0
                break
            elif chNext == '[':
                if jsString[0] == '[':
                    jsString = jsString[1:]
                if 0 != len(self.jsArrayValue):
                    self.jsArrayValue = []
                nIdxTmp, bEndObject = self.ArrayParse(jsString)
                jsString = jsString[len(jsString) - nIdxTmp + 1:]
                jsStringBak = jsString
                nIdxRet += nIdxTmp
                nIdxTmp = 0
                break
            elif chNext == '{':
                jsObjectValue = JsonHelper()
                strRes = jsString[idx+1:]#从{的下一个位置开始解析接下来的object
                strRes = strRes.strip()
                nIdxTmp, bEndObject = jsObjectValue.ObjectParse(strRes, True)
                self.dictResult[self.jsEleName] = jsObjectValue
                if bEndObject:
                    jsString = strRes[len(strRes) - nIdxTmp:]
                else:
                    jsString = strRes[len(strRes) - nIdxTmp + 1:]
                jsStringBak = jsString
                if bEndObject:
                    bCorrectFormat, bEndObject = self.CheckBlankByte(jsString, 4)#判断是否还有下一个element，并校验格式
                    if not bCorrectFormat:
                        raise ParseException('ElementParse json error 3|||' + jsString[0:20])
                    else:
                        if not bEndObject:
                            nIdxTmp = jsString.find(',')
                            if -1 != nIdxTmp:
                                jsString = jsString[nIdxTmp+1:]
                                nIdxRet = nIdxRet + nIdxTmp + 1
                                jsStringBak = jsString
                            bCorrectFormat, bEndObject = self.CheckBlankByte(jsString, 3)#还有下一个element，校验,到"之间的格式
                            if not bCorrectFormat:
                                raise ParseException('ElementParse json error 4|||' + jsString[0:20])
                            else:
                                nIdxTmp = jsString.find('"')
                                if -1 != nIdxTmp:
                                    jsString = jsString[nIdxTmp:]
                                    nIdxRet = nLenString - len(jsString)
                                    jsStringBak = jsString
                        else:
                            nIdxTmp = jsString.find('}')
                            if -1 != nIdxTmp:
                                jsString = jsString[nIdxTmp + 1:]
                                jsStringBak = jsString
                nIdxTmp = 0
                break
            else:
                #其他情况解析为数据，如果无法解析，则json格式错了
                strNum = jsString.strip()
                matchRes = re.match(r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?', strNum, re.M | re.I)
                if matchRes:
                    bNtf = True
                    try:
                        strNum = matchRes.group()
                        try:
                            self.dictResult[self.jsEleName] = int(strNum)
                        except ValueError:
                            self.dictResult[self.jsEleName] = float(strNum)#指数可能会失败，如果精度要求太高的话
                            self.dictResult[self.jsEleName+'String'] = strNum

                        nIdxRet = nIdxRet + jsString.find(strNum) + len(strNum)
                        nIdxTmp = len(strNum)
                        jsStringBak = jsString[nIdxRet:]
                    except ValueError:
                        raise ParseException('ElementParse json error 5|||' + jsString[0:20])
                else:
                    raise ParseException('ElementParse json error 6|||' + jsString[0:20])

        return len(jsStringBak), bEndObject

    # 类型名失败测试
    # 'us%"e\\"r\\\\%c Pho\'n:e": \"13030\"rc Pho\'n:303131\"'
    # 类型名成功用力
    # 'us%e\\"r\\\\%c Pho\'n:e": \"13030\"rc Pho\'n:303131\"'
    # ‘userName": "张三李四王麻子",’

    # 值失败测试
    # '13030\"rc Pho\'n:303131"sdf,'
    # '张三李四王麻子" qw}'
    # 值成功测试
    # '13030\"rc Pho\'n:303131",'
    # ‘张三李四王麻子"}’
    def ElementStringParse(self, jsString, bVal = False, bNormalString = False):
        nRet = 0#返回解析完成之后开始继续遍历字符串的位置
        strRet = ''#返回字符串值
        ch = ''#临时字符
        bEnd = False#字符串是否结束了
        bEndObject = False#当前object是否结束
        nLenString = len(jsString)
        for n in range(nLenString):
            try:
                ch = jsString[n]
            except ValueError:
                raise ParseException('ElementStringParse visit overstep the boundary 1|||' + jsString[n:n+20])

            nRet = n + 1

            if not bEnd:
                if ch == '\\':
                    chNext = ''
                    chPre = ''
                    try:
                         chNext = jsString[n+1]
                         if n > 0:
                             chPre = jsString[n-1]
                    except ValueError:
                        raise ParseException('ElementStringParse visit overstep the boundary 2|||' + jsString[n:n+20])

                    if chNext != '"' and chNext != '\\' and chPre != '\\':
                        raise ParseException('ElementStringParse json error 1|||' + jsString[n:n+20])
                    strRet = strRet + ch
                else:
                    if ch == '"':
                        if not (n > 0 and jsString[n-1] == '\\'):
                            bEnd = True  # 找到结束”
                            if bNormalString:
                                break
                            continue
                    strRet = strRet + ch
            else:
                if not bVal:
                    if ch != ' ' and ch != '\t' and ch != ':': # "到：之间有其他字符
                        raise ParseException('ElementStringParse json error 2|||' + jsString[n:n+20])
                    else:
                        if ch == ':':  # //字段名结尾是:
                            break
                else:
                    if ch != ' ' and ch != '\t' and ch != ',' and ch != '}':  # "到,或者}之间有其他字符
                        raise ParseException('ElementStringParse json error 3|||' + jsString[n:n+20])
                    else:
                        if ch == ',' or ch == '}':  # 值结尾可能是,也可能是}
                            if ch == '}':
                                bEndObject = True
                            break
        return strRet, nLenString-nRet+1, bEndObject

    # 校验空白字符是否正确
    def CheckBlankByte(self, jsString, nCheckPos):

        if 0 == jsString.find('666'):
            jsString = jsString

        chTmp = ''
        bEndObject = False
        bCorrectFormat = True
        for n in range(len(jsString)):
            chTmp = jsString[n]
            if nCheckPos == 0:#[到{之间
                if chTmp != '{' and chTmp != ' ' and chTmp != '\t':
                    bCorrectFormat = False
                    break
                if chTmp == '{':
                    break
            elif nCheckPos == 1 or nCheckPos == 3:#1、{到"之间 3、，到“之间
                if chTmp != '"' and chTmp != ' ' and chTmp != '\t':
                    bCorrectFormat = False
                    break
                if chTmp == '"':
                    break
            elif nCheckPos == 2:#:到数值之间，可能是"也可能是{
                if chTmp != '[' and chTmp != '{' and chTmp != '"' and chTmp != ' ' and chTmp != '\t':
                    bCorrectFormat = False
                    break
                if chTmp == '[' or chTmp == '{' or chTmp == '"':
                    break
            elif nCheckPos == 4:#子object结束，可能是,也可能是}
                if chTmp != ',' and chTmp != '}' and chTmp != ' ' and chTmp != '\t':
                    bCorrectFormat = False
                    break
                if chTmp == ',' or chTmp == '}':
                    if chTmp == '}':
                        bEndObject = True
                    break
            elif nCheckPos == 5:#array节点结束，可能是,也可能是]
                if chTmp != ',' and chTmp != ']' and chTmp != ' ' and chTmp != '\t':
                    bCorrectFormat = False
                    break
                if chTmp == ',' or chTmp == ']':
                    break
            elif nCheckPos == 6:  # array节点结束到下一个节点开始只能是,到{
                if chTmp != ',' and chTmp != '{' and chTmp != ' ' and chTmp != '\t':
                    bCorrectFormat = False
                    break
                if chTmp == ',' or chTmp == '{':
                    break
            elif nCheckPos == 7:
                if chTmp != ']' and chTmp != ' ' and chTmp != '\t':
                    bCorrectFormat = False
                    break
                if chTmp == ']':
                    bEndObject = True
                    break

        return bCorrectFormat, bEndObject


def printSingleObject(obj):
    print repr(obj)


def printObject(obj, nTab):
    print '\t' * (nTab-1), '{'
    for i in obj.dictResult:
        if isinstance(obj.dictResult[i], list):
            printList(obj.dictResult[i], nTab + 1, i)
        elif isinstance(obj.dictResult[i], JsonHelper):
            printObject(obj.dictResult[i], nTab + 1)
        else:
            print '\t' * nTab, '"{}":\t{}'.format(i, repr(obj.dictResult[i]))

    print '\t' * (nTab - 1), '}'


def printList(lst, nTab, strEleName = ''):
    if 0==len(strEleName):
        strEleName = ''
    else:
        strEleName = '"{}":'.format(strEleName)
    print '\t' * (nTab - 1), strEleName, '['
    for i in lst:
        if isinstance(i, list):
            printList(i, nTab + 1)
        elif isinstance(i, JsonHelper):
            printObject(i, nTab + 1)

    print '\t' * (nTab - 1), ']'


if __name__ == "__main__":

    try:
        str = '    [{\
      "userId": "111111111111",\
      "userName": "张三李四王麻子",\
      "us%e\\"r\\\\%c Pho\'n:e": "13030\\"rc Pho\'n:303131",\
      "userFollow": 86,\
      "userFuns": -2e-5,\
      "userFavorite": true,\
      "userEBuy": null,\
      "userComment": "999",\
      "userNews": "3",\
      "userPoints": "3",\
      "userOrder": "8",\
      "userLocation": "5",\
      "isSeller": "1",\
      "aaa": {\
         "userId": "2222222222222",\
         "userPhone": "13030303131",\
         "userFollow": "86",\
         "userFuns": "5125",\
         "userFavorite": "615",\
         "userEBuy": "103",\
         "userComment": "999",\
         "userNews": "3",\
         "userPoints": "3",\
         "userOrder": "8",\
         "userLocation": "5",\
         "isSeller": "1",\
         "bbb": {\
            "userId": "333333333333",\
            "userName": "张三李四王麻子",\
            "userPhone": "1303\\"0303131",\
            "userFollow": 86,\
            "userFuns": 66.66,\
            "userFavorite": true,\
            "userEBuy": null,\
            "userC\\"omment": "999",\
            "userNews": "3",\
            "userPoints": "3",\
            "userOrder": "8",\
            "userLocation": "5",\
            "isSeller": "1"\
         },\
         "ccc": {\
            "userId": "444444444444",\
            "userName": "张三李四王麻子",\
            "userPhone": "13030303131",\
            "userFollow": "86",\
            "userFuns": "5125",\
            "userFavorite": "615",\
            "userEBuy": "103",\
            "userComment": "999",\
            "userNews": "3",\
            "userPoints": "3",\
            "userOrder": "8",\
            "userLocation": "5",\
            "isSeller": "1",\
            "sdfsdf": {\
               "Name": "55555555555555",\
               "X": "85",\
               "Y": "78",\
               "Z": "10"\
            }\
         }\
      }\
   },\
   {\
      "userId": "66666666666666",\
      "userName": "张三李四王麻子",\
      "userPhone": "13030303131",\
      "userFollow": "86",\
      "userFuns": "5125",\
      "userFavorite": "615",\
      "userEBuy": "103",\
      "userComment": "999",\
      "userNews": "3",\
      "userPoints": "3",\
      "userOrder": "8",\
      "userLocation": "5",\
      "isSeller": "1",\
      "Values": [{\
            "Name": "7777777777777777",\
            "X": "85",\
            "Y": "78",\
            "Z": "10"\
         },\
         {\
            "Name": "8888888888888888",\
            "X": "85",\
            "Y": "78",\
            "Z": "10"\
         }\
      ]\
   }\
 ]'
        # str = '     [  {\
      #     "Name": "8888888888888888",\
      #     "X": "85",\
      #     "Y": "78",\
      #     "Z": null\
      #  }]'
        # str = '        {"bbb": {\
      #     "userId": "333333333333",\
      #     "userName": "张三李四王麻子",\
      #     "userPhone": "1303\\"0303131",\
      #     "userFollow": 86,\
      #     "userFuns": 66.66,\
      #     "userFavorite": true,\
      #     "userEBuy": null,\
      #     "userC\\"omment": "999",\
      #     "userNews": "3",\
      #     "userPoints": "3",\
      #     "userOrder": "8",\
      #     "userLocation": "5",\
      #     "isSeller": "1"\
      #  },\
      #  "ccc": {\
      #     "userId": "444444444444",\
      #     "userName": "张三李四王麻子",\
      #     "userPhone": "13030303131",\
      #     "userFollow": "86",\
      #     "userFuns": "5125",\
      #     "userFavorite": "615",\
      #     "userEBuy": "103",\
      #     "userComment": "999",\
      #     "userNews": "3",\
      #     "userPoints": "3",\
      #     "userOrder": "8",\
      #     "userLocation": "5",\
      #     "isSeller": "1",\
      #     "sdfsdf": {\
      #        "Name": "55555555555555",\
      #        "X": "85",\
      #        "Y": "78",\
      #        "Z": "10"\
      #     }\
      #  }}'

        # str = '[{\
      #     "Name": "7777777777777777",\
      #     "w": false,\
      #     "X": 85,\
      #     "Y": 78.66,\
      #     "Z": "10",\
      #     "we": null,\
      #     "us%e\\"r\\\\%c Pho\'n:e": "13030\\"rc Pho\'n:303131"\
      #  },\
      #  {\
      #     "Name": "8888888888888888",\
      #     "q": "85",\
      #     "w": "78",\
      #     "e": "10",\
      #     "sdfsdf": {\
      #        "Name": "9999999999999",\
      #        "a": "85",\
      #        "b": "78",\
      #        "c": "10"\
      #     }\
      #  }\
      # ]'
#         str = '{\
#  "Name": "7777777777777777",\
#  "w": false,\
#  "X": 85,\
#  "Y": 78.66,\
#  "Z": "10",\
#  "we": null,\
#  "us%e\\"r\\\\%c Pho\'n:e": "13030\\"rc Pho\'n:303131"\
# }'
#         str = '666666'
        jsObj = JsonHelper()
        jsObj.JsonParse(str)

        if jsObj.jsObjectType == JsonBaseType.object_type:
            printObject(jsObj.dictResult[''], 1)
        elif jsObj.jsObjectType == JsonBaseType.array_type:
            printList(jsObj.dictResult[''], 1)
        else:
            printSingleObject(jsObj.dictResult[''])

        print('json parsed success.')
    except ParseException as e:
        print(e)
        print('json parsed failed.')

    # debug(21361583)
AmoyCHC
关注
「Python系列」Python JSON数据解析
日常笔记/总结/系列知识梳理
02-26 3237
在Python中，将数据类型编码为JSON格式时，Python的内置类型会与JSON类型之间有一个自然的映射关系。需要注意的是，一些Python对象类型（如自定义类、集合、日期等）在默认情况下并不能直接转换为JSON类型。模块提供了将JSON格式的数据转换为Python对象（如列表、字典等）以及将Python对象转换为JSON格式的数据的方法。对于日期对象，你可以使用。属性被转换为ISO 8601格式的字符串，这是一个JSON兼容的日期格式。如果你想将Python对象转换为JSON格式的字符串，可以使用。
Python爬虫——使用JSON库解析JSON数据_爬虫json解析
最新发布
m0_60721823的博客
04-30 783
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。发现有 js 后缀的文件，这就是我们想要的 json 数据了。
python json解析_深入理解Python对Json的解析
weixin_39611937的博客
11-23 202
Json简介JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于JavaScript（Standard ECMA-262 3rd Edition - December 1999）的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Pytho...
demjson php,有关Python解析JSON的内容详解
weixin_36476695的博客
03-11 229
JSON 函数使用 JSON 函数需要导入 json 库：import json。函数 描述json.dumps 将 Python 对象编码成 JSON 字符串json.loads 将已编码的 JSON 字符串解码为 Python 对象json.dumps语法json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=T...
Python 中的json解析
羽过天晴
10-28 1482
情景:爬虫离不了json的解析，但是目前很多网站中都使用json进行数据传输，动态展现，所以json的解析对于爬虫是很重要的 python解析json的包是json，使用时需要先引入json包 import json 常用的三个函数load(),loads(),dumps() （1）json.loads():传入一个json字符串，返回一个字符串解析出来的list或d
python中的json解析
zwt0909的博客
07-24 511
json.dumps()dict_obj = {'key1': 'value1', 'key2': 'value2'} json_str = json.dumps(dict_obj) print json_str //字符串 {"key2": "value2", "key1": "value1"}list_obj = ['element1', True, 333] json_str = json.d
python解析JSON数据
侯小啾技术博客
01-15 6190
JSON（JavaScript Object Natation）是一种轻量级的数据交换格式，其基于ECMAScript的一个子集。Python中提供了json模块来对JSON数据进行编码和解码。 json模块包含以下两个函数： json.dumps()：对数据进行编码 jsonloads()：对数据进行解码 示例 import json data1 = { 'id': '001', 'name': '李华', 'date': '20220115' } json_str = j
非常快速的Python JSON解析库-C/C++开发
05-27
cysimdjson用于Python的快速JSON解析库，比标准Python JSON解析器快7-12倍。 它是使用Cyth cysimdjson用于Python的快速JSON解析库为simdjson的Python绑定，比标准Python JSON解析器快7-12倍。 这是使用Cython的...
Python json解析库jsonpath原理及使用示例
01-19
jsonpath 用于多层嵌套 json格式的 解析。 pip install jsonpath JsonPath 描述 $ 根节点 @ 现行节点 .or[] 取子节点 n/a 取父节点，jsonpath为支持 .. 就是不管位置，选择所有复合条件的条件 * ...
Python解析JSON数据
这个杀手不太累的博客
12-06 2272
文章目录JSON简介JSON数据和Python数据对应关系表json模块读取复杂json JSON简介 JSON(全称JavaScript Object Notation) 是一种轻量级的数据交换格式。百度有详细的解释，这里就不详细copy了。 度娘一下，你就知道JSON JSON数据和Python数据对应关系表 JSON类型 Python类型 object dict ar...
pythonjson数据解析_Python—JSON数据解析
weixin_39607798的博客
12-02 78
1.安装pippip是python的包管理工具，使用它能非常方便地安装和卸载各种python工具包第一步：直接用浏览器访问地址：https://raw.github.com/pypa/pip/master/contrib/get-pip.py，直接打开了get-pip.py的源代码，可以直接把内容拷贝出来，然后在本地创建get-pip.py第二步：控制台进入到get-pip.py所在目录，运行代码...
Python解析JSON对象
北山啦的博客
03-23 9653
Python解析JSON对象 本章节我们将为大家介绍如何使用 Python 语言来编码和解码 JSON 对象。 json处理模块的主要任务，是将一个JSON对象，转换成Python数据类型数据进行处理，或者反之，将Python数据类型数据，转换成JSON对象（字符串流），在不同的模块或者系统间传输。 文章目录Python解析JSON对象1. JSON数据格式特点2. 常用方法总结3. 系列化和反系列化3.1 系列化3.2 反系列化 1. JSON数据格式特点 对象表示为键值对 数据由逗号分隔 花
Python 实现 JSON 解析器
qq_52785898的博客
01-18 4836
Python 实现 Json 解析
python中json解析_Python语言解析JSON详解
weixin_30326905的博客
02-03 538
本文主要向大家介绍了Python语言解析JSON详解，通过具体的内容向大家展示，希望对大家学习Python语言有所帮助。JSON函数使用JSON函数需要导入json库：importjson。函数描述json.dumps将Python对象编码成JSON字符串json.loads将已编码的JSON字符串解码为Python对象json.dumps语法json.du...
pythonjson文件解析步骤_Python解析Json文件
weixin_39772566的博客
12-15 192
Python解析Json文件写在前面在项目开发中，难免会遇到需要解析别人发过来的Json文件或将自己的输出打包成Json发生给别人，(尤其是做算法，50%-70%的工作量都在数据处理，而数据标注文件大多是Json、XML、txt类型)，如果你试图直接用记事本或其他编辑器打开Json文件找里面的内容，那恭喜你，你的工作任务将从此刻开始指数级增长，里面密密麻麻都是字符，本文将介绍怎么利用Python解...
python处理json文件详解_python解析json文件方法
weixin_29223603的博客
01-29 3112
我们在获取一份第三方的数据后，需要进行数据的分析，但发现它是json的文件形式并不能直接使用。这就需要用到解析的方法，我们在python中就可以完成这样操作。下面就json说进行简单说明，然后理清解析json文件 的思路，最后把相关的解析代码分享给大家，一起往下看具体内容。1.json说明json就是一种长得像嵌套字典的字符串。数据被“{}”和“[]”层层包裹，需要“拆包”才能拿到我们需要的数据。...
python解析json数据的三种方式
热门推荐
weixin_44894162的博客
04-11 5万+
1、运用re、json、jsonpath包解析json思路 （1）re：正则表达式，通过json的形式对症下药，写表达式去解析json； （2）json: 通过json中的json.loads()方法，将str类型转为dict类型，运用python字典的数据结构特点去解析json； （3）jsonpath：对比与json包，jsonpath可以根据路径去解析json，比较适合用来解析json中带“[ ]”的数据。 2、三种方式的json解析案例 #json数据样式，本文采用带[]的数据样式 { "v
ParseException（解析异常）可能的原因和解决方法
Java开源程序猿
12-28 6870
时，适当地检查异常的类型，并采取适当的处理措施。详细的错误日志和异常堆栈信息对于定位和解决问题非常有帮助。表示在解析数据时发生异常。
python json解析
06-09
Python中的JSON解析可以使用内置的json模块来实现。具体步骤如下： 1. 导入json模块 ```python import json ``` 2. 将JSON字符串转换为Python对象 可以使用`json.loads()`方法将JSON字符串转换为Python对象，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值