Python 比较两个键处的值中的元素

给定一个字典和两个键，我们如何在两个 指定的键，并从该索引的每个键中筛选出不匹配的元素

前

那么它的作用是：

>>> equal_keys({'i.year': ['1997', '1997'], 'i.month': ['March', 'April'], 'j.month': ['March', 'April'], 'j.year': ['1997', '2003']}, 'i.year', 'j.year')
{'i.year': ['1997'], 'j.month': ['April'], 'i.month': ['April'], 'j.year': ['2003']} 

两个指定的键作为参数是i.year和j.year，因此我们比较这两个键中的元素并检查它们是否相等。i年的第一个元素是1997年，j年的第一个元素是1997年，它们相等，所以我们继续下一个元素。i.year中的下一个元素是1997年，j.year中的下一个元素是2003年，它们不相等，因此我们删除该索引中每个键中的每个元素，因此我们得到：

{'i.year': ['1997', '1997'], 'i.month': ['March', 'April'], 'j.month': ['March', 'April'], 'j.year': ['1997', '2003']}

虽然这确实有效：

 {'i.year': ['1997'], 'j.month': ['March'], 'i.month': ['March'], 'j.year': ['2003']} 

有没有一种方法可以编写类似于开头代码的代码，有三个参数，没有zip，没有导入，没有*，或者没有一行代码，格式如下：

def equal_keys(d, *keys):
    indexes = [i for i, x in enumerate(zip(*(d[key] for key in keys)))
               if len(set(x)) == 1]
    return {key: [value[x] for x in indexes] for key, value in d.items()}

---

这几乎是一种简单易懂的逐行方式，无需导入，无需压缩编码，无需一行（除一行；-），

min

）：

---

给你，没有导入，没有

zip

，没有单行线（除了一条；-），

min

）：

---

给你，没有导入，没有

zip

，没有单行线（除了一条；-），

min

）：

---

给你，没有导入，没有

zip

，没有单行线（除了一条；-），

min

）：

---

这基本上只是对您所提供的内容进行解包，但希望更容易理解：

def equal_keys(d, *keys):

    indexes = []
    #get the length of shortest list
    min_ = min(len(d[x]) for x in keys)

    for i in xrange(min_):
        items = []         #collect items on same index in this list
        for key in keys:
            items.append(d[key][i])
        # If len(set(items)) != 1 means all items are not same, so add this
        # index to indexes
        if len(set(items)) != 1:
            indexes.append(i)

    dic = {}
    #Now iterate over each (key, value) pair and for each value
    #keep only those items that are present on the indices stored in indexes list.
    for k, v in d.items():
        dic[k] = []
        for i in indexes:
           dic[k].append(d[k][i])

    return dic

当你以

def matching_values_by_keys(d, key1, key2):
    # figure out which elements of each list to keep
    keep_indices = set()
    for index,value in enumerate(d[key1]):
        if value == d[key2][index]:
            keep_indices.add(index)

    # now go through each dictionary entry and keep the wanted elements
    new_d = {}
    for key,lst in d.items():
        new_lst = []
        for index,value in enumerate(lst):
            if index in keep_indices:
                new_lst.append(value)
        new_d[key] = new_lst

    return new_d

返回

matching_values_by_keys({'i.year': ['1997', '1997'], 'i.month': ['March', 'April'], 'j.month': ['March', 'April'], 'j.year': ['1997', '2003']}, 'i.year', 'j.year')

---

根据您的描述，我认为这是正确的答案（“三月”，而不是上面给出的“四月”）

这基本上是对您所给出的内容的解包，但希望更容易理解：

def equal_keys(d, *keys):

    indexes = []
    #get the length of shortest list
    min_ = min(len(d[x]) for x in keys)

    for i in xrange(min_):
        items = []         #collect items on same index in this list
        for key in keys:
            items.append(d[key][i])
        # If len(set(items)) != 1 means all items are not same, so add this
        # index to indexes
        if len(set(items)) != 1:
            indexes.append(i)

    dic = {}
    #Now iterate over each (key, value) pair and for each value
    #keep only those items that are present on the indices stored in indexes list.
    for k, v in d.items():
        dic[k] = []
        for i in indexes:
           dic[k].append(d[k][i])

    return dic

当你以

def matching_values_by_keys(d, key1, key2):
    # figure out which elements of each list to keep
    keep_indices = set()
    for index,value in enumerate(d[key1]):
        if value == d[key2][index]:
            keep_indices.add(index)

    # now go through each dictionary entry and keep the wanted elements
    new_d = {}
    for key,lst in d.items():
        new_lst = []
        for index,value in enumerate(lst):
            if index in keep_indices:
                new_lst.append(value)
        new_d[key] = new_lst

    return new_d

返回

matching_values_by_keys({'i.year': ['1997', '1997'], 'i.month': ['March', 'April'], 'j.month': ['March', 'April'], 'j.year': ['1997', '2003']}, 'i.year', 'j.year')

---

