Question

我正在开发一个程序，它有两个具有相同数量元素的列表

第一个列表由一个模式组成（注意：pat总是至少有两个不同的元素）：

pat = ['G', 'H', 'G' ]

然后第二个列表是一个包含列表的列表。

mylist = [['Hello'], ['Hey'], ['Hello']]

我需要仔细检查模式，看看mylist是否遵循模式。

所以在这种情况下，mylist遵循pat模式，因为mylist [0] == mylist [2]和mylist [1]可以什么都没有，因为根据拍拍，它不必遵循任何其他模式。

所以程序应该返回mylist中的元素，这些元素不遵循pat中的模式：

[]

但是如果mylist没有遵循pat中的模式，那么程序应该返回一个列表，其中只有mylist中的元素没有遵循相同顺序的模式，这里有一些函数调用：

>>>pat_check(['G', 'W', 'G', 'G'], [[12], ['E'], [12], [13]])    #[13], [12], [12] should be the same but they are not therefor the program returns all those values
[[12], [12], [13]]

>>>pat_check(['G', 'H', 'G'], [['G'], ['H'], ['L']])    #['G'] and ['L'] are supposed to be the same but they are not, the program will output the 2 elements that should be the same but are not
[['G'], ['L']]

>>>pat_check(['G', 'H', 'G'], [['Hello'], ['Hey'], ['Hello']])  # everything is correct
[]

我是python的新手，非常感谢使用易于理解的形式和基本方法。（没有导入和其他类似的东西）

问：有没有算法可以做到这一点？

Answer 1

使用dict跟踪您遇到的情况：

def pat_check(pat, mylist):
    dct = {}
    res = []
    for p, q in zip(pat, mylist):
        if dct.setdefault(p, q) != q:
            res.append(q)
    return res

注意：您必须添加代码来处理不同长度的pat和mylist。

另外，pat_check(['G', 'H', 'G'], [['G'], ['H'], ['L']])应为[['L']]，这不是您在帖子中写的内容。

使用列表理解：

def pat_check(pat, mylist):
    dct = {}
    return [q for p, q in zip(pat, mylist) if dct.setdefault(p, q) != q]

编辑：

from collections import defaultdict


def key_vals(pat, mylist):
    res = defaultdict(list)
    for p, q in zip(pat, mylist):
        res[p].append(q)
    return res


def pat_check(pat, mylist):
    res = []
    for p, vals in key_vals_order(pat, mylist).items():
        # could be vals[1:], but that makes a copy so it should be benched with
        # actual data
        if any(v != vals[0] for v in vals):
            res.extend(vals)
    return res

如果您关心订单：

from collections import OrderedDict


def key_vals(pat, mylist):
    res = OrderedDict()
    for p, q in zip(pat, mylist):
        res.setdefault(p, []).append(q)
    return res

Answer 2

也许尝试这样的事情：

def pat_check(pattern, list_to_check):
    pattern_dict = {}
    not_matching = []
    for i, value in enumerate(pattern):
        try:
            if pattern_dict[value] != list_to_check[i]:
                not_matching.append(list_to_check[i])
        except KeyError:
            pattern_dict[value] = list_to_check[i]
    return not_matching

请记住，您的示例中存在一些模棱两可的情况：

pat_check（['G'，'H'，'G']，[['G']，['H']，['L']]）＃['G']和['L' ]应该是相同的，但它们不是[['G']，['L']]

此算法仅在['L']认为['G']与其自身匹配时输出{{1}}。

一个列表中的模式比较另一个列表

2 个答案: