从字符串列表中获取子字符串列表，其中子字符串与某个正则表达式匹配

Question

This question is for Python 3.6+ (but feel free to answer for lower Pythons for other readers).

I want to extract a substring from each string that matches a regular expression.

Say I have the following:

a = ['v-01-001', 'v-01-002', 'v-02-001', 'v-02-002', 'v-02-003', 'v-03-001']

I want the last 3 digits of all strings matching v-02-\\d\\d\\d , ie:

['001', '002', '003']

My naive attempt:

[x[1] for x in list(map(lambda i: re.search(r'v-02-(\d\d\d)', i), a)) if x]

Can you come up with anything more elegant?

Thanks

Answer 1

You could do something like this:

import re

a = ['v-01-001', 'v-01-002', 'v-02-001', 'v-02-002', 'v-02-003', 'v-03-001']
pattern = re.compile('v-02-(\d{3})$')
print([m.group(1) for m in map(pattern.match, a) if m])

Output

['001', '002', '003']

Also you could use finditer :

print([m.group(1) for ms in map(pattern.finditer, a) for m in ms])

Output

['001', '002', '003']

Answer 2

Four ways to do this.

The first is just a regular 'ole loop:

li=[]
for s in a:
    m = re.search(r'v-02-(\d\d\d)', s)
    if m:
        li.append(m.group(1))
 # li=['001', '002', '003']

Second in two calls to the same regex in a list comprehension:

>>> [re.search(r'v-02-(\d\d\d)', s).group(1) for s in a if re.search(r'v-02-(\d\d\d)', s)]
['001', '002', '003']

Third is to use map :

>>> [m.group(1) for m in map(lambda s: re.search(r'v-02-(\d\d\d)', s), a) if m]
['001', '002', '003']

Finally, you can flatten the list with .join and then use findall :

>>> re.findall(r'\bv-02-(\d\d\d)\b', '\t'.join(a))
['001', '002', '003']

Or, use \\n and re.M vs two \\b :

>>> re.findall(r'^v-02-(\d\d\d)$', '\n'.join(a), flags=re.M)
['001', '002', '003']

I would probably write this in that same order if I were writing this bit of code.

What is considered more elegant is in the eye of the beholder I suppose. I would consider the last one to be more elegant.

---

You can also skip the regex and use Python's string methods:

>>> prefix='v-02-'
>>> [e[len(prefix):] for e in filter(lambda s: s.startswith(prefix),a)]
['001', '002', '003']

That would likely be the fastest if that matters in this case.

---

In December of 2019, there will be a more elegant alternative. As defined in PEP 572 , you will be able to use an assignment statement so you can assign the match and test the match in one step:

[m.group(1) for s in a if (m:=re.search(r'v-02-(\d\d\d)', s))]