如何在python中动态组合集合

我有一个字典列表，需要遍历它们并检查已经存在的键。我已经实现了一个python代码来手动计算分数，如下所示。在我的代码中，我在每次迭代中手动组合来自以前字典的键。迭代将从dict11开始

如何更改此代码以自动迭代动态数量的字典，以及如何在每次迭代中动态组合键

dict10={'A'：1，'C'：2}
dict11={'B'：3，'C'：4}
dict12={'A'：5'E'：6'F'：7}
dict13={'G'：8'E'：9}
存在\ U分数=0
对于dict11.keys（）和dict10.keys（）中的键：
exist_分数+=dict11[关键点]
对于dict12.keys（）和set（dict11.keys（））.union（set（dict10.keys（））中的键：
exist_分数+=12[关键点]
对于dict13.keys（）和set（dict12.keys（））.union（set（dict11.keys（））.union（set（dict10.keys（）））中的键：
exist_分数+=dict13[关键点]
打印（存在分数）

首先，您需要将其转换为可以放入循环的内容。同样的事情也会发生在

dict11

、

dict12

和

dict13

：

#dict10、dict11、dict12、dict13的定义相同
存在\ U分数=0
seen_keys=set（dict10.keys（））
对于dict11.keys（）中的键：
如果输入U键：
exist_分数+=dict11[关键点]
已查看\u keys.update（dict11.keys（））
对于dict12.keys（）中的键：
如果输入U键：
exist_分数+=12[关键点]
已查看\u keys.update（dict12.keys（））
对于dict13.keys（）中的键：
如果输入U键：
exist_分数+=dict13[关键点]
查看\u keys.update（dict13.keys（））

这应该与您的脚本执行相同的操作。现在你可以把它放到一个循环中

#dict10、dict11、dict12、dict13的定义相同
存在\ U分数=0
seen_keys=set（dict10.keys（））
其他条款=[条款11、条款12、条款13]
对于其他条款中的d：
对于d.keys（）中的键：
如果输入U键：
存在_分数+=d[关键点]
已查看\u keys.update（d.keys（））

首先，您需要将其转换为可以放入循环的内容。同样的事情也会发生在

dict11

、

dict12

和

dict13

：

#dict10、dict11、dict12、dict13的定义相同
存在\ U分数=0
seen_keys=set（dict10.keys（））
对于dict11.keys（）中的键：
如果输入U键：
exist_分数+=dict11[关键点]
已查看\u keys.update（dict11.keys（））
对于dict12.keys（）中的键：
如果输入U键：
exist_分数+=12[关键点]
已查看\u keys.update（dict12.keys（））
对于dict13.keys（）中的键：
如果输入U键：
exist_分数+=dict13[关键点]
查看\u keys.update（dict13.keys（））

这应该与您的脚本执行相同的操作。现在你可以把它放到一个循环中

#dict10、dict11、dict12、dict13的定义相同
存在\ U分数=0
seen_keys=set（dict10.keys（））
其他条款=[条款11、条款12、条款13]
对于其他条款中的d：
对于d.keys（）中的键：
如果输入U键：
存在_分数+=d[关键点]
已查看\u keys.update（d.keys（））

最有意义的做法是将dict本身保存在一个列表中。将这种逻辑应用到函数中也是一件轻而易举的事

dicts = [
    {'A': 1, 'C': 2},
    {'B': 3, 'C': 4},
    {'A': 5, 'E': 6, 'F': 7},
    {'G': 8, 'E': 9}
]

def score_dicts(dicts):
    score = 0
    all_keys = set()
    for d in dicts:
        keys = d.keys()
        for key in keys & all_keys:
            score += d[key]
        all_keys.update(keys)
    return score

exist_score = score_dicts(dicts)

如果需要定期更新分数（一次更新一个dict），可以在类或闭包中维护状态

类别：

class DictScorer():
    def __init__(self):
        self.exist_score = 0
        self.all_keys = set()
    def score(self, d):
        keys = d.keys()
        for key in keys & self.all_keys:
            self.exist_score += d[key]
        self.all_keys.update(keys)
        return self.exist_score

dict10 = {'A': 1, 'C': 2}
dict11 = {'B': 3, 'C': 4}
dict12 = {'A': 5, 'E': 6, 'F': 7}
dict13 = {'G': 8, 'E': 9}

scorer = DictScorer()

exist_score = scorer.score(dict10)
print(exist_score)

exist_score = scorer.score(dict11)
print(exist_score)

exist_score = scorer.score(dict12)
print(exist_score)

exist_score = scorer.score(dict13)
print(exist_score)

