如何将字符串与多个正则表达式匹配？

Question

At the moment I am using the below filter to increment elements in arr, given a list of strings as an argument, is there an efficient way to do this in python.I got millions of such lists to validate upon.

  def countbycat(tempfilter):
        arr=[0,0,0,0,0]
        apattern,dpattern,mpattern,upattern,tpattern = re.compile("^[a]--*"),re.compile("^[d]--*"),re.compile("^[m]--*"),re.compile("^[u]--*"),re.compile("^[t]--*")
        for each in tempfilter:
            if upattern.match(each):
                 arr[0]+=1
            elif mpattern.match(each):
                 arr[1]+=1
            elif dpattern.match(each):
                 arr[2]=1
            elif apattern.match(each):
                 arr[3]+=1
            elif tpattern.match(each):
                 arr[4]+=1
        return arr  

Answer 1

For the regular expressions given in the question, you can use following regular expression using character class:

[admut]-

• [admut] will match any of a , d , m , u , t
• ^ can be omitted because re.match matches only at the beginning of the string.
• removed -* because it's pointless; only one - is enough to check - appear after the a/d/m/u/t .

And instead of using array, you can use a dictionary; no need to remember indexes:

def countbycat(tempfilter):
    count = dict.fromkeys('admut', 0)
    pattern = re.compile("[admut]-")
    for each in tempfilter:
        if pattern.match(each):
            count[each[0]] += 1
    return count

Instead of dict.fromkeys , you can use collections.Counter .

Answer 2

Don't use regex for this. You are checking for a very specific, fixed condition. Namely, each[1] == '-' and each[0] in 'admut' . Both of these are much faster than regex. The later can also be used as a mapping.

def countbycat(tempfilter):
  arr = [0, 0, 0, 0, 0]
  char_idx = {  # map admit to indices
    'u': 0,
    'm': 1,
    'd': 2,
    'a': 3,
    't': 4,
    }
  for each in tempfilter:
    if each[1] == '-':  # detect trailing -
      try:
        arr[char_idx[each[0]]] += 1  # increment position pointed to by admut
      except KeyError:  # each[0] not any of admut
        pass
  return arr  

Answer 3

In your simple case, go for falsetru's answer

In general case, you can combine your patterns into one regex (provided that your regexes doesn't contain capturing groups), and check which wart of regex matched:

patterns = ["^[a]-+", "^[d]-+", "^[m]-+", "^[u]-+", "^[t]-+"]

complex_pattern = re.compile('|'.join(['(%s)' % i for i in patterns]))

# imperative way

arr = [0, 0, 0, 0, 0]

for each in tempfilter:
    match = complex_pattern.match(each)
    if match:
        arr[match.lastgroup + 1] += 1

return arr

# functional way

from collections import Counter

matches_or_none = (complex_pattern.match(each) for each in tempfilter)

return Counter(match.lastgroup + 1 for match in matches_or_none if match is not None)