如何预先生成元组映射查找表以提升优化流程效率？

核心思路：原函数中二进制处理、delta键生成的逻辑是固定不变的，仅delta_dict中的参数值会随优化步骤更新。我们可以提前预生成所有目标元组（结合正向/反向标识）对应的delta键列表，后续优化步骤只需根据列表从delta_dict取值计算，彻底避免重复执行耗时的映射逻辑。

步骤1：预生成映射查找表 #

在优化流程启动前，执行一次预计算，把所有需要处理的映射规则存储为查找表：

def precompute_mapping_lookup(self, all_tuples, all_identifications):
    self.mapping_lookup = {}
    ident_list_forward = ['Intra -> S1', 'S1 -> S2', 'S2 -> S3', 'S3 -> S4', 'S4 -> S5', 'S5 -> S6', 'S6 -> Extra']
    
    for identification in all_identifications:
        for tuple_item in all_tuples:
            s1 = self.decode(tuple_item[0])
            s2 = self.decode(tuple_item[1])
            delta_keys = []
            
            # 复用原函数的条件判断
            if ((s1.count('1') or s2.count('1')) > 1) or ((s1.count('1') == 1 and s2.count('1')) == 2):
                # 计算共享的位运算结果
                common_bits = bin(int(s1, 2) & int(s2, 2))[2:].zfill(len(s1))
                diff_bits = bin(int(s1, 2) ^ int(s2, 2))[2:].zfill(len(s1))
                
                indices = [i for i, bit in enumerate(common_bits) if bit == '1']
                transition_occupancy = [i for i, bit in enumerate(diff_bits) if bit == '1']
                
                if not transition_occupancy:
                    self.mapping_lookup[(identification, tuple_item)] = delta_keys
                    continue
                
                transition_occupancy_first = transition_occupancy[0]
                ident_prefix = diff_bits + '_'
                
                # 生成对应的delta键列表
                for i in indices:
                    delta_prime = []
                    if i < transition_occupancy_first:
                        delta_prime = [i - n for n in range(i + 1)]
                    elif i > transition_occupancy_first:
                        delta_prime = [i + n for n in range(6 - i)]
                    
                    # 根据标识类型决定是否加_rev后缀
                    if identification in ident_list_forward:
                        delta_keys.extend([f"{ident_prefix}{j+1}" for j in delta_prime])
                    else:
                        delta_keys.extend([f"{ident_prefix}{j+1}_rev" for j in delta_prime])
            
            self.mapping_lookup[(identification, tuple_item)] = delta_keys

调用方式：

• 传入所有需要处理的元组集合all_tuples（比如包含200个元组的列表）
• 传入所有可能的identification类型列表
• 此方法仅需执行一次，后续优化流程无需重复调用

步骤2：优化后的计算函数 #

替换原get_weird_mapping函数，直接通过查找表快速计算：

def get_weird_mapping(self, identification, tuple_item):
    delta_value = 0
    delta_keys = self.mapping_lookup.get((identification, tuple_item), [])
    
    if delta_keys:
        delta_multiplicand = 1
        for key in delta_keys:
            delta_multiplicand *= self.delta_dict.get(key, 1)
        delta_value += delta_multiplicand
    
    return delta_value

优化效果说明 #

• 预计算阶段一次性完成所有二进制解码、位运算和键生成逻辑，后续每次优化步骤仅需执行简单的字典取值与乘法操作，耗时大幅降低
• 映射规则不变的情况下，查找表可以一直复用；若元组集合或标识类型变更，仅需重新执行一次预计算即可

内容的提问来源于stack exchange，提问作者Confused_scientist