根据您的描述，我认为这是正确的答案（“三月”，而不是上面给出的“四月”）

这基本上是对您所给出的内容的解包，但希望更容易理解：

def equal_keys(d, *keys):

    indexes = []
    #get the length of shortest list
    min_ = min(len(d[x]) for x in keys)

    for i in xrange(min_):
        items = []         #collect items on same index in this list
        for key in keys:
            items.append(d[key][i])
        # If len(set(items)) != 1 means all items are not same, so add this
        # index to indexes
        if len(set(items)) != 1:
            indexes.append(i)

    dic = {}
    #Now iterate over each (key, value) pair and for each value
    #keep only those items that are present on the indices stored in indexes list.
    for k, v in d.items():
        dic[k] = []
        for i in indexes:
           dic[k].append(d[k][i])

    return dic

当你以

def matching_values_by_keys(d, key1, key2):
    # figure out which elements of each list to keep
    keep_indices = set()
    for index,value in enumerate(d[key1]):
        if value == d[key2][index]:
            keep_indices.add(index)

    # now go through each dictionary entry and keep the wanted elements
    new_d = {}
    for key,lst in d.items():
        new_lst = []
        for index,value in enumerate(lst):
            if index in keep_indices:
                new_lst.append(value)
        new_d[key] = new_lst

    return new_d

返回

matching_values_by_keys({'i.year': ['1997', '1997'], 'i.month': ['March', 'April'], 'j.month': ['March', 'April'], 'j.year': ['1997', '2003']}, 'i.year', 'j.year')

---

根据您的描述，我认为这是正确的答案（“三月”，而不是上面给出的“四月”）

这基本上是对您所给出的内容的解包，但希望更容易理解：

def equal_keys(d, *keys):

    indexes = []
    #get the length of shortest list
    min_ = min(len(d[x]) for x in keys)

    for i in xrange(min_):
        items = []         #collect items on same index in this list
        for key in keys:
            items.append(d[key][i])
        # If len(set(items)) != 1 means all items are not same, so add this
        # index to indexes
        if len(set(items)) != 1:
            indexes.append(i)

    dic = {}
    #Now iterate over each (key, value) pair and for each value
    #keep only those items that are present on the indices stored in indexes list.
    for k, v in d.items():
        dic[k] = []
        for i in indexes:
           dic[k].append(d[k][i])

    return dic

当你以

def matching_values_by_keys(d, key1, key2):
    # figure out which elements of each list to keep
    keep_indices = set()
    for index,value in enumerate(d[key1]):
        if value == d[key2][index]:
            keep_indices.add(index)

    # now go through each dictionary entry and keep the wanted elements
    new_d = {}
    for key,lst in d.items():
        new_lst = []
        for index,value in enumerate(lst):
            if index in keep_indices:
                new_lst.append(value)
        new_d[key] = new_lst

    return new_d

返回

matching_values_by_keys({'i.year': ['1997', '1997'], 'i.month': ['March', 'April'], 'j.month': ['March', 'April'], 'j.year': ['1997', '2003']}, 'i.year', 'j.year')

---

根据您的描述，我认为这是正确的答案（“三月”，而不是上面给出的“四月”。

谢谢您，您能解释一下这部分吗：如果len（set（items））！=1:@Sc4r一个集合只能包含唯一的键，因此如果我们将从相同索引接收的项传递给它，那么我们可以通过检查集合的长度来检查它们是否都相同<代码>集合（['1997'，2003'，1997']）-->

集合（['2003'，1997']）

所有项目相同：

集合（['1997'，1997'，1997']）

-->

集合（['1997']）

谢谢你，你能解释一下这部分吗：如果len（集合（项目））！=1:@Sc4r一个集合只能包含唯一的键，因此如果我们将从相同索引接收的项传递给它，那么我们可以通过检查集合的长度来检查它们是否都相同<代码>集合（['1997'，2003'，1997']）-->

集合（['2003'，1997']）

所有项目相同：

集合（['1997'，1997'，1997']）

-->

集合（['1997']）

谢谢你，你能解释一下这部分吗：如果len（集合（项目））！=1:@Sc4r一个集合只能包含唯一的键，因此如果我们将从相同索引接收的项传递给它，那么我们可以通过检查集合的长度来检查它们是否都相同<代码>集合（['1997'，2003'，1997']）-->

集合（['2003'，1997']）

所有项目相同：

集合（['1997'，1997'，1997']）

-->

集合（['1997']）

谢谢你，你能解释一下这部分吗：如果len（集合（项目））！=1:@Sc4r一个集合只能包含唯一的键，因此如果我们将从相同索引接收的项传递给它，那么我们可以通过检查集合的长度来检查它们是否都相同<代码>集合（['1997'，2003'，1997']）-->

集合（['2003'，1997']）

所有项目相同：

集合（['1997'，1997'，1997']）

-->

集合（['1997']）

非常感谢您，这更容易理解非常感谢您，这更容易理解非常感谢您，这更容易理解