关闭：

# returns a scorer which can
# be used incrementally
def create_dict_scorer():
    score = 0
    all_keys = set()
    def dict_scorer(d):
        nonlocal score
        keys = d.keys()
        for key in keys & all_keys:
            score += d[key]
        all_keys.update(keys)
        return score
    return dict_scorer

dict10 = {'A': 1, 'C': 2}
dict11 = {'B': 3, 'C': 4}
dict12 = {'A': 5, 'E': 6, 'F': 7}
dict13 = {'G': 8, 'E': 9}

scorer = create_dict_scorer()

exist_score = scorer(dict10)
print(exist_score)

exist_score = scorer(dict11)
print(exist_score)

exist_score = scorer(dict12)
print(exist_score)

exist_score = scorer(dict13)
print(exist_score)

---

最有意义的做法是将口述记录自己列在一个清单中。将这种逻辑应用到函数中也是一件轻而易举的事

dicts = [
    {'A': 1, 'C': 2},
    {'B': 3, 'C': 4},
    {'A': 5, 'E': 6, 'F': 7},
    {'G': 8, 'E': 9}
]

def score_dicts(dicts):
    score = 0
    all_keys = set()
    for d in dicts:
        keys = d.keys()
        for key in keys & all_keys:
            score += d[key]
        all_keys.update(keys)
    return score

exist_score = score_dicts(dicts)

如果需要定期更新分数（一次更新一个dict），可以在类或闭包中维护状态

类别：

class DictScorer():
    def __init__(self):
        self.exist_score = 0
        self.all_keys = set()
    def score(self, d):
        keys = d.keys()
        for key in keys & self.all_keys:
            self.exist_score += d[key]
        self.all_keys.update(keys)
        return self.exist_score

dict10 = {'A': 1, 'C': 2}
dict11 = {'B': 3, 'C': 4}
dict12 = {'A': 5, 'E': 6, 'F': 7}
dict13 = {'G': 8, 'E': 9}

scorer = DictScorer()

exist_score = scorer.score(dict10)
print(exist_score)

exist_score = scorer.score(dict11)
print(exist_score)

exist_score = scorer.score(dict12)
print(exist_score)

exist_score = scorer.score(dict13)
print(exist_score)

关闭：

# returns a scorer which can
# be used incrementally
def create_dict_scorer():
    score = 0
    all_keys = set()
    def dict_scorer(d):
        nonlocal score
        keys = d.keys()
        for key in keys & all_keys:
            score += d[key]
        all_keys.update(keys)
        return score
    return dict_scorer

dict10 = {'A': 1, 'C': 2}
dict11 = {'B': 3, 'C': 4}
dict12 = {'A': 5, 'E': 6, 'F': 7}
dict13 = {'G': 8, 'E': 9}

scorer = create_dict_scorer()

exist_score = scorer(dict10)
print(exist_score)

exist_score = scorer(dict11)
print(exist_score)

exist_score = scorer(dict12)
print(exist_score)

exist_score = scorer(dict13)
print(exist_score)

具有切片和

set

操作的短魔术：

dicts = [dict10, dict11, dict12, dict13]
exist_score = 0

for i, d in enumerate(dicts[:0:-1]):
    offset = -(i - 2)
    exist_score += sum(d[k] for k in d.keys() & set().union(*dicts[offset::-1]))

print(exist_score)

• dicts[：0:-1]

  -按相反顺序排列的词典切片，不包括第一个

• -（i-2）

  -负偏移，以获得连续的“向后”切片，以便进一步

  设置

  联合

输出（与初始方法相同）：

具有切片和

set

操作的短魔术：

dicts = [dict10, dict11, dict12, dict13]
exist_score = 0

for i, d in enumerate(dicts[:0:-1]):
    offset = -(i - 2)
    exist_score += sum(d[k] for k in d.keys() & set().union(*dicts[offset::-1]))

print(exist_score)

• dicts[：0:-1]

  -按相反顺序排列的词典切片，不包括第一个

• -（i-2）

  -负偏移，以获得连续的“向后”切片，以便进一步

  设置

  联合

输出（与初始方法相同）：

---

你可以简单地把不同的词条放到一个列表中，然后在列表上迭代。。。这是否回答了您的问题？我可能可以给您提供比下面更快的解决方案，但如果您添加所需的输出和获得该输出的逻辑，这将是非常有用的。您只需将不同的命令放入一个列表中，然后在该列表上迭代。。。这是否回答了您的问题？我可能能够为您提供比下面更快的解决方案，但如果您添加所需的输出和逻辑以获得该输出，这将非常有用。