python 字典嵌套列表，列表嵌套字典，数字，字符递归排序、去空值和转请求参数和加密验证

瑾怀轩

已于 2022-03-30 22:30:31 修改

阅读量1.2k

点赞数 1

分类专栏：项目实战文章标签： python

于 2022-03-30 22:28:31 首次发布

本文链接：https://blog.csdn.net/ckq707718837/article/details/123858988

版权

项目实战专栏收录该内容

2 篇文章 0 订阅

订阅专栏

该项目重点是处理多数据类型的Json数据，

由于设计项目不能全部展示，留作博客记录，DRY

import hashlib
from collections import OrderedDict
import json


# 使用MD5进行加密
def encodeByMD5(sign):
    md5 = hashlib.md5()
    md5.update(sign.encode(encoding='utf-8'))
    return md5.hexdigest()

#检查列表中是否包含字典或列表
def checkList(org):
    isAllValue = True
    for ele in org:
        if isinstance(ele,dict) or isinstance(ele,list)  or isinstance(ele,tuple):
            isAllValue = False
    return isAllValue

# 递归排序，使用字典，列表，数字，字符，不适用含有元组值
def sortDict2(orgindict, flag, Orderdict):
    # 结束条件
    if flag:
        return Orderdict
    # 循环体
    #如果当前待排值为 dict ，将当前dict排序后，递归调用
    if isinstance(orgindict, dict):
        order = dict()
        for key,value in sorted(orgindict.items() , key=lambda x : x[0]):    #sorted(orgindict)获取字典中所有排序后的key
                # 如果值为字典将继续遍历排序

                Orderdict[key] = sortDict2(value, flag, order)
        return Orderdict
    if isinstance(orgindict,list):
        #如果是列表，先排序，再递归遍历

        #判断该列表层级是否包含列表和字典
        sortlist = list()
        if checkList(orgindict): #当列表全文值时进行排序， 当前只处理含有数字和字符值,排序后将数字放前位，若含有字典，元组，列表，将不进行排序
            return sorted(orgindict,key= lambda x :(isinstance(x,str),x))
        for ele in orgindict:        #el = {"d":1,"c":2}  ele = [2,3]
             if isinstance(ele,dict):
                 order = dict()
                 sortlist.append(sortDict2(ele, flag, order))
                 continue
             if isinstance(ele,list):
                 order = list()
                 sortlist.append(sortDict2(ele, flag, order))
                 continue
             sortlist.append(ele)

        return sortlist
    if not isinstance(orgindict,list) and not isinstance(orgindict,dict):
        return orgindict
    flag = True
    return Orderdict

# 递归嵌套排序,当前方法只是用与字典中嵌套字典，不能有列表


def sortDict(orgindict, flag, Orderdict):
    # 结束条件
    if flag:
        return Orderdict
    # 循环体
    for key in sorted(orgindict):
        #如果是字典，递归遍历
        if isinstance(orgindict[key], dict):
            # 如果值为字典将继续遍历排序
            order = dict()
            orgindict[key] = sortDict(orgindict[key], flag, order)
        #如果是列表，先排序，在遍历
        Orderdict[key] = orgindict[key]
    flag = True
    return Orderdict

#递归嵌套 去空 和sign参数，不包含列表中值去空
def fliterDict(orgindict, flag, Orderdict):
    # 结束条件
    if flag:
        return Orderdict
    # 循环体
    for key in orgindict.keys():
        if isinstance(orgindict[key], dict):
            # 如果值为字典将继续遍历排序
            order = dict()
            orgindict[key] = sortDict(orgindict[key], flag, order)
        if orgindict[key] and orgindict[key] != '' and key != 'sign':
            if isinstance(orgindict[key],list) and len(orgindict[key]) == 0:
                continue
            Orderdict[key] = orgindict[key]
    flag = True
    return Orderdict

