如何修正Python代码以正确提取X2和Y2变量的目标数据？

原始代码 #

thread_list = ['DWr','Idle','MulWr','Lock']
Target_list = ['0','0','0','1']
trd_coor = [26,10,51,10,226,10,251,10]
mem_coor = [10,215,35,215,60,215,85,215,210,215,235,215,260,215,285,215]
targ_1 = ['write-back','uncachable-high']
count_dash_T_list = [0,1,2,3]
count_T = 0
count_X1 = 0
count_Y1 = 0
count_target = 0
count_target_1 = 0
count_dash_T = 0
T = []
trd_Y1 = []
count_dash_T_list = []

for i in trd_coor[1::2]:
    Y1 = i
    trd_Y1.append(Y1)


            
for i in range(0,len(count_dash_T_list)):
    print(i)
    target = Target_list[count_target]
    count_target += 1
    
    for i in targ_1:
        if (target == '0'):
            if (i == 'write-back'):
                X2 = mem_coor[0]
                Y2 = mem_coor[1]
            elif (i == 'uncachable-high'):
                X2 = mem_coor[2]
                Y2 = mem_coor[3]
            elif (i == 'write-through'):
                X2 = mem_coor[4]
                Y2 = mem_coor[5]
            elif (i == 'write-combining'):
                X2 = mem_coor[6]
                Y2 = mem_coor[7]
        elif (target == '1'):
            if (i == 'write-high'):
                X2 = mem_coor[8]
                Y2 = mem_coor[9]
            elif (i == 'uncachable-high'):
                X2 = mem_coor[10]
                Y2 = mem_coor[11]
            elif (i == 'write-through'):
                X2 = mem_coor[12]
                Y2 = mem_coor[13]
            elif (i == 'write-combining'):
                X2 = mem_coor[14]
                Y2 = mem_coor[15]
                                
    print(X2)
    print(Y2)
    arrow_thread = thread_list[count_T]
    #print(arrow_thread)
    arrow_X1 = trd_coor[count_X1]
    #print(arrow_X1)
    arrow_Y1 = trd_Y1[count_Y1]
    #print(arrow_Y1)
    count_T += 1
    count_X1 += 2
    count_Y1 += 1               
    arrow = '<g> <line x1="{}" y1="{}" x2="{}" y2="{}" stroke="#000" stroke-width="1" marker-end="url(#arrowhead)" /><text x="0" y="0" font-family="Verdana" font-size="5" fill="black">{}</text> </g>'.format(arrow_X1,arrow_Y1,X2,Y2,arrow_thread)
    #print(arrow)

当前输出 #

0,
35,
215,
1,
35,
215,
2,
35,
215,
3,
235,
215

期望输出 #

0,
10,
215,
1,
10,
215,
2,
10,
215,
3,
235,
215

问题原因 #

内层循环遍历targ_1时，当target为'0'，会先匹配到'write-back'并设置X2=10,Y2=215，但紧接着循环到'uncachable-high'时，又会覆盖X2/Y2的值为35/215，最终输出的是内层循环最后一次赋值的结果，与期望不符。

修正方案 #

方案1：匹配到目标后终止内层循环

在找到对应内存类型并赋值后，添加break跳出内层循环，避免后续值覆盖：

for i in targ_1:
    if (target == '0'):
        if (i == 'write-back'):
            X2 = mem_coor[0]
            Y2 = mem_coor[1]
            break  # 匹配到目标后停止循环
        elif (i == 'uncachable-high'):
            X2 = mem_coor[2]
            Y2 = mem_coor[3]
            break
        # 其他分支同理
    elif (target == '1'):
        if (i == 'write-high'):
            X2 = mem_coor[8]
            Y2 = mem_coor[9]
            break
        elif (i == 'uncachable-high'):
            X2 = mem_coor[10]
            Y2 = mem_coor[11]
            break
        # 其他分支同理

方案2：用字典映射简化逻辑（更推荐）

将内存类型与坐标的对应关系用字典存储，直接根据target取值，避免多层嵌套判断：

# 定义内存类型到坐标的映射
mem_map = {
    '0': {
        'write-back': (mem_coor[0], mem_coor[1]),
        'uncachable-high': (mem_coor[2], mem_coor[3]),
        'write-through': (mem_coor[4], mem_coor[5]),
        'write-combining': (mem_coor[6], mem_coor[7])
    },
    '1': {
        'write-high': (mem_coor[8], mem_coor[9]),
        'uncachable-high': (mem_coor[10], mem_coor[11]),
        'write-through': (mem_coor[12], mem_coor[13]),
        'write-combining': (mem_coor[14], mem_coor[15])
    }
}

# 替换原内层循环逻辑
if target == '0':
    X2, Y2 = mem_map['0']['write-back']
elif target == '1':
    X2, Y2 = mem_map['1']['uncachable-high']

注：如果targ_1需要遍历多个内存类型，可根据实际需求调整字典的使用方式。

调试建议 #

• 打印中间值：在内层循环中每次赋值后打印X2和Y2，观察值的变化，确认是否被意外覆盖。
• 简化逻辑：用字典替代多层if-elif，让代码逻辑更清晰，减少出错概率。
• 检查循环必要性：确认内层循环遍历targ_1的实际用途，如果仅需要匹配特定内存类型，可直接取值而非循环遍历。

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