python json 解析

最新推荐文章于 2023-12-28 11:42:59 发布
最新推荐文章于 2023-12-28 11:42:59 发布
阅读量306 收藏
点赞数
文章标签： 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 3056
在Python中，将数据类型编码为JSON格式时，Python的内置类型会与JSON类型之间有一个自然的映射关系。需要注意的是，一些Python对象类型（如自定义类、集合、日期等）在默认情况下并不能直接转换为JSON类型。模块提供了将JSON格式的数据转换为Python对象（如列表、字典等）以及将Python对象转换为JSON格式的数据的方法。对于日期对象，你可以使用。属性被转换为ISO 8601格式的字符串，这是一个JSON兼容的日期格式。如果你想将Python对象转换为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
Python 实现 JSON 解析器
qq_52785898的博客
01-18 4780
Python 实现 Json 解析
demjson php,有关Python解析JSON的内容详解
weixin_36476695的博客
03-11 217
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模块】python解析json文件详解
All_In_gzx_cc的博客
07-11 9536
python解析json文件
非常快速的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代码实例解析
09-18
Python与JSON解析的知识点主要包括了以下几个方面： 1. JSON简介：JSON（JavaScript Object Notation）是一种轻量级的数据交换格式。它与XML相比，JSON格式更简单，结构更紧凑，易于阅读和编写，同时也更便于机器...
Python json解析库jsonpath原理及使用示例
01-19
jsonpath 用于多层嵌套 json格式的 解析。 pip install jsonpath JsonPath 描述 $ 根节点 @ 现行节点 .or[] 取子节点 n/a 取父节点，jsonpath为支持 .. 就是不管位置，选择所有复合条件的条件 * ...
python解析多层json操作示例
09-18
在Python中解析多层嵌套的JSON数据是一项基础技能，而Python提供的json模块可以非常方便地处理JSON数据。以下将详细介绍在Python中如何读取、解析、修改和保存多层嵌套的JSON数据。 首先，Python的json模块主要提供...
python中json用法详解
IT之一小佬的博客
01-06 2万+
python中json用法详解
ParseException（解析异常）可能的原因和解决方法
最新发布
Java开源程序猿
12-28 6024
时，适当地检查异常的类型，并采取适当的处理措施。详细的错误日志和异常堆栈信息对于定位和解决问题非常有帮助。表示在解析数据时发生异常。
如何用Python解析JSON数据
candice931020的博客
10-29 3万+
使用Python读取和解析JSON数据教程 JSON格式是网站和API使用的通用标准格式，现在主流的一些数据库（如PostgreSQL）都支持JSON格式。在本文中，我们将介绍如何使用Python处理JSON数据。首先，让我们先来看看JSON的定义。 什么是JSON？ JSON或JavaScript Object Notation，是一种使用文本存储数据对象的格式。换句话说，它是一种数据结构，将对象用文本形式表示出来。尽管它来源自JavaScript，但它已成为传输对象的实际标准。 大多....
python入参json格式化，json格式没有引号解析错误（备份）
异想实验室|Arduion|ESP8266|Micro Python|
07-04 1930
报错： {'msg': "JSON parse error: Unrecognized token 'phone': was expecting (JSON String, Number, Array, Object or token 'null', 'true' or 'false'); nested exception is com.fasterxml.jackson.core.JsonParseException: Unrecognized token 'phone': was expecting (
python解析JSON数据
侯小啾技术博客
01-15 6177
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解析_深入理解Python对Json的解析
weixin_39611937的博客
11-23 192
Json简介JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于JavaScript（Standard ECMA-262 3rd Edition - December 1999）的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Pytho...
异常-throws的方式处理异常
兴趣是最好的老师
09-02 751
定义功能方法时，需要把出现的问题暴露出来让调用者去处理。那么就通过throws在方法上标识。 package cn.itcast_01; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; /* * 有些时候，我们是可以对异常进行处理的，但是又有些时候，我们根...
python中的json解析
qq_41721660的博客
06-08 369
python中解析json语句
Python解析JSON数据
这个杀手不太累的博客
12-06 2256
文章目录JSON简介JSON数据和Python数据对应关系表json模块读取复杂json JSON简介 JSON(全称JavaScript Object Notation) 是一种轻量级的数据交换格式。百度有详细的解释，这里就不详细copy了。 度娘一下，你就知道JSON JSON数据和Python数据对应关系表 JSON类型 Python类型 object dict ar...
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、付费专栏及课程。

余额充值