Python pattern searching using re standard lib, str.find()

Question

I'm trying to improve some code in order to get a better perfomance, I have to do a lot of pattern matching for little tags on medium large strings, for example:

import re
STR = "0001x10x11716506872xdc23654&xd01371600031832xx10xID=000110011001010\n"

def getID(string):
    result = re.search('.*ID=(\d+)', string)
    if result:
        print result.group(1)
    else:
        print "No Results"

Taking in mind the perfomance I rewrite it:

def getID2(string):
    result = string.find('ID=')
    if result:
        result += 3
        print string[result:result+15]
    else:
        print 'No Results'

Are there a better way to improve these approaches? Any comments are welcome...

Answer 1

If you name your function getSomething(), I expect it to return a value with no side effects. I do not expect it to print anything. Therefore, your function should either return the found string, or None if it is not not found.

Your original and revised code look for different things: the former wants as many digits as possible, and the latter wants 15 characters. Combining the two requirements, I take it that you want 15 digits.

re.search() lets the regular expression match any part of the string, rather than the entire string. Therefore, you can omit .* from the beginning of your regular expression.

Here's how I would write it:

import re
STR = "0001x10x11716506872xdc23654&xd01371600031832xx10xID=000110011001010\n"

def getID(string):
    result = re.search('ID=(\d{15})', string)
    return result and result.group(1)

print getID(STR) or "No Results"

Answer 2

You are trying to get what's after ID=?
I'm not sure about performance (you'll have to benchmark on your own data) but I would do this:

def get_id(string):
    try:
        id = str.split('ID=')[1].strip()
        return id
    except IndexError:
        return None

string = "0001x10x11716506872xdc23654&xd01371600031832xx10xID=000110011001010\n"
id = get_id(string)

This only works if there are 0 or 1 ID= parts. If there are 2 or more only the first one gets returned.

Edit:

This is how I would do benchmarks (I might be wrong, I don't have much experience in this):

>>> #string with escaped '\n' at the end:
>>> string = '0001x10x11716506872xdc23654&xd01371600031832xx10xID=000110011001010\\n'
>>> #original regex + getting the match object:
>>> timeit.timeit(stmt="re.search(r'.*ID=(\d+)', '{}').group(1)".format(string), setup="import re")
3.4012476679999963
>>> #original regex only:
>>> timeit.timeit(stmt="re.search(r'.*ID=(\d+)', '{}')".format(string), setup="import re")
2.560870873996464
>>> #alternative regex + match object (had to use c-style string formatting):
>>> timeit.timeit(stmt="re.search(r'ID=(\d{15})', '%s').group(1)" % string, setup="import re")
3.0494329900029697
>>> #alternative regex only:
>>> timeit.timeit(stmt="re.search(r'ID=(\d{15})', '%s')" % string, setup="import re")
2.2219171980032115
>>> #str.split:
>>> timeit.timeit(stmt="'{}'.split('ID=')[1].strip()".format(string))
1.127366863998759

I think these are the benchmarks for the relevant parts. This is on a CoreDuo MacBook Pro and your results may vary. It's been my experience that using methods from the standard library usually yields the best results. On the other hand, this is important only if you have a ton of data to process. Otherwise a more flexible but "slower" way of doing things might be better.