如何在python中動態組合集合

Question

我有一個字典列表，需要遍歷它們並檢查已經存在的鍵。 我已經實現了一個python代碼來手動計算得分，如下所示。 在我的代碼中，我在每次迭代中手動組合先前字典中的鍵。 迭代將從dict11開始。

如何更改此代碼以自動迭代動態數量的詞典，並且在每次迭代中如何動態組合鍵？

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

exist_score = 0

for key in dict11.keys() & dict10.keys():
    exist_score += dict11[key]

for key in dict12.keys() & set(dict11.keys()).union(set(dict10.keys())):
    exist_score += dict12[key]

for key in dict13.keys() & set(dict12.keys()).union(set(dict11.keys()).union(set(dict10.keys()))):
    exist_score += dict13[key]

print(exist_score)

Answer 1

首先，您需要將其變成可以放入循環的內容。 dict11 ， dict12和dict13必須發生相同的事情：

# same definition for dict10, dict11, dict12, dict13

exist_score = 0
seen_keys = set(dict10.keys())

for key in dict11.keys():
  if key in seen_keys:
    exist_score += dict11[key]
seen_keys.update(dict11.keys())

for key in dict12.keys():
  if key in seen_keys:
    exist_score += dict12[key]
seen_keys.update(dict12.keys())

for key in dict13.keys():
  if key in seen_keys:
    exist_score += dict13[key]
seen_keys.update(dict13.keys())

這應該與腳本執行相同的操作。 現在，您可以將其放入循環...

# same definition for dict10, dict11, dict12, dict13

exist_score = 0
seen_keys = set(dict10.keys())
other_dicts = [dict11, dict12, dict13]

for d in other_dicts:
  for key in d.keys():
    if key in seen_keys:
      exist_score += d[key]
  seen_keys.update(d.keys())

Answer 2

將字典本身保留在列表中是最有意義的。 將此邏輯放入函數中也很容易。

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)

如果您需要定期更新分數（一次更新一個字典），則可以在類或閉包中維護狀態。

類：

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)

Answer 3

切片和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並set

輸出（與您的初始方法相同）：

18