Python从列表中获取所有正则表达式匹配组

Question

Suppose I have read all the lines of a text file as follows:

ifile = open('myfile.txt')
lines = ifile.readlines()

Now, suppose I have the following regular expression:

rgx = re.compile(r'Found ([0-9]+) solutions')

I can use

result = filter(rgx.match,lines)
print result

to obtain a list of matches, but what I want is a list of matching groups. For example, instead of output like:

Found 3 solutions
Found 35 solutions
Found 0 solutions

I want output like:

3
35
0

How can I do this?

Answer 1

import re

rgx = re.compile(r'Found ([0-9]+) solutions')

with open('myfile.txt') as f:
    result = [m.group(1) for m in (rgx.match(line) for line in f) if m]

The inner loop, (rgx.match(line) for line in f) is a generator expression that acts like apply() . For each line in the file, it calls rgx.match() and yields up the result, an SRE_Match object (I usually just call it a "match object").

The outer loop has if m which discards any result that does not evaluate true ( re.match() returns None when the pattern doesn't match). Then m.group(1) uses the match object to get the text from inside the parentheses. See the documentation for the re module for details. Since the outer loop is part of a list comprehension, a list of results is built and returned.

Answer 2

Since the prefix and suffix are fixed string, you can use look-around:

r'(?<=Found )\d+(?= solutions)'

I think there should be some way to use your regular expression to do the job, though.

Answer 3

You get "match" objects back from the match command (unless you implicitly turn it into a string using filter), alas. there isn't decent documentation available via. ipython help but it is online: http://docs.python.org/3/library/re.html#match-objects

Eg.

for line in lines:
  result = rgx.match(line)
  if not result: continue
  print result.group(1)

Answer 4

print '\n'.join([m.group(1) for l in lines for m in [rgx.search(l)] if m])

Answer 5

So the other solutions offered here are fine and probably the most readable, but in the specific example of your needs, I would suggest there are a couple of one-line alternatives (bearing in mind of course that your question was from 2013 and you probably don't work at the same company, let alone work on the same project). I also think this is of some general interest if anyone finds themself here. Because your premise is very simple (one interesting piece of data on each line), You can do the following:

>>> # simulate reading the (hopefully not ginormous) file into a single string
>>> lines = "Found 3 solutions\nFound 35 solutions\nFound 0 solutions\n"
>>> # we're now in the state we would be after "lines = file.readlines()"
>>> print(lines)
Found 3 solutions
Found 35 solutions
Found 0 solutions

>>> # we're so constrained, we can get away with murder in a single line
>>> solution_counts = re.findall(r'\d+', file_contents)
>>> solution_counts
['3', '35', '0']
>>> # bazinga!

This is a surprisingly robust solution. If your file is localized in a way that changes the words "found" and "solutions" to translated equivalents, this solution doesn't care, as long as the formatting remains the same. Headers and footers that don't contain decimal integers? Doesn't care. It could work on a single string like "Found solution sets of count 3, 35, and 0" The exact same code will extract the answer you want. However, it's more common that you know the format, but can't control it, and each line/record is full of heterogeneous data and that the section you care about is surrounded by others that you may or may not care bout. So consider the wacky variant below:

file_contents = "99 bottles of beer on the wall\n" \
                "50 ways to leave your lover\n" \
                "6 kinds of scary\n" \
                "Found 3 solutions of type A\n" \
                "Found 35 solutions of type C\n" \
                "Found 4 solutions of unknown type\n" \
                "2 heads are better than 1\n" \
                "etc, ...\n"

Our naive solution will return ['99', '50', '6', '3', '35', '4', '2', '1'] , which is not all that interesting unless you know how to filter out the extraneous data, so confusing, error-prone, and fragile - 1 star out of five. It would be easy, and probably nice clean solution involving iterating over the lines in stead of ingesting the whole stream of bytes into memory, but let's stick with the assumption that we have to for some reason. Maybe it doesn't come from a file (captured from TCPIP stream or whatever. Using another one-liner, lines.split('\\n') , we get the lines separated again (without the newlines), and can iterate and do comprehensions, etc., but we could also skip right to it using finditer

>>> [ m.group(1) for m in re.finditer(r'Found (\d+)', file_contents) ]
>>> ['3', '35', '4']

Pretty robust. I'm not even sure it's faster to pre-compile unless you're processing lots nightmare files.