按值排序的打印序列和值

如何解决按值排序的打印序列和值

我有一个代码，它采用 6 到 10 张红色或黑色卡片序列的所有可能组合。在数学方程的帮助下，给定的 surprise 度量是基于两个抽取的卡片序列计算的。代码如下：

from itertools import combinations_with_replacement 

deckOrder=[]

Box_1=['R','B']
comb = combinations_with_replacement(Box_1,6) 
for i in list(comb): 
  deckOrder.append(i)

comb = combinations_with_replacement(Box_1,7) 
for i in list(comb): 
  deckOrder.append(i)
 
comb = combinations_with_replacement(Box_1,8) 
for i in list(comb): 
  deckOrder.append(i)

comb = combinations_with_replacement(Box_1,9) 
for i in list(comb): 
  deckOrder.append(i)

comb = combinations_with_replacement(Box_1,10) 
for i in list(comb): 
  deckOrder.append(i)

outcome = []

for i in range(len(deckOrder)):
  for j in range(len(deckOrder)):

#Draw

first_draw = deckOrder[i]
second_draw = deckOrder[j]

#Before first draw

initial_estimate = 0.5
initial_variance = 1/12

#After first draw 

r_count = first_draw.count('R')
b_count = first_draw.count('B')


alpha = 1 + r_count
beta = 1 + b_count


e_of_theta = alpha/(alpha+beta)

surprise = ((e_of_theta - initial_estimate)**2)/(initial_variance)

var_theta = (alpha * beta)/ ((alpha + beta) **2 *(alpha + beta + 1))   

#After second draw 

r_count = second_draw.count('R')
b_count = second_draw.count('B')

new_alpha = alpha + r_count 
new_beta = beta + b_count 

new_e_of_theta = new_alpha/(new_alpha + new_beta)

surprise = ((new_e_of_theta - e_of_theta)**2)/var_theta

#Export

new_list = [surprise]

for a in new_list:
  outcome.append(a)

order = sorted(outcome)
print(*order,sep='\n')

现在的代码只显示 suprise 值。有什么方法可以显示使用的序列和值，以便我知道哪个值以有序的方式属于哪个序列（通过 surprise val）？

解决方法

您可以使用 OrderedDict 来拥有有序的数据结构并使其成为 可以将每个序列映射到一个值

,

正如之前的答案所建议的，解决这个问题的一个很好的候选方法是使用 OrderedDict，其中 surprise 用作键，序列作为值存储。不过，原始代码段相当杂乱无章，缩进也有缺陷。以下是我对解决方案的建议：

from itertools import combinations_with_replacement 
from collections import OrderedDict

deckOrder,card_colors,draw_num_cards = [],['R','B'],[x for x in range(6,11)]

for num_cards in draw_num_cards:
    combs = combinations_with_replacement(card_colors,num_cards)
    deckOrder.extend(list(combs))

outcome = {}
initial_estimate = 0.5
initial_variance = 1/12
        
for i in range(len(deckOrder)):
    #Draw
    first_draw = deckOrder[i]
    
    #After first draw 
    r_count = first_draw.count('R')
    b_count = first_draw.count('B')

    #Before first draw
    alpha = 1 + r_count
    beta = 1 + b_count
    
    for j in range(len(deckOrder)):
        #Draw
        second_draw = deckOrder[j]

        e_of_theta = alpha/(alpha+beta)
        surprise = ((e_of_theta - initial_estimate)**2) / (initial_variance)
        var_theta = (alpha * beta) / ((alpha + beta)**2 * (alpha + beta + 1))   
        
        #After second draw 
        r_count = second_draw.count('R')
        b_count = second_draw.count('B')
        
        new_alpha = alpha + r_count 
        new_beta = beta + b_count 
        
        new_e_of_theta = new_alpha / (new_alpha + new_beta)
        surprise = ((new_e_of_theta - e_of_theta)**2) / var_theta
        sequences = (first_draw,second_draw)
        
        outcome[surprise] = sequences


#sort by `surprise`
outcome_ordered = OrderedDict()
for surprise in sorted(outcome.keys()):
    outcome_ordered[surprise] = outcome[surprise]

for surprise,(first,second) in outcome_ordered.items():
    print(surprise,": ",first,second)