Is there a better way to find if string contains digits?

Question

I'm working with strings that contain both digits and alphanumerics, or just digits, but not just alphas. In order to test for false matches, I need to check if the strings contain at least one digit, printing an error message if it doesn't. I have been using the following code:

s = '0798237 sh 523-123-asdjlh'

def contains_digits(s):
    for char in list(s):
        if char.isdigit():
            return True
            break
    return False

if contains_digits(s) == True:
    print s
else:
    print 'Error'

Is there a more pythonic or simpler way to do so, or does this suffice? Also, I can't just check to see if the string is alphanumeric, because the string may contain various symbols ('-', spaces, etc.)

Answer 1

This is one of those places where a regular expression is just the thing:

_digits = re.compile('\d')
def contains_digits(d):
    return bool(_digits.search(d))

Little demo:

>>> _digits = re.compile('\d')
>>> def contains_digits(d):
...     return bool(_digits.search(d))
... 
>>> contains_digits('0798237 sh 523-123-asdjlh')
True
>>> contains_digits('sh asdjlh')
False

You could use the any method with .isdigit() as described in @Wallacolloo's answer, but that's slower than the simple regular expression:

>>> import timeit
>>> timeit.timeit("contains_digits('0798237 sh 523-123-asdjlh')", 'from __main__ import contains_digits')
0.77181887626647949
>>> timeit.timeit("contains_digits_any('0798237 sh 523-123-asdjlh')", 'from __main__ import contains_digits_any')
1.7796030044555664

The if method is on par with the regular expression:

>>> timeit.timeit("contains_digits_if('0798237 sh 523-123-asdjlh')", 'from __main__ import contains_digits_if')
0.87261390686035156

But things get worse if the digits appear late in the text:

>>> timeit.timeit("contains_digits('asdjlhtaheoahueoaea 11 thou')", 'from __main__ import contains_digits')
1.202538013458252
>>> timeit.timeit("contains_digits_any('asdjlhtaheoahueoaea 11 thou')", 'from __main__ import contains_digits_any')
5.0348429679870605
>>> timeit.timeit("contains_digits_if('asdjlhtaheoahueoaea 11 thou')", 'from __main__ import contains_digits_if')
3.707183837890625

Timings tested on python 2.6 on Mac OS X 10.7.

Answer 2

Use the any function, passing in a sequence.
If any element of the sequence is true (ie is a digit, in this case), then any returns True, else False. https://docs.python.org/library/functions.html#any

def contains_digits(s):
    return any(char.isdigit() for char in s)

If you're concerned about performance though, your current method is actually faster.

Answer 3

After reading the discussion above, I was curious about the performance of a set-based version like this:

def contains_digit(s, digits=set('0123456789')):
    return bool(digits.intersection(s))

In my testing, this was slightly faster on average than the re version on one computer and slightly slower on another (?). Just for fun, I compared some other versions as well.

import math
import re
import timeit


def contains_digit_set_intersection(s, digits=set('0123456789')):
    return bool(digits.intersection(s))


def contains_digit_iter_set(s, digits=set('0123456789')):
    for c in s:
        if c in digits:
            return True
    return False


def contains_digit_iter_str(s, digits='0123456789'):
    for c in s:
        if c in digits:
            return True
    return False


def contains_digit_re(s, digits=re.compile(r'\d')):
    return bool(digits.search(s))


def print_times(func, times):
    name = func.__name__
    average = sum(times) / len(times)
    formatted_times = ' '.join('{:.3f}'.format(t) for t in times)
    message = '{name:<31} {times} ~{average:.3f}'
    print(message.format(name=name, times=formatted_times, average=average))


funcs = [
    contains_digit_set_intersection,
    contains_digit_iter_set,
    contains_digit_iter_str,
    contains_digit_re,
]


cases = [
    '1bcdefg7',
    'abcdefg7',
    'abcdefgh',
    '0798237 sh 523-123-asdjlh',
    'asdjlhtaheoahueoaea 11 thou',
]


for func in funcs:
    times = []
    for case in cases:
        func_case = '{func.__name__}("{case}")'.format(func=func, case=case)
        time = timeit.timeit(func_case, globals={func.__name__: func})
        times.append(time)
    print_times(func, times)

Sample runs for the two computers (time for each case and the ~average):

contains_digit_set_intersection 0.744 0.731 0.724 1.227 1.113 ~0.908
contains_digit_iter_set         0.264 0.541 0.566 0.260 1.068 ~0.540
contains_digit_iter_str         0.272 0.649 0.632 0.274 1.211 ~0.607
contains_digit_re               0.748 0.854 0.679 0.744 1.006 ~0.806

contains_digit_set_intersection 0.860 0.870 0.855 1.456 1.357 ~1.080
contains_digit_iter_set         0.285 0.613 0.617 0.307 1.163 ~0.597
contains_digit_iter_str         0.295 0.748 0.799 0.288 1.595 ~0.745
contains_digit_re               1.157 1.236 0.927 1.086 1.450 ~1.171

Answer 4

For those seeking shorter solution: any(d in s for d in'0123456789')