正则表达式（按顺序查找匹配的字符）

Question

Let us say that I have the following string variables:

welcome = "StackExchange 2016"
string_to_find = "Sx2016"

Here, I want to find the string string_to_find inside welcome using regular expressions. I want to see if each character in string_to_find comes in the same order as in welcome .

For instance, this expression would evaluate to True since the 'S' comes before the 'x' in both strings, the 'x' before the '2' , the '2' before the 0 , and so forth.

Is there a simple way to do this using regex?

Answer 1

Your answer is rather trivial. The .* character combination matches 0 or more characters. For your purpose, you would put it between all characters in there. As in S.*x.*2.*0.*1.*6 . If this pattern is matched, then the string obeys your condition.

For a general string you would insert the .* pattern between characters, also taking care of escaping special characters like literal dots, stars etc. that may otherwise be interpreted by regex.

Answer 2

Use wildcard matches with . , repeating with * :

expression = 'S.*x.*2.*0.*1.*6'

You can also assemble this expression with join() :

expression = '.*'.join('Sx2016')

Or just find it without a regular expression, checking whether the location of each of string_to_find 's characters within welcome proceeds in ascending order, handling the case where a character in string_to_find is not present in welcome by catching the ValueError :

>>> welcome = "StackExchange 2016"
>>> string_to_find = "Sx2016"
>>> try:
...     result = [welcome.index(c) for c in string_to_find]
... except ValueError:
...     result = None
...
>>> print(result and result == sorted(result))
True

Answer 3

This function might fit your need

import re
def check_string(text, pattern):
    return re.match('.*'.join(pattern), text)

'.*'.join(pattern) create a pattern with all you characters separated by '.*' . For instance

>> ".*".join("Sx2016")
'S.*x.*2.*0.*1.*6'

Answer 4

Actually having a sequence of chars like Sx2016 the pattern that best serve your purpose is a more specific:

S[^x]*x[^2]*2[^0]*0[^1]*1[^6]*6

You can obtain this kind of check defining a function like this:

import re
def contains_sequence(text, seq):
    pattern = seq[0] + ''.join(map(lambda c: '[^' + c + ']*' + c, list(seq[1:])))
    return re.search(pattern, text)

This approach add a layer of complexity but brings a couple of advantages as well:

1. It's the fastest one because the regex engine walk down the string only once while the dot-star approach go till the end of the sequence and back each time a .* is used . Compare on the same string (~1k chars):

   • Negated class -> 12 steps
   • Dot star -> 4426 step

2. It works on multiline strings in input as well.

Example code

>>> sequence = 'Sx2016'
>>> inputs = ['StackExchange2015','StackExchange2016','Stack\nExchange\n2015','Stach\nExchange\n2016']
>>> map(lambda x: x + ': yes' if contains_sequence(x,sequence) else x + ': no', inputs)
['StackExchange2015: no', 'StackExchange2016: yes', 'Stack\nExchange\n2015: no', 'Stach\nExchange\n2016: yes']