#递归嵌套 去空值，不包含列表中值去空
def fliterDict2(orgindict, flag, Orderdict):
    # 结束条件
    if flag:
        return Orderdict
    # 循环体
    #将该层级字典键值对检查
    if isinstance(orgindict, dict):
        order = dict()
        for key,value in orgindict.items():
            if value:       # 若value为 ''，[],{} 将过滤
                # 如果有值继续遍历排序
                Orderdict[key] = fliterDict2(value, flag, order)
        return Orderdict
    if isinstance(orgindict,list):
        #判断该列表层级是否包含列表和字典
        sortlist = list()
        for ele in orgindict:        #el = {"d":1,"c":2}  ele = [2,3]
            if not ele:
                continue
            if isinstance(ele,dict):
                order = dict()
                sortlist.append(fliterDict2(ele, flag, order))
                continue
            if isinstance(ele,list):
                order = list()
                sortlist.append(fliterDict2(ele, flag, order))
                continue
            sortlist.append(ele)

        return sortlist
    if not isinstance(orgindict,list) and not isinstance(orgindict,dict):
        return orgindict
    flag = True
    return Orderdict

a ={'a': 3,
    'b': 2,
    'c': 1,
    'd':     {'a':      [{'a': 1,
                          'b': ['d', 'a', 5, 1, 'h']
                          },
                         'd',
                         1,
                         {'a': 3,
                          'd': 2}
                         ],
              'c': 3,
              'd': 1},
    'sign': 1234234}
# {a=3&
#    b=2&
#      c=1&
#        d={  a=  [{a=1&
#                     b=[1,5,a,d,h]
# },
# d,
# 1,
# {a=3&d=2}]
# &c=3
#    &d=1}
# &sign=1234234}
#递归嵌套 拼接字符串
def Dict2String(orgindict, flag, Orderdict):
    # 结束条件
    if flag:
        return Orderdict
    # 循环体
    #将该层级字典键值对检查
    if isinstance(orgindict, dict):
        order = '{'
        dilsit = orgindict.items()
        count = 1
        for key,value in dilsit:
            #将每个键值对组合，遇到值为字典，列表，递归
            if isinstance(value,dict) or isinstance(value,list):
                order += '{}={}'.format(key,str(Dict2String(value,flag,order)))
                if count < len(dilsit):
                    count += 1
                    order += '&'
                continue
            #普通键值对
            order += '{}={}'.format(key,value)
            if count < len(dilsit):
                count += 1
                order += '&'
        order += '}'
        return order
    if isinstance(orgindict,list):
        #判断该列表层级是否包含列表和字典
        strlist = '['
        countl = 1
        for ele in orgindict:
            if not ele:
                continue
            if isinstance(ele,dict):
                strlist += Dict2String(ele, flag, strlist)
                if countl < len(orgindict):
                    countl +=1
                    strlist += ','
                continue
            if isinstance(ele,list):
                strlist += '['
                strlist += Dict2String(ele, flag, strlist)
                strlist += ']'
                if countl < len(orgindict):
                    countl +=1
                    strlist += ','
                continue
            strlist += str(ele)
            if countl < len(orgindict):
                countl +=1
                strlist += ','
        strlist += ']'
        return strlist
    if not isinstance(orgindict,list) and not isinstance(orgindict,dict):
        return str(orgindict)

    flag = True
    return str(Orderdict)

# 请求验证签名
"""
    param: 该参数为post发送来的json参数
    
    return : 验证结果
"""


