Gsyfuy

In Python I try to find the last position in an arbitrary string that does not match a given pattern, which is specified as regex pattern (that includes the "not" in the match). For example, with the string uiae1iuae200, and the pattern of not being a number (regex pattern in Python for this would be [^0-9]), I would need '8' (the last 'e' before the '200') as result. What is the most pythonic way to achieve this?

As it's a little tricky to quickly find method documentation and the best suited method for something in the Python docs (due to method docs being somewhere in the middle of the corresponding page, like re.search() in the re page), the best way I quickly found myself is using re.search() - but the current form simply must be a suboptimal way of doing it:

import re

string = 'uiae1iuae200' # the string to investigate

len(string) - re.search(r'[^0-9]', string[::-1]).start()

I am not satisfied with this for two reasons: a) I need to reverse string before using it with [::-1], and b) I also need to reverse the resulting position (subtracting it from len(string) because of having reversed the string before. There needs to be better ways for this, likely even with the result of re.search().

I am aware of re.search(...).end() over .start(), but re.search() seems to split the results into groups, for which I did not quickly find a not-cumbersome way to apply it to the last matched group. Without specifying the group, .start(), .end(), etc, seem to always match the first group, which does not have the position information about the last match. However, selecting the group seems to at first require the return value to temporarily be saved in a variable (which prevents neat one-liners), as I would need to access both the information about selecting the last group and then to select .end() from this group.

What's your pythonic solution to this? I would value being pythonic more than having the most optimized runtime.

Update

The solution should be functional also in corner cases, like 123 (no position that matches the regex), empty string, etc. It should not crash e.g. because of selecting the last index of an empty list. However, as even my ugly answer above in the question would need more than one line for this, I guess a one-liner might be impossible for this (simply because one needs to check the return value of re.search() or re.finditer() before handling it). I'll accept pythonic multi-line solutions to this answer for this reason.

You can use re.finditer to extract start positions of all matches and return the last one from list. Try this Python code (apologies if it is non-Pythonic as I am quite new to Python),

import re

print([m.start(0) for m in re.finditer(r'D', 'uiae1iuae200')][-1])

Prints,

8

Edit:
For making the solution a bit more elegant to behave properly in for all kind of inputs, here is the updated code. Now the solution goes in two lines as the check has to be performed if list is empty then it will print -1 else the index value.

import re



arr = ['', '123', 'uiae1iuae200', 'uiae1iuae200aaaaaaaa']



for s in arr:

    lst = [m.start() for m in re.finditer(r'D', s)]

    print(s, '-->', lst[-1] if len(lst) > 0 else -1)

Prints the following, where if no such index is found then prints -1 instead of index.

 --> -1

123 --> -1

uiae1iuae200 --> 8

uiae1iuae200aaaaaaaa --> 19

This is a really clean way, which works perfectly with the new requirement:

(printing None with no errors when string = '123')

import re



string = 'uiae1iuae200'

ls = list(re.finditer(r'[^0-9]', string))

print(ls[-1].start() if ls else None)

Output:

8

Or alternatively using collections.deque:

import re

from collections import deque



string = 'uiae1iuae200'

que = deque(re.finditer(r'[^0-9]', string), maxlen=1)

print(que.pop().start() if que else None)

Here's my original very pythonic and efficient answer:

(Which unfortunately will throw a ValueError when string = '123')

import re



string = 'uiae1iuae200'

*_, last = re.finditer(r'[^0-9]', string)

print(last.start())

This does not look Pythonic because it's not a one-liner, and it uses range(len(foo)), but it's pretty straightforward and probably not too inefficient.

def last_match(pattern, string):

    for i in range(1, len(string) + 1):

        substring = string[-i:]

        if re.match(pattern, substring):

            return len(string) - i

The idea is to iterate over the suffixes of string from the shortest to the longest, and to check if it matches pattern.

Since we're checking from the end, we know for sure that the first substring we meet that matches the pattern is the last.