'''
算法：
1. 先判断传入的参数是否是字典，如果不是，则停止比较---》not isinstance(dict1, dict) or not isinstance(dict2, dict)
2. 如果都是字典，先比较字典长度是否一致；如果不一致，则停止比较，结果：长的字典大于短的字典
3. 如字典长度一致，则继续比较key，key的比较顺序和keys()方法返回键的顺序相同（相同的键会映射到哈希表的同一个位置，这就保证了对字典键的检查的一致性）
4. 通过hash(dict1_keys_list[i]) != hash(dict2_keys_list[i])来判断两个key的哈希值是否一样，一样则说明key相同
5. 如果key不同，则判断key的类型是否一致，不一致则不能比较大小---》type(dict1_keys_list[i]) != type(dict2_keys_list[i])
6. 如果key类型一致，则继续比较key的大小，返回结果
7. 如果所有key相同，继续比较key对应的value
8. 先判断value的类型是否一致，不一致则不能比较大小
9. 如果value类型一致，则比较value大小---》type(dict1[key]) != type(dict2[key])
'''

def compare_dict(dict1, dict2):

    result = ""
    # 判断传入的两个参数是否都是字典，只要有一个不是字典，则停止比较
    if not isinstance(dict1, dict) or not isinstance(dict2, dict):                      
        result = "传入的参数不全是字典，请确认后再进行比较！"
        return result

    # 比较长度值大小
    if len(dict1.keys()) > len(dict2.keys()):                                           
        result = "%s > %s，原因：第一个字典长度大于第二个字典长度 " % (dict1, dict2)
        return result
    elif len(dict1.keys()) < len(dict2.keys()):
        result = "%s < %s，原因：第一个字典长度小于第二个字典长度" % (dict1, dict2)
        return result

    # 字典1的key列表
    dict1_keys_list = list(dict1.keys())   
    # 字典2的key列表                                  
    dict2_keys_list = list(dict2.keys())   

    # 遍历key列表索引                                  
    for i in range(len(dict1.keys())):

        # 判断两个字典key的hash值是否相等，hash值相同，说明key相同
        if hash(dict1_keys_list[i]) != hash(dict2_keys_list[i]):
            # hash值不一致时，判断不同key的类型是否一致，如果类型不一致，停止比较
            if type(dict1_keys_list[i]) != type(dict2_keys_list[i]):
                result = "第一个字典第%s个key【%s】的类型与第二个字典第%s个key【%s】的类型不一致，不能进行比较" \
                        % ((i + 1), repr(dict1_keys_list[i]), (i + 1), repr(dict2_keys_list[i]))
                return result    

            # 类型一致的情况下，比较两个key的大小
            # 判断第一个字典的key是否大于第二个字典的key
            if dict1_keys_list[i] > dict2_keys_list[i]:                                    
                result = "%s > %s，原因：第一个字典第%s个key【%s】大于第二个字典第%s个key【%s】" \
                        % (dict1, dict2, (i + 1), dict1_keys_list[i], (i + 1), dict2_keys_list[i])

            # 判断第一个字典的key是否小于第二个字典的key
            else:                                                                           
                result = "%s < %s，原因：第一个字典第%s个key【%s】小于第二个字典第%s个key【%s】" \
                        % (dict1, dict2, (i + 1), dict1_keys_list[i], (i + 1), dict2_keys_list[i])
            
            # key值不一致的情况，不会再比较value大小，返回key值的比较结果
            return result

    # key相同时，比较value大小
    for key in dict1.keys():  
        
        # 判断不同value的类型是否一致，如果类型不一致，停止比较              
        if type(dict1[key]) != type(dict2[key]):                                                # 判断value的类型是否一致
            result = "第一个字典key【%s】对应value【%s】的类型与第二个字典key【%s】对应value【%s】的类型不一致，不能进行比较" \
                    % (repr(key), repr(dict1[key]), repr(key), repr(dict2[key]))
            return result

        # 类型一致的情况下，比较两个key的大小
        # 判断第一个字典的key是否大于第二个字典的key, 如果大于，不再比较后面的value，返回结果
        if dict1[key] > dict2[key]:                                                        
            result = "%s > %s，原因：第一个字典key【%s】对应的value【%s】大于第二个字典key【%s】对应的value【%s】" \
                    % (dict1, dict2, repr(key), dict1[key], (key), dict2[key])
            return result
         # 判断第一个字典的key是否小于第二个字典的key, 如果小于，不再比较后面的value，返回结果
        elif dict1[key] < dict2[key]:
            result = "%s < %s，原因：第一个字典key【%s】对应的value【%s】小于第二个字典key【%s】对应的value【%s】" \
                    % (dict1, dict2, repr(key), dict1[key], repr(key), dict2[key])
            return result                            
        else:
            result = "两个字典相等"

    # value相等，返回结果
    return result

if __name__ == '__main__':
    dict1 = {1: 2, '3': 4}
    dict2 = {1: 2, '3': 500}
    print(compare_dict(dict1, dict2))