def verification(appSecret, param):
    result = False
    resultDict = dict()
    # 将json字符串转字典
    paramDict = json.loads(param)
    #保存sign参数值
    sign = paramDict['sign']
    del paramDict['sign']
    filter_sort_dict = dict()
    filter_sort_dict = fliterDict(paramDict,False,filter_sort_dict)
    #将嵌套字典进行排序
    orderdict = dict()
    orderdict = sortDict2(filter_sort_dict,False,orderdict)
    #将sign和''去掉 value为 数组且长度为0

    S1 = ""
    """①数据内非空参数值的参数按照参数名ASCII码从小到大排序（字典序）
        1、参数名ASCII码从小到大排序（字典序）；
        2、如果参数的值为空不参与签名；
        3、参数名区分大小写；
        4、sign参数不参与签名
        5、如果集合参数内包含集合，那么此包含的集合也递归使用url键值对排序拼装方式；
    """
    # 1、排序
    #递归遍历拼接字符串
    S1 = Dict2String(orderdict, False,S1 )
    print("s1",S1)
    """②前部和尾部加入appSecret（appSecret+S1+appSecret）"""
    S2 = appSecret + S1 + appSecret
    print("s2",S2)

    verify = encodeByMD5(S2)
    print("sign",sign)
    print("verfy",verify)
    if sign == verify:
        result = True

    return result

#生成签名
"""
appSecret: 秘钥
parm : 参数字典
"""
def generSign(appSecret, param):

    # 将json字符串转字典
    paramDict = json.loads(param)
    filter_sort_dict = dict()
    filter_sort_dict = fliterDict(paramDict,False,filter_sort_dict)
    #将嵌套字典进行排序
    orderdict = dict()
    orderdict = sortDict2(filter_sort_dict,False,orderdict)
    #将''去掉 value为 数组且长度为0

    S1 = ""
    """①数据内非空参数值的参数按照参数名ASCII码从小到大排序（字典序）
        1、参数名ASCII码从小到大排序（字典序）；
        2、如果参数的值为空不参与签名；
        3、参数名区分大小写；
        4、sign参数不参与签名
        5、如果集合参数内包含集合，那么此包含的集合也递归使用url键值对排序拼装方式；
    """
    # 1、排序
    #递归遍历拼接字符串
    S1 = Dict2String(orderdict, False,S1 )
    print("s1",S1)
    """②前部和尾部加入appSecret（appSecret+S1+appSecret）"""
    S2 = appSecret + S1 + appSecret
    print("s2",S2)

    verify = encodeByMD5(S2)
    return verify

#测试方法

# Create your tests here.

from member import unitTools

orig = {
    "c": 1,
    "b": 2,
    "a": 3,
    'd': {
        "c": 3,
        "b": "",
        "d": 1,
        "a": [{
                "b": ["d",'a',5,1,"h","",{}],
                "a": 1
                },
                "d",
                1,
                {"d":2,"a":3,"b":[],"h":None}
            ]
    },
    "sign": 1234234
 }


print(type(orig),orig)

order = dict()
org2 = unitTools.fliterDict2(orig, False, order)
# print(order)
print(org2)

orderDict = dict()
org1 = unitTools.sortDict2(org2, False, orderDict)
print(org1)
# print(orderDict)

si =''
org3 = unitTools.Dict2String(org1, False, si)
print(org3)
# print(si)




param = {
    "c": 1,
    "b": None,
    "a": 3,
    'd': {
        "c": 3,
        "b": '',
        "d": [],
        "a": {
            "b": 2,
            "a": 1
        }
    }
}


param2 = '{"b":1,"a":2,"d": {"c": 1,"a": 3},"page_num": 1,"page_size": 50,"appKey": "sdfsgdsfhfgjgdj","version": "1.0","timestamp": 1601031894,"sign": "dsfhfhjgjljlfdghdkjsdfsggdhj"}'

appScreat = '123'
print(unitTools.verification(appScreat, param2))


# print(unitTools.encodeByMD5('aaa'))

瑾怀轩

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
python 字典嵌套列表，列表嵌套字典，数字，字符递归排序、去空值和转请求参数和加密验证

由于设计项目不能全部展示，留作博客记录，DRYimport hashlibfrom collections import OrderedDictimport json# 使用MD5进行加密def encodeByMD5(sign): md5 = hashlib.md5() md5.update(sign.encode(encoding='utf-8')) return md5.hexdigest()#检查列表中是否包含字典或列表def checkList(or
复制链接

扫一扫