Python，循环遍历文件中的行；如果行等于另一个文件中的行，则返回原始行

Question

文本文件 1 具有以下格式：

'WORD': 1
'MULTIPLE WORDS': 1
'WORD': 2

等。

即，用冒号分隔的单词，后跟数字。

文本文件 2 具有以下格式：

'WORD'
'WORD'

等等。

我需要从文件 1 中提取单个单词（即，仅单词而不是多个单词），如果它们与文件 2 中的单词匹配，则返回文件 1 中的单词及其值。

我有一些功能不佳的代码：

def GetCounts(file1, file2):
    target_contents  = open(file1).readlines()  #file 1 as list--> 'WORD': n
    match_me_contents = open(file2).readlines()   #file 2 as list -> 'WORD'
    ls_stripped = [x.strip('\n') for x in match_me_contents]  #get rid of newlines

    match_me_as_regex= re.compile("|".join(ls_stripped))   

    for line in target_contents:
        first_column = line.split(':')[0]  #get the first item in line.split
        number = line.split(':')[1]   #get the number associated with the word
        if len(first_column.split()) == 1: #get single word, no multiple words 
            """ Does the word from target contents match the word
            from match_me contents?  If so, return the line from  
            target_contents"""
            if re.findall(match_me_as_regex, first_column):  
                print first_column, number

#OUTPUT: WORD, n
         WORD, n
         etc.

由于使用正则表达式，输出很短。例如，代码将返回“asset, 2”，因为 re.findall() 将匹配来自 match_me 的“set”。我需要将 target_word 与 match_me 中的整个单词进行匹配，以阻止部分正则表达式匹配导致的错误输出。

Answer 1

如果 file2 不是很大，请将它们放入一个集合中：

file2=set(open("file2").read().split())
for line in open("file1"):
    if line.split(":")[0].strip("'") in file2:
        print line

Answer 2

我猜你所说的“功能不佳”是指速度方面？因为我测试过，它似乎确实有效。

您可以通过在 file2 中创建单词的集合来提高效率：

word_set = set(ls_stripped)

然后您会看到它是否在集合中，而不是findall：

in_set = just_word in word_set

也感觉比正则表达式。

Answer 3

看起来这可能只是 grep 的一个特例。如果 file2 本质上是一个模式列表，并且输出格式与 file1 相同，那么您可能可以这样做：

grep -wf file2 file1

-w 告诉 grep 仅匹配整个单词。

Answer 4

我就是这样做的。我手头没有Python解释器，所以可能有一些拼写错误。

在使用 Python 时（特别是来自 Perl），您应该记住的主要事情之一是正则表达式通常不是一个好主意：字符串方法功能强大且速度非常快。

def GetCounts(file1, file2):
    data = {}
    for line in open(file1):
        try:
            word, n = line.rsplit(':', 1)
        except ValueError: # not enough values
            #some kind of input error, go to next line
            continue
        n = int(n.strip())
        if word[0] == word[-1] == "'":
            word = word[1:-1]
        data[word] = n

    for line in open(file2):
        word = line.strip()
        if word[0] == word[-1] == "'":
            word = word[1:-1]
        if word in data:
            print word, data[word]

Answer 5

import re, methodcaller

re_target = re.compile(r"^'([a-z]+)': +(\d+)", re.M|re.I)
match_me_contents = open(file2).read().splitlines()
match_me_contents = set(map(methodcaller('strip', "'"), match_me_contents))

res = []
for match in re_target.finditer(open(file1).read()):
    word, value = match.groups()
    if word in match_me_contents:
        res.append((word, value))

Answer 6

我的两个输入文件：

file1.txt:

'WORD': 1
'MULTIPLE WORDS': 1
'OTHER': 2

file2.txt:

'WORD'
'NONEXISTENT'

如果file2.txt保证没有一行中有多个单词，则无需从第一个文件中显式过滤这些单词。这将通过成员资格测试来完成：

# Build a set of what words we can return a count for.
with open('file2.txt', 'r') as f:
    allowed_words = set(word.strip() for word in f)

# See which of them exist in the first file.
with open('file1.txt', 'r') as f:
    for line in f:
        word, count = line.strip().split(':')

        # This assumes that strings with a space (multiple words) do not exist in
        # the second file.
        if word in allowed_words:
            print word, count

运行此命令会给出：

$ python extract.py
'WORD' 1

如果 file2.txt 可能包含多个单词，只需修改循环中的测试：

# Build a set of what words we can return a count for.
with open('file2.txt', 'r') as f:
    allowed_words = set(word.strip() for word in f)

# See which of them exist in the first file.
with open('file1.txt', 'r') as f:
    for line in f:
        word, count = line.strip().split(':')

        # This prevents multiple words from being selected.
        if word in allowed_words and not ' ' in word:
            print word, count

注意我没有费心从单词中删除引号。我不确定这是否有必要 - 这取决于输入是否保证有它们。添加它们是微不足道的。

您应该考虑的其他事情是区分大小写。如果小写和大写单词应该被视为相同，那么您应该在进行任何测试之前将所有输入转换为大写（或小写，无论是小写）。

编辑：从允许的单词集中删除多个单词可能比对 file1 的每一行进行检查更有效：

# Build a set of what words we can return a count for.
with open('file2.txt', 'r') as f:
    allowed_words = set(word.strip() for word in f if not ' ' in f)

# See which of them exist in the first file.
with open('file1.txt', 'r') as f:
    for line in f:
        word, count = line.strip().split(':')

        # Check if the word is allowed.
        if word in allowed_words:
            print word, count

Answer 7

这就是我想到的：

def GetCounts(file1, file2):
    target_contents  = open(file1).readlines()  #file 1 as list--> 'WORD': n
    match_me_contents = set(open(file2).read().split('\n'))   #file 2 as list -> 'WORD'  
    for line in target_contents:
        word = line.split(': ')[0]  #get the first item in line.split
        if " " not in word:
            number = line.split(': ')[1]   #get the number associated with the word
            if word in match_me_contents:  
                print word, number

对您版本的更改：

• 从正则表达式移至设置
• 去分割而不是读取行以摆脱换行符而无需额外处理
• 将单词拆分为单词并检查其长度是否为一更改为只需直接检查“单词”中是否有空格
  • 如果“空格”不是实际的空格，这可能会导致错误。这可以使用“\s”或等效的正则表达式来修复，但会降低性能。
• 在 line.split(': ') 中添加了一个空格，这样数字就不会以空格为前缀
  • 如果数字前没有空格，这可能会导致错误。
• 为了提高效率，在检查单词是否包含空格后移动了 number = line.split(': ')[1]，尽管速度差异很小（几乎可以肯定大部分时间将花费时间检查目标中是否有工作）

但是，只有当实际输入不是您提供的格式时，才会出现潜在的错误。

Answer 8

让我们利用文件格式与 Python 表达式语法的相似性：

from ast import literal_eval
with file("file1") as f:
  word_values = ast.literal_eval('{' + ','.join(line for line in f) + '}')
with file("file2") as f:
  expected_words = set(ast.literal_eval(line) for line in f)
word_values = {k: v for (k, v) in word_values if k in expected_words}