如何在元組列表中識別部分元組匹配

Question

如果我有一個包含元組列表的字典，例如：

d = {'ENSG00000186092': [('ENST00000641515', '3'),
                        ('ENST00000641515', '1'),
                        ('ENST00000641515', '2'),
                        ('ENST00000335137', '1')],
    'ENSG00000284662': [('ENST00000332831', '1')],
    'ENSG00000284733': [('ENST00000426406', '1')]}

如何確定每個鍵是否有元組，而元組的第一個元素不匹配，而第二個元素匹配？

例如，在上面的示例中，我們只會看到一個“ hit”，而該鍵是ENSG00000186092的鍵，原因是：

('ENST00000641515', '1')
('ENST00000335137', '1')

Answer 1

令人困惑的列表理解會引起您的興趣嗎？

[
  k for k, v in d.items()
  if any(
    (i, j)
    for i, j in v
    for x, y in v
    if i != x and j == y
  )
]
>>> ['ENSG00000186092']

1. 遍歷字典
2. 遍歷每個鍵的元組列表
3. 對於每個元組，循環訪問相同的列表，並檢查第一個條目不匹配，而第二個匹配
4. 如果找到任何內容，則記錄第2步中的密鑰。

Answer 2

非常冗長：

d = {
    "ENSG00000186092": [
        ("ENST00000641515", "3"),
        ("ENST00000641515", "1"),
        ("ENST00000641515", "2"),
        ("ENST00000335137", "1"),
    ],
    "ENSG00000284662": [("ENST00000332831", "1")],
    "ENSG00000284733": [("ENST00000426406", "1")],
}

def has_duplicates(list_of_tuples):
    seen = set()
    for _, value in list_of_tuples:
        if value in seen:
            return True
        seen.add(value)
    return False

dupes = [key for key, value in d.items() if has_duplicates(value)]

print(dupes)

has_duplicates函數從您的字典中獲取一個值。 如果該值中的任何元組具有相同的第二個值，則返回True。

返回中的列表理解為您提供了has_duplicates為True的所有鍵。

Answer 3

d = {'ENSG00000186092': [('ENST00000641515', '3'),
                        ('ENST00000641515', '1'),
                        ('ENST00000641515', '2'),
                        ('ENST00000335137', '1')],
    'ENSG00000284662': [('ENST00000332831', '1')],
    'ENSG00000284733': [('ENST00000426406', '1')]}

for k, a in d.items():
    a_s = sorted(a, key=lambda x: (x[1], x[0]))
    for i in range(len(a_s)-1):
        if a_s[i][1] == a_s[i+1][1] and a_s[i][0] != a_s[i+1][0]:
            print (k, a_s[i], a_s[i+1])

• 按第二個元素對元組進行排序，然后按元組的第一個元素對元組進行排序，以便使元組通過第二個元素然后按第一個元素組合在一起
• 檢查排序列表中當前元組和下一個元組之間的條件，並在滿足條件時打印它們
• 時間復雜度，如果d有k項目且列表大小為'n'，則為O(k*nlogn) [ k用於外循環， nlogn用於排序]