Question

dependent = ["R", "S"]

L = {"R": [0.8, 0.2], "S": [0.5, 0.5], "K": [0.1, 0.1]}

sequence = [[0,0], [0, 1], [1, 0], [1,1]]

我希望归纳出一种没有导入的特定方法。

鉴于这三个列表，字典将输出序列。因此对于R和S，第一个元素表示R = 0，S =0。我想要的是：

0.8 x 0.5 + 0.8 x 0.5 + 0.2 x 0.5 + 0.2 x 0.5

基本上

（R = 0 x S = 0）+（R = 0 x S = 1）+（R = 1 x S = 0）+（R = 1 x S = 1）由序列表给出。 / p>

我知道我从序列中进行迭代，但是在那之后我不确定如何同时使用dependent和L。

Answer 1

鉴于您不想使用导入，我认为最好的方法是定义功能，例如：

def cartesian(items):
    if len(items) == 0:
        return [[]]
    else:
        return [
            [x] + c 
            for x in items[0] 
            for c in cartesian(items[1:])
        ]

获得给定可迭代数的笛卡尔乘积。

我们只想将此功能应用于您的依赖项，所以首先：

dep_items = [v for k, v in L.items() if k in dependent]

然后计算乘积：

>>> sum([eval("*".join(map(str, c))) for c in cartesian(dep_items)])
1.0

更新

在阅读了您的评论之一后，我相信我在您的问题中误解了sequence的作用，即sequence始终可用，并非由所有组合组成，因此您不需要{ {1}}功能。在这种情况下，我认为cartesian和sequence应该保持相同的顺序，所以首先：

dependent

然后我得到根据items = [L[k] for k in dependent]的组合：

sequence

最后计算出乘积之和。

我将显示一个示例，其中包含您在评论中请求的特定combos = [[items[i][ind] for i, ind in enumerate(s)] for s in sequence]和dependent：

sequence

Answer 2

我必须离开，无法完成此操作，但这就是我的位置。也许它将帮助您踏上解决之路！

dependent = ["R", "S"]

L = {"R": [0.8, 0.2], "S": [0.5, 0.5], "K": [0.1, 0.1]}

sequence = [[0, 0], [0, 1], [1, 0], [1, 1]]
my_list = []
for item in sequence:
    item_total = 1
    for index in range(len(item) - 1):
        print(L[dependent[index]][item[index]])
        item_total = item_total * L[dependent[index]][item[index]]
        # print(item_total)
    my_list.append(item_total)

print(my_list)
total = sum(my_list)
print(total)

现在我要得到

0.8
0.8
0.2
0.2
[0.8, 0.8, 0.2, 0.2]
2.0

这显然是不正确的，但是很接近。 D处只有一个索引错误：

给定字典和序列以python返回其总数

2 个答案: