Python 如何比较字符串与备用列表中元素匹配的2个列表

嗨，我正在学习，所以你可能不得不忍受我。我有两个列表，我想在保留任何匹配项的同时进行比较，并在将任何不匹配项附加到另一个输出列表的同时附加它们。 这是我的密码：

def EntryToFieldMatch(Entry, Fields):
    valid = []
    invalid = []
    for c in Entry:
        count = 0
        for s in Fields:
            count +=1
            if s in c:
                valid.append(c)
            elif count == len(Entry):
                invalid.append(s)
                Fields.remove(s)



    print valid
    print "-"*50
    print invalid


def main():
    vEntry = ['27/04/2014', 'Hours = 28', 'Site = Abroad', '03/05/2015', 'Date = 28-04-2015', 'Travel = 2']
    Fields = ['Week_Stop', 'Date', 'Site', 'Hours', 'Travel', 'Week_Start', 'Letters']
    EntryToFieldMatch(vEntry, Fields)

if __name__ = "__main__":
    main()

除了没有返回2个输出列表中的所有字段外，输出看起来很好。这是我收到的输出：

['Hours = 28', 'Site = Abroad', 'Date = 28-04-2015', 'Travel = 2']
--------------------------------------------------
['Week_Start', 'Letters']

我只是不知道为什么第二个列表不包括“周站”。我已经运行了调试器，并按照代码执行了几次，但都没有效果。我读过关于集合的文章，但我没有看到任何方法可以返回匹配的字段，并丢弃不匹配的字段。 我也愿意接受这个建议，如果有人知道简化整个过程的方法，我不是要求免费代码，只是向正确的方向点头。

---

Python2.7，谢谢

您只有两个条件，要么在字符串中，要么计数等于条目的长度，这两个条件都不捕捉第一个元素

'Week\u Stop'

，长度从7-6-5捕捉

Week\u Start

到

0

，因此您永远不会到达

Week\u Stop

如果要保持秩序，更有效的方法是使用集合或A：

from collections import OrderedDict
def EntryToFieldMatch(Entry, Fields):
    valid = []
    # create orderedDict from the words in Fields
    # dict lookups are 0(1)
    st = OrderedDict.fromkeys(Fields)
    # iterate over Entry
    for word in Entry:
        # split the words once on whitespace
        spl = word.split(None, 1)
        # if the first word/word appears in our dict keys
        if spl[0] in st:
            # add to valid list
            valid.append(word)
            # remove the key
            del st[spl[0]]
    print valid
    print "-"*50
    # only invalid words will be left
    print st.keys()

输出：

['Hours = 28', 'Site = Abroad', 'Date = 28-04-2015', 'Travel = 2']
--------------------------------------------------
['Week_Stop', 'Week_Start', 'Letters']    

对于大型列表，这将比二次方法快得多。拥有

0（1）

dict查找意味着每次在字段

中执行
时，代码都会从二次型变为线性型，这是一个
0（n）
操作

使用类似的方法：

def EntryToFieldMatch(Entry, Fields):
    valid = []
    st = set(Fields)
    for word in Entry:
        spl = word.split(None,1)
        if spl[0] in st:
            valid.append(word)
            st.remove(spl[0])
    print valid
    print "-"*50
    print st

使用集合的差异是不保持顺序的
 您只有两个条件，要么在字符串中，要么计数等于条目的长度，这两个条件都不能捕获第一个元素
'Week\u Stop'
，长度从7-6-5捕获
Week\u Start
，但永远不能到达
0
，因此您永远无法到达
Week\u Stop

如果要保持秩序，更有效的方法是使用集合或A：

from collections import OrderedDict
def EntryToFieldMatch(Entry, Fields):
    valid = []
    # create orderedDict from the words in Fields
    # dict lookups are 0(1)
    st = OrderedDict.fromkeys(Fields)
    # iterate over Entry
    for word in Entry:
        # split the words once on whitespace
        spl = word.split(None, 1)
        # if the first word/word appears in our dict keys
        if spl[0] in st:
            # add to valid list
            valid.append(word)
            # remove the key
            del st[spl[0]]
    print valid
    print "-"*50
    # only invalid words will be left
    print st.keys()

