blocks|key|535371|text|这是正则表达式最适合的地方之一：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|535372|_digits+=+re.compile('\d')
def+contains_digits(d):
++++return+bool(_digits.search(d))|code-block|syntax|javascript|535373|小演示：|535374|>>>+_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|535375|您可以像@Wallacolloo's+answer中描述的那样对.isdigit()使用any方法，但这比简单的正则表达式要慢：|offset|length|style|CODE|535376|>>>+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|535377|if方法与正则表达式不相上下：|535378|>>>+timeit.timeit("contains_digits_if('0798237+sh+523-123-asdjlh')",+'from+__main__+import+contains_digits_if')
0.87261390686035156|535379|但是，如果文本中出现较晚的数字，情况会变得更糟：|535380|>>>+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|535381|在Mac+OS+X+10.7上的python+2.6上测试的计时。|535382|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/11232523/100297^0|0|0|0|0|W|A|18|3|4|L|0|0|0|0|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1C|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1E|8|@$M|1F|N|1G|O|P]|$M|1H|N|1I|O|P]]|9|@$M|1J|N|1K|1|1L]]|A|$]]|$1|Q|3|R|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1N|8|@$M|1O|N|1P|O|P]]|9|@]|A|$]]|$1|U|3|V|5|D|7|1Q|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1S|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1T|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|13|$14|$5|15|16|17|A|$18|19]]]]

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

<pre><code>_digits = re.compile('\d')
def contains_digits(d):
 return bool(_digits.search(d))
</code></pre>

Little demo:

<pre><code>&gt;&gt;&gt; _digits = re.compile('\d')
&gt;&gt;&gt; def contains_digits(d):
... return bool(_digits.search(d))
... 
&gt;&gt;&gt; contains_digits('0798237 sh 523-123-asdjlh')
True
&gt;&gt;&gt; contains_digits('sh asdjlh')
False
</code></pre>

You could use the <code>any</code> method with <code>.isdigit()</code> as described in <a href="https://stackoverflow.com/a/11232523/100297">@Wallacolloo's answer</a>, but that's slower than the simple regular expression:

<pre><code>&gt;&gt;&gt; import timeit
&gt;&gt;&gt; timeit.timeit("contains_digits('0798237 sh 523-123-asdjlh')", 'from __main__ import contains_digits')
0.77181887626647949
&gt;&gt;&gt; timeit.timeit("contains_digits_any('0798237 sh 523-123-asdjlh')", 'from __main__ import contains_digits_any')
1.7796030044555664
</code></pre>

The <code>if</code> method is on par with the regular expression:

<pre><code>&gt;&gt;&gt; timeit.timeit("contains_digits_if('0798237 sh 523-123-asdjlh')", 'from __main__ import contains_digits_if')
0.87261390686035156
</code></pre>

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

<pre><code>&gt;&gt;&gt; timeit.timeit("contains_digits('asdjlhtaheoahueoaea 11 thou')", 'from __main__ import contains_digits')
1.202538013458252
&gt;&gt;&gt; timeit.timeit("contains_digits_any('asdjlhtaheoahueoaea 11 thou')", 'from __main__ import contains_digits_any')
5.0348429679870605
&gt;&gt;&gt; timeit.timeit("contains_digits_if('asdjlhtaheoahueoaea 11 thou')", 'from __main__ import contains_digits_if')
3.707183837890625
</code></pre>

Timings tested on python 2.6 on Mac OS X 10.7.

blocks|key|318462|text|对于那些寻求更短解决方案的人：any(d+in+s+for+d+in'0123456789')|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|318463|entityMap^0|F|W|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

For those seeking shorter solution: <code>any(d in s for d in'0123456789')</code>

blocks|key|535522|text|读完上面的讨论后，我对基于set的版本的性能很好奇：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|535523|def+contains_digit(s,+digits=set('0123456789')):
++++return+bool(digits.intersection(s))|code-block|syntax|javascript|535524|在我的测试中，它在一台计算机上的平均速度比re版本稍快，在另一台计算机上的速度稍慢(?)。只是为了好玩，我也比较了一些其他版本。|offset|length|style|CODE|535525|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)|535526|两台计算机的示例运行(每种情况的时间和~平均值)：|535527|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|535528|entityMap^0|0|0|L|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

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

<pre><code>def contains_digit(s, digits=set('0123456789')):
 return bool(digits.intersection(s))
</code></pre>

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

<pre><code>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:&lt;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)
</code></pre>

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

<pre><code>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
</code></pre>

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:

<pre><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'
</code></pre>

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.)

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

我正在处理同时包含数字和字母数字的字符串，或者只包含数字，而不仅仅是字母。为了测试错误匹配，我需要检查字符串是否至少包含一个数字，如果不包含，则打印一条错误消息。s = '0798237 sh 523-123-asdjlh'def contains_digits(s):    for char in list(s): ...

问有没有更好的方法来查找字符串是否包含数字？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有更好的方法来查找字符串是否包含数字？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有更好的方法来查找字符串是否包含数字？
EN