输出：

['Hours = 28', 'Site = Abroad', 'Date = 28-04-2015', 'Travel = 2']
--------------------------------------------------
['Week_Stop', 'Week_Start', 'Letters']    

对于大型列表，这将比二次方法快得多。拥有
0（1）
dict查找意味着每次在字段
中执行
时，代码都会从二次型变为线性型，这是一个
0（n）
操作

使用类似的方法：

def EntryToFieldMatch(Entry, Fields):
    valid = []
    st = set(Fields)
    for word in Entry:
        spl = word.split(None,1)
        if spl[0] in st:
            valid.append(word)
            st.remove(spl[0])
    print valid
    print "-"*50
    print st

使用集合的差异是不保持顺序的
 使用：


使用：


有点不清楚输出应该是什么。1） 有效条目2）无效条目或缺少字段？
count==len（条目）
对我来说毫无意义。这应该是
count==len（Fields）
可能吗？现在来看，应该用下面所示的方法之一完成，当时我的想法是，如果有更多的条目，那么当所有的字段都被排序时，一些条目将被取消选中。这可能是针对我的情况，但是条目总是比字段包含更多的元素。输出应该是什么还不清楚。1） 有效条目2）无效条目或缺少字段？
count==len（条目）
对我来说毫无意义。这应该是
count==len（Fields）
可能吗？现在来看，应该用下面所示的方法之一完成，当时我的想法是，如果有更多的条目，那么当所有的字段都被排序时，一些条目将被取消选中。这可能是针对我的情况，但条目中的元素总是比字段多。我想你可能误读了这篇文章，有效列表的预期结果应该是相同的，但无效列表中应该只有与“条目”中的任何内容不匹配的字段。例如“停止工作周”、“开始工作周”和“信件”。不过我很喜欢这种方式。也很抱歉投票被否决了。我不知道为什么会发生这种情况。谢谢！我认为这个问题不清楚，我添加了一条评论来澄清，并编辑了我的答案，将两者都包括在内……我认为你可能误读了这篇文章，你的有效列表的预期结果应该是相同的，但在无效列表中，应该只有与“条目”中的任何内容不匹配的字段。例如“停止工作周”、“开始工作周”和“信件”。不过我很喜欢这种方式。也很抱歉投票被否决了。我不知道为什么会发生这种情况。谢谢！我认为问题中不清楚，我添加了一条评论以澄清并编辑了我的答案，将两者都包括在内……那么您的第二个解决方案会比mpolednik的解决方案更快吗？顺序不是一个关键因素。@SidSpace，是的，对于任何合理的输入大小集来说，都是非常有效的，线性的总是比二次的好得多。循环输入的唯一额外成本条是建立集合/指令，这是一个线性运算。这似乎是一个更可计算的解决方案，我将把它作为正确答案。我也很抱歉我不知道为什么会这样happening@SidSpace，不用担心，选择最适合你的答案，但是知道二次解和线性解之间的区别很重要，dicts和set可以帮助你提高代码的效率。这是某种错误吗？我肯定不是我，而是说我连投票权都没有所以你的第二个解决方案会比mpolednik的更快吗？顺序不是一个关键因素。@SidSpace，是的，对于任何合理的输入大小集来说，都是非常有效的，线性的总是比二次的好得多。循环输入的唯一额外成本条是建立集合/指令，这是一个线性运算。这似乎是一个更可计算的解决方案，我将把它作为正确答案。我也很抱歉我不知道为什么会这样happening@SidSpace，不用担心，选择最适合你的答案，但是知道二次解和线性解之间的区别很重要，dicts和set可以帮助你提高代码的效率。这是某种错误吗？我肯定不是我，而是说我还